def draw(self): bgl.glActiveTexture(bgl.GL_TEXTURE0) bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.texture[0]) bgl.glBindVertexArray(self.vertex_array[0]) bgl.glDrawArrays(bgl.GL_TRIANGLE_FAN, 0, 4); bgl.glBindVertexArray(0) bgl.glBindTexture(bgl.GL_TEXTURE_2D, 0)
def draw_one(u): c = PCVCache.cache[u] # update matrix, every frame for now, it should be done better.. but it works well.. m = c['object'].matrix_world matrix = [] for v in m.transposed(): matrix.extend(list(v.to_tuple())) matrix_buffer = bgl.Buffer(bgl.GL_FLOAT, len(matrix), matrix) c['matrix'] = m c['matrix_buffer'] = matrix_buffer bgl.glPushMatrix() bgl.glMultMatrixf(c['matrix_buffer']) bgl.glEnable(bgl.GL_DEPTH_TEST) bgl.glEnableClientState(bgl.GL_VERTEX_ARRAY) bgl.glVertexPointer(3, bgl.GL_FLOAT, 0, c['vertex_buffer']) bgl.glEnableClientState(bgl.GL_COLOR_ARRAY) bgl.glColorPointer(3, bgl.GL_FLOAT, 0, c['color_buffer']) if(PCVCache.cache[u]['smooth']): bgl.glEnable(bgl.GL_POINT_SMOOTH) l = int((c['length'] / 100) * c['display_percent']) bgl.glDrawArrays(bgl.GL_POINTS, 0, l) bgl.glDisableClientState(bgl.GL_VERTEX_ARRAY) bgl.glDisableClientState(bgl.GL_COLOR_ARRAY) if(c['smooth']): bgl.glDisable(bgl.GL_POINT_SMOOTH) bgl.glDisable(bgl.GL_DEPTH_TEST) bgl.glPopMatrix()
def draw(self): bgl.glActiveTexture(bgl.GL_TEXTURE0) bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.texture[0]) bgl.glBindVertexArray(self.vertex_array[0]) bgl.glDrawArrays(bgl.GL_TRIANGLE_FAN, 0, 4) bgl.glBindVertexArray(0) bgl.glBindTexture(bgl.GL_TEXTURE_2D, 0)
def draw_one(u): c = PCVCache.cache[u] # update matrix, every frame for now, it should be done better.. but it works well.. m = c['object'].matrix_world matrix = [] for v in m.transposed(): matrix.extend(list(v.to_tuple())) matrix_buffer = bgl.Buffer(bgl.GL_FLOAT, len(matrix), matrix) c['matrix'] = m c['matrix_buffer'] = matrix_buffer bgl.glPushMatrix() bgl.glMultMatrixf(c['matrix_buffer']) bgl.glEnable(bgl.GL_DEPTH_TEST) bgl.glEnableClientState(bgl.GL_VERTEX_ARRAY) bgl.glVertexPointer(3, bgl.GL_FLOAT, 0, c['vertex_buffer']) bgl.glEnableClientState(bgl.GL_COLOR_ARRAY) bgl.glColorPointer(3, bgl.GL_FLOAT, 0, c['color_buffer']) if (PCVCache.cache[u]['smooth']): bgl.glEnable(bgl.GL_POINT_SMOOTH) l = int((c['length'] / 100) * c['display_percent']) bgl.glDrawArrays(bgl.GL_POINTS, 0, l) bgl.glDisableClientState(bgl.GL_VERTEX_ARRAY) bgl.glDisableClientState(bgl.GL_COLOR_ARRAY) if (c['smooth']): bgl.glDisable(bgl.GL_POINT_SMOOTH) bgl.glDisable(bgl.GL_DEPTH_TEST) bgl.glPopMatrix()
def draw(self): self.log.info('CustomDrawData.draw() [%s]' % self) bgl.glActiveTexture(bgl.GL_TEXTURE0) bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.texture[0]) bgl.glBindVertexArray(self.vertex_array[0]) bgl.glDrawArrays(bgl.GL_TRIANGLE_FAN, 0, 4) bgl.glBindVertexArray(0) bgl.glBindTexture(bgl.GL_TEXTURE_2D, 0)
def draw(self): if self.updateTextureOnDraw: self.updateTexture() self.updateTextureOnDraw = False bgl.glActiveTexture(bgl.GL_TEXTURE0) bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.texture[0]) bgl.glBindVertexArray(self.vertex_array[0]) bgl.glDrawArrays(bgl.GL_TRIANGLE_FAN, 0, 4) bgl.glBindVertexArray(0) bgl.glBindTexture(bgl.GL_TEXTURE_2D, 0)
def draw(self, pixels): width, height = self.dimensions bgl.glActiveTexture(bgl.GL_TEXTURE0) bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.texture[0]) pixels = bgl.Buffer(bgl.GL_FLOAT, width * height * 4, pixels) bgl.glTexSubImage2D(bgl.GL_TEXTURE_2D, 0, 0, 0, width, height, bgl.GL_RGBA, bgl.GL_FLOAT, pixels) bgl.glBindVertexArray(self.vertex_array[0]) bgl.glDrawArrays(bgl.GL_TRIANGLE_FAN, 0, 4) bgl.glBindVertexArray(0) bgl.glBindTexture(bgl.GL_TEXTURE_2D, 0)
def _draw_texture(texture_id, x, y, width, height): # INITIALIZATION # Getting shader program shader_program = bgl.Buffer(bgl.GL_INT, 1) bgl.glGetIntegerv(bgl.GL_CURRENT_PROGRAM, shader_program) # Generate vertex array vertex_array = bgl.Buffer(bgl.GL_INT, 1) bgl.glGenVertexArrays(1, vertex_array) texturecoord_location = bgl.glGetAttribLocation( shader_program[0], "texCoord") position_location = bgl.glGetAttribLocation(shader_program[0], "pos") # Generate geometry buffers for drawing textured quad position = [x, y, x + width, y, x + width, y + height, x, y + height] position = bgl.Buffer(bgl.GL_FLOAT, len(position), position) texcoord = [0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0, 1.0] texcoord = bgl.Buffer(bgl.GL_FLOAT, len(texcoord), texcoord) vertex_buffer = bgl.Buffer(bgl.GL_INT, 2) bgl.glGenBuffers(2, vertex_buffer) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, vertex_buffer[0]) bgl.glBufferData(bgl.GL_ARRAY_BUFFER, 32, position, bgl.GL_STATIC_DRAW) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, vertex_buffer[1]) bgl.glBufferData(bgl.GL_ARRAY_BUFFER, 32, texcoord, bgl.GL_STATIC_DRAW) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, 0) # DRAWING bgl.glActiveTexture(bgl.GL_TEXTURE0) bgl.glBindTexture(bgl.GL_TEXTURE_2D, texture_id) bgl.glBindVertexArray(vertex_array[0]) bgl.glEnableVertexAttribArray(texturecoord_location) bgl.glEnableVertexAttribArray(position_location) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, vertex_buffer[0]) bgl.glVertexAttribPointer(position_location, 2, bgl.GL_FLOAT, bgl.GL_FALSE, 0, None) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, vertex_buffer[1]) bgl.glVertexAttribPointer(texturecoord_location, 2, bgl.GL_FLOAT, bgl.GL_FALSE, 0, None) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, 0) bgl.glDrawArrays(bgl.GL_TRIANGLE_FAN, 0, 4) bgl.glBindVertexArray(0) bgl.glBindTexture(bgl.GL_TEXTURE_2D, 0) # DELETING bgl.glDeleteBuffers(2, vertex_buffer) bgl.glDeleteVertexArrays(1, vertex_array)
def draw_vertex_array(key, mode, dimensions, color): if key in VAO and VAO[key] and program: vao = VAO[key] bgl.glUseProgram(program) bgl.glUniform4f(bgl.glGetUniformLocation(program, "color"), *color) bgl.glEnableClientState(bgl.GL_VERTEX_ARRAY) bgl.glVertexPointer(dimensions, bgl.GL_FLOAT, 0, vao) bgl.glDrawArrays(mode, 0, int(len(vao) / dimensions)) bgl.glDisableClientState(bgl.GL_VERTEX_ARRAY) bgl.glUseProgram(0)
def _draw(self, sx, sy, sz): bmeshShader.assign('vert_scale', (sx, sy, sz)) if self.DEBUG_PRINT: print('==> drawing %d %s (%d) (%d verts)' % ( self.count / self.gl_count, self.gltype_name, self.gltype, self.count)) if self.render_indices: bgl.glDrawElements(self.gltype, self.count, bgl.GL_UNSIGNED_INT, buf_zero) self._check_error('_draw: glDrawElements (%d, %d, %d)' % ( self.gltype, self.count, bgl.GL_UNSIGNED_INT)) else: bgl.glDrawArrays(self.gltype, 0, self.count) self._check_error('_draw: glDrawArrays (%d)' % self.count)
def draw(self, engine, scene): bgl.glEnable(bgl.GL_BLEND) bgl.glBlendFunc(bgl.GL_ONE, bgl.GL_ONE_MINUS_SRC_ALPHA) engine.bind_display_space_shader(scene) bgl.glActiveTexture(bgl.GL_TEXTURE0) bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.texture[0]) bgl.glBindVertexArray(self.vertex_array[0]) bgl.glDrawArrays(bgl.GL_TRIANGLE_FAN, 0, 4) bgl.glBindVertexArray(0) bgl.glBindTexture(bgl.GL_TEXTURE_2D, 0) engine.unbind_display_space_shader() bgl.glDisable(bgl.GL_BLEND)
def draw_callback_view(verts, faces): VERT = 0 FACES = 1 buffers = bgl.Buffer(bgl.GL_INT, [2]) bgl.glGenBuffers(2, buffers) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, buffers[VERT]) bgl.glBufferData(bgl.GL_ARRAY_BUFFER, 4 * 3 * len(verts), verts, bgl.GL_STATIC_DRAW) bgl.glVertexPointer(3, bgl.GL_FLOAT, 0, verts) bgl.glColor3f(1.0, 0, 0) bgl.glEnableClientState(bgl.GL_VERTEX_ARRAY) bgl.glDrawArrays(bgl.GL_POINTS, 0, len(verts)) bgl.glDisableClientState(bgl.GL_VERTEX_ARRAY)
def draw(self, index_offset): self.first_index = index_offset bgl.glUseProgram(self.shader.program) bgl.glBindVertexArray(self.vao[0]) bgl.glUniformMatrix4fv(self.unif_MVP, 1, bgl.GL_TRUE, self.MVP) # bgl.glUniform1f(self.unif_size, float(2.0)) if self.draw_segs: self.bind(self.vbo_segs_co, self.vbo_segs, index_offset) bgl.glDrawArrays(bgl.GL_LINES, 0, self.num_segs * 2) index_offset += self.num_segs if self.draw_origin: self.bind(self.vbo_origin_co, self.vbo_origin, index_offset) bgl.glDrawArrays(bgl.GL_POINTS, 0, self.num_origins) index_offset += self.num_origins bgl.glBindVertexArray(0)
def view_draw(self, ctx, dg): if self.scene is None: return buf = bgl.Buffer(bgl.GL_INT, 1) bgl.glGetIntegerv(bgl.GL_DRAW_FRAMEBUFFER_BINDING, buf) if buf[0] == 0: return width, height = ctx.region.width, ctx.region.height if self.dim != (width, height): self.delfb() self.prepare_viewport(ctx, dg) # Render the scene bgl.glViewport(0, 0, width, height) cam = ctx.region_data.perspective_matrix zu.scene_cam(self.scene, mat(cam)) zu.scene_draw(self.scene, self.fb) # Copy the rendered scene to the viewport (through the color space adjustment shader) bgl.glBindFramebuffer(bgl.GL_FRAMEBUFFER, buf[0]) bgl.glEnable(bgl.GL_BLEND) bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA) self.bind_display_space_shader(dg.scene) bgl.glBindVertexArray(self.vao) bgl.glEnableVertexAttribArray(self.quad_in) bgl.glEnableVertexAttribArray(self.uv_in) bgl.glActiveTexture(bgl.GL_TEXTURE0) bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.tex) bgl.glDrawArrays(bgl.GL_TRIANGLE_FAN, 0, 4) bgl.glBindTexture(bgl.GL_TEXTURE_2D, 0) bgl.glDisableVertexAttribArray(self.quad_in) bgl.glDisableVertexAttribArray(self.uv_in) bgl.glBindVertexArray(0) self.unbind_display_space_shader() bgl.glDisable(bgl.GL_BLEND)
def draw(self, engine, context, scene): if self._transparent: bgl.glEnable(bgl.GL_BLEND) bgl.glBlendFunc(bgl.GL_ONE, bgl.GL_ONE_MINUS_SRC_ALPHA) engine.bind_display_space_shader(scene) bgl.glActiveTexture(bgl.GL_TEXTURE0) bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.texture_id) bgl.glBindVertexArray(self.vertex_array[0]) bgl.glDrawArrays(bgl.GL_TRIANGLE_FAN, 0, 4) bgl.glBindVertexArray(NULL) bgl.glBindTexture(bgl.GL_TEXTURE_2D, NULL) engine.unbind_display_space_shader() err = bgl.glGetError() if err != bgl.GL_NO_ERROR: print("GL Error:", err) if self._transparent: bgl.glDisable(bgl.GL_BLEND)
def Draw(self, index_offset): self.first_index = index_offset bgl.glUseProgram(self.shader.program) bgl.glBindVertexArray(self.vao[0]) bgl.glUniformMatrix4fv(self.unif_MV, 1, bgl.GL_TRUE, self.MV) bgl.glUniformMatrix4fv(self.unif_MVP, 1, bgl.GL_TRUE, self.MVP) if self.draw_tris: bgl.glUniform1f(self.unif_offset, float(index_offset)) # bgl has no glUniform1ui :\ bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vbo_tris[0]) bgl.glEnableVertexAttribArray(self.attr_pos) bgl.glVertexAttribPointer(self.attr_pos, 3, bgl.GL_FLOAT, bgl.GL_FALSE, 0, self._NULL) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vbo_tri_indices[0]) bgl.glEnableVertexAttribArray(self.attr_primitive_id) bgl.glVertexAttribPointer(self.attr_primitive_id, 1, bgl.GL_FLOAT, bgl.GL_FALSE, 0, self._NULL) bgl.glDrawArrays(bgl.GL_TRIANGLES, 0, self.num_tris * 3) index_offset += self.num_tris bgl.glDepthRange(-0.00005, 0.99995) if self.draw_edges: bgl.glUniform1f(self.unif_offset, float(index_offset)) #TODO: use glUniform1ui bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vbo_edges[0]) bgl.glVertexAttribPointer(self.attr_pos, 3, bgl.GL_FLOAT, bgl.GL_FALSE, 0, self._NULL) bgl.glEnableVertexAttribArray(self.attr_pos) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vbo_edge_indices[0]) bgl.glVertexAttribPointer(self.attr_primitive_id, 1, bgl.GL_FLOAT, bgl.GL_FALSE, 0, self._NULL) bgl.glEnableVertexAttribArray(self.attr_primitive_id) bgl.glDrawArrays(bgl.GL_LINES, 0, self.num_edges * 2) index_offset += self.num_edges if self.draw_verts: bgl.glUniform1f(self.unif_offset, float(index_offset)) #TODO: use glUniform1ui bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vbo_verts[0]) bgl.glVertexAttribPointer(self.attr_pos, 3, bgl.GL_FLOAT, bgl.GL_FALSE, 0, self._NULL) bgl.glEnableVertexAttribArray(self.attr_pos) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vbo_looseverts_indices[0]) bgl.glVertexAttribPointer(self.attr_primitive_id, 1, bgl.GL_FLOAT, bgl.GL_FALSE, 0, self._NULL) bgl.glEnableVertexAttribArray(self.attr_primitive_id) bgl.glDrawArrays(bgl.GL_POINTS, 0, self.num_verts) bgl.glDepthRange(0.0, 1.0)
def draw(self, index_offset): self.first_index = index_offset bgl.glUseProgram(self.shader.program) check_error("glUseProgram") bgl.glBindVertexArray(self.vao[0]) check_error("glBindVertexArray(self.vao[0])") bgl.glUniformMatrix4fv(self.unif_MVP, 1, bgl.GL_TRUE, self.MVP) check_error("glUniformMatrix4fv") # 2.91 - require sequence of floats # self.shader.uniform_float("MVP", np.reshape(self.MVP, 16)) if self.draw_segs: self.bind(self.vbo_segs_co, self.vbo_segs, index_offset) check_error("draw_segs bind") # 2.91 # self.shader.uniform_float("offset", float(index_offset)) bgl.glDrawArrays(bgl.GL_LINES, 0, self.num_segs * 2) check_error("draw_segs glDrawArrays") index_offset += self.num_segs if self.draw_origin: self.bind(self.vbo_origin_co, self.vbo_origin, index_offset) check_error("draw_origin bind") # 2.91 # self.shader.uniform_float("offset", float(index_offset)) bgl.glDrawArrays(bgl.GL_POINTS, 0, self.num_origins) check_error("draw_origin glDrawArrays") index_offset += self.num_origins if self.draw_bounds: self.bind(self.vbo_bounds_co, self.vbo_bounds, index_offset) check_error("draw_bounds bind") # 2.91 # self.shader.uniform_float("offset", float(index_offset)) bgl.glDrawArrays(bgl.GL_POINTS, 0, self.num_bounds) check_error("draw_bounds glDrawArrays") index_offset += self.num_bounds bgl.glBindVertexArray(0) check_error("glBindVertexArray(0)")
def draw_view(): ###################### ######## BIND ######## ###################### first_time = not bgl.glIsVertexArray(namespace['vao'][0]) if first_time: namespace['uniform_set'] = False # Unlike VBOs, a VAO has to be generated and deleted from within the draw callback in which it will be bound. bgl.glGenVertexArrays(1, namespace['vao']) bgl.glBindVertexArray(namespace['vao'][0]) float_byte_count = 4 # Attribute: "point", 3D float vector bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, namespace['vbo_point'][0]) bgl.glBufferData(bgl.GL_ARRAY_BUFFER, len(namespace['data_point']) * float_byte_count, namespace['data_point'], bgl.GL_DYNAMIC_DRAW) bgl.glVertexAttribPointer(0, 3, bgl.GL_FLOAT, bgl.GL_FALSE, 0, None) bgl.glEnableVertexAttribArray(0) # Attribute: "color", 4D float vector bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, namespace['vbo_color'][0]) bgl.glBufferData(bgl.GL_ARRAY_BUFFER, len(namespace['data_color']) * float_byte_count, namespace['data_color'], bgl.GL_DYNAMIC_DRAW) bgl.glVertexAttribPointer(1, 4, bgl.GL_FLOAT, bgl.GL_FALSE, 0, None) bgl.glEnableVertexAttribArray(1) bgl.glBindVertexArray(0) ###################### ######## DRAW ######## ###################### bgl.glEnable(bgl.GL_BLEND) bgl.glUseProgram(namespace['shader_program']) if not namespace['uniform_set']: bgl.glUniformMatrix4fv( namespace['perspective_uniform_location'], 1, bgl. GL_TRUE, # Matrices in Blender are row-major while matrices in OpenGL are column-major, so Blender's perspective matrix has to be transposed for OpenGL. namespace['projection_matrix']) # In this case I only want to update the uniform once, even though namespace['projection_matrix'] is being updated constantly. namespace['uniform_set'] = True bgl.glBindVertexArray(namespace['vao'][0]) bgl.glDrawArrays(bgl.GL_TRIANGLES, 0, 3) bgl.glUseProgram(0) bgl.glBindVertexArray(0) bgl.glDisable(bgl.GL_BLEND)