def setAttributes(self, data): self.data = data self.dataLen = data.shape[0] # Make this buffer the default one gl.glBindVertexArray(self.VAO) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.buffer) # Upload data gl.glBufferData(gl.GL_ARRAY_BUFFER, data.nbytes, data, gl.GL_DYNAMIC_DRAW) offset = 0 for i, name in enumerate(data.dtype.names): # import ipdb; ipdb.set_trace() stride = data[name].strides[0] if data[name].ndim == 1: size = 1 else: size = data[name].shape[1] loc = gl.glGetAttribLocation(self.program, name) # remember these properties for later updating of buffer self.attribute_layout[name] = {'offset':offset} gl.glVertexAttribPointer(loc, size, gl.GL_FLOAT, False, stride, ctypes.c_void_p(offset)) gl.glEnableVertexAttribArray(loc) offset += data.dtype[name].itemsize gl.glBindBuffer(gl.GL_ARRAY_BUFFER, 0) gl.glBindVertexArray(0) # ensure correct mask is rendered: self.setMask()
def display(): global offsetUniform, theProgram GL.glClearColor(0.0, 0.0, 0.0, 0.0) GL.glClear(GL.GL_COLOR_BUFFER_BIT) GL.glUseProgram(theProgram) GL.glUniform2f(offsetUniform, 0.5, 0.5) colorData = sizeOfFloat*len(vertexData)/2 GL.glBindBuffer(GL.GL_ARRAY_BUFFER, vertexBufferObject) positionLocation = GL.glGetAttribLocation(theProgram, 'position') colorLocation = GL.glGetAttribLocation(theProgram, 'color') GL.glEnableVertexAttribArray(positionLocation) GL.glVertexAttribPointer(positionLocation, 4, GL.GL_FLOAT, False, 0, null) GL.glEnableVertexAttribArray(colorLocation) GL.glVertexAttribPointer(colorLocation, 4, GL.GL_FLOAT, False, 0, c_void_p(colorData)) GL.glDrawArrays(GL.GL_TRIANGLES, 0, 36) GL.glDisableVertexAttribArray(positionLocation) GL.glDisableVertexAttribArray(colorLocation) GL.glUseProgram(0)
def init_vertex_buf(self): self.vbo = GL.glGenBuffers(1) GL.glBindBuffer(GL.GL_ARRAY_BUFFER,self.vbo) array_type = (GL.GLfloat*len(VERTICES)) GL.glBufferData(GL.GL_ARRAY_BUFFER,len(VERTICES)*SIZE_FLOAT, array_type(*VERTICES),GL.GL_STATIC_DRAW) GL.glBindBuffer(GL.GL_ARRAY_BUFFER,0)
def initializeGL(self): gl.glClearColor(1.0,1.0,1.0,0.0) # gl.glColor3f(0.0,0.0, 0.0) # gl.glPointSize(4.0) # gl.glMatrixMode(gl.GL_PROJECTION) # gl.glLoadIdentity() # glu.gluOrtho2D(0.0,640.0,0.0,480.0) gl.glViewport (0, 0, 800, 600) gl.glClearColor (0.0, 0.5, 0.5, 1.0) gl.glEnableClientState (gl.GL_VERTEX_ARRAY) self._vertices, self._normals = util.load_obj("monkey.obj") self._vbo = gl.glGenBuffers(1) gl.glBindBuffer (gl.GL_ARRAY_BUFFER, self._vbo) gl.glBufferData (gl.GL_ARRAY_BUFFER, self._vertices.size*4, self._vertices, gl.GL_STATIC_DRAW) self._normal_vbo = gl.glGenBuffers(1) gl.glBindBuffer (gl.GL_ARRAY_BUFFER, self._normal_vbo) gl.glBufferData (gl.GL_ARRAY_BUFFER, self._normals.size*4, self._normals, gl.GL_STATIC_DRAW) self._shader_program = shader.LoadShaders("shader8.vs", "shader8.ps") gl.glEnable(gl.GL_DEPTH_TEST) gl.glDepthFunc(gl.GL_LESS)
def init(self): self.vao = GL.glGenVertexArrays(1) GL.glBindVertexArray(self.vao) self.initializeProgram() self.initializeVertexBuffer() colorDataOffset = 3*self.float_size*self.numberOfVertices GL.glBindBuffer(GL.GL_ARRAY_BUFFER,self.vertexBufferObject) GL.glEnableVertexAttribArray(0) GL.glEnableVertexAttribArray(1) GL.glVertexAttribPointer(0, 3, GL.GL_FLOAT, GL.GL_FALSE, 0, None) GL.glVertexAttribPointer(1, 4, GL.GL_FLOAT, GL.GL_FALSE, 0, GL.GLvoidp(colorDataOffset)) GL.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER,self.indexBufferObject) GL.glBindVertexArray(0) GL.glEnable(GL.GL_CULL_FACE) GL.glCullFace(GL.GL_BACK) GL.glFrontFace(GL.GL_CW) GL.glEnable(GL.GL_DEPTH_TEST) GL.glDepthMask(GL.GL_TRUE) GL.glDepthFunc(GL.GL_LESS) GL.glDepthRange(0.0, 1.0)
def initializeGL(self): """ Create the graphic buffers and compile the shaders. """ # Create and bind a new VAO (Vertex Array Object). self.vertex_array_object = gl.glGenVertexArrays(1) gl.glBindVertexArray(self.vertex_array_object) # Upload color values (one for each triangle vertex) in RGB format. colBuf = gl.glGenBuffers(1) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, colBuf) col = np.array([1,0,0,0,1,0,0,0,1], dtype=np.float32) gl.glBufferData(gl.GL_ARRAY_BUFFER, col, gl.GL_STATIC_DRAW) gl.glVertexAttribPointer(0, 3, gl.GL_FLOAT, gl.GL_FALSE, 0, None) gl.glEnableVertexAttribArray(0) # Create and bind GPU buffer for vertex data. self.vertexBuffer = gl.glGenBuffers(1) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.vertexBuffer) # Associate the vertex buffer with the "Layout 0" shader variable (look # for "v_N" variable in vertex shader program). gl.glVertexAttribPointer(1, 4, gl.GL_FLOAT, gl.GL_FALSE, 0, None) gl.glEnableVertexAttribArray(1) # Enable depth-sorting. gl.glEnable(gl.GL_DEPTH_TEST) gl.glDepthFunc(gl.GL_LESS) # Background color. gl.glClearColor(0, 0, 0, 0) # Compile- and install shader programs. self.shaders = self.linkShaders('blog4.vs', 'blog4.fs') gl.glUseProgram(self.shaders)
def paintGL(self): # clear the buffer gl.glClear(gl.GL_COLOR_BUFFER_BIT) # Run the compute phase i = 0 while (i * MAX_WORKGROUPS < self.count): upper = min(self.count, (i+1) * MAX_WORKGROUPS) data = self.valueBuffer[i*MAX_WORKGROUPS:upper] status = self.statusBuffer[i*MAX_WORKGROUPS:upper] gl.glBindBufferBase(gl.GL_SHADER_STORAGE_BUFFER, 0, self.ssbos['data']) gl.glBufferData(gl.GL_SHADER_STORAGE_BUFFER, data.nbytes, data, gl.GL_DYNAMIC_COPY) gl.glBindBufferBase(gl.GL_SHADER_STORAGE_BUFFER, 1, self.ssbos['status']) gl.glBufferData(gl.GL_SHADER_STORAGE_BUFFER, status.nbytes, status, gl.GL_DYNAMIC_COPY) gl.glUseProgram(self.compute_program) gl.glDispatchCompute(min(MAX_WORKGROUPS, self.count - i * MAX_WORKGROUPS), 1, 1) gl.glMemoryBarrier(gl.GL_SHADER_STORAGE_BARRIER_BIT) # Read back the modified data. gl.glBindBufferBase(gl.GL_SHADER_STORAGE_BUFFER, 0, self.ssbos['data']) gl.glGetBufferSubData(gl.GL_SHADER_STORAGE_BUFFER, 0, data.nbytes, self.valueBuffer[i*MAX_WORKGROUPS]) gl.glBindBufferBase(gl.GL_SHADER_STORAGE_BUFFER, 1, self.ssbos['status']) gl.glGetBufferSubData(gl.GL_SHADER_STORAGE_BUFFER, 0, status.nbytes, self.statusBuffer[i*MAX_WORKGROUPS]) i += 1 self.iterations += ITER_PER_CYCLE # bind the VBO self.vbo.bind() # tell OpenGL that the VBO contains an array of vertices gl.glEnableClientState(gl.GL_VERTEX_ARRAY) # these vertices contain 2 single precision coordinates gl.glVertexPointer(2, gl.GL_FLOAT, 0, self.vbo) # Bind statuses gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.ssbos['status']) gl.glBufferData(gl.GL_ARRAY_BUFFER, self.statusBuffer.nbytes, self.statusBuffer, gl.GL_DYNAMIC_COPY) gl.glVertexAttribIPointer(1, 2, gl.GL_INT, 0, None) gl.glEnableVertexAttribArray(1); # Use our pipeline. gl.glUseProgram(self.render_program) # draw "count" points from the VBO gl.glDrawArrays(gl.GL_POINTS, 0, self.count) # Update the window title. self.parent().setWindowTitle("Iterations: %d; zoom; %f" % (self.iterations, self.zoom))
def bind(self): assert threading.current_thread() is threading.main_thread() if self.length: self.unbind() if self.glsl_dtype == "vec4": size, dtype = 4, gl.GL_FLOAT elif self.glsl_dtype == "vec3": size, dtype = 3, gl.GL_FLOAT elif self.glsl_dtype == "vec2": size, dtype = 2, gl.GL_FLOAT elif self.glsl_dtype == "float": size, dtype = 1, gl.GL_FLOAT else: raise TypeError(self.glsl_dtype) self.verify_dtype() self.store.bind() offset = self.store.offset stride = self.store.strides[0] buf = self.store.opengl_id loc = gl.glGetAttribLocation(self.shader_program, self.attribute) if loc == -1: print("WARNING: unused attribute '%s'" % self.attribute) self.enabled = False else: gl.glEnableVertexAttribArray(loc) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, buf) gl.glVertexAttribPointer(loc, size, dtype, False, stride, ctypes.c_void_p(offset)) if self.instanced: gl.glVertexAttribDivisor(loc,1) self.enabled = True self.length = self.store.shape[0]
def __init__(self, vertices, indices, draw_method): from . import SHORT_SIZE, FLOAT_SIZE self.draw_method = draw_method self.indices = indices self.vao = GL.glGenVertexArrays(1) GL.glBindVertexArray(self.vao) vertexBufferObject = GL.glGenBuffers(1) GL.glBindBuffer(GL.GL_ARRAY_BUFFER, vertexBufferObject) array_type = (GL.GLfloat*len(vertices)) GL.glBufferData( GL.GL_ARRAY_BUFFER, len(vertices)*FLOAT_SIZE, array_type(*vertices), GL.GL_STATIC_DRAW) GL.glEnableVertexAttribArray(0) GL.glVertexAttribPointer(0, 3, GL.GL_FLOAT, GL.GL_FALSE, 0, None) indexBufferObject = GL.glGenBuffers(1) GL.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, indexBufferObject) array_type = (GL.GLushort*len(self.indices)) GL.glBufferData( GL.GL_ELEMENT_ARRAY_BUFFER, len(self.indices)*SHORT_SIZE, array_type(*self.indices), GL.GL_STATIC_DRAW) GL.glBindVertexArray(0)
def initializeGL(self): """Initialize OpenGL, VBOs, upload data on the GPU, etc.""" # background color gl.glClearColor(0.8, 0.8, 0.8, 0) # Make initial data array. # compile the vertex shader vs = compile_shader(VERTEX, gl.GL_VERTEX_SHADER) # compile the geometry shader gs = compile_shader(GEOMETRY, gl.GL_GEOMETRY_SHADER) # compile the fragment shader fs = compile_shader(FRAGMENT, gl.GL_FRAGMENT_SHADER) # Link the programs. self.render_program = link_shaders(vs, gs, fs) # Compile the compute shader cs = compile_shader(COMPUTE, gl.GL_COMPUTE_SHADER) # Create the compute shader buffers. self.makeBuffers() #self.vbo = glvbo.VBO(self.attributes) self.vbo = gl.glGenBuffers(1) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.vbo) gl.glBufferData(gl.GL_ARRAY_BUFFER, self.attributes.nbytes, self.attributes, gl.GL_DYNAMIC_COPY) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, 0) self.ssbo = gl.glGenBuffers(1) gl.glBindBufferBase(gl.GL_SHADER_STORAGE_BUFFER, 1, self.ssbo) gl.glBufferData(gl.GL_SHADER_STORAGE_BUFFER, self.velocities.nbytes, self.velocities, gl.GL_DYNAMIC_COPY) self.compute_program = link_shaders(cs)
def build_buffer(program, data, data_usage=gl.GL_STATIC_DRAW, buffer_target=gl.GL_ARRAY_BUFFER): # with use_program(program): buffer = gl.glGenBuffers(1) gl.glBindBuffer(buffer_target, buffer) gl.glBufferData(buffer_target, data.nbytes, data, data_usage) gl.glBindBuffer(buffer_target, 0) return buffer
def bind_attrib(self, attrib_id, size, data, storagetype=gl.GL_STATIC_DRAW, instance_divisor=0, datatype=gl.GL_FLOAT, stride=0, offset=None, normalize=False): if RenderObject.bound_vao is not self.vao_id: gl.glBindVertexArray(self.vao_id) RenderObject.bound_vao = self.vao_id # Keep track of max instance divisor self.max_instance_divisor = max(instance_divisor, self.max_instance_divisor) # If the input is an array create a new GL buffer, otherwise assume the buffer already exists and a buffer ID is passed if type(data) is np.ndarray: # Get an index to one new buffer in GPU mem, bind it, and copy the array data to it buf_id = gl.glGenBuffers(1) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, buf_id) gl.glBufferData(gl.GL_ARRAY_BUFFER, data.nbytes, data, storagetype) else: # Assume that a GLuint is passed which means that the buffer is already in GPU memory buf_id = data gl.glBindBuffer(gl.GL_ARRAY_BUFFER, buf_id) # Assign this buffer to one of the attributes in the shader gl.glEnableVertexAttribArray(attrib_id) gl.glVertexAttribPointer(attrib_id, size, datatype, normalize, stride, offset) # For instanced data, indicate per how many instances we move a step in the buffer (1=per instance) if instance_divisor > 0: gl.glVertexAttribDivisor(attrib_id, instance_divisor) # Clean up gl.glDisableVertexAttribArray(attrib_id) self.enabled_attributes[attrib_id] = [size, buf_id, instance_divisor, datatype] return buf_id
def _make_gl_selection_box(self): """ Creates the Vertex Array Object, Vertex Buffer Objects and fill the shaders with the data of the corresponding points. Since we will use two kind of drawing methods, lines and triangles, the index buffer will set to GL_DYNAMIC_DRAW, so as the coordinates, but not the colors, which will be set as GL_STATIC_DRAW. """ self.vao = GL.glGenVertexArrays(1) GL.glBindVertexArray(self.vao) ind_vbo = GL.glGenBuffers(1) GL.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, ind_vbo) GL.glBufferData(GL.GL_ELEMENT_ARRAY_BUFFER, self.indexes.itemsize*int(len(self.indexes)), self.indexes, GL.GL_DYNAMIC_DRAW) coord_vbo = GL.glGenBuffers(1) GL.glBindBuffer(GL.GL_ARRAY_BUFFER, coord_vbo) GL.glBufferData(GL.GL_ARRAY_BUFFER, self.points.itemsize*int(len(self.points)), self.points, GL.GL_DYNAMIC_DRAW) att_position = GL.glGetAttribLocation(self.selection_box_program, 'vert_coord') GL.glEnableVertexAttribArray(att_position) GL.glVertexAttribPointer(att_position, 2, GL.GL_FLOAT, GL.GL_FALSE, 2*self.points.itemsize, ctypes.c_void_p(0)) col_vbo = GL.glGenBuffers(1) GL.glBindBuffer(GL.GL_ARRAY_BUFFER, col_vbo) GL.glBufferData(GL.GL_ARRAY_BUFFER, self.color.itemsize*int(len(self.color)), self.color, GL.GL_STATIC_DRAW) att_colors = GL.glGetAttribLocation(self.selection_box_program, 'vert_color') GL.glEnableVertexAttribArray(att_colors) GL.glVertexAttribPointer(att_colors, 3, GL.GL_FLOAT, GL.GL_FALSE, 3*self.color.itemsize, ctypes.c_void_p(0)) GL.glBindVertexArray(0) GL.glDisableVertexAttribArray(att_position) GL.glDisableVertexAttribArray(att_colors) GL.glBindBuffer(GL.GL_ARRAY_BUFFER, 0) GL.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, 0) self.buffers = (ind_vbo, coord_vbo, col_vbo)
def initializeGL(self): """ Set OpenGL variables """ self.qglClearColor(QtGui.QColor(250,250,250,255)) #GL.glShadeModel(GL.GL_FLAT) GL.glShadeModel(GL.GL_SMOOTH) GL.glEnable(GL.GL_DEPTH_TEST) GL.glEnable(GL.GL_POINT_SMOOTH ) #GL.glEnable(GL.GL_CULL_FACE) # Creates the pixel buffer object for the background and loads image data into it self.pbo = long(GL.glGenBuffers(1)) GL.glBindBuffer(GL.GL_PIXEL_UNPACK_BUFFER, self.pbo) if self.str: GL.glBufferData(GL.GL_PIXEL_UNPACK_BUFFER, self.str.current(), GL.GL_DYNAMIC_DRAW) # Creates the texture object for the background self.texid = long(GL.glGenTextures(1)) GL.glBindTexture(GL.GL_TEXTURE_2D, self.texid) GL.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_NEAREST) GL.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_NEAREST) GL.glPixelStorei(GL.GL_UNPACK_ALIGNMENT,1) # Loads image data from the PBO to the texture object if self.str: GL.glTexImage2D(GL.GL_TEXTURE_2D, 0, 3, self.str.width, self.str.height, 0, GL.GL_RGB, GL.GL_UNSIGNED_BYTE, GL.GLvoid) # Unbinds everything GL.glBindTexture(GL.GL_TEXTURE_2D, 0) GL.glBindBuffer(GL.GL_PIXEL_UNPACK_BUFFER, 0)
def setBackground(self, aStreamer=None): """ Sets an streamer object as the one who provides the background image """ self.str = aStreamer if self.str: GL.glBindBuffer(GL.GL_PIXEL_UNPACK_BUFFER, self.pbo) GL.glBufferData(GL.GL_PIXEL_UNPACK_BUFFER, self.str.current(), GL.GL_DYNAMIC_DRAW) GL.glBindBuffer(GL.GL_PIXEL_UNPACK_BUFFER, 0)
def sync(self): # Sync the buffer with the graphics hardware if the buffer is dirty if self.status == 'synced': return size = self.stride * self.count gl.glBindBuffer(self.target, self.id) gl.glBufferData(self.target, size, self.element, self.usage) self.status = 'synced'
def updateBackground(self): """ Updates the Background image """ if self.str: GL.glBindBuffer(GL.GL_PIXEL_UNPACK_BUFFER, self.pbo) GL.glBufferSubData( GL.GL_PIXEL_UNPACK_BUFFER , 0 , self.str.current()) GL.glBindBuffer(GL.GL_PIXEL_UNPACK_BUFFER, 0) self.updateGL()
def change_vbo_colors (col_vbo = None, colors = [], program = None): """ Function doc """ GL.glBindBuffer(GL.GL_ARRAY_BUFFER, col_vbo) GL.glBufferData(GL.GL_ARRAY_BUFFER, colors.itemsize*int(len(colors)), colors, GL.GL_STATIC_DRAW) att_colors = GL.glGetAttribLocation(program, 'vert_color') GL.glEnableVertexAttribArray(att_colors) GL.glVertexAttribPointer(att_colors, 3, GL.GL_FLOAT, GL.GL_FALSE, 3*colors.itemsize, ctypes.c_void_p(0))
def __init__(self, vertices, normals, indices, draw_method): self.draw_method = draw_method self.indices = indices self.vao = GL.glGenVertexArrays(1) GL.glBindVertexArray(self.vao) vertexBufferObject = GL.glGenBuffers(1) GL.glBindBuffer(GL.GL_ARRAY_BUFFER, vertexBufferObject) data = vertices + normals array_type = (GL.GLfloat*len(data)) GL.glBufferData( GL.GL_ARRAY_BUFFER, len(data)*FLOAT_SIZE, array_type(*data), GL.GL_STATIC_DRAW) GL.glEnableVertexAttribArray(0) GL.glEnableVertexAttribArray(1) GL.glVertexAttribPointer(0, 3, GL.GL_FLOAT, GL.GL_FALSE, 0, None) GL.glVertexAttribPointer(1, 3, GL.GL_FLOAT, GL.GL_FALSE, 0, GL.GLvoidp(len(vertices)*FLOAT_SIZE)) indexBufferObject = GL.glGenBuffers(1) GL.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, indexBufferObject) array_type = (GL.GLuint*len(self.indices)) GL.glBufferData( GL.GL_ELEMENT_ARRAY_BUFFER, len(self.indices)*FLOAT_SIZE, array_type(*self.indices), GL.GL_STATIC_DRAW) GL.glBindVertexArray(0)
def draw_grid(self,): gl.glUseProgram(self.simple_object_shader) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glEnable(gl.GL_DEPTH_TEST) gl.glDepthFunc(gl.GL_LESS) gl.glBindVertexArray(self.grid_vao) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.grid_vbo) vProjection = gl.glGetUniformLocation(self.simple_object_shader, 'vProjection') vPosisition = gl.glGetAttribLocation(self.simple_object_shader, "vPosisition") vColor = gl.glGetAttribLocation(self.simple_object_shader, "vColor") vCamera = gl.glGetUniformLocation(self.simple_object_shader, 'vCamera') gl.glUniformMatrix4fv(vProjection, 1, gl.GL_FALSE, self.projection_matrix_function()) gl.glUniformMatrix4fv(vCamera, 1, gl.GL_FALSE, self.camera_matrix_function()) gl.glEnableVertexAttribArray(vPosisition) gl.glEnableVertexAttribArray(vColor) gl.glVertexAttribPointer(vPosisition, 4, gl.GL_FLOAT, gl.GL_FALSE, 0, None) gl.glVertexAttribPointer(vColor, 4, gl.GL_FLOAT, gl.GL_FALSE, 0, ctypes.c_void_p(self.grid_size * 4)) gl.glDrawArrays(gl.GL_TRIANGLES, 0, self.grid_size / 4)
def create_object(shader): # Create a new VAO (Vertex Array Object) and bind it vertex_array_object = GL.glGenVertexArrays(1) GL.glBindVertexArray( vertex_array_object ) # Generate buffers to hold our vertices vertex_buffer = GL.glGenBuffers(1) GL.glBindBuffer(GL.GL_ARRAY_BUFFER, vertex_buffer) # Get the position of the 'position' in parameter of our shader and bind it. position = GL.glGetAttribLocation(shader, 'position') GL.glEnableVertexAttribArray(position) coord = GL.glGetAttribLocation(shader, 'coord') GL.glEnableVertexAttribArray(coord) # Describe the 'position' data layout in the buffer GL.glVertexAttribPointer(position, 2, GL.GL_FLOAT, False, 16, GL.GLvoidp(0)) GL.glVertexAttribPointer(coord, 2, GL.GL_FLOAT, False, 16, GL.GLvoidp(8)) # Send the data over to the buffer GL.glBufferData(GL.GL_ARRAY_BUFFER, 96, vertices, GL.GL_STATIC_DRAW) # Unbind the VAO first (Important) GL.glBindVertexArray(0) # Unbind other stuff GL.glDisableVertexAttribArray(position) GL.glDisableVertexAttribArray(coord) GL.glBindBuffer(GL.GL_ARRAY_BUFFER, 0) return vertex_array_object
def bind(self): GL.glBindBuffer(GL.GL_ARRAY_BUFFER, self.vboID) # Select vbo GL.glVertexAttribPointer(0, # Attribute number in this Vertex Array Object (VAO) 3, # This attribute uses 3 elements. I could make this adaptive and probably will. GL.GL_FLOAT, # These values are of type "GL_FLOAT" GL.GL_FALSE, # These values will not be normalized (made to range between 0.0 and 1.0) 8*4, # Bits per row. n*elements * bits/element. verts: 3, norms: 3, uv-coords: 2, floats: 4 bit ct.c_void_p(0)) # Where (in bits) in each row does this attribute start?) GL.glEnableVertexAttribArray(0) # Enable VBO, assign it to VAO at location = 0 GL.glVertexAttribPointer(1, # Attribute number in this Vertex Array Object (VAO) 3, # This attribute uses 3 elements. I could make this adaptive and probably will. GL.GL_FLOAT, # These values are of type "GL_FLOAT" GL.GL_FALSE, # These values will not be normalized (made to range between 0.0 and 1.0) 8*4, # Bits per row. n*elements * bits/element. verts: 3, norms: 3, uv-coords: 2, floats: 4 bit ct.c_void_p(3*4)) # Where (in bits) in each row does this attribute start?) GL.glEnableVertexAttribArray(1) # Enable VBO, assign it to VAO at location = 1 GL.glVertexAttribPointer(2, # Attribute number in this Vertex Array Object (VAO) 2, # This attribute uses 3 elements. I could make this adaptive and probably will. GL.GL_FLOAT, # These values are of type "GL_FLOAT" GL.GL_FALSE, # These values will not be normalized (made to range between 0.0 and 1.0) 8*4, # Bits per row. n*elements * bits/element. verts: 3, norms: 3, uv-coords: 2, floats: 4 bit ct.c_void_p(6*4)) # Where (in bits) in each row does this attribute start?) GL.glEnableVertexAttribArray(2) # Enable VBO, assign it to VAO at location = 2 GL.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, self.iboID) # Select ibo GL.glDrawElements( GL.GL_TRIANGLES, self.nindices, GL.GL_UNSIGNED_INT, ct.c_void_p(0))
def map(self): try: gl.glBindBuffer(gl.GL_UNIFORM_BUFFER, self.ubo) self.vp = gl.glMapBuffer(gl.GL_UNIFORM_BUFFER, gl.GL_WRITE_ONLY) except Exception, e: print "ubo: %s" % str(self.ubo) raise
def draw(self, **frame_data): view = frame_data.get('view_matrix', None) projection = frame_data.get('projection_matrix', None) if self._before_draw: self._before_draw(self, frame_data) if view is not None: self.world_matrix.dot(view, out=self._modelview) self._normal[:] = np.linalg.inv(self._modelview[:3,:3].T) for material, prims in self.primitives.items(): material.use(u_view=view, u_projection=projection, u_modelview=self._modelview, u_modelview_inverse_transpose=self._normal, u_model=self.world_matrix, frame_data=frame_data) technique = material.technique for prim in prims: gl.glBindVertexArray(prim.vaos[technique]) gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, prim.index_buffer) gl.glDrawElements(prim.mode, prim.indices.size, DTYPE_COMPONENT_TYPE[prim.indices.dtype], c_void_p(0)) if CHECK_GL_ERRORS: err = gl.glGetError() if err != gl.GL_NO_ERROR: raise Exception('error drawing primitive elements: %d' % err) gl.glBindVertexArray(0) # for location in technique.attribute_locations.values(): # gl.glDisableVertexAttribArray(location) material.release() material.technique.release() if self._after_draw: self._after_draw(self, frame_data) super().draw(**frame_data)
def element_buffer(self, value): if value.dtype.base not in element_buffer_dtypes: raise ValueError("Invalid dtype for an element buffer") with self: GL.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, value.handle) GL.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, 0) self._element_buffer = value
def draw_text(self, text, color=(1.0, 1.0, 1.0, 0.0), view_matrix=None, projection_matrix=None): gl.glUseProgram(self._program_id) gl.glActiveTexture(gl.GL_TEXTURE0+0) gl.glBindTexture(gl.GL_TEXTURE_2D, self._texture_id) gl.glBindSampler(0, self._sampler_id) gl.glUniform1i(self._uniform_locations['u_fonttex'], 0) gl.glUniform4f(self._uniform_locations['u_color'], *color) if view_matrix is not None: self._matrix.dot(view_matrix, out=self._modelview_matrix) gl.glUniformMatrix4fv(self._uniform_locations['u_modelviewMatrix'], 1, False, self._modelview_matrix) if projection_matrix is not None: gl.glUniformMatrix4fv(self._uniform_locations['u_projectionMatrix'], 1, False, projection_matrix) gl.glEnableVertexAttribArray(0) gl.glEnableVertexAttribArray(1) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) x = 0.0 text = [ord(c) - 32 for c in text] for i in text: if i >= 0 and i < 95: gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self._buffer_ids[i]) gl.glVertexAttribPointer(0, 2, gl.GL_FLOAT, False, 0, c_void_p(0)) gl.glVertexAttribPointer(1, 2, gl.GL_FLOAT, False, 0, c_void_p(8*4)) gl.glUniform1f(self._uniform_locations['advance'], x) gl.glDrawArrays(gl.GL_TRIANGLE_STRIP, 0, 4) x += self._advance[i] gl.glDisableVertexAttribArray(0) gl.glDisableVertexAttribArray(1) gl.glDisable(gl.GL_BLEND)
def init_gl(self, force=False): if self._initialized and not force: return self._initialized = False for material, prims in self.primitives.items(): material.init_gl(force=force) technique = material.technique for prim in prims: prim.init_gl(force=force) if technique in prim.vaos: continue vao = gl.glGenVertexArrays(1) prim.vaos[technique] = vao gl.glBindVertexArray(vao) for attribute_name, location in technique.attribute_locations.items(): attribute = prim.attributes[attribute_name] gl.glEnableVertexAttribArray(location) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, prim.buffers[attribute_name]) gl.glVertexAttribPointer(location, attribute.shape[-1], DTYPE_COMPONENT_TYPE[attribute.dtype], False, attribute.dtype.itemsize * attribute.shape[-1], NULL_PTR) if attribute_name in technique.attribute_divisors: gl.glVertexAttribDivisor(location, technique.attribute_divisors[attribute_name]) gl.glBindVertexArray(0) for location in technique.attribute_locations.values(): gl.glDisableVertexAttribArray(location) err = gl.glGetError() if err != gl.GL_NO_ERROR: raise Exception('failed to init primitive: %s' % err) _logger.info('%s.init_gl: OK' % self.__class__.__name__) self._initialized = True
def display(): global phi, theta gl.glDepthMask(gl.GL_TRUE) gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) # Filled cube gl.glDisable(gl.GL_BLEND) gl.glEnable(gl.GL_DEPTH_TEST) gl.glEnable(gl.GL_POLYGON_OFFSET_FILL) gl.glUniform4f(gpu["uniform"]["u_color"], 1, 1, 1, 1) gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, gpu["buffer"]["filled"]) gl.glDrawElements(gl.GL_TRIANGLES, len(f_indices), gl.GL_UNSIGNED_INT, None) # Outlined cube gl.glDisable(gl.GL_POLYGON_OFFSET_FILL) gl.glEnable(gl.GL_BLEND) gl.glDepthMask(gl.GL_FALSE) gl.glUniform4f(gpu["uniform"]["u_color"], 0, 0, 0, 0.5) gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, gpu["buffer"]["outline"]) gl.glDrawElements(gl.GL_LINES, len(o_indices), gl.GL_UNSIGNED_INT, None) gl.glDepthMask(gl.GL_TRUE) # Rotate cube theta += 0.5 # degrees phi += 0.5 # degrees model = np.eye(4, dtype=np.float32) rotate(model, theta, 0, 0, 1) rotate(model, phi, 0, 1, 0) gl.glUniformMatrix4fv(gpu["uniform"]["u_model"], 1, False, model) glut.glutSwapBuffers()
def __init__(self, elements, indices): temp_list = [0] # noinspection PyCallingNonCallable self.vbo = (ctypes.c_uint32 * 1)(*temp_list) # noinspection PyCallingNonCallable self.ibo = (ctypes.c_uint32 * 1)(*temp_list) GL.glGenBuffers(1, self.vbo) GL.glBindBuffer(GL.GL_ARRAY_BUFFER, self.vbo) # noinspection PyCallingNonCallable GL.glBufferData( GL.GL_ARRAY_BUFFER, len(elements) * 4, (ctypes.c_float * len(elements))(*elements), GL.GL_STATIC_DRAW ) GL.glGenBuffers(1, self.ibo) GL.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, self.ibo) # noinspection PyCallingNonCallable GL.glBufferData( GL.GL_ELEMENT_ARRAY_BUFFER, len(indices) * 4, (ctypes.c_uint32 * len(indices))(*indices), GL.GL_STATIC_DRAW ) self.indices_number = ctypes.c_uint32(len(indices))
def setup_buffers(gltf, uri_path): buffers = gltf['buffers'] data_buffers = {} for buffer_name, buffer in buffers.items(): uri = buffer['uri'] if uri.startswith('data:application/octet-stream;base64,'): data_buffers[buffer_name] = base64.b64decode(uri.split(',')[1]) else: filename = os.path.join(uri_path, buffer['uri']) if buffer['type'] == 'arraybuffer': data_buffers[buffer_name] = open(filename, 'rb').read() elif buffer['type'] == 'text': raise Exception('TODO') #data_buffers[buffer_name] = open(filename, 'r').read() _logger.debug('* loaded buffer "%s" (from %s)', buffer_name, filename) for bufferView_name, bufferView in gltf['bufferViews'].items(): buffer_id = gl.glGenBuffers(1) #byteLength = bufferView['byteLength'] byteOffset = bufferView['byteOffset'] gl.glBindBuffer(bufferView['target'], buffer_id) gl.glBufferData(bufferView['target'], bufferView['byteLength'], data_buffers[bufferView['buffer']][byteOffset:], gl.GL_STATIC_DRAW) if gl.glGetError() != gl.GL_NO_ERROR: raise Exception('failed to create buffer "%s"' % bufferView_name) bufferView['id'] = buffer_id gl.glBindBuffer(bufferView['target'], 0) _logger.debug('* created buffer "%s"' % bufferView_name)
def main(): glfw.init() glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3) glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3) glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE) window = glfw.create_window(800, 600, "LearnOpenGL", None, None) if not window: print("Window Creation failed!") glfw.terminate() glfw.make_context_current(window) glfw.set_window_size_callback(window, on_resize) shader = Shader(CURDIR / 'shaders/4.1.texture.vs', CURDIR / 'shaders/4.1.texture.fs') shader_mix = Shader(CURDIR / 'shaders/4.1.texture.vs', CURDIR / 'shaders/4.1.texture_mix.fs') vertices = [ # positions colors tex_coords 0.5, 0.5, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, # top right 0.5, -0.5, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, # bottom right -0.5, -0.5, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, # bottom left -0.5, 0.5, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0, # top left ] vertices = (c_float * len(vertices))(*vertices) indices = [0, 1, 3, 1, 2, 3] indices = (c_uint * len(indices))(*indices) vao = gl.glGenVertexArrays(1) gl.glBindVertexArray(vao) vbo = gl.glGenBuffers(1) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vbo) gl.glBufferData(gl.GL_ARRAY_BUFFER, sizeof(vertices), vertices, gl.GL_STATIC_DRAW) ebo = gl.glGenBuffers(1) gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, ebo) gl.glBufferData(gl.GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, gl.GL_STATIC_DRAW) gl.glVertexAttribPointer(0, 3, gl.GL_FLOAT, gl.GL_FALSE, 8 * sizeof(c_float), c_void_p(0)) gl.glEnableVertexAttribArray(0) gl.glVertexAttribPointer(1, 3, gl.GL_FLOAT, gl.GL_FALSE, 8 * sizeof(c_float), c_void_p(3 * sizeof(c_float))) gl.glEnableVertexAttribArray(1) gl.glVertexAttribPointer(2, 2, gl.GL_FLOAT, gl.GL_FALSE, 8 * sizeof(c_float), c_void_p(6 * sizeof(c_float))) gl.glEnableVertexAttribArray(2) # -- load texture texture = gl.glGenTextures(1) gl.glBindTexture(gl.GL_TEXTURE_2D, texture) # -- texture wrapping gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_REPEAT) gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_REPEAT) # -- texture filterting gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR_MIPMAP_LINEAR) gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR) img = Image.open(Tex('container.jpg')) gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGB, img.width, img.height, 0, gl.GL_RGB, gl.GL_UNSIGNED_BYTE, img.tobytes()) gl.glGenerateMipmap(gl.GL_TEXTURE_2D) while not glfw.window_should_close(window): process_input(window) gl.glClearColor(.2, .3, .3, 1.0) gl.glClear(gl.GL_COLOR_BUFFER_BIT) gl.glBindTexture(gl.GL_TEXTURE_2D, texture) shader.use() # -- uncomment to see mixture of vertex color and texture color # shader_mix.use() gl.glBindVertexArray(vao) gl.glDrawElements(gl.GL_TRIANGLES, 6, gl.GL_UNSIGNED_INT, c_void_p(0)) glfw.poll_events() glfw.swap_buffers(window) gl.glDeleteVertexArrays(1, id(vao)) gl.glDeleteBuffers(1, id(vbo)) gl.glDeleteBuffers(1, id(ebo)) glfw.terminate()
def initialize(): global shaderProgram global VAO global idxCnt global texUnitUniform global sampleTexture vertexStaticShader = shaders.compileShader( """ #version 330 core layout (location=0) in vec3 position; layout (location=1) in vec3 aNormal; uniform mat4 rot; uniform mat4 translation; uniform mat4 projection; uniform mat4 view; out vec3 theCoords; out vec3 theNormal; void main() { vec4 world = translation*rot*vec4((1*position), 1); gl_Position = projection*view*world; theCoords = 0.5*(vec3(1,1,1)+1*position); theNormal = aNormal; } """, GL.GL_VERTEX_SHADER) fragmentShader = shaders.compileShader( """ #version 330 core uniform sampler3D texUnit; in vec3 theCoords; in vec3 theNormal; uniform vec3 lightPos; out vec4 outputColour; float ambientStrenght; float diff; vec3 lightColor; vec3 ambient; vec3 norm; vec3 lightDir; vec3 diffuse; void main() { // ambient lightColor = vec3(1, 1, 1); ambientStrenght = 1.0; ambient = ambientStrenght * lightColor; // diffusse norm = normalize(theNormal); lightDir = normalize(lightPos - theCoords); diff = max(dot(norm, lightDir), 0.0); diffuse = diff * lightColor; // out outputColour = vec4(diffuse+ambient, 1.0)*texture(texUnit, theCoords); } """, GL.GL_FRAGMENT_SHADER) vertexData = np.array([ 1.0, -1.0, -1.0, 0, -1, 0, 1.0, -1.0, 1.0, 0, -1, 0, -1.0, -1.0, 1.0, 0, -1, 0, -1.0, -1.0, -1.0, 0, -1, 0, 1.0, 1.0, -1.0, 0, 1, 0, 1.0, 1.0, 1.0, 0, 1, 0, -1.0, 1.0, 1.0, 0, 1, 0, -1.0, 1.0, -1.0, 0, 1, 0, 1.0, -1.0, -1.0, 1, 0, 0, 1.0, -1.0, 1.0, 1, 0, 0, 1.0, 1.0, -1.0, 1, 0, 0, 1.0, 1.0, 1.0, 1, 0, 0, 1.0, -1.0, -1.0, 0, 0, -1, -1.0, -1.0, -1.0, 0, 0, -1, 1.0, 1.0, -1.0, 0, 0, -1, -1.0, 1.0, -1.0, 0, 0, -1, -1.0, -1.0, 1.0, -1, 0, 0, -1.0, -1.0, -1.0, -1, 0, 0, -1.0, 1.0, 1.0, -1, 0, 0, -1.0, 1.0, -1.0, -1, 0, 0, 1.0, -1.0, 1.0, 0, 0, 1, -1.0, -1.0, 1.0, 0, 0, 1, 1.0, 1.0, 1.0, 0, 0, 1, -1.0, 1.0, 1.0, 0, 0, 1, ], dtype=np.float32) faceData = np.array([ 1, 3, 0, 7, 5, 4, 22, 21, 20, 10, 9, 8, 12, 15, 14, 16, 19, 17, 1, 2, 3, 7, 6, 5, 22, 23, 21, 10, 11, 9, 12, 13, 15, 16, 18, 19, ], dtype=np.uint32) idxCnt = faceData.shape[0] GL.glEnable(GL.GL_DEPTH_TEST) GL.glDepthFunc(GL.GL_LEQUAL) shaderProgram = shaders.compileProgram(vertexStaticShader, fragmentShader) GL.glDeleteShader(vertexStaticShader) GL.glDeleteShader(fragmentShader) VAO = GL.glGenVertexArrays(1) GL.glBindVertexArray(VAO) # Need VBO for triangle vertices coordinates VBO = GL.glGenBuffers(1) GL.glBindBuffer(GL.GL_ARRAY_BUFFER, VBO) GL.glBufferData(GL.GL_ARRAY_BUFFER, vertexData.nbytes, vertexData, GL.GL_STATIC_DRAW) GL.glEnableVertexAttribArray(0) GL.glVertexAttribPointer(0, 3, GL.GL_FLOAT, GL.GL_FALSE, stride, vertex_offset) GL.glVertexAttribPointer(1, 3, GL.GL_FLOAT, GL.GL_FALSE, stride, normal_offset) GL.glEnableVertexAttribArray(1) IBO = GL.glGenBuffers(1) GL.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, IBO) GL.glBufferData(GL.GL_ELEMENT_ARRAY_BUFFER, faceData.nbytes, faceData, GL.GL_STATIC_DRAW) # Finished GL.glBindBuffer(GL.GL_ARRAY_BUFFER, 0) GL.glBindVertexArray(0) GL.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, 0) GL.glBindBuffer(GL.GL_ARRAY_BUFFER, 0) GL.glBindVertexArray(0) GL.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, 0) # load texture and assign texture unit for shaders sampleTexture = loadTexture(texture) texUnitUniform = GL.glGetUniformLocation(shaderProgram, 'texUnit')
def main(): global delta_time, last_frame glfw.init() glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3) glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3) glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE) window = glfw.create_window(SRC_WIDTH, SRC_HEIGHT, "learnOpenGL", None, None) if not window: glfw.terminate() raise ValueError("Failed to create window") glfw.make_context_current(window) glfw.set_framebuffer_size_callback(window, framebuffer_size_callback) glfw.set_cursor_pos_callback(window, mouse_callback) glfw.set_scroll_callback(window, scroll_callback) glfw.set_input_mode(window, glfw.CURSOR, glfw.CURSOR_DISABLED) gl.glEnable(gl.GL_DEPTH_TEST) lamp_shader = Shader(CURDIR / "shaders/1.lamp.vs", CURDIR / "shaders/1.lamp.fs") lighting_shader = Shader(CURDIR / "shaders/5.1.light_casters.vs", CURDIR / "shaders/5.1.light_casters.fs") vertices = [ # positions normals texture coords -0.5, -0.5, -0.5, 0.0, 0.0, -1.0, 0.0, 0.0, 0.5, -0.5, -0.5, 0.0, 0.0, -1.0, 1.0, 0.0, 0.5, 0.5, -0.5, 0.0, 0.0, -1.0, 1.0, 1.0, 0.5, 0.5, -0.5, 0.0, 0.0, -1.0, 1.0, 1.0, -0.5, 0.5, -0.5, 0.0, 0.0, -1.0, 0.0, 1.0, -0.5, -0.5, -0.5, 0.0, 0.0, -1.0, 0.0, 0.0, -0.5, -0.5, 0.5, 0.0, 0.0, 1.0, 0.0, 0.0, 0.5, -0.5, 0.5, 0.0, 0.0, 1.0, 1.0, 0.0, 0.5, 0.5, 0.5, 0.0, 0.0, 1.0, 1.0, 1.0, 0.5, 0.5, 0.5, 0.0, 0.0, 1.0, 1.0, 1.0, -0.5, 0.5, 0.5, 0.0, 0.0, 1.0, 0.0, 1.0, -0.5, -0.5, 0.5, 0.0, 0.0, 1.0, 0.0, 0.0, -0.5, 0.5, 0.5, -1.0, 0.0, 0.0, 1.0, 0.0, -0.5, 0.5, -0.5, -1.0, 0.0, 0.0, 1.0, 1.0, -0.5, -0.5, -0.5, -1.0, 0.0, 0.0, 0.0, 1.0, -0.5, -0.5, -0.5, -1.0, 0.0, 0.0, 0.0, 1.0, -0.5, -0.5, 0.5, -1.0, 0.0, 0.0, 0.0, 0.0, -0.5, 0.5, 0.5, -1.0, 0.0, 0.0, 1.0, 0.0, 0.5, 0.5, 0.5, 1.0, 0.0, 0.0, 1.0, 0.0, 0.5, 0.5, -0.5, 1.0, 0.0, 0.0, 1.0, 1.0, 0.5, -0.5, -0.5, 1.0, 0.0, 0.0, 0.0, 1.0, 0.5, -0.5, -0.5, 1.0, 0.0, 0.0, 0.0, 1.0, 0.5, -0.5, 0.5, 1.0, 0.0, 0.0, 0.0, 0.0, 0.5, 0.5, 0.5, 1.0, 0.0, 0.0, 1.0, 0.0, -0.5, -0.5, -0.5, 0.0, -1.0, 0.0, 0.0, 1.0, 0.5, -0.5, -0.5, 0.0, -1.0, 0.0, 1.0, 1.0, 0.5, -0.5, 0.5, 0.0, -1.0, 0.0, 1.0, 0.0, 0.5, -0.5, 0.5, 0.0, -1.0, 0.0, 1.0, 0.0, -0.5, -0.5, 0.5, 0.0, -1.0, 0.0, 0.0, 0.0, -0.5, -0.5, -0.5, 0.0, -1.0, 0.0, 0.0, 1.0, -0.5, 0.5, -0.5, 0.0, 1.0, 0.0, 0.0, 1.0, 0.5, 0.5, -0.5, 0.0, 1.0, 0.0, 1.0, 1.0, 0.5, 0.5, 0.5, 0.0, 1.0, 0.0, 1.0, 0.0, 0.5, 0.5, 0.5, 0.0, 1.0, 0.0, 1.0, 0.0, -0.5, 0.5, 0.5, 0.0, 1.0, 0.0, 0.0, 0.0, -0.5, 0.5, -0.5, 0.0, 1.0, 0.0, 0.0, 1.0 ] vertices = (c_float * len(vertices))(*vertices) cube_positions = [(0.0, 0.0, 0.0), (2.0, 5.0, -15.0), (-1.5, -2.2, -2.5), (-3.8, -2.0, -12.3), (2.4, -0.4, -3.5), (-1.7, 3.0, -7.5), (1.3, -2.0, -2.5), (1.5, 2.0, -2.5), (1.5, 0.2, -1.5), (-1.3, 1.0, -1.5)] cube_vao = gl.glGenVertexArrays(1) vbo = gl.glGenBuffers(1) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vbo) gl.glBufferData(gl.GL_ARRAY_BUFFER, sizeof(vertices), vertices, gl.GL_STATIC_DRAW) gl.glBindVertexArray(cube_vao) # -- position attribute gl.glVertexAttribPointer(0, 3, gl.GL_FLOAT, gl.GL_FALSE, 8 * sizeof(c_float), c_void_p(0)) gl.glEnableVertexAttribArray(0) # -- normal attribute gl.glVertexAttribPointer(1, 3, gl.GL_FLOAT, gl.GL_FALSE, 8 * sizeof(c_float), c_void_p(3 * sizeof(c_float))) gl.glEnableVertexAttribArray(1) # -- texture coordinate gl.glVertexAttribPointer(2, 2, gl.GL_FLOAT, gl.GL_FALSE, 8 * sizeof(c_float), c_void_p(6 * sizeof(c_float))) gl.glEnableVertexAttribArray(2) # -- second configure light vao (vbo is the same) light_vao = gl.glGenVertexArrays(1) gl.glBindVertexArray(light_vao) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vbo) gl.glVertexAttribPointer(0, 3, gl.GL_FLOAT, gl.GL_FALSE, 8 * sizeof(c_float), c_void_p(0)) gl.glEnableVertexAttribArray(0) # -- load texture diffuse_map = load_texture("container2.png") specular_map = load_texture("container2_specular.png") # -- shader configuration lighting_shader.use() lighting_shader.set_int("material.diffuse", 0) lighting_shader.set_int("material.specular", 1) while not glfw.window_should_close(window): # -- time logic current_frame = glfw.get_time() delta_time = current_frame - last_frame last_frame = current_frame # -- input process_input(window) # -- render gl.glClearColor(0.1, 0.1, 0.1, 1.0) gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) lighting_shader.use() lighting_shader.set_vec3("light.direction", Vector3([-0.2, -1.0, -0.3])) lighting_shader.set_vec3("viewPos", camera.position) # -- light properties lighting_shader.set_vec3("light.ambient", Vector3([0.2, 0.2, 0.2])) lighting_shader.set_vec3("light.diffuse", Vector3([0.5, 0.5, 0.5])) lighting_shader.set_vec3("light.specular", Vector3([1.0, 1.0, 1.0])) # -- material properties lighting_shader.set_float("material.shininess", 32.0) # -- view.projection transformations projection = Matrix44.perspective_projection(camera.zoom, SRC_WIDTH / SRC_HEIGHT, 0.1, 100.0) view = camera.get_view_matrix() lighting_shader.set_mat4("projection", projection) lighting_shader.set_mat4("view", view) # -- world transformation model = Matrix44.identity() lighting_shader.set_mat4("model", model) # -- bind diffuse map gl.glActiveTexture(gl.GL_TEXTURE0) gl.glBindTexture(gl.GL_TEXTURE_2D, diffuse_map) # -- bind specular map gl.glActiveTexture(gl.GL_TEXTURE1) gl.glBindTexture(gl.GL_TEXTURE_2D, specular_map) # -- render cube # gl.glBindVertexArray(cube_vao) # gl.glDrawArrays(gl.GL_TRIANGLES, 0, 36) # -- render continers gl.glBindVertexArray(cube_vao) for idx, position in enumerate(cube_positions): angle = 20.0 * idx rotation = matrix44.create_from_axis_rotation([1.0, 0.3, 0.5], math.radians(angle)) translation = Matrix44.from_translation(position) model = translation * rotation lighting_shader.set_mat4('model', model) gl.glDrawArrays(gl.GL_TRIANGLES, 0, 36) # a lamp object is weird when we only have a directional light, don't render the light object # -- draw lamp object # lamp_shader.use() # lamp_shader.set_mat4("projection", projection) # lamp_shader.set_mat4("view", view) # model = Matrix44.identity() # model *= Matrix44.from_translation(light_pos) # model *= Matrix44.from_scale(Vector3([.2, .2, .2])) # lamp_shader.set_mat4("model", model) # gl.glBindVertexArray(light_vao) # gl.glDrawArrays(gl.GL_TRIANGLES, 0, 36) glfw.swap_buffers(window) glfw.poll_events() gl.glDeleteVertexArrays(1, id(cube_vao)) gl.glDeleteVertexArrays(1, id(light_vao)) gl.glDeleteBuffers(1, id(vbo)) glfw.terminate()
def draw_vbo(self): gl.glEnableClientState(gl.GL_VERTEX_ARRAY) gl.glEnableClientState(gl.GL_COLOR_ARRAY) gl.glColorMaterial(gl.GL_FRONT_AND_BACK, gl.GL_DIFFUSE) gl.glEnable(gl.GL_COLOR_MATERIAL) # bind color buffer gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, self.buffers[2]) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.buffers[1]) gl.glColorPointer(3, gl.GL_FLOAT, 0, None) # bind vertex buffer - cylinder # stride is one vertex gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, self.buffers[2]) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.buffers[0]) gl.glVertexPointer(3, gl.GL_FLOAT, 3 * self.__FLOAT_BYTE_SIZE__, None) gl.glDrawElements(gl.GL_TRIANGLES, len(self.indices), gl.GL_UNSIGNED_INT, None) gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, self.buffers[2]) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.buffers[0]) gl.glVertexPointer(3, gl.GL_FLOAT, 3 * self.__FLOAT_BYTE_SIZE__, c_void_p(4 * 3)) gl.glDrawElements(gl.GL_TRIANGLES, len(self.indices), gl.GL_UNSIGNED_INT, None) gl.glDisableClientState(gl.GL_COLOR_ARRAY) gl.glDisableClientState(gl.GL_VERTEX_ARRAY)
def initialize(): global shaderProgram global VAO global VBO vertexShader = shaders.compileShader( """ #version 330 layout (location=0) in vec4 position; layout (location=1) in vec4 colour; smooth out vec4 theColour; void main() { gl_Position = position; theColour = colour; } """, GL.GL_VERTEX_SHADER) fragmentShader = shaders.compileShader( """ #version 330 smooth in vec4 theColour; out vec4 outputColour; void main() { outputColour = theColour; } """, GL.GL_FRAGMENT_SHADER) shaderProgram = shaders.compileProgram(vertexShader, fragmentShader) vertexData = numpy.array( [ # Vertex Positions 0.0, 0.5, 0.0, 1.0, 0.5, -0.366, 0.0, 1.0, -0.5, -0.366, 0.0, 1.0, # Vertex Colours 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, ], dtype=numpy.float32) # Core OpenGL requires that at least one OpenGL vertex array be bound VAO = GL.glGenVertexArrays(1) GL.glBindVertexArray(VAO) # Need VBO for triangle vertices and colours VBO = GL.glGenBuffers(1) GL.glBindBuffer(GL.GL_ARRAY_BUFFER, VBO) GL.glBufferData(GL.GL_ARRAY_BUFFER, vertexData.nbytes, vertexData, GL.GL_STATIC_DRAW) # enable array and set up data GL.glEnableVertexAttribArray(0) GL.glEnableVertexAttribArray(1) GL.glVertexAttribPointer(0, 4, GL.GL_FLOAT, GL.GL_FALSE, 0, None) # the last parameter is a pointer GL.glVertexAttribPointer(1, 4, GL.GL_FLOAT, GL.GL_FALSE, 0, ctypes.c_void_p(48)) GL.glBindBuffer(GL.GL_ARRAY_BUFFER, 0) GL.glBindVertexArray(0)
def _deactivate(self): """ Unbind the current bound buffer """ log("GPU: Deactivating buffer") gl.glBindBuffer(self._target, 0)
def _activate(self): """ Bind the buffer to some target """ log("GPU: Activating buffer") gl.glBindBuffer(self._target, self._handle)
def main(): glfw.init() glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3) glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3) glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE) window = glfw.create_window(width, height, "LearnOpenGL", None, None) if not window: print("Window Creation failed!") glfw.terminate() glfw.make_context_current(window) glfw.set_window_size_callback(window, on_resize) gl.glEnable(gl.GL_DEPTH_TEST) shader = Shader(CURDIR / 'shaders/6.1.coordinate_systems.vs', CURDIR / 'shaders/6.1.coordinate_systems.fs') vertices = [ # positions tex_coords -0.5, -0.5, -0.5, 0.0, 0.0, 0.5, -0.5, -0.5, 1.0, 0.0, 0.5, 0.5, -0.5, 1.0, 1.0, 0.5, 0.5, -0.5, 1.0, 1.0, -0.5, 0.5, -0.5, 0.0, 1.0, -0.5, -0.5, -0.5, 0.0, 0.0, -0.5, -0.5, 0.5, 0.0, 0.0, 0.5, -0.5, 0.5, 1.0, 0.0, 0.5, 0.5, 0.5, 1.0, 1.0, 0.5, 0.5, 0.5, 1.0, 1.0, -0.5, 0.5, 0.5, 0.0, 1.0, -0.5, -0.5, 0.5, 0.0, 0.0, -0.5, 0.5, 0.5, 1.0, 0.0, -0.5, 0.5, -0.5, 1.0, 1.0, -0.5, -0.5, -0.5, 0.0, 1.0, -0.5, -0.5, -0.5, 0.0, 1.0, -0.5, -0.5, 0.5, 0.0, 0.0, -0.5, 0.5, 0.5, 1.0, 0.0, 0.5, 0.5, 0.5, 1.0, 0.0, 0.5, 0.5, -0.5, 1.0, 1.0, 0.5, -0.5, -0.5, 0.0, 1.0, 0.5, -0.5, -0.5, 0.0, 1.0, 0.5, -0.5, 0.5, 0.0, 0.0, 0.5, 0.5, 0.5, 1.0, 0.0, -0.5, -0.5, -0.5, 0.0, 1.0, 0.5, -0.5, -0.5, 1.0, 1.0, 0.5, -0.5, 0.5, 1.0, 0.0, 0.5, -0.5, 0.5, 1.0, 0.0, -0.5, -0.5, 0.5, 0.0, 0.0, -0.5, -0.5, -0.5, 0.0, 1.0, -0.5, 0.5, -0.5, 0.0, 1.0, 0.5, 0.5, -0.5, 1.0, 1.0, 0.5, 0.5, 0.5, 1.0, 0.0, 0.5, 0.5, 0.5, 1.0, 0.0, -0.5, 0.5, 0.5, 0.0, 0.0, -0.5, 0.5, -0.5, 0.0, 1.0 ] vertices = (c_float * len(vertices))(*vertices) vao = gl.glGenVertexArrays(1) gl.glBindVertexArray(vao) vbo = gl.glGenBuffers(1) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vbo) gl.glBufferData(gl.GL_ARRAY_BUFFER, sizeof(vertices), vertices, gl.GL_STATIC_DRAW) gl.glVertexAttribPointer(0, 3, gl.GL_FLOAT, gl.GL_FALSE, 5 * sizeof(c_float), c_void_p(0)) gl.glEnableVertexAttribArray(0) gl.glVertexAttribPointer(1, 2, gl.GL_FLOAT, gl.GL_FALSE, 5 * sizeof(c_float), c_void_p(3 * sizeof(c_float))) gl.glEnableVertexAttribArray(1) # -- load texture 1 texture1 = gl.glGenTextures(1) gl.glBindTexture(gl.GL_TEXTURE_2D, texture1) # -- texture wrapping gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_REPEAT) gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_REPEAT) # -- texture filterting 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) img = Image.open(Tex('container.jpg')).transpose(Image.FLIP_TOP_BOTTOM) gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGB, img.width, img.height, 0, gl.GL_RGB, gl.GL_UNSIGNED_BYTE, img.tobytes()) gl.glGenerateMipmap(gl.GL_TEXTURE_2D) # -- load texture 2 texture2 = gl.glGenTextures(1) gl.glBindTexture(gl.GL_TEXTURE_2D, texture2) # -- texture wrapping gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_REPEAT) gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_REPEAT) # -- texture filterting 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) img = Image.open(Tex('awesomeface.png')).transpose(Image.FLIP_TOP_BOTTOM) gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGB, img.width, img.height, 0, gl.GL_RGBA, gl.GL_UNSIGNED_BYTE, img.tobytes()) gl.glGenerateMipmap(gl.GL_TEXTURE_2D) shader.use() shader.set_int("texture1", 0) shader.set_int("texture2", 1) while not glfw.window_should_close(window): process_input(window) gl.glClearColor(.2, .3, .3, 1.0) gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) gl.glActiveTexture(gl.GL_TEXTURE0) gl.glBindTexture(gl.GL_TEXTURE_2D, texture1) gl.glActiveTexture(gl.GL_TEXTURE1) gl.glBindTexture(gl.GL_TEXTURE_2D, texture2) shader.use() model = Matrix44.from_x_rotation( glfw.get_time() * 0.5) * Matrix44.from_y_rotation(glfw.get_time()) view = Matrix44.from_translation([0, 0, -3]) projection = Matrix44.perspective_projection(45, width / height, 0.1, 100.0) shader.set_mat4('view', view) shader.set_mat4('model', model) shader.set_mat4('projection', projection) gl.glBindVertexArray(vao) gl.glDrawArrays(gl.GL_TRIANGLES, 0, 36) glfw.poll_events() glfw.swap_buffers(window) gl.glDeleteVertexArrays(1, id(vao)) gl.glDeleteBuffers(1, id(vbo)) glfw.terminate()
def init_target() -> RenderTarget: # pragma: no cover # Setting up VAO vao = gl.glGenVertexArrays(1) gl.glBindVertexArray(vao) # Quad vertex buffer vbo = gl.glGenBuffers(1) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vbo) gl.glBufferData(gl.GL_ARRAY_BUFFER, QUAD_VERTS.nbytes, QUAD_VERTS, gl.GL_DYNAMIC_DRAW) gl.glEnableVertexAttribArray(0) gl.glVertexAttribPointer(0, 2, gl.GL_FLOAT, gl.GL_FALSE, 0, None) # Finish setting up VAO gl.glBindVertexArray(0) # Quad index buffer ebo = gl.glGenBuffers(1) gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, ebo) gl.glBufferData(gl.GL_ELEMENT_ARRAY_BUFFER, QUAD_IDX.nbytes, QUAD_IDX, gl.GL_STATIC_DRAW) # Regions data world_ssbo = gl.glGenBuffers(1) # Create shaders vs_src, fs_src = __load_shaders() vs = shaders.compileShader(vs_src, gl.GL_VERTEX_SHADER) fs = shaders.compileShader(fs_src, gl.GL_FRAGMENT_SHADER) program = shaders.compileProgram(vs, fs) # Create target texture render_texture = gl.glGenTextures(1) gl.glBindTexture(gl.GL_TEXTURE_2D, render_texture) gl.glTexImage2D( gl.GL_TEXTURE_2D, 0, # level gl.GL_RGBA, # internalFormat 1, # width 1, # height 0, # border gl.GL_RGBA, # format gl.GL_FLOAT, # type None # data ) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_NEAREST) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_NEAREST) # Create target framebuffer # Create target framebuffer render_fbo = gl.glGenFramebuffers(1) gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, render_fbo) gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0, gl.GL_TEXTURE_2D, render_texture, 0) _validate_fbo_complete() gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0) return RenderTarget( vao=vao, vbo=vbo, ebo=ebo, world_ssbo=world_ssbo, vertex_shader=vs, fragment_shader=fs, program=program, indices=np.copy(QUAD_IDX), render_fbo=render_fbo, render_texture=render_texture, )
def initialize(self): vertices = np.array( [ 0.5, 0.5, 0.0, 1.0, 0.0, 0.0, 0.55, 0.55, # top right 0.5, -0.5, 0.0, 0.0, 1.0, 0.0, 0.55, 0.45, # bottom right -0.5, -0.5, 0.0, 0.0, 0.0, 1.0, 0.45, 0.45, # bottom left -0.5, 0.5, 0.0, 1.0, 1.0, 0.0, 0.45, 0.55 # top left ], dtype=np.float32) indices = np.array([0, 1, 3, 1, 2, 3], dtype=np.uint32) self._vao = GL.glGenVertexArrays(1) GL.glBindVertexArray(self._vao) vbo = GL.glGenBuffers(1) GL.glBindBuffer(GL.GL_ARRAY_BUFFER, vbo) GL.glBufferData(GL.GL_ARRAY_BUFFER, vertices, GL.GL_STATIC_DRAW) float_size = ctypes.sizeof(ctypes.c_float) GL.glVertexAttribPointer(0, 3, GL.GL_FLOAT, GL.GL_FALSE, 8 * float_size, ctypes.c_void_p(0)) GL.glEnableVertexAttribArray(0) GL.glVertexAttribPointer(1, 3, GL.GL_FLOAT, GL.GL_FALSE, 8 * float_size, ctypes.c_void_p(3 * float_size)) GL.glEnableVertexAttribArray(1) GL.glVertexAttribPointer(2, 2, GL.GL_FLOAT, GL.GL_FALSE, 8 * float_size, ctypes.c_void_p(6 * float_size)) GL.glEnableVertexAttribArray(2) ebo = GL.glGenBuffers(1) GL.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, ebo) GL.glBufferData(GL.GL_ELEMENT_ARRAY_BUFFER, indices, GL.GL_STATIC_DRAW) GL.glBindVertexArray(0) self._texture = Texture2D("awesomeface.png", flip_y=True, wrap_s=GL.GL_REPEAT, wrap_t=GL.GL_REPEAT, min_filter=GL.GL_NEAREST, mag_filter=GL.GL_NEAREST) vertex_shader = Shader(GL.GL_VERTEX_SHADER, "shaders_src/textures_vertex.glsl") fragment_shader = Shader(GL.GL_FRAGMENT_SHADER, "shaders_src/textures_frag.glsl") self._shader_program = ShaderProgram(vertex_shader, fragment_shader) vertex_shader.delete() fragment_shader.delete()
def main(): glfw.init() glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3) glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3) glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE) window = glfw.create_window(800, 600, "LearnOpenGL", None, None) if not window: print("Window Creation failed!") glfw.terminate() glfw.make_context_current(window) glfw.set_window_size_callback(window, on_resize) shader = Shader(CURDIR / 'shaders/5.1.transform.vs', CURDIR / 'shaders/5.1.transform.fs') vertices = [ # positions tex_coords 0.5, 0.5, 0.0, 1.0, 1.0, # top right 0.5, -0.5, 0.0, 1.0, 0.0, # bottom right -0.5, -0.5, 0.0, 0.0, 0.0, # bottom left -0.5, 0.5, 0.0, 0.0, 1.0, # top left ] vertices = (c_float * len(vertices))(*vertices) indices = [ 0, 1, 3, 1, 2, 3 ] indices = (c_uint * len(indices))(*indices) vao = gl.glGenVertexArrays(1) gl.glBindVertexArray(vao) vbo = gl.glGenBuffers(1) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vbo) gl.glBufferData(gl.GL_ARRAY_BUFFER, sizeof(vertices), vertices, gl.GL_STATIC_DRAW) ebo = gl.glGenBuffers(1) gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, ebo) gl.glBufferData(gl.GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, gl.GL_STATIC_DRAW) gl.glVertexAttribPointer(0, 3, gl.GL_FLOAT, gl.GL_FALSE, 5 * sizeof(c_float), c_void_p(0)) gl.glEnableVertexAttribArray(0) gl.glVertexAttribPointer(1, 2, gl.GL_FLOAT, gl.GL_FALSE, 5 * sizeof(c_float), c_void_p(3 * sizeof(c_float))) gl.glEnableVertexAttribArray(1) # -- load texture 1 texture1 = gl.glGenTextures(1) gl.glBindTexture(gl.GL_TEXTURE_2D, texture1) # -- texture wrapping gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_REPEAT) gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_REPEAT) # -- texture filterting 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) img = Image.open(Tex('container.jpg')).transpose(Image.FLIP_TOP_BOTTOM) gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGB, img.width, img.height, 0, gl.GL_RGB, gl.GL_UNSIGNED_BYTE, img.tobytes()) gl.glGenerateMipmap(gl.GL_TEXTURE_2D) # -- load texture 2 texture2 = gl.glGenTextures(1) gl.glBindTexture(gl.GL_TEXTURE_2D, texture2) # -- texture wrapping gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_REPEAT) gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_REPEAT) # -- texture filterting 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) img = Image.open(Tex('awesomeface.png')).transpose(Image.FLIP_TOP_BOTTOM) gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGB, img.width, img.height, 0, gl.GL_RGBA, gl.GL_UNSIGNED_BYTE, img.tobytes()) gl.glGenerateMipmap(gl.GL_TEXTURE_2D) shader.use() shader.set_int("texture1", 0) shader.set_int("texture2", 1) while not glfw.window_should_close(window): process_input(window) gl.glClearColor(.2, .3, .3, 1.0) gl.glClear(gl.GL_COLOR_BUFFER_BIT) gl.glActiveTexture(gl.GL_TEXTURE0) gl.glBindTexture(gl.GL_TEXTURE_2D, texture1) gl.glActiveTexture(gl.GL_TEXTURE1) gl.glBindTexture(gl.GL_TEXTURE_2D, texture2) translation = Matrix44.from_translation([0.5, -0.5, 0.0]) rotation = Matrix44.from_z_rotation(glfw.get_time()) transform = translation * rotation shader.use() shader.set_mat4('transform', transform) gl.glBindVertexArray(vao) gl.glDrawElements(gl.GL_TRIANGLES, 6, gl.GL_UNSIGNED_INT, c_void_p(0)) # -- second container translation = Matrix44.from_translation([-0.5, 0.5, 0.0]) scale = Matrix44.from_scale([math.sin(glfw.get_time())]*3) transform = translation * scale shader.set_mat4('transform', transform) gl.glDrawElements(gl.GL_TRIANGLES, 6, gl.GL_UNSIGNED_INT, c_void_p(0)) glfw.poll_events() glfw.swap_buffers(window) gl.glDeleteVertexArrays(1, id(vao)) gl.glDeleteBuffers(1, id(vbo)) gl.glDeleteBuffers(1, id(ebo)) glfw.terminate()
def __init__(self, vec1:mmath.Vec3, vec2:mmath.Vec3, vec3:mmath.Vec3, vec4:mmath.Vec3, vec5:mmath.Vec3, vec6:mmath.Vec3, vec7:mmath.Vec3, vec8:mmath.Vec3, textureId:int, textureVerNum_f:float, textureHorNum_f:float, shininess:float, specularStrength:float, startPos_l:list): super().__init__() self.renderFlag = True self.vertices_l = [vec1, vec2, vec3, vec4, vec5, vec6, vec7, vec8] self.textureId = textureId self.textureVerNum_f = float(textureVerNum_f) self.textureHorNum_f = float(textureHorNum_f) self.shininess_f = float(shininess) self.specularStrength_f = float(specularStrength) self.pos_l = startPos_l self.selectedTexId = self.textureId self.textureId2 = None self.collideModels_l.append( co.AabbActor(vec3, vec5, self) ) #self.collideModels_l.append() #### #### self.vao = gl.glGenVertexArrays(1) gl.glBindVertexArray(self.vao) vertices = np.array([*vec1.getXYZ(), *vec2.getXYZ(), *vec3.getXYZ(), *vec1.getXYZ(), *vec3.getXYZ(), *vec4.getXYZ(), *vec2.getXYZ(), *vec6.getXYZ(), *vec7.getXYZ(), *vec2.getXYZ(), *vec7.getXYZ(), *vec3.getXYZ(), *vec3.getXYZ(), *vec7.getXYZ(), *vec8.getXYZ(), *vec3.getXYZ(), *vec8.getXYZ(), *vec4.getXYZ(), *vec4.getXYZ(), *vec8.getXYZ(), *vec5.getXYZ(), *vec4.getXYZ(), *vec5.getXYZ(), *vec1.getXYZ(), *vec1.getXYZ(), *vec5.getXYZ(), *vec6.getXYZ(), *vec1.getXYZ(), *vec6.getXYZ(), *vec2.getXYZ(), *vec8.getXYZ(), *vec7.getXYZ(), *vec6.getXYZ(), *vec8.getXYZ(), *vec6.getXYZ(), *vec5.getXYZ()], dtype=np.float32) size = vertices.size * vertices.itemsize self.vertexSize_i = vertices.size self.verticesBuffer = gl.glGenBuffers(1) # Create a buffer. gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.verticesBuffer) # Bind the buffer. gl.glBufferData(gl.GL_ARRAY_BUFFER, size, vertices, gl.GL_STATIC_DRAW) # Allocate memory. gl.glVertexAttribPointer(0, 3, gl.GL_FLOAT, gl.GL_FALSE, 0, None) # Defines vertex attributes. What are those? gl.glEnableVertexAttribArray(0) #### Texture Coord #### textureCoords = np.array([0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1], dtype=np.float32) size = textureCoords.size * textureCoords.itemsize self.texCoordBuffer = gl.glGenBuffers(1) # Create a buffer. gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.texCoordBuffer) # Bind the buffer. gl.glBufferData(gl.GL_ARRAY_BUFFER, size, textureCoords, gl.GL_STATIC_DRAW) # Allocate memory. gl.glVertexAttribPointer(1, 2, gl.GL_FLOAT, gl.GL_FALSE, 0, None) # Defines vertex attributes. What are those? gl.glEnableVertexAttribArray(1)
def update_buffer(buf_id, data, offset=0, target=gl.GL_ARRAY_BUFFER): gl.glBindBuffer(target, buf_id) gl.glBufferSubData(target, offset, data.nbytes, data)
def _update_region_sub_data(self, region_idx: int, region_data: bytes): gl.glBindBuffer(gl.GL_SHADER_STORAGE_BUFFER, self.target.world_ssbo) gl.glBufferSubData(gl.GL_SHADER_STORAGE_BUFFER, offset=region_idx * REGION_SIZE, data=region_data)
def unbind_all(): gl.glBindVertexArray(0) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, 0) RenderObject.bound_vao = -1
def update(self, offset=0, size=None): if size is None: size = self.nbytes gl.glBindBuffer(gl.GL_UNIFORM_BUFFER, self.ubo) gl.glBufferSubData(gl.GL_UNIFORM_BUFFER, offset, size, pointer(self.data))
# Get rid of shaders (no more needed) gl.glDetachShader(program, vertex) gl.glDetachShader(program, fragment) # Make program the default program gl.glUseProgram(program) # Build buffer # -------------------------------------- # Request a buffer slot from GPU buffer = gl.glGenBuffers(1) # Make this buffer the default one gl.glBindBuffer(gl.GL_ARRAY_BUFFER, buffer) # Upload data gl.glBufferData(gl.GL_ARRAY_BUFFER, data.nbytes, data, gl.GL_DYNAMIC_DRAW) # Bind the position attribute # -------------------------------------- stride = data.strides[0] offset = ctypes.c_void_p(0) loc = gl.glGetAttribLocation(program, "position") gl.glEnableVertexAttribArray(loc) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, buffer) gl.glVertexAttribPointer(loc, 2, gl.GL_FLOAT, False, stride, offset) # Upload the uniform color # --------------------------------------
def create_empty_buffer(size, target=gl.GL_ARRAY_BUFFER, usage=gl.GL_STATIC_DRAW): buf_id = gl.glGenBuffers(1) gl.glBindBuffer(target, buf_id) gl.glBufferData(target, size, None, usage) return buf_id
def _init_buffers(self, vertices, normals, _): # prepare data for the gpu gpu_data = np.array(vertices + normals, dtype=np.float32) # create VBOs self.vbos = list(GL.glGenBuffers(3)) # init VBO 0 - static mesh data GL.glBindBuffer(GL.GL_ARRAY_BUFFER, self.vbos[0]) loc = self.get_attribute_location("position") GL.glEnableVertexAttribArray(loc) GL.glVertexAttribPointer(loc, 3, GL.GL_FLOAT, GL.GL_FALSE, 0, ctypes.c_void_p(0)) loc = self.get_attribute_location("normal") GL.glEnableVertexAttribArray(loc) GL.glVertexAttribPointer(loc, 3, GL.GL_FLOAT, GL.GL_FALSE, 0, ctypes.c_void_p(self.size * 12)) GL.glBufferData(GL.GL_ARRAY_BUFFER, 12 * len(gpu_data), gpu_data, GL.GL_STATIC_DRAW) GL.glBindBuffer(GL.GL_ARRAY_BUFFER, 0) # init VBO 1 - dynamic offset data GL.glBindBuffer(GL.GL_ARRAY_BUFFER, self.vbos[1]) loc = self.get_attribute_location("offset") GL.glEnableVertexAttribArray(loc) GL.glVertexAttribPointer(loc, 3, GL.GL_FLOAT, GL.GL_FALSE, 0, ctypes.c_void_p(0)) GL.glVertexAttribDivisor(loc, 1) GL.glBufferData(GL.GL_ARRAY_BUFFER, 0, np.array([], dtype=np.float32), GL.GL_DYNAMIC_DRAW) GL.glBindBuffer(GL.GL_ARRAY_BUFFER, 0) # init VBO 2 - dynamic color data GL.glBindBuffer(GL.GL_ARRAY_BUFFER, self.vbos[2]) loc = self.get_attribute_location("color") GL.glEnableVertexAttribArray(loc) GL.glVertexAttribPointer(loc, 4, GL.GL_FLOAT, GL.GL_FALSE, 0, ctypes.c_void_p(0)) GL.glVertexAttribDivisor(loc, 1) GL.glBufferData(GL.GL_ARRAY_BUFFER, 0, np.array([], dtype=np.float32), GL.GL_DYNAMIC_DRAW) GL.glBindBuffer(GL.GL_ARRAY_BUFFER, 0)
def main(): # declare draw method so it can be reused during resizing def draw(): gl.glClearColor(0.2, 0.3, 0.3, 1.0) gl.glClear(gl.GL_COLOR_BUFFER_BIT) gl.glUseProgram(shaderProgram) gl.glBindVertexArray(VAO) gl.glDrawElements(gl.GL_TRIANGLES, 3 * indices.shape[0], gl.GL_UNSIGNED_INT, None) gl.glBindVertexArray(0) glfw.swap_buffers(window) # declaring resize callback in main to allow access to variables def window_size_callback(window, width, height): gl.glViewport(0, 0, width, height) # calling draw to allow drawing while resizing draw() # glfw: initialize and configure glfw.init() glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3) glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3) glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE) # No deprecated functions glfw.window_hint(glfw.RESIZABLE, gl.GL_TRUE) # checking if run on Mac OS X if sys.platform == 'darwin': glfw.window_hint(glfw.OPENGL_FORWARD_COMPAT, gl.GL_TRUE) # glfw window creation window = glfw.create_window(WIDTH, HEIGHT, 'LearnOpenGL', None, None) # tutorial: (800, 600... if window is None: glfw.terminate() raise Exception("ERROR: Failed to create GLFW window") glfw.make_context_current(window) glfw.set_key_callback(window, key_callback) width, height = glfw.get_framebuffer_size(window) glfw.set_window_size_callback(window, window_size_callback) # build and compile shader program # vertex shader vertexShader = gl.glCreateShader(gl.GL_VERTEX_SHADER) gl.glShaderSource(vertexShader, vertexShaderSource) gl.glCompileShader(vertexShader) if not gl.glGetShaderiv(vertexShader, gl.GL_COMPILE_STATUS): infoLog = gl.glGetShaderInfoLog(vertexShader).decode() raise Exception("ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" + infoLog) # fragment shader fragmentShader = gl.glCreateShader(gl.GL_FRAGMENT_SHADER) gl.glShaderSource(fragmentShader, fragmentShaderSource) gl.glCompileShader(fragmentShader) if not gl.glGetShaderiv(fragmentShader, gl.GL_COMPILE_STATUS): infoLog = gl.glGetShaderInfoLog(fragmentShader).decode() raise Exception("ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n" + infoLog) # link shaders shaderProgram = gl.glCreateProgram() gl.glAttachShader(shaderProgram, vertexShader) gl.glAttachShader(shaderProgram, fragmentShader) gl.glLinkProgram(shaderProgram) if not gl.glGetProgramiv(shaderProgram, gl.GL_LINK_STATUS): infoLog = gl.glGetProgramInfoLog(shaderProgram).decode() raise Exception("ERROR::SHADER::PROGRAM::LINKING_FAILED\n" + infoLog) gl.glDeleteShader(vertexShader) gl.glDeleteShader(fragmentShader) # set up vertex data (and buffer(s)) and configure vertex attributes vertices = np.array( [ [0.5, 0.5, 0.0], # Left [0.5, -0.5, 0.0], # Right [-0.5, -0.5, 0.0], [-0.5, 0.5, 0.0], [1.0, -0.5, 0.0] ], # Top dtype=np.float32) indices = np.array( [ [3, 2, 1], # first triangle [0, 1, 4] ], # second triangle dtype=np.int32) VBO, VAO, EBO = gl.GLuint(), gl.GLuint(), gl.GLuint() gl.glGenVertexArrays(1, VAO) # 1 -> 1 buffer to be generated gl.glGenBuffers(1, VBO) gl.glGenBuffers(1, EBO) # bind the Vertex Array Object first, then bind and set vertex buffer(s), and then configure vertex attributes(s) gl.glBindVertexArray(VAO) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, VBO) # bind = make active/current for subsequent ops gl.glBufferData(gl.GL_ARRAY_BUFFER, vertices, gl.GL_STATIC_DRAW) gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, EBO) gl.glBufferData(gl.GL_ELEMENT_ARRAY_BUFFER, indices, gl.GL_STATIC_DRAW) stride = vertices.itemsize * vertices.shape[1] offset = gl.ctypes.c_void_p(vertices.itemsize * 0) gl.glVertexAttribPointer(0, 3, gl.GL_FLOAT, gl.GL_FALSE, stride, offset) gl.glEnableVertexAttribArray(0) # location = 0 gl.glBindBuffer(gl.GL_ARRAY_BUFFER, 0) gl.glBindVertexArray(0) # to put in wireframe mode # gl.glPolygonMode(gl.GL_FRONT_AND_BACK, gl.GL_LINE) # render loop while not glfw.window_should_close(window): glfw.poll_events() draw() glfw.terminate() return 0
def load_gltf(filepath, opt_input_flags: List[str] = ()) -> List[Entity]: obj = glb_object(filepath) # if not len(obj.meshes) == 1: # raise Exception("only 1 mesh") # if not len(obj.meshes[0].primitives) == 1: # raise Exception("only 1 primitive") # initialize gltf stuff blob = np.frombuffer(obj.binary_blob(), dtype='uint8') obj.destroy_binary_blob() buffers = UnboundBufferCollection() for i in range(len(obj.bufferViews)): buffer_view = obj.bufferViews[i] data_slice = blob[buffer_view.byteOffset:buffer_view.byteOffset + buffer_view.byteLength] buffers.add_buffer(UnboundBuffer(buffer_view, data_slice, index=i)) def get_texture(index) -> TextureUnit: tex = obj.textures[index] img = obj.images[tex.source] data = buffers[img.bufferView].data if tex.sampler is not None: sampler = clean_sampler(obj.samplers[tex.sampler]) else: sampler = get_default_sampler() return load_gltf_image(img, data, sampler) materials = [] for material in obj.materials: mat = Material.from_gltf_material(material) if not material.alphaMode == 'OPAQUE': raise Exception( "Special case! Discard model, and find the nearest exit.") color = material.pbrMetallicRoughness.baseColorTexture normal = material.normalTexture metallic = material.pbrMetallicRoughness.metallicRoughnessTexture if color is not None: mat.set_texture(get_texture(color.index), MaterialTexture.COLOR) if normal is not None: mat.set_texture(get_texture(normal.index), MaterialTexture.NORMAL) if metallic is not None: mat.set_texture(get_texture(metallic.index), MaterialTexture.METALLIC) # add extras just in case for prop, value in material.extras.items(): if value == 'flag': mat.add_flag(prop) else: mat.set_property(prop, value) for f in opt_input_flags: mat.add_flag(f) if mat.has_flag('reflective'): mat.add_fbo_texture(fbos.find_fbo_by_type(FBO.REFLECTION), GL.GL_COLOR_ATTACHMENT0) materials.append(mat) # for each primitive in each mesh . . . entities: List[Entity] = [] for n in obj.nodes: if n.mesh is None: continue ent = Entity(n.name) # do the mesh, using only the first primitive mesh = Mesh() mesh.bind_vao() gltf_mesh = obj.meshes[n.mesh] primitive = gltf_mesh.primitives[0] index_acc = obj.accessors[ primitive.indices] if primitive.indices is not None else None if index_acc is not None: mesh.element = True mesh.elementInfo = index_acc index_buff: UnboundBuffer = buffers[index_acc.bufferView] index_buff.optional_binder()(GL.GL_ELEMENT_ARRAY_BUFFER) mesh.elementBufID = index_buff.buffer_id # do materials # todo: create materials, then apply to meshes mesh.material = None materialIdx = gltf_mesh.primitives[0].material if materialIdx is not None: mesh.material = copy.deepcopy(materials[materialIdx]) if len(mesh.material.get_all_mat_textures()) == 0 or ( primitive.attributes.TEXCOORD_0 is None and primitive.attributes.TEXCOORD_1 is None): if primitive.attributes.COLOR_0 is not None: mesh.material.add_flag('useVertexColor') mesh.find_shader('flat_shaded') print('using a flat shader for material %s' % mesh.material.name) else: mesh.find_shader('default') # print('using default shader for material %s'%mesh.material.name) else: mesh.set_shader(shaders.get_default_program()) mesh.material = mesh.program.create_material() print('WARNING: you used a default program!') # do vbos attrs = 'COLOR_0,JOINTS_0,NORMAL,POSITION,TANGENT,TEXCOORD_0,TEXCOORD_1,WEIGHTS_0'.split( ',') # attrs = 'COLOR_0,NORMAL,POSITION,TEXCOORD_0'.split(',') unsupported = 'JOINTS_0,TANGENT,TEXCOORD_1,WEIGHTS_0'.split( ',') # todo: fix this for att in attrs: val = getattr(primitive.attributes, att) if val is None: continue if att in unsupported: print( f'WARNING: {att} in model {gltf_mesh.name} is currently unsupported and may cause problems in rendering.' ) continue name = att.lower() acc = obj.accessors[val] location = GL.glGetAttribLocation(mesh.gl_program, name) # compiler can automatically assume that a location might not exist. # for example, if a mesh has a texcoord_0 defined but no textures, the shader it requested will have the # #defines set up so that it never actually calls on the attribute texcoord_0, so the compiler pretends it does # not exist. Hence, this value can be -1 even if you do define everything correctly :/ if location == -1: print(f'WARNING: location of {name} returned -1') continue buff = buffers[acc.bufferView] byte_stride = buff.buffer_view.byteStride if byte_stride is None: vec = accessor_type_dim(acc.type) byte_size = np.array([1], dtype=accessor_dtype( acc.componentType)).itemsize byte_stride = vec * byte_size buff.optional_binder()( GL.GL_ARRAY_BUFFER ) # if not bound already, bind with that target (that target is correct for all these attributes) GL.glEnableVertexAttribArray(location) GL.glBindBuffer(GL.GL_ARRAY_BUFFER, buff.buffer_id) GL.glVertexAttribPointer( location, type_to_dim[acc.type], acc.componentType, acc.normalized, byte_stride, ctypes.c_void_p(acc.byteOffset), ) if name == 'position': # this is ok because gltf specifies position, see attrs mesh.tri_count = acc.count // 3 GL.glBindBuffer(GL.GL_ARRAY_BUFFER, 0) mesh.unbind_vao() ent.mesh = mesh ent.transform.set_translation(n.translation) ent.transform.set_rotation(n.rotation) ent.transform.set_scale(n.scale) entities.append(ent) return entities
def main(): global delta_time, last_frame if not glfw.init(): raise ValueError("Failed to initialize glfw") glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3) glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3) glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE) window = glfw.create_window(SRC_WIDTH, SRC_HEIGHT, "learnOpenGL", None, None) if not window: glfw.terminate() raise ValueError("Failed to create window") glfw.make_context_current(window) glfw.set_framebuffer_size_callback(window, framebuffer_size_callback) glfw.set_cursor_pos_callback(window, mouse_callback) glfw.set_scroll_callback(window, scroll_callback) glfw.set_input_mode(window, glfw.CURSOR, glfw.CURSOR_DISABLED) gl.glEnable(gl.GL_DEPTH_TEST) lamp_shader = Shader(CURDIR / "shaders/1.lamp.vs", CURDIR / "shaders/1.lamp.fs") lighting_shader = Shader(CURDIR / "shaders/2.1.basic_lighting.vs", CURDIR / "shaders/2.1.basic_lighting.fs") vertices = [ -0.5, -0.5, -0.5, 0.0, 0.0, -1.0, 0.5, -0.5, -0.5, 0.0, 0.0, -1.0, 0.5, 0.5, -0.5, 0.0, 0.0, -1.0, 0.5, 0.5, -0.5, 0.0, 0.0, -1.0, -0.5, 0.5, -0.5, 0.0, 0.0, -1.0, -0.5, -0.5, -0.5, 0.0, 0.0, -1.0, -0.5, -0.5, 0.5, 0.0, 0.0, 1.0, 0.5, -0.5, 0.5, 0.0, 0.0, 1.0, 0.5, 0.5, 0.5, 0.0, 0.0, 1.0, 0.5, 0.5, 0.5, 0.0, 0.0, 1.0, -0.5, 0.5, 0.5, 0.0, 0.0, 1.0, -0.5, -0.5, 0.5, 0.0, 0.0, 1.0, -0.5, 0.5, 0.5, -1.0, 0.0, 0.0, -0.5, 0.5, -0.5, -1.0, 0.0, 0.0, -0.5, -0.5, -0.5, -1.0, 0.0, 0.0, -0.5, -0.5, -0.5, -1.0, 0.0, 0.0, -0.5, -0.5, 0.5, -1.0, 0.0, 0.0, -0.5, 0.5, 0.5, -1.0, 0.0, 0.0, 0.5, 0.5, 0.5, 1.0, 0.0, 0.0, 0.5, 0.5, -0.5, 1.0, 0.0, 0.0, 0.5, -0.5, -0.5, 1.0, 0.0, 0.0, 0.5, -0.5, -0.5, 1.0, 0.0, 0.0, 0.5, -0.5, 0.5, 1.0, 0.0, 0.0, 0.5, 0.5, 0.5, 1.0, 0.0, 0.0, -0.5, -0.5, -0.5, 0.0, -1.0, 0.0, 0.5, -0.5, -0.5, 0.0, -1.0, 0.0, 0.5, -0.5, 0.5, 0.0, -1.0, 0.0, 0.5, -0.5, 0.5, 0.0, -1.0, 0.0, -0.5, -0.5, 0.5, 0.0, -1.0, 0.0, -0.5, -0.5, -0.5, 0.0, -1.0, 0.0, -0.5, 0.5, -0.5, 0.0, 1.0, 0.0, 0.5, 0.5, -0.5, 0.0, 1.0, 0.0, 0.5, 0.5, 0.5, 0.0, 1.0, 0.0, 0.5, 0.5, 0.5, 0.0, 1.0, 0.0, -0.5, 0.5, 0.5, 0.0, 1.0, 0.0, -0.5, 0.5, -0.5, 0.0, 1.0, 0.0 ] vertices = (c_float * len(vertices))(*vertices) cube_vao = gl.glGenVertexArrays(1) vbo = gl.glGenBuffers(1) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vbo) gl.glBufferData(gl.GL_ARRAY_BUFFER, sizeof(vertices), vertices, gl.GL_STATIC_DRAW) gl.glBindVertexArray(cube_vao) # -- position attribute gl.glVertexAttribPointer(0, 3, gl.GL_FLOAT, gl.GL_FALSE, 6 * sizeof(c_float), c_void_p(0)) gl.glEnableVertexAttribArray(0) # -- normal attribute gl.glVertexAttribPointer(1, 3, gl.GL_FLOAT, gl.GL_FALSE, 6 * sizeof(c_float), c_void_p(3 * sizeof(c_float))) gl.glEnableVertexAttribArray(1) # -- second configure light vao (vbo is the same) light_vao = gl.glGenVertexArrays(1) gl.glBindVertexArray(light_vao) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vbo) gl.glVertexAttribPointer(0, 3, gl.GL_FLOAT, gl.GL_FALSE, 6 * sizeof(c_float), c_void_p(0)) gl.glEnableVertexAttribArray(0) while not glfw.window_should_close(window): # -- time logic current_frame = glfw.get_time() delta_time = current_frame - last_frame last_frame = current_frame # -- input process_input(window) # -- render gl.glClearColor(0.1, 0.1, 0.1, 1.0) gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) lighting_shader.use() lighting_shader.set_vec3("objectColor", Vector3([1.0, 0.5, 0.31])) lighting_shader.set_vec3("lightColor", Vector3([1.0, 1.0, 1.0])) lighting_shader.set_vec3("lightPos", light_pos) # -- view.projection transformations projection = Matrix44.perspective_projection(camera.zoom, SRC_WIDTH/SRC_HEIGHT, 0.1, 100.0) view = camera.get_view_matrix() lighting_shader.set_mat4("projection", projection) lighting_shader.set_mat4("view", view) # -- world transformation model = Matrix44.identity() lighting_shader.set_mat4("model", model) # -- render cube gl.glBindVertexArray(cube_vao) gl.glDrawArrays(gl.GL_TRIANGLES, 0, 36) # -- draw lamp object lamp_shader.use() lamp_shader.set_mat4("projection", projection) lamp_shader.set_mat4("view", view) model = Matrix44.identity() model *= Matrix44.from_translation(light_pos) model *= Matrix44.from_scale(Vector3([.2, .2, .2])) lamp_shader.set_mat4("model", model) gl.glBindVertexArray(light_vao) gl.glDrawArrays(gl.GL_TRIANGLES, 0, 36) glfw.swap_buffers(window) glfw.poll_events() gl.glDeleteVertexArrays(1, id(cube_vao)) gl.glDeleteVertexArrays(1, id(light_vao)) gl.glDeleteBuffers(1, id(vbo)) glfw.terminate()
def glize(node): model = node.transformation.astype(numpy.float32) gl.glUniformMatrix4fv( gl.glGetUniformLocation(shader, "model"), 1 , gl.GL_FALSE, model ) gl.glUniformMatrix4fv( gl.glGetUniformLocation(shader, "view"), 1 , gl.GL_FALSE, glm.value_ptr(view) ) gl.glUniformMatrix4fv( gl.glGetUniformLocation(shader, "projection"), 1 , gl.GL_FALSE, glm.value_ptr(projection) ) for mesh in node.meshes: #assert False , texture #prueba para ver el nombre de la textura texture_surface = pygame.image.load(getTexture(mesh)) texture_data = pygame.image.tostring(texture_surface, "RGB", 1) width = texture_surface.get_width() height = texture_surface.get_height() texture = gl.glGenTextures(1) gl.glBindTexture(gl.GL_TEXTURE_2D, texture) gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGB, width, height, 0, gl.GL_RGB, gl.GL_UNSIGNED_BYTE, texture_data) gl.glGenerateMipmap(gl.GL_TEXTURE_2D) vertex_data = numpy.hstack(( numpy.array(mesh.vertices, dtype=numpy.float32), numpy.array(mesh.normals, dtype=numpy.float32), numpy.array(mesh.texturecoords[0], dtype=numpy.float32) )) index_data = numpy.hstack( numpy.array(mesh.faces, dtype=numpy.int32) ) vertex_buffer_object = gl.glGenVertexArrays(1) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vertex_buffer_object) gl.glBufferData(gl.GL_ARRAY_BUFFER, vertex_data.nbytes, vertex_data, gl.GL_STATIC_DRAW) gl.glVertexAttribPointer(0, 3, gl.GL_FLOAT, False, 9 * 4, None) gl.glEnableVertexAttribArray(0) gl.glVertexAttribPointer(1, 3, gl.GL_FLOAT, False, 9 * 4, ctypes.c_void_p(3 * 4)) gl.glEnableVertexAttribArray(1) gl.glVertexAttribPointer(2, 3, gl.GL_FLOAT, False, 9 * 4, ctypes.c_void_p(6 * 4)) gl.glEnableVertexAttribArray(2) element_buffer_object = gl.glGenBuffers(1) gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, element_buffer_object) gl.glBufferData(gl.GL_ELEMENT_ARRAY_BUFFER, index_data.nbytes, index_data, gl.GL_STATIC_DRAW) diffuse = mesh.material.properties["diffuse"] gl.glUniform4f( gl.glGetUniformLocation(shader, "color"), *diffuse, 1 ) gl.glUniform4f( gl.glGetUniformLocation(shader, "light"), int(lighting.x), int(lighting.y), int(lighting.z), 1 ) gl.glDrawElements(gl.GL_TRIANGLES, len(index_data), gl.GL_UNSIGNED_INT, None) for child in node.children: glize(child)
def run(): if sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) != 0: print(sdl2.SDL_GetError()) return -1 window = sdl2.SDL_CreateWindow(b"OpenGL demo", sdl2.SDL_WINDOWPOS_UNDEFINED, sdl2.SDL_WINDOWPOS_UNDEFINED, 800, 600, sdl2.SDL_WINDOW_OPENGL) if not window: print(sdl2.SDL_GetError()) return -1 # Force OpenGL 3.3 'core' context. # Must set *before* creating GL context! video.SDL_GL_SetAttribute(video.SDL_GL_CONTEXT_MAJOR_VERSION, 3) video.SDL_GL_SetAttribute(video.SDL_GL_CONTEXT_MINOR_VERSION, 3) video.SDL_GL_SetAttribute(video.SDL_GL_CONTEXT_PROFILE_MASK, video.SDL_GL_CONTEXT_PROFILE_CORE) context = sdl2.SDL_GL_CreateContext(window) quad = [-0.5, -0.5, 0.0, 1.0, 0.0, 0.0, 0.5, -0.5, 0.0, 0.0, 1.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0, 1.0, -0.5, 0.5, 0.0, 1.0, 1.0, 1.0] quad = numpy.array(quad, dtype=numpy.float32) indices = [0, 1, 2, 2, 3, 0] indices = numpy.array(indices, dtype=numpy.uint32) # Setup GL shaders, data, etc. vertex_shader = shaders.compileShader(""" #version 330 in vec3 position; in vec3 color; out vec3 newColor; void main() { gl_Position = vec4(position, 1.0f); newColor = color; } """ , GL.GL_VERTEX_SHADER) fragment_shader = shaders.compileShader(""" #version 330 in vec3 newColor; out vec4 outColor; void main() { outColor = vec4(newColor, 1.0f); } """ , GL.GL_FRAGMENT_SHADER) shaderProgram = shaders.compileProgram(vertex_shader, fragment_shader) GL.glUseProgram(shaderProgram) # Need VBO for triangle vertices and colours VBO = GL.glGenBuffers(1) GL.glBindBuffer(GL.GL_ARRAY_BUFFER, VBO) GL.glBufferData(GL.GL_ARRAY_BUFFER, 96, quad, GL.GL_STATIC_DRAW) EBO = GL.glGenBuffers(1) GL.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, EBO) GL.glBufferData(GL.GL_ELEMENT_ARRAY_BUFFER, 24, indices, GL.GL_STATIC_DRAW) position = GL.glGetAttribLocation(shaderProgram, "position") GL.glVertexAttribPointer(position, 3, GL.GL_FLOAT, GL.GL_FALSE, 24, ctypes.c_void_p(0)) GL.glEnableVertexAttribArray(position) color = GL.glGetAttribLocation(shaderProgram, "color") GL.glVertexAttribPointer(color, 3, GL.GL_FLOAT, GL.GL_FALSE, 24, ctypes.c_void_p(12)) GL.glEnableVertexAttribArray(color) event = sdl2.SDL_Event() running = True GL.glClearColor(0, 0, 0, 1) while running: while sdl2.SDL_PollEvent(ctypes.byref(event)) != 0: if event.type == sdl2.SDL_QUIT: running = False try: GL.glClear(GL.GL_COLOR_BUFFER_BIT) GL.glDrawElements(GL.GL_TRIANGLES, 6, GL.GL_UNSIGNED_INT, None) finally: GL.glUseProgram(0) sdl2.SDL_GL_SwapWindow(window) sdl2.SDL_Delay(10) sdl2.SDL_GL_DeleteContext(context) sdl2.SDL_DestroyWindow(window) sdl2.SDL_Quit() return 0
def make_gl_cylinder(self, program, bond_list, vao_list, ribbon=True): """ Function doc """ for bond in bond_list: if ribbon: vertices, indexes, colors, normals = shapes.get_cylinder( bond[0].pos, bond[0].color, bond[2], bond[3], bond[1], 10, radius=0.2, level='level_6') self.ribbon_indexes = len(indexes) else: vertices, indexes, colors, normals = shapes.get_cylinder( bond[0].pos, bond[0].color, bond[2], bond[3], bond[1], 10, radius=0.1, level='level_6') self.stick_indexes = len(indexes) vao = GL.glGenVertexArrays(1) GL.glBindVertexArray(vao) ind_vbo = GL.glGenBuffers(1) GL.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, ind_vbo) GL.glBufferData(GL.GL_ELEMENT_ARRAY_BUFFER, indexes.itemsize * len(indexes), indexes, GL.GL_STATIC_DRAW) vert_vbo = GL.glGenBuffers(1) GL.glBindBuffer(GL.GL_ARRAY_BUFFER, vert_vbo) GL.glBufferData(GL.GL_ARRAY_BUFFER, vertices.itemsize * len(vertices), vertices, GL.GL_STATIC_DRAW) att_position = GL.glGetAttribLocation(program, 'coordinate') GL.glEnableVertexAttribArray(att_position) GL.glVertexAttribPointer(att_position, 3, GL.GL_FLOAT, GL.GL_FALSE, 3 * vertices.itemsize, ctypes.c_void_p(0)) center_vbo = GL.glGenBuffers(1) GL.glBindBuffer(GL.GL_ARRAY_BUFFER, center_vbo) GL.glBufferData(GL.GL_ARRAY_BUFFER, normals.itemsize * len(normals), normals, GL.GL_STATIC_DRAW) att_center = GL.glGetAttribLocation(program, 'center') GL.glEnableVertexAttribArray(att_center) GL.glVertexAttribPointer(att_center, 3, GL.GL_FLOAT, GL.GL_FALSE, 3 * normals.itemsize, ctypes.c_void_p(0)) col_vbo = GL.glGenBuffers(1) GL.glBindBuffer(GL.GL_ARRAY_BUFFER, col_vbo) GL.glBufferData(GL.GL_ARRAY_BUFFER, colors.itemsize * len(colors), colors, GL.GL_STATIC_DRAW) att_colors = GL.glGetAttribLocation(program, 'vert_color') GL.glEnableVertexAttribArray(att_colors) GL.glVertexAttribPointer(att_colors, 3, GL.GL_FLOAT, GL.GL_FALSE, 3 * colors.itemsize, ctypes.c_void_p(0)) vao_list.append(vao) GL.glBindVertexArray(0) GL.glDisableVertexAttribArray(att_position) GL.glDisableVertexAttribArray(att_colors) GL.glDisableVertexAttribArray(att_center) GL.glBindBuffer(GL.GL_ARRAY_BUFFER, 0) GL.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, 0)
def init_gl_modern(display_size): """ Initialise open GL in the 'modern' open GL style for open GL versions greater than 3.1. :param display_size: Size of the window/viewport. """ # Create shaders # -------------------------------------- vertex_code = """ #version 150 uniform mat4 model; uniform mat4 view; uniform mat4 projection; uniform vec4 colour_mul; uniform vec4 colour_add; in vec4 vertex_colour; // vertex colour in in vec3 vertex_position; out vec4 vertex_color_out; // vertex colour out void main() { vertex_color_out = (colour_mul * vertex_colour) + colour_add; gl_Position = projection * view * model * vec4(vertex_position, 1.0); } """ fragment_code = """ #version 150 in vec4 vertex_color_out; // vertex colour from vertex shader out vec4 fragColor; void main() { fragColor = vertex_color_out; } """ program = GL.glCreateProgram() vertex = GL.glCreateShader(GL.GL_VERTEX_SHADER) fragment = GL.glCreateShader(GL.GL_FRAGMENT_SHADER) GL.glShaderSource(vertex, vertex_code) GL.glCompileShader(vertex) # this logs issues the shader compiler finds. log = GL.glGetShaderInfoLog(vertex) if isinstance(log, bytes): log = log.decode() for line in log.split("\n"): print(line) GL.glAttachShader(program, vertex) GL.glShaderSource(fragment, fragment_code) GL.glCompileShader(fragment) # this logs issues the shader compiler finds. log = GL.glGetShaderInfoLog(fragment) if isinstance(log, bytes): log = log.decode() for line in log.split("\n"): print(line) GL.glAttachShader(program, fragment) GL.glValidateProgram(program) GL.glLinkProgram(program) GL.glDetachShader(program, vertex) GL.glDetachShader(program, fragment) GL.glUseProgram(program) # Create vertex buffers and shader constants # ------------------------------------------ # Cube Data vertices = zeros(8, [("vertex_position", float32, 3), ("vertex_colour", float32, 4)]) vertices["vertex_position"] = [ [1, 1, 1], [-1, 1, 1], [-1, -1, 1], [1, -1, 1], [1, -1, -1], [1, 1, -1], [-1, 1, -1], [-1, -1, -1], ] vertices["vertex_colour"] = [ [0, 1, 1, 1], [0, 0, 1, 1], [0, 0, 0, 1], [0, 1, 0, 1], [1, 1, 0, 1], [1, 1, 1, 1], [1, 0, 1, 1], [1, 0, 0, 1], ] filled_cube_indices = array( [ 0, 1, 2, 0, 2, 3, 0, 3, 4, 0, 4, 5, 0, 5, 6, 0, 6, 1, 1, 6, 7, 1, 7, 2, 7, 4, 3, 7, 3, 2, 4, 7, 6, 4, 6, 5, ], dtype=uint32, ) outline_cube_indices = array( [ 0, 1, 1, 2, 2, 3, 3, 0, 4, 7, 7, 6, 6, 5, 5, 4, 0, 5, 1, 6, 2, 7, 3, 4 ], dtype=uint32, ) shader_data = {"buffer": {}, "constants": {}} GL.glBindVertexArray(GL.glGenVertexArrays(1)) # Have to do this first shader_data["buffer"]["vertices"] = GL.glGenBuffers(1) GL.glBindBuffer(GL.GL_ARRAY_BUFFER, shader_data["buffer"]["vertices"]) GL.glBufferData(GL.GL_ARRAY_BUFFER, vertices.nbytes, vertices, GL.GL_DYNAMIC_DRAW) stride = vertices.strides[0] offset = ctypes.c_void_p(0) loc = GL.glGetAttribLocation(program, "vertex_position") GL.glEnableVertexAttribArray(loc) GL.glVertexAttribPointer(loc, 3, GL.GL_FLOAT, False, stride, offset) offset = ctypes.c_void_p(vertices.dtype["vertex_position"].itemsize) loc = GL.glGetAttribLocation(program, "vertex_colour") GL.glEnableVertexAttribArray(loc) GL.glVertexAttribPointer(loc, 4, GL.GL_FLOAT, False, stride, offset) shader_data["buffer"]["filled"] = GL.glGenBuffers(1) GL.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, shader_data["buffer"]["filled"]) GL.glBufferData( GL.GL_ELEMENT_ARRAY_BUFFER, filled_cube_indices.nbytes, filled_cube_indices, GL.GL_STATIC_DRAW, ) shader_data["buffer"]["outline"] = GL.glGenBuffers(1) GL.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, shader_data["buffer"]["outline"]) GL.glBufferData( GL.GL_ELEMENT_ARRAY_BUFFER, outline_cube_indices.nbytes, outline_cube_indices, GL.GL_STATIC_DRAW, ) shader_data["constants"]["model"] = GL.glGetUniformLocation( program, "model") GL.glUniformMatrix4fv(shader_data["constants"]["model"], 1, False, eye(4)) shader_data["constants"]["view"] = GL.glGetUniformLocation(program, "view") view = translate(eye(4), z=-6) GL.glUniformMatrix4fv(shader_data["constants"]["view"], 1, False, view) shader_data["constants"]["projection"] = GL.glGetUniformLocation( program, "projection") GL.glUniformMatrix4fv(shader_data["constants"]["projection"], 1, False, eye(4)) # This colour is multiplied with the base vertex colour in producing # the final output shader_data["constants"]["colour_mul"] = GL.glGetUniformLocation( program, "colour_mul") GL.glUniform4f(shader_data["constants"]["colour_mul"], 1, 1, 1, 1) # This colour is added on to the base vertex colour in producing # the final output shader_data["constants"]["colour_add"] = GL.glGetUniformLocation( program, "colour_add") GL.glUniform4f(shader_data["constants"]["colour_add"], 0, 0, 0, 0) # Set GL drawing data # ------------------- GL.glClearColor(0, 0, 0, 0) GL.glPolygonOffset(1, 1) GL.glEnable(GL.GL_LINE_SMOOTH) GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA) GL.glDepthFunc(GL.GL_LESS) GL.glHint(GL.GL_LINE_SMOOTH_HINT, GL.GL_NICEST) GL.glLineWidth(1.0) projection = perspective(45.0, display_size[0] / float(display_size[1]), 2.0, 100.0) GL.glUniformMatrix4fv(shader_data["constants"]["projection"], 1, False, projection) return shader_data, filled_cube_indices, outline_cube_indices
def add_vert_attrib(self, name, arr, each): self.vert_attrib[name] = (GL.glGenBuffers(1), each) GL.glBindBuffer(GL.GL_ARRAY_BUFFER, self.vert_attrib[name][0]) GL.glBufferData(GL.GL_ARRAY_BUFFER, arr.nbytes, arr, GL.GL_STATIC_DRAW)
0.5, 0.5, 0, 1, 0, 0, 1, 1, 0.5, -0.5, 0, 0, 1, 0, 1, 0, -0.5, -0.5, 0, 0, 0, 1, 0, 0, -0.5, 0.5, 0, 1, 1, 0, 0, 1 ], dtype=numpy.float32) index_data = numpy.array([ 0, 1, 3, 1, 2, 3 ], dtype=numpy.uint32) vertex_array_object = gl.glGenVertexArrays(1) gl.glBindVertexArray(vertex_array_object) vertex_buffer_object = gl.glGenBuffers(1) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vertex_buffer_object) gl.glBufferData(gl.GL_ARRAY_BUFFER, vertex_data.nbytes, vertex_data, gl.GL_STATIC_DRAW) element_buffer_object = gl.glGenBuffers(1) gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, element_buffer_object) gl.glBufferData(gl.GL_ELEMENT_ARRAY_BUFFER, index_data.nbytes, index_data, gl.GL_STATIC_DRAW) gl.glVertexAttribPointer(0, 3, gl.GL_FLOAT, False, 8 * 4, ctypes.c_void_p(0)) gl.glEnableVertexAttribArray(0) gl.glVertexAttribPointer(1, 3, gl.GL_FLOAT, False, 8 * 4, ctypes.c_void_p(3 * 4)) gl.glEnableVertexAttribArray(1) gl.glVertexAttribPointer(2, 2, gl.GL_FLOAT, False, 8 * 4, ctypes.c_void_p(6 * 4)) gl.glEnableVertexAttribArray(2) # glfw requires shaders to be compiled after buffer binding
def __init__(self): # Load Shader self.attrib_locs = { "aPosCoord": -1, "aTexCoord": -1 } self.uniform_locs = { "tsdf": -1, "tsdf_cnt": -1, "s2w": -1, "c": -1, "vol_dim": -1, "volStart": -1, "volEnd": -1, "random_colors": -1 } vert_prog = shaders.compileShader(open('tsdf_render.vert').read(), gl.GL_VERTEX_SHADER) if not gl.glGetShaderiv(vert_prog, gl.GL_COMPILE_STATUS): sys.stderr.write("Error: Could not compile vertex shader.\n") exit(2) frag_prog = shaders.compileShader(open('tsdf_render.frag').read(), gl.GL_FRAGMENT_SHADER) if not gl.glGetShaderiv(frag_prog, gl.GL_COMPILE_STATUS): sys.stderr.write("Error: Could not compile fragment shader.\n") exit(3) self.program = gl.glCreateProgram() gl.glAttachShader(self.program, vert_prog) gl.glAttachShader(self.program, frag_prog) gl.glLinkProgram(self.program) if gl.glGetProgramiv(self.program, gl.GL_LINK_STATUS) != gl.GL_TRUE: sys.stderr.write("Error: {0}\n".format(gl.glGetProgramInfoLog(self.program))) exit(4) for name in self.attrib_locs: self.attrib_locs[name] = gl.glGetAttribLocation(self.program, name) for name in self.uniform_locs: self.uniform_locs[name] = gl.glGetUniformLocation(self.program, name) vertices = np.array([-1, -1, -1, 1, 1, -1, 1, 1], np.float32) texture_coords = np.array([0, 1, 0, 0, 1, 1, 1, 0], np.float32) # Load Object self.vbos = gl.glGenBuffers(2) self.vao = gl.glGenVertexArrays(1) gl.glBindVertexArray(self.vao) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, 0) gl.glEnableVertexAttribArray(self.attrib_locs['aPosCoord']) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.vbos[0]) gl.glBufferData(gl.GL_ARRAY_BUFFER, 8 * 4, vertices, gl.GL_STATIC_DRAW) gl.glVertexAttribPointer(self.attrib_locs['aPosCoord'], 2, gl.GL_FLOAT, False, 0, ctypes.c_void_p(0)) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, 0) gl.glEnableVertexAttribArray(self.attrib_locs['aTexCoord']) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.vbos[1]) gl.glBufferData(gl.GL_ARRAY_BUFFER, 8 * 4, texture_coords, gl.GL_STATIC_DRAW) gl.glVertexAttribPointer(self.attrib_locs['aTexCoord'], 2, gl.GL_FLOAT, False, 0, ctypes.c_void_p(0)) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, 0) gl.glBindVertexArray(0) gl.glUseProgram(self.program) gl.glUniform1i(self.uniform_locs['tsdf'], 0) gl.glUniform1i(self.uniform_locs['tsdf_cnt'], 1) rand_colors = np.random.rand(32, 3) gl.glUniform3fv(self.uniform_locs['random_colors'], 32, rand_colors.astype(np.float32))
def make_gl_sphere(self, program, atom_list, vao_list, covalent=True): """ Function doc """ for atom in atom_list: if covalent: vertices, indexes, colors = shapes.get_sphere(atom.pos, atom.cov_rad, atom.color, level='level_2') else: vertices, indexes, colors = shapes.get_sphere(atom.pos, atom.ball_radius, atom.color, level='level_2') centers = [atom.pos[0], atom.pos[1], atom.pos[2]] * len(indexes) centers = np.array(centers, dtype=np.float32) vao = GL.glGenVertexArrays(1) GL.glBindVertexArray(vao) atom.triangles = len(indexes) ind_vbo = GL.glGenBuffers(1) GL.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, ind_vbo) GL.glBufferData(GL.GL_ELEMENT_ARRAY_BUFFER, indexes.itemsize * len(indexes), indexes, GL.GL_STATIC_DRAW) vert_vbo = GL.glGenBuffers(1) GL.glBindBuffer(GL.GL_ARRAY_BUFFER, vert_vbo) GL.glBufferData(GL.GL_ARRAY_BUFFER, vertices.itemsize * len(vertices), vertices, GL.GL_STATIC_DRAW) att_position = GL.glGetAttribLocation(program, 'coordinate') GL.glEnableVertexAttribArray(att_position) GL.glVertexAttribPointer(att_position, 3, GL.GL_FLOAT, GL.GL_FALSE, 3 * vertices.itemsize, ctypes.c_void_p(0)) center_vbo = GL.glGenBuffers(1) GL.glBindBuffer(GL.GL_ARRAY_BUFFER, center_vbo) GL.glBufferData(GL.GL_ARRAY_BUFFER, centers.itemsize * len(centers), centers, GL.GL_STATIC_DRAW) att_center = GL.glGetAttribLocation(program, 'center') GL.glEnableVertexAttribArray(att_center) GL.glVertexAttribPointer(att_center, 3, GL.GL_FLOAT, GL.GL_FALSE, 3 * centers.itemsize, ctypes.c_void_p(0)) col_vbo = GL.glGenBuffers(1) GL.glBindBuffer(GL.GL_ARRAY_BUFFER, col_vbo) GL.glBufferData(GL.GL_ARRAY_BUFFER, colors.itemsize * len(colors), colors, GL.GL_STATIC_DRAW) att_colors = GL.glGetAttribLocation(program, 'vert_color') GL.glEnableVertexAttribArray(att_colors) GL.glVertexAttribPointer(att_colors, 3, GL.GL_FLOAT, GL.GL_FALSE, 3 * colors.itemsize, ctypes.c_void_p(0)) vao_list.append(vao) GL.glBindVertexArray(0) GL.glDisableVertexAttribArray(att_position) GL.glDisableVertexAttribArray(att_colors) GL.glDisableVertexAttribArray(att_center) GL.glBindBuffer(GL.GL_ARRAY_BUFFER, 0) GL.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, 0)