def init_opengl(cls): # OpenGL was already initialized, nothing to do here. if cls.shader is not None: return cls.shader = Shader( load_shader('3D_vert.glsl'), None, load_shader('primitive_id_frag.glsl'), ) cls.unif_use_clip_planes = bgl.glGetUniformLocation( cls.shader.program, 'use_clip_planes') cls.unif_clip_plane = bgl.glGetUniformLocation(cls.shader.program, 'clip_plane') cls.unif_MVP = bgl.glGetUniformLocation(cls.shader.program, 'MVP') cls.unif_MV = bgl.glGetUniformLocation(cls.shader.program, 'MV') cls.unif_offset = bgl.glGetUniformLocation(cls.shader.program, 'offset') cls.attr_pos = bgl.glGetAttribLocation(cls.shader.program, 'pos') cls.attr_primitive_id = bgl.glGetAttribLocation( cls.shader.program, 'primitive_id') cls.P = bgl.Buffer(bgl.GL_FLOAT, (4, 4)) cls.MV = bgl.Buffer(bgl.GL_FLOAT, (4, 4)) # returns of public API # cls.vert_index = bgl.Buffer(bgl.GL_INT, 1) cls.tri_co = bgl.Buffer(bgl.GL_FLOAT, (3, 3)) cls.edge_co = bgl.Buffer(bgl.GL_FLOAT, (2, 3)) cls.vert_co = bgl.Buffer(bgl.GL_FLOAT, 3)
def __init__(self, dimensions): # Generate dummy float image buffer self.dimensions = dimensions width, height = dimensions pixels = [1, 0.2, 0.1, 1.0] * width * height pixels = bgl.Buffer(bgl.GL_FLOAT, width * height * 4, pixels) # Generate texture self.texture = bgl.Buffer(bgl.GL_INT, 1) bgl.glGenTextures(1, self.texture) bgl.glActiveTexture(bgl.GL_TEXTURE0) bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.texture[0]) bgl.glTexImage2D(bgl.GL_TEXTURE_2D, 0, bgl.GL_RGBA16F, width, height, 0, bgl.GL_RGBA, bgl.GL_FLOAT, pixels) bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MIN_FILTER, bgl.GL_LINEAR) bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MAG_FILTER, bgl.GL_LINEAR) bgl.glBindTexture(bgl.GL_TEXTURE_2D, 0) # Bind shader that converts from scene linear to display space, # use the scene's color management settings. shader_program = bgl.Buffer(bgl.GL_INT, 1) bgl.glGetIntegerv(bgl.GL_CURRENT_PROGRAM, shader_program) # Generate vertex array self.vertex_array = bgl.Buffer(bgl.GL_INT, 1) bgl.glGenVertexArrays(1, self.vertex_array) bgl.glBindVertexArray(self.vertex_array[0]) texturecoord_location = bgl.glGetAttribLocation( shader_program[0], "texCoord") position_location = bgl.glGetAttribLocation(shader_program[0], "pos") bgl.glEnableVertexAttribArray(texturecoord_location) bgl.glEnableVertexAttribArray(position_location) # Generate geometry buffers for drawing textured quad position = [0.0, 0.0, width, 0.0, width, height, 0.0, 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) self.vertex_buffer = bgl.Buffer(bgl.GL_INT, 2) bgl.glGenBuffers(2, self.vertex_buffer) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vertex_buffer[0]) bgl.glBufferData(bgl.GL_ARRAY_BUFFER, 32, position, bgl.GL_STATIC_DRAW) bgl.glVertexAttribPointer(position_location, 2, bgl.GL_FLOAT, bgl.GL_FALSE, 0, None) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vertex_buffer[1]) bgl.glBufferData(bgl.GL_ARRAY_BUFFER, 32, texcoord, bgl.GL_STATIC_DRAW) bgl.glVertexAttribPointer(texturecoord_location, 2, bgl.GL_FLOAT, bgl.GL_FALSE, 0, None) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, 0) bgl.glBindVertexArray(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 __init__(self, dimensions): # Generate dummy float image buffer self.dimensions = dimensions width, height = dimensions pixels = [0.1, 0.2, 0.1, 1.0] * width * height pixels = bgl.Buffer(bgl.GL_FLOAT, width * height * 4, pixels) # Generate texture self.texture = bgl.Buffer(bgl.GL_INT, 1) bgl.glGenTextures(1, self.texture) bgl.glActiveTexture(bgl.GL_TEXTURE0) bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.texture[0]) bgl.glTexImage2D(bgl.GL_TEXTURE_2D, 0, bgl.GL_RGBA16F, width, height, 0, bgl.GL_RGBA, bgl.GL_FLOAT, pixels) bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MIN_FILTER, bgl.GL_LINEAR) bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MAG_FILTER, bgl.GL_LINEAR) bgl.glBindTexture(bgl.GL_TEXTURE_2D, 0) # Bind shader that converts from scene linear to display space, # use the scene's color management settings. shader_program = bgl.Buffer(bgl.GL_INT, 1) bgl.glGetIntegerv(bgl.GL_CURRENT_PROGRAM, shader_program); # Generate vertex array self.vertex_array = bgl.Buffer(bgl.GL_INT, 1) bgl.glGenVertexArrays(1, self.vertex_array) bgl.glBindVertexArray(self.vertex_array[0]) texturecoord_location = bgl.glGetAttribLocation(shader_program[0], "texCoord"); position_location = bgl.glGetAttribLocation(shader_program[0], "pos"); bgl.glEnableVertexAttribArray(texturecoord_location); bgl.glEnableVertexAttribArray(position_location); # Generate geometry buffers for drawing textured quad position = [0.0, 0.0, width, 0.0, width, height, 0.0, 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) self.vertex_buffer = bgl.Buffer(bgl.GL_INT, 2) bgl.glGenBuffers(2, self.vertex_buffer) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vertex_buffer[0]) bgl.glBufferData(bgl.GL_ARRAY_BUFFER, 32, position, bgl.GL_STATIC_DRAW) bgl.glVertexAttribPointer(position_location, 2, bgl.GL_FLOAT, bgl.GL_FALSE, 0, None) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vertex_buffer[1]) bgl.glBufferData(bgl.GL_ARRAY_BUFFER, 32, texcoord, bgl.GL_STATIC_DRAW) bgl.glVertexAttribPointer(texturecoord_location, 2, bgl.GL_FLOAT, bgl.GL_FALSE, 0, None) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, 0) bgl.glBindVertexArray(0)
def _init_opengl(self, engine, scene): # Create texture self.texture = bgl.Buffer(bgl.GL_INT, 1) bgl.glGenTextures(1, self.texture) self.texture_id = self.texture[0] # Bind shader that converts from scene linear to display space, # use the scene's color management settings. engine.bind_display_space_shader(scene) shader_program = bgl.Buffer(bgl.GL_INT, 1) bgl.glGetIntegerv(bgl.GL_CURRENT_PROGRAM, shader_program) # Generate vertex array self.vertex_array = bgl.Buffer(bgl.GL_INT, 1) bgl.glGenVertexArrays(1, self.vertex_array) bgl.glBindVertexArray(self.vertex_array[0]) texturecoord_location = bgl.glGetAttribLocation( shader_program[0], "texCoord") position_location = bgl.glGetAttribLocation(shader_program[0], "pos") bgl.glEnableVertexAttribArray(texturecoord_location) bgl.glEnableVertexAttribArray(position_location) # Generate geometry buffers for drawing textured quad width = self._width * self._pixel_size height = self._height * self._pixel_size position = [ self._offset_x, self._offset_y, self._offset_x + width, self._offset_y, self._offset_x + width, self._offset_y + height, self._offset_x, self._offset_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) self.vertex_buffer = bgl.Buffer(bgl.GL_INT, 2) bgl.glGenBuffers(2, self.vertex_buffer) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vertex_buffer[0]) bgl.glBufferData(bgl.GL_ARRAY_BUFFER, 32, position, bgl.GL_STATIC_DRAW) bgl.glVertexAttribPointer(position_location, 2, bgl.GL_FLOAT, bgl.GL_FALSE, 0, None) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vertex_buffer[1]) bgl.glBufferData(bgl.GL_ARRAY_BUFFER, 32, texcoord, bgl.GL_STATIC_DRAW) bgl.glVertexAttribPointer(texturecoord_location, 2, bgl.GL_FLOAT, bgl.GL_FALSE, 0, None) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, NULL) bgl.glBindVertexArray(NULL) engine.unbind_display_space_shader()
def __init__(self, dimensions): self.dimensions = dimensions width, height = dimensions pixels = [0.1, 0.2, 0.1, 1.0] * width * height pixels = bgl.Buffer(bgl.GL_FLOAT, width * height * 4, pixels) self.texture = bgl.Buffer(bgl.GL_INT, 1) bgl.glGenTextures(1, self.texture) bgl.glActiveTexture(bgl.GL_TEXTURE0) bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.texture[0]) bgl.glTexImage2D(bgl.GL_TEXTURE_2D, 0, bgl.GL_RGBA16F, width, height, 0, bgl.GL_RGBA, bgl.GL_FLOAT, pixels) bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MIN_FILTER, bgl.GL_LINEAR) bgl.glBindTexture(bgl.GL_TEXTURE_2D, 0) shader_program = bgl.Buffer(bgl.GL_INT, 1) bgl.glGetIntegerv(bgl.GL_CURRENT_PROGRAM, shader_program) self.vertex_array = bgl.Buffer(bgl.GL_INT, 1) bgl.glGenVertexArrays(1, self.vertex_array) bgl.glBindVertexArray(self.vertex_array[0]) texturecoord_location = bgl.glGetAttribLocation( shader_program[0], "texCoord") position_location = bgl.glGetAttribLocation(shader_program[0], "pos") bgl.glEnableVertexAttribArray(texturecoord_location) bgl.glEnableVertexAttribArray(position_location) position = [0.0, 0.0, width, 0.0, width, height, 0.0, 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) self.vertex_buffer = bgl.Buffer(bgl.GL_INT, 2) bgl.glGenBuffers(2, self.vertex_buffer) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vertex_buffer[0]) bgl.glBufferData(bgl.GL_ARRAY_BUFFER, 32, position, bgl.GL_STATIC_DRAW) bgl.glVertexAttribPointer(position_location, 2, bgl.GL_FLOAT, bgl.GL_FALSE, 0, None) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vertex_buffer[1]) bgl.glBufferData(bgl.GL_ARRAY_BUFFER, 32, texcoord, bgl.GL_STATIC_DRAW) bgl.glVertexAttribPointer(texturecoord_location, 2, bgl.GL_FLOAT, bgl.GL_FALSE, 0, None) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, 0) bgl.glBindVertexArray(0)
def init_opengl(self, engine, scene): self.texture = bgl.Buffer(bgl.GL_INT, 1) bgl.glGenTextures(1, self.texture) self.generate_texture() engine.bind_display_space_shader(scene) shader_program = bgl.Buffer(bgl.GL_INT, 1) bgl.glGetIntegerv(bgl.GL_CURRENT_PROGRAM, shader_program) self.vertex_array = bgl.Buffer(bgl.GL_INT, 1) bgl.glGenVertexArrays(1, self.vertex_array) bgl.glBindVertexArray(self.vertex_array[0]) texturecoord_location = bgl.glGetAttribLocation( shader_program[0], "texCoord") position_location = bgl.glGetAttribLocation(shader_program[0], "pos") bgl.glEnableVertexAttribArray(texturecoord_location) bgl.glEnableVertexAttribArray(position_location) position = [ 0.0, 0.0, self.width, 0.0, self.width, self.height, 0.0, self.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) self.vertex_buffer = bgl.Buffer(bgl.GL_INT, 2) bgl.glGenBuffers(2, self.vertex_buffer) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vertex_buffer[0]) bgl.glBufferData(bgl.GL_ARRAY_BUFFER, 32, position, bgl.GL_STATIC_DRAW) bgl.glVertexAttribPointer(position_location, 2, bgl.GL_FLOAT, bgl.GL_FALSE, 0, None) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vertex_buffer[1]) bgl.glBufferData(bgl.GL_ARRAY_BUFFER, 32, texcoord, bgl.GL_STATIC_DRAW) bgl.glVertexAttribPointer(texturecoord_location, 2, bgl.GL_FLOAT, bgl.GL_FALSE, 0, None) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, 0) bgl.glBindVertexArray(0) engine.unbind_display_space_shader()
def prepare_viewport(self, ctx, dg): width, height = ctx.region.width, ctx.region.height self.dim = (width, height) buf = bgl.Buffer(bgl.GL_INT, 1) bgl.glGetIntegerv(bgl.GL_DRAW_FRAMEBUFFER_BINDING, buf) fb = buf[0] self.genfb(width, height) bgl.glGenVertexArrays(1, buf) self.vao = buf[0] bgl.glBindVertexArray(self.vao) quad = bgl.Buffer(bgl.GL_FLOAT, 2 * 4, [0, 0, width, 0, width, height, 0, height]) uv = bgl.Buffer(bgl.GL_FLOAT, 2 * 4, [0, 0, 1, 0, 1, 1, 0, 1]) self.bind_display_space_shader(dg.scene) bgl.glGetIntegerv(bgl.GL_CURRENT_PROGRAM, buf) self.unbind_display_space_shader() self.quad_in = bgl.glGetAttribLocation(buf[0], "pos") self.uv_in = bgl.glGetAttribLocation(buf[0], "texCoord") bgl.glEnableVertexAttribArray(self.quad_in) bgl.glEnableVertexAttribArray(self.uv_in) self.vtx_buf = bgl.Buffer(bgl.GL_INT, 2) bgl.glGenBuffers(2, self.vtx_buf) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vtx_buf[0]) bgl.glBufferData(bgl.GL_ARRAY_BUFFER, 2 * 4 * 4, quad, bgl.GL_STATIC_DRAW) bgl.glVertexAttribPointer(self.quad_in, 2, bgl.GL_FLOAT, bgl.GL_FALSE, 0, None) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vtx_buf[1]) bgl.glBufferData(bgl.GL_ARRAY_BUFFER, 2 * 4 * 4, uv, bgl.GL_STATIC_DRAW) bgl.glVertexAttribPointer(self.uv_in, 2, bgl.GL_FLOAT, bgl.GL_FALSE, 0, None) bgl.glDisableVertexAttribArray(self.quad_in) bgl.glDisableVertexAttribArray(self.uv_in) bgl.glBindFramebuffer(bgl.GL_FRAMEBUFFER, fb)
def init_opengl(cls): # OpenGL was already initialized, nothing to do here. if cls.shader is not None: return import atexit # Make sure we only registered the callback once. atexit.unregister(cls.end_opengl) atexit.register(cls.end_opengl) cls.shader = Shader( load_shader('3D_vert.glsl'), None, load_shader('primitive_id_frag.glsl'), ) cls.unif_use_clip_planes = bgl.glGetUniformLocation( cls.shader.program, 'use_clip_planes') cls.unif_clip_plane = bgl.glGetUniformLocation(cls.shader.program, 'clip_plane') cls._NULL = gl_buffer_void_as_long(0) cls.unif_MVP = bgl.glGetUniformLocation(cls.shader.program, 'MVP') cls.unif_MV = bgl.glGetUniformLocation(cls.shader.program, 'MV') cls.unif_offset = bgl.glGetUniformLocation(cls.shader.program, 'offset') cls.attr_pos = bgl.glGetAttribLocation(cls.shader.program, 'pos') cls.attr_primitive_id = bgl.glGetAttribLocation( cls.shader.program, 'primitive_id') cls.P = bgl.Buffer(bgl.GL_FLOAT, (4, 4)) cls.MV = bgl.Buffer(bgl.GL_FLOAT, (4, 4)) cls.MVP = bgl.Buffer(bgl.GL_FLOAT, (4, 4)) # returns of public API # cls.vert_index = bgl.Buffer(bgl.GL_INT, 1) cls.tri_co = bgl.Buffer(bgl.GL_FLOAT, (3, 3)) cls.edge_co = bgl.Buffer(bgl.GL_FLOAT, (2, 3)) cls.vert_co = bgl.Buffer(bgl.GL_FLOAT, 3)
def init_opengl(cls): # OpenGL was already initialized, nothing to do here. if cls.shader is not None: return import atexit # Make sure we only registered the callback once. atexit.unregister(cls.end_opengl) atexit.register(cls.end_opengl) cls.shader = Shader( load_shader('3D_vert.glsl'), None, load_shader('primitive_id_frag.glsl'), ) cls.unif_use_clip_planes = bgl.glGetUniformLocation(cls.shader.program, 'use_clip_planes') cls.unif_clip_plane = bgl.glGetUniformLocation(cls.shader.program, 'clip_plane') cls._NULL = gl_buffer_void_as_long(0) cls.unif_MVP = bgl.glGetUniformLocation(cls.shader.program, 'MVP') cls.unif_MV = bgl.glGetUniformLocation(cls.shader.program, 'MV') cls.unif_offset = bgl.glGetUniformLocation(cls.shader.program, 'offset') cls.attr_pos = bgl.glGetAttribLocation(cls.shader.program, 'pos') cls.attr_primitive_id = bgl.glGetAttribLocation(cls.shader.program, 'primitive_id') cls.P = bgl.Buffer(bgl.GL_FLOAT, (4, 4)) cls.MV = bgl.Buffer(bgl.GL_FLOAT, (4, 4)) cls.MVP = bgl.Buffer(bgl.GL_FLOAT, (4, 4)) # returns of public API # cls.vert_index = bgl.Buffer(bgl.GL_INT, 1) cls.tri_co = bgl.Buffer(bgl.GL_FLOAT, (3, 3)) cls.edge_co = bgl.Buffer(bgl.GL_FLOAT, (2, 3)) cls.vert_co = bgl.Buffer(bgl.GL_FLOAT, 3)
class GPU_Indices: # if bpy.app.version >= (2, 91, 0): shader = gpu.types.GPUShader(vert_3d, primitive_id_frag) unif_MVP = shader.uniform_from_name("MVP") unif_offset = shader.uniform_from_name("offset") attr_pos = shader.attr_from_name('pos') attr_primitive_id = shader.attr_from_name('primitive_id') else: from .utils_shader import Shader shader = Shader(gl_version + vert_3d, None, gl_version + primitive_id_frag) unif_MVP = bgl.glGetUniformLocation(shader.program, 'MVP') unif_offset = bgl.glGetUniformLocation(shader.program, 'offset') attr_pos = bgl.glGetAttribLocation(shader.program, 'pos') attr_primitive_id = bgl.glGetAttribLocation(shader.program, 'primitive_id') # returns of public API # # knot_co = bgl.Buffer(bgl.GL_FLOAT, 3) seg_co = bgl.Buffer(bgl.GL_FLOAT, (2, 3)) origin_co = bgl.Buffer(bgl.GL_FLOAT, 3) bounds_co = bgl.Buffer(bgl.GL_FLOAT, 3) def __init__(self, obj, typ): self._NULL = VoidBufValue(0) self.MVP = bgl.Buffer(bgl.GL_FLOAT, (4, 4)) # self.obj = obj self.first_index = 0 self.vbo_segs = None self.vbo_segs_co = None self.vbo_origin = None self.vbo_origin_co = None self.vbo_bounds = None self.vbo_bounds_co = None self.num_segs = 0 self.num_origins = 0 self.num_bounds = 0 self._draw_segs = False self._draw_origins = False self._draw_bounds = False self.is_mesh = False self.snap_mode = 0 self.vao = bgl.Buffer(bgl.GL_INT, 1) bgl.glGenVertexArrays(1, self.vao) check_error("glGenVertexArrays(1, self.vao)") bgl.glBindVertexArray(self.vao[0]) check_error("glBindVertexArray(self.vao[0])") _arrays = _Object_Arrays(obj, typ) if _arrays.segs_co: self.vbo_segs_co = bgl.Buffer(bgl.GL_INT, 1) self.num_segs = len(_arrays.segs_co) bgl.glGenBuffers(1, self.vbo_segs_co) check_error("glGenBuffers") bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vbo_segs_co[0]) check_error("glBindBuffer") bgl.glBufferData(bgl.GL_ARRAY_BUFFER, self.num_segs * 24, _arrays.segs_co, bgl.GL_STATIC_DRAW) check_error("glBufferData") segs_indices = np.repeat(np.arange(self.num_segs, dtype='f4'), 2) self.vbo_segs = bgl.Buffer(bgl.GL_INT, 1) bgl.glGenBuffers(1, self.vbo_segs) check_error("glGenBuffers") bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vbo_segs[0]) check_error("glBindBuffer") bgl.glBufferData( bgl.GL_ARRAY_BUFFER, self.num_segs * 8, np_array_as_bgl_Buffer(segs_indices), bgl.GL_STATIC_DRAW ) check_error("glBufferData") del segs_indices self._draw_segs = True # objects origin if _arrays.origin_co: self.vbo_origin_co = bgl.Buffer(bgl.GL_INT, 1) self.num_origins = len(_arrays.origin_co) bgl.glGenBuffers(1, self.vbo_origin_co) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vbo_origin_co[0]) check_error("glBindBuffer") bgl.glBufferData(bgl.GL_ARRAY_BUFFER, self.num_origins * 12, _arrays.origin_co, bgl.GL_STATIC_DRAW) check_error("glBufferData") orig_indices = np.arange(self.num_origins, dtype='f4') self.vbo_origin = bgl.Buffer(bgl.GL_INT, 1) bgl.glGenBuffers(1, self.vbo_origin) check_error("glGenBuffers") bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vbo_origin[0]) check_error("glBindBuffer") bgl.glBufferData( bgl.GL_ARRAY_BUFFER, self.num_origins * 4, np_array_as_bgl_Buffer(orig_indices), bgl.GL_STATIC_DRAW ) check_error("glBufferData") del orig_indices self.is_mesh = _arrays.is_mesh self._draw_origins = True # objects bound box if _arrays.bounds_co: self.vbo_bounds_co = bgl.Buffer(bgl.GL_INT, 1) self.num_bounds = len(_arrays.bounds_co) bgl.glGenBuffers(1, self.vbo_bounds_co) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vbo_bounds_co[0]) bgl.glBufferData(bgl.GL_ARRAY_BUFFER, self.num_bounds * 12, _arrays.bounds_co, bgl.GL_STATIC_DRAW) bounds_indices = np.arange(self.num_bounds, dtype='f4') self.vbo_bounds = bgl.Buffer(bgl.GL_INT, 1) bgl.glGenBuffers(1, self.vbo_bounds) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vbo_bounds[0]) bgl.glBufferData( bgl.GL_ARRAY_BUFFER, self.num_bounds * 4, np_array_as_bgl_Buffer(bounds_indices), bgl.GL_STATIC_DRAW ) del bounds_indices self._draw_bounds = True del _arrays bgl.glBindVertexArray(0) check_error("glBindVertexArray(0)") def get_tot_elems(self): tot = 0 if self.draw_segs: tot += self.num_segs if self.draw_origin: tot += self.num_origins if self.draw_bounds: tot += self.num_bounds return tot @property def draw_segs(self): return self._draw_segs and self.vbo_segs is not None @property def draw_bounds(self): return self._draw_bounds and self.vbo_bounds is not None @property def draw_origin(self): # origins and isolated vertices return (self._draw_origins or (self._draw_segs and self.is_mesh)) and self.vbo_origin is not None def set_snap_mode(self, snap_mode): self.snap_mode = snap_mode def set_draw_mode(self, draw_segs, draw_origin, draw_bounds): self._draw_segs = draw_segs self._draw_origins = draw_origin self._draw_bounds = draw_bounds @classmethod def set_ProjectionMatrix(cls, P): cls.P = P def set_ModelViewMatrix(self, MV): self.MVP[:] = self.P @ MV def bind(self, co, buf_id, offset): bgl.glUniform1f(self.unif_offset, float(offset)) check_error("glUniform1f") bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, co[0]) check_error("glBindBuffer") bgl.glVertexAttribPointer(self.attr_pos, 3, bgl.GL_FLOAT, bgl.GL_FALSE, 0, self._NULL.buf) check_error("glVertexAttribPointer") bgl.glEnableVertexAttribArray(self.attr_pos) check_error("glEnableVertexAttribArray") bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, buf_id[0]) check_error("glBindBuffer") bgl.glVertexAttribPointer(self.attr_primitive_id, 1, bgl.GL_FLOAT, bgl.GL_FALSE, 0, self._NULL.buf) check_error("glVertexAttribPointer") bgl.glEnableVertexAttribArray(self.attr_primitive_id) check_error("glEnableVertexAttribArray") 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 get_seg_co(self, index): bgl.glBindVertexArray(self.vao[0]) check_error("glBindVertexArray(self.vao[0])") bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vbo_segs_co[0]) check_error("glBindBuffer") bgl.glGetBufferSubData(bgl.GL_ARRAY_BUFFER, index * 24, 24, self.seg_co) check_error("glGetBufferSubData") bgl.glBindVertexArray(0) check_error("glBindVertexArray(0)") return self.seg_co def get_origin_co(self, index): bgl.glBindVertexArray(self.vao[0]) check_error("glBindVertexArray(self.vao[0])") bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vbo_origin_co[0]) check_error("glBindBuffer") bgl.glGetBufferSubData(bgl.GL_ARRAY_BUFFER, index * 12, 12, self.origin_co) check_error("glGetBufferSubData") bgl.glBindVertexArray(0) check_error("glBindVertexArray(0)") return self.origin_co def get_bounds_co(self, index): bgl.glBindVertexArray(self.vao[0]) check_error("glBindVertexArray(self.vao[0])") bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vbo_bounds_co[0]) check_error("glBindBuffer") bgl.glGetBufferSubData(bgl.GL_ARRAY_BUFFER, index * 12, 12, self.bounds_co) check_error("glGetBufferSubData") bgl.glBindVertexArray(0) check_error("glBindVertexArray(0)") return self.bounds_co def __del__(self): del self._NULL if self.vbo_segs_co: bgl.glDeleteBuffers(1, self.vbo_segs_co) bgl.glDeleteBuffers(1, self.vbo_segs) if self.vbo_origin_co: bgl.glDeleteBuffers(1, self.vbo_origin_co) bgl.glDeleteBuffers(1, self.vbo_origin) if self.vbo_bounds_co: bgl.glDeleteBuffers(1, self.vbo_bounds_co) bgl.glDeleteBuffers(1, self.vbo_bounds) bgl.glDeleteVertexArrays(1, self.vao)
def __init__(self, img): print('CustomDrawData.__init__()') self.img = img width, height = self.dimensions = self.img.size imgbytes = img.transpose(Image.FLIP_TOP_BOTTOM).tobytes() nimg = numpy.frombuffer(imgbytes, dtype=numpy.uint8) nimg = nimg.astype(numpy.float32) / 255.0 pixels = bgl.Buffer(bgl.GL_FLOAT, width * height * 4, nimg) # Generate texture self.texture = bgl.Buffer(bgl.GL_INT, 1) bgl.glGenTextures(1, self.texture) bgl.glActiveTexture(bgl.GL_TEXTURE0) bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.texture[0]) bgl.glTexImage2D(bgl.GL_TEXTURE_2D, 0, bgl.GL_RGBA16F, width, height, 0, bgl.GL_RGBA, bgl.GL_FLOAT, pixels) bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MIN_FILTER, bgl.GL_NEAREST) bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MAG_FILTER, bgl.GL_NEAREST) bgl.glBindTexture(bgl.GL_TEXTURE_2D, 0) # Bind shader that converts from scene linear to display space, # use the scene's color management settings. shader_program = bgl.Buffer(bgl.GL_INT, 1) bgl.glGetIntegerv(bgl.GL_CURRENT_PROGRAM, shader_program) # Generate vertex array self.vertex_array = bgl.Buffer(bgl.GL_INT, 1) bgl.glGenVertexArrays(1, self.vertex_array) bgl.glBindVertexArray(self.vertex_array[0]) texturecoord_location = bgl.glGetAttribLocation( shader_program[0], "texCoord") position_location = bgl.glGetAttribLocation(shader_program[0], "pos") bgl.glEnableVertexAttribArray(texturecoord_location) bgl.glEnableVertexAttribArray(position_location) # Generate geometry buffers for drawing textured quad position = [0.0, 0.0, width, 0.0, width, height, 0.0, 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) self.vertex_buffer = bgl.Buffer(bgl.GL_INT, 2) bgl.glGenBuffers(2, self.vertex_buffer) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vertex_buffer[0]) bgl.glBufferData(bgl.GL_ARRAY_BUFFER, 32, position, bgl.GL_STATIC_DRAW) bgl.glVertexAttribPointer(position_location, 2, bgl.GL_FLOAT, bgl.GL_FALSE, 0, None) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vertex_buffer[1]) bgl.glBufferData(bgl.GL_ARRAY_BUFFER, 32, texcoord, bgl.GL_STATIC_DRAW) bgl.glVertexAttribPointer(texturecoord_location, 2, bgl.GL_FLOAT, bgl.GL_FALSE, 0, None) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, 0) bgl.glBindVertexArray(0)
class GPU_Indices_Mesh(): shader = Shader( load_shader('3D_vert.glsl'), None, load_shader('primitive_id_frag.glsl'), ) unif_use_clip_planes = bgl.glGetUniformLocation(shader.program, 'use_clip_planes') unif_clip_plane = bgl.glGetUniformLocation(shader.program, 'clip_plane') unif_MVP = bgl.glGetUniformLocation(shader.program, 'MVP') unif_MV = bgl.glGetUniformLocation(shader.program, 'MV') unif_offset = bgl.glGetUniformLocation(shader.program, 'offset') attr_pos = bgl.glGetAttribLocation(shader.program, 'pos') attr_primitive_id = bgl.glGetAttribLocation(shader.program, 'primitive_id') P = bgl.Buffer(bgl.GL_FLOAT, (4, 4)) MV = bgl.Buffer(bgl.GL_FLOAT, (4, 4)) # returns of public API # vert_index = bgl.Buffer(bgl.GL_INT, 1) tri_co = bgl.Buffer(bgl.GL_FLOAT, (3, 3)) edge_co = bgl.Buffer(bgl.GL_FLOAT, (2, 3)) vert_co = bgl.Buffer(bgl.GL_FLOAT, 3) def __init__(self, obj, draw_tris, draw_edges, draw_verts): self._NULL = VoidBufValue(0) self.MVP = bgl.Buffer(bgl.GL_FLOAT, (4, 4)) self.obj = obj self.draw_tris = draw_tris self.draw_edges = draw_edges self.draw_verts = draw_verts self.vbo = None self.vbo_tris = None self.vbo_edges = None self.vbo_verts = None ## Create VAO ## self.vao = bgl.Buffer(bgl.GL_INT, 1) bgl.glGenVertexArrays(1, self.vao) bgl.glBindVertexArray(self.vao[0]) ## Init Array ## mesh_arrays = _Mesh_Arrays(obj, draw_tris, draw_edges, draw_verts) ## Create VBO for vertices ## if mesh_arrays.verts_co is None: self.draw_tris = False self.draw_edges = False self.draw_verts = False return if False: # Blender 2.8 self.vbo_len = len(mesh_arrays.verts_co) self.vbo = bgl.Buffer(bgl.GL_INT, 1) bgl.glGenBuffers(1, self.vbo) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vbo[0]) bgl.glBufferData(bgl.GL_ARRAY_BUFFER, self.vbo_len * 12, np_array_as_bgl_Buffer(mesh_arrays.verts_co), bgl.GL_STATIC_DRAW) ## Create VBO for Tris ## if mesh_arrays.tri_verts is not None: self.tri_verts = mesh_arrays.tri_verts self.num_tris = len(self.tri_verts) np_tris_co = mesh_arrays.verts_co[mesh_arrays.tri_verts] self.vbo_tris = bgl.Buffer(bgl.GL_INT, 1) bgl.glGenBuffers(1, self.vbo_tris) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vbo_tris[0]) bgl.glBufferData(bgl.GL_ARRAY_BUFFER, self.num_tris * 36, np_array_as_bgl_Buffer(np_tris_co), bgl.GL_STATIC_DRAW) del np_tris_co tri_indices = np.repeat(np.arange(self.num_tris, dtype='f4'), 3) self.vbo_tri_indices = bgl.Buffer(bgl.GL_INT, 1) bgl.glGenBuffers(1, self.vbo_tri_indices) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vbo_tri_indices[0]) bgl.glBufferData(bgl.GL_ARRAY_BUFFER, self.num_tris * 12, np_array_as_bgl_Buffer(tri_indices), bgl.GL_STATIC_DRAW) del tri_indices else: self.num_tris = 0 self.draw_tris = False ## Create VBO for Edges ## if mesh_arrays.edge_verts is not None: self.edge_verts = mesh_arrays.edge_verts self.num_edges = len(self.edge_verts) np_edges_co = mesh_arrays.verts_co[mesh_arrays.edge_verts] self.vbo_edges = bgl.Buffer(bgl.GL_INT, 1) bgl.glGenBuffers(1, self.vbo_edges) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vbo_edges[0]) bgl.glBufferData(bgl.GL_ARRAY_BUFFER, self.num_edges * 24, np_array_as_bgl_Buffer(np_edges_co), bgl.GL_STATIC_DRAW) del np_edges_co edge_indices = np.repeat(np.arange(self.num_edges, dtype='f4'), 2) self.vbo_edge_indices = bgl.Buffer(bgl.GL_INT, 1) bgl.glGenBuffers(1, self.vbo_edge_indices) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vbo_edge_indices[0]) bgl.glBufferData(bgl.GL_ARRAY_BUFFER, self.num_edges * 8, np_array_as_bgl_Buffer(edge_indices), bgl.GL_STATIC_DRAW) del edge_indices else: self.num_edges = 0 self.draw_edges = False ## Create EBO for Loose Verts ## if mesh_arrays.looseverts is not None: self.looseverts = mesh_arrays.looseverts self.num_verts = len(mesh_arrays.looseverts) np_lverts_co = mesh_arrays.verts_co[mesh_arrays.looseverts] self.vbo_verts = bgl.Buffer(bgl.GL_INT, 1) bgl.glGenBuffers(1, self.vbo_verts) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vbo_verts[0]) bgl.glBufferData(bgl.GL_ARRAY_BUFFER, self.num_verts * 12, np_array_as_bgl_Buffer(np_lverts_co), bgl.GL_STATIC_DRAW) del np_lverts_co looseverts_indices = np.arange(self.num_verts, dtype='f4') self.vbo_looseverts_indices = bgl.Buffer(bgl.GL_INT, 1) bgl.glGenBuffers(1, self.vbo_looseverts_indices) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vbo_looseverts_indices[0]) bgl.glBufferData(bgl.GL_ARRAY_BUFFER, self.num_verts * 4, np_array_as_bgl_Buffer(looseverts_indices), bgl.GL_STATIC_DRAW) del looseverts_indices else: self.num_verts = 0 self.draw_verts = False del mesh_arrays bgl.glBindVertexArray(0) def get_tot_elems(self): tot = 0 if self.draw_tris: tot += self.num_tris if self.draw_edges: tot += self.num_edges if self.draw_verts: tot += self.num_verts return tot def set_draw_mode(self, draw_tris, draw_edges, draw_verts): self.draw_tris = draw_tris and self.vbo_tris self.draw_edges = draw_edges and self.vbo_edges self.draw_verts = draw_verts and self.vbo_verts def set_ModelViewMatrix(self, MV): self.MV[:] = MV[:] self.MVP[:] = Matrix(self.P) * MV 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.buf) 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.buf) 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.buf) 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.buf) 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.buf) 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.buf) bgl.glEnableVertexAttribArray(self.attr_primitive_id) bgl.glDrawArrays(bgl.GL_POINTS, 0, self.num_verts) bgl.glDepthRange(0.0, 1.0) def get_tri_co(self, index): bgl.glBindVertexArray(self.vao[0]) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vbo_tris[0]) bgl.glGetBufferSubData(bgl.GL_ARRAY_BUFFER, index * 36, 36, self.tri_co) bgl.glBindVertexArray(0) return self.tri_co def get_edge_co(self, index): bgl.glBindVertexArray(self.vao[0]) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vbo_edges[0]) bgl.glGetBufferSubData(bgl.GL_ARRAY_BUFFER, index * 24, 24, self.edge_co) bgl.glBindVertexArray(0) return self.edge_co def get_loosevert_co(self, index): bgl.glBindVertexArray(self.vao[0]) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vbo_verts[0]) bgl.glGetBufferSubData(bgl.GL_ARRAY_BUFFER, index * 12, 12, self.vert_co) bgl.glBindVertexArray(0) return self.vert_co def get_tri_verts(self, index): return self.tri_verts[index] def get_edge_verts(self, index): return self.edge_verts[index] def get_loosevert_index(self, index): return self.looseverts[index] def __del__(self): del self._NULL if self.vbo_tris: bgl.glDeleteBuffers(1, self.vbo_tris) bgl.glDeleteBuffers(1, self.vbo_tri_indices) del self.tri_verts if self.vbo_edges: bgl.glDeleteBuffers(1, self.vbo_edges) bgl.glDeleteBuffers(1, self.vbo_edge_indices) del self.edge_verts if self.vbo_verts: bgl.glDeleteBuffers(1, self.vbo_verts) bgl.glDeleteBuffers(1, self.vbo_looseverts_indices) del self.looseverts bgl.glDeleteVertexArrays(1, self.vao)
class GPU_Indices: shader = gpu.types.GPUShader(vert_3d, primitive_id_frag) unif_MVP = bgl.glGetUniformLocation(shader.program, 'MVP') unif_offset = bgl.glGetUniformLocation(shader.program, 'offset') attr_pos = bgl.glGetAttribLocation(shader.program, 'pos') attr_primitive_id = bgl.glGetAttribLocation(shader.program, 'primitive_id') # returns of public API # knot_co = bgl.Buffer(bgl.GL_FLOAT, 3) seg_co = bgl.Buffer(bgl.GL_FLOAT, (2, 3)) origin_co = bgl.Buffer(bgl.GL_FLOAT, 3) def __init__(self, obj): self._NULL = VoidBufValue(0) self.MVP = bgl.Buffer(bgl.GL_FLOAT, (4, 4)) # self.obj = obj self.first_index = 0 self.vbo_segs = None self.vbo_segs_co = None self.vbo_origin = None self.vbo_origin_co = None self.num_segs = 0 self.num_origins = 0 self._draw_segs = False self._draw_origins = False self.is_mesh = False self.snap_mode = 0 self.vao = bgl.Buffer(bgl.GL_INT, 1) bgl.glGenVertexArrays(1, self.vao) bgl.glBindVertexArray(self.vao[0]) _arrays = _Object_Arrays(obj) if _arrays.segs_co: self.vbo_segs_co = bgl.Buffer(bgl.GL_INT, 1) self.num_segs = len(_arrays.segs_co) bgl.glGenBuffers(1, self.vbo_segs_co) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vbo_segs_co[0]) bgl.glBufferData(bgl.GL_ARRAY_BUFFER, self.num_segs * 24, _arrays.segs_co, bgl.GL_STATIC_DRAW) segs_indices = np.repeat(np.arange(self.num_segs, dtype='f4'), 2) self.vbo_segs = bgl.Buffer(bgl.GL_INT, 1) bgl.glGenBuffers(1, self.vbo_segs) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vbo_segs[0]) bgl.glBufferData( bgl.GL_ARRAY_BUFFER, self.num_segs * 8, np_array_as_bgl_Buffer(segs_indices), bgl.GL_STATIC_DRAW ) del segs_indices self._draw_segs = True # objects origin if _arrays.origin_co: self.vbo_origin_co = bgl.Buffer(bgl.GL_INT, 1) self.num_origins = len(_arrays.origin_co) bgl.glGenBuffers(1, self.vbo_origin_co) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vbo_origin_co[0]) bgl.glBufferData(bgl.GL_ARRAY_BUFFER, self.num_origins * 12, _arrays.origin_co, bgl.GL_STATIC_DRAW) orig_indices = np.arange(self.num_origins, dtype='f4') self.vbo_origin = bgl.Buffer(bgl.GL_INT, 1) bgl.glGenBuffers(1, self.vbo_origin) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vbo_origin[0]) bgl.glBufferData( bgl.GL_ARRAY_BUFFER, self.num_origins * 4, np_array_as_bgl_Buffer(orig_indices), bgl.GL_STATIC_DRAW ) del orig_indices self.is_mesh = _arrays.is_mesh self._draw_origins = True del _arrays bgl.glBindVertexArray(0) def get_tot_elems(self): tot = 0 if self.draw_segs: tot += self.num_segs if self.draw_origin: tot += self.num_origins return tot @property def draw_segs(self): return self._draw_segs and self.vbo_segs_co is not None def set_snap_mode(self, snap_mode): self.snap_mode = snap_mode @property def draw_origin(self): return (self._draw_origins or (self._draw_segs and self.is_mesh)) and self.vbo_origin_co is not None def set_draw_mode(self, draw_segs, draw_origin): self._draw_segs = draw_segs self._draw_origins = draw_origin @classmethod def set_ProjectionMatrix(cls, P): cls.P = P def set_ModelViewMatrix(self, MV): self.MVP[:] = self.P @ MV def bind(self, co, buf_id, offset): bgl.glUniform1f(self.unif_offset, float(offset)) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, co[0]) bgl.glVertexAttribPointer(self.attr_pos, 3, bgl.GL_FLOAT, bgl.GL_FALSE, 0, self._NULL.buf) bgl.glEnableVertexAttribArray(self.attr_pos) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, buf_id[0]) bgl.glVertexAttribPointer(self.attr_primitive_id, 1, bgl.GL_FLOAT, bgl.GL_FALSE, 0, self._NULL.buf) bgl.glEnableVertexAttribArray(self.attr_primitive_id) 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 get_seg_co(self, index): bgl.glBindVertexArray(self.vao[0]) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vbo_segs_co[0]) bgl.glGetBufferSubData(bgl.GL_ARRAY_BUFFER, index * 24, 24, self.seg_co) bgl.glBindVertexArray(0) return self.seg_co def get_origin_co(self, index): bgl.glBindVertexArray(self.vao[0]) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vbo_origin_co[0]) bgl.glGetBufferSubData(bgl.GL_ARRAY_BUFFER, index * 12, 12, self.origin_co) bgl.glBindVertexArray(0) return self.origin_co def __del__(self): del self._NULL if self.vbo_segs_co: bgl.glDeleteBuffers(1, self.vbo_segs_co) bgl.glDeleteBuffers(1, self.vbo_segs) if self.vbo_origin_co: bgl.glDeleteBuffers(1, self.vbo_origin_co) bgl.glDeleteBuffers(1, self.vbo_origin) bgl.glDeleteVertexArrays(1, self.vao)
def __init__(self, dimensions): global urhoImage # Generate dummy float image buffer self.dimensions = dimensions width, height = dimensions print("NEW CUSTOMDRAWDATA with resolution %s:%s" % (width, height)) blank = Image.new('RGBA', (width, height), (100, 100, 100, 255)) blank.alpha_composite(urhoImage, dest=(int(width / 2 - urhoImage.width / 2), int(height / 2 - urhoImage.height / 2))) #self.pixels = [255,0,0,255] * width * height self.pixels = list(blank.tobytes()) self.pixels = bgl.Buffer(bgl.GL_BYTE, width * height * 4, self.pixels) # Generate texture self.updateTextureOnDraw = False self.texture = bgl.Buffer(bgl.GL_INT, 1) bgl.glGenTextures(1, self.texture) bgl.glActiveTexture(bgl.GL_TEXTURE0) bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.texture[0]) bgl.glTexImage2D(bgl.GL_TEXTURE_2D, 0, bgl.GL_RGBA, width, height, 0, bgl.GL_RGBA, bgl.GL_UNSIGNED_BYTE, self.pixels) bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MIN_FILTER, bgl.GL_LINEAR) bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MAG_FILTER, bgl.GL_LINEAR) bgl.glBindTexture(bgl.GL_TEXTURE_2D, 0) # Bind shader that converts from scene linear to display space, # use the scene's color management settings. shader_program = bgl.Buffer(bgl.GL_INT, 1) bgl.glGetIntegerv(bgl.GL_CURRENT_PROGRAM, shader_program) # Generate vertex array self.vertex_array = bgl.Buffer(bgl.GL_INT, 1) bgl.glGenVertexArrays(1, self.vertex_array) bgl.glBindVertexArray(self.vertex_array[0]) texturecoord_location = bgl.glGetAttribLocation( shader_program[0], "texCoord") position_location = bgl.glGetAttribLocation(shader_program[0], "pos") bgl.glEnableVertexAttribArray(texturecoord_location) bgl.glEnableVertexAttribArray(position_location) # Generate geometry buffers for drawing textured quad position = [0.0, 0.0, width, 0.0, width, height, 0.0, height] position = bgl.Buffer(bgl.GL_FLOAT, len(position), position) texcoord = [0.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0] texcoord = bgl.Buffer(bgl.GL_FLOAT, len(texcoord), texcoord) self.vertex_buffer = bgl.Buffer(bgl.GL_INT, 2) bgl.glGenBuffers(2, self.vertex_buffer) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vertex_buffer[0]) bgl.glBufferData(bgl.GL_ARRAY_BUFFER, 32, position, bgl.GL_STATIC_DRAW) bgl.glVertexAttribPointer(position_location, 2, bgl.GL_FLOAT, bgl.GL_FALSE, 0, None) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vertex_buffer[1]) bgl.glBufferData(bgl.GL_ARRAY_BUFFER, 32, texcoord, bgl.GL_STATIC_DRAW) bgl.glVertexAttribPointer(texturecoord_location, 2, bgl.GL_FLOAT, bgl.GL_FALSE, 0, None) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, 0) bgl.glBindVertexArray(0)
def try_initialize(self): if self.initialized: return self.initialized = True resx, resy = self.resx, self.resy width, height = self.dimensions self.pixels = bgl.Buffer(bgl.GL_FLOAT, resx * resy * 3, self.pixels_np) # Generate texture self.texture = bgl.Buffer(bgl.GL_INT, 1) bgl.glGenTextures(1, self.texture) bgl.glActiveTexture(bgl.GL_TEXTURE0) bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.texture[0]) bgl.glTexImage2D(bgl.GL_TEXTURE_2D, 0, bgl.GL_RGB16F, resx, resy, 0, bgl.GL_RGB, bgl.GL_FLOAT, self.pixels) bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MIN_FILTER, bgl.GL_NEAREST) bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MAG_FILTER, bgl.GL_NEAREST) bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_WRAP_S, bgl.GL_CLAMP_TO_EDGE) bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_WRAP_T, bgl.GL_CLAMP_TO_EDGE) bgl.glBindTexture(bgl.GL_TEXTURE_2D, 0) # Bind shader that converts from scene linear to display space, # use the scene's color management settings. shader_program = bgl.Buffer(bgl.GL_INT, 1) bgl.glGetIntegerv(bgl.GL_CURRENT_PROGRAM, shader_program) # Generate vertex array self.vertex_array = bgl.Buffer(bgl.GL_INT, 1) bgl.glGenVertexArrays(1, self.vertex_array) bgl.glBindVertexArray(self.vertex_array[0]) texturecoord_location = bgl.glGetAttribLocation( shader_program[0], "texCoord") position_location = bgl.glGetAttribLocation(shader_program[0], "pos") bgl.glEnableVertexAttribArray(texturecoord_location) bgl.glEnableVertexAttribArray(position_location) # Generate geometry buffers for drawing textured quad position = [0.0, 0.0, width, 0.0, width, height, 0.0, 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) self.vertex_buffer = bgl.Buffer(bgl.GL_INT, 2) bgl.glGenBuffers(2, self.vertex_buffer) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vertex_buffer[0]) bgl.glBufferData(bgl.GL_ARRAY_BUFFER, 32, position, bgl.GL_STATIC_DRAW) bgl.glVertexAttribPointer(position_location, 2, bgl.GL_FLOAT, bgl.GL_FALSE, 0, None) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vertex_buffer[1]) bgl.glBufferData(bgl.GL_ARRAY_BUFFER, 32, texcoord, bgl.GL_STATIC_DRAW) bgl.glVertexAttribPointer(texturecoord_location, 2, bgl.GL_FLOAT, bgl.GL_FALSE, 0, None) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, 0) bgl.glBindVertexArray(0)
def __init__(self, viewport_dimensions, image_dimensions, pixels): self.log = logging.getLogger('blospray') self.log.info('CustomDrawData.__init__(viewport_dimensions=%s, image_dimensions=%s, fbpixels=%s) [%s]' % \ (viewport_dimensions, image_dimensions, pixels.shape, self)) viewport_width, viewport_height = self.viewport_dimensions = viewport_dimensions image_width, image_height = self.image_dimensions = image_dimensions assert pixels is not None pixels = bgl.Buffer(bgl.GL_FLOAT, image_width * image_height * 4, pixels) # Generate texture self.texture = bgl.Buffer(bgl.GL_INT, 1) bgl.glGenTextures(1, self.texture) bgl.glActiveTexture(bgl.GL_TEXTURE0) bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.texture[0]) bgl.glTexImage2D(bgl.GL_TEXTURE_2D, 0, bgl.GL_RGBA16F, image_width, image_height, 0, bgl.GL_RGBA, bgl.GL_FLOAT, pixels) bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MIN_FILTER, bgl.GL_NEAREST) bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MAG_FILTER, bgl.GL_NEAREST) bgl.glBindTexture(bgl.GL_TEXTURE_2D, 0) # Bind shader that converts from scene linear to display space, # use the scene's color management settings. shader_program = bgl.Buffer(bgl.GL_INT, 1) bgl.glGetIntegerv(bgl.GL_CURRENT_PROGRAM, shader_program) # Generate vertex array self.vertex_array = bgl.Buffer(bgl.GL_INT, 1) bgl.glGenVertexArrays(1, self.vertex_array) bgl.glBindVertexArray(self.vertex_array[0]) texturecoord_location = bgl.glGetAttribLocation( shader_program[0], "texCoord") position_location = bgl.glGetAttribLocation(shader_program[0], "pos") bgl.glEnableVertexAttribArray(texturecoord_location) bgl.glEnableVertexAttribArray(position_location) # Generate geometry buffers for drawing textured quad position = [ 0.0, 0.0, viewport_width, 0.0, viewport_width, viewport_height, 0.0, viewport_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) self.vertex_buffer = bgl.Buffer(bgl.GL_INT, 2) bgl.glGenBuffers(2, self.vertex_buffer) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vertex_buffer[0]) bgl.glBufferData(bgl.GL_ARRAY_BUFFER, 32, position, bgl.GL_STATIC_DRAW) bgl.glVertexAttribPointer(position_location, 2, bgl.GL_FLOAT, bgl.GL_FALSE, 0, None) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vertex_buffer[1]) bgl.glBufferData(bgl.GL_ARRAY_BUFFER, 32, texcoord, bgl.GL_STATIC_DRAW) bgl.glVertexAttribPointer(texturecoord_location, 2, bgl.GL_FLOAT, bgl.GL_FALSE, 0, None) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, 0) bgl.glBindVertexArray(0)
def __init__(self, dimensions, perspective, region3d): self.dimensions = dimensions self.perspective = perspective width = bpy.context.scene.tina_resolution_x height = bpy.context.scene.tina_resolution_y pixels = worker.render_main(width, height, region3d) # Generate dummy image buffer pixels = bgl.Buffer(bgl.GL_INT, width * height, pixels) # Generate texture self.texture = bgl.Buffer(bgl.GL_INT, 1) bgl.glGenTextures(1, self.texture) bgl.glActiveTexture(bgl.GL_TEXTURE0) bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.texture[0]) bgl.glTexImage2D(bgl.GL_TEXTURE_2D, 0, bgl.GL_RGBA16F, width, height, 0, bgl.GL_RGBA, bgl.GL_UNSIGNED_INT_8_8_8_8_REV, pixels) bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MIN_FILTER, bgl.GL_LINEAR) bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MAG_FILTER, bgl.GL_LINEAR) bgl.glBindTexture(bgl.GL_TEXTURE_2D, 0) bgl.glUseProgram(self.program) # Generate vertex array self.vertex_array = bgl.Buffer(bgl.GL_INT, 1) bgl.glGenVertexArrays(1, self.vertex_array) bgl.glBindVertexArray(self.vertex_array[0]) texturecoord_location = bgl.glGetAttribLocation( self.program, "texCoord") position_location = bgl.glGetAttribLocation(self.program, "pos") tex0_location = bgl.glGetAttribLocation(self.program, "tex0") bgl.glUniform1i(tex0_location, 0) bgl.glEnableVertexAttribArray(texturecoord_location) bgl.glEnableVertexAttribArray(position_location) # Generate geometry buffers for drawing textured quad width, height = dimensions position = [0.0, 0.0, width, 0.0, width, height, 0.0, 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) self.vertex_buffer = bgl.Buffer(bgl.GL_INT, 2) bgl.glGenBuffers(2, self.vertex_buffer) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vertex_buffer[0]) bgl.glBufferData(bgl.GL_ARRAY_BUFFER, 32, position, bgl.GL_STATIC_DRAW) bgl.glVertexAttribPointer(position_location, 2, bgl.GL_FLOAT, bgl.GL_FALSE, 0, None) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vertex_buffer[1]) bgl.glBufferData(bgl.GL_ARRAY_BUFFER, 32, texcoord, bgl.GL_STATIC_DRAW) bgl.glVertexAttribPointer(texturecoord_location, 2, bgl.GL_FLOAT, bgl.GL_FALSE, 0, None) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, 0) bgl.glBindVertexArray(0)
def __init__(self, scene, dimensions, perspective, blocksize): print('redraw!') # Generate dummy float image buffer self.dimensions = dimensions self.perspective = perspective width, height = dimensions resx, resy = scene.res if blocksize != 0: resx //= blocksize resy //= blocksize pixels = np.empty(resx * resy * 3, np.float32) scene._fast_export_image(pixels, blocksize) self.pixels = bgl.Buffer(bgl.GL_FLOAT, resx * resy * 3, pixels) # Generate texture self.texture = bgl.Buffer(bgl.GL_INT, 1) bgl.glGenTextures(1, self.texture) bgl.glActiveTexture(bgl.GL_TEXTURE0) bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.texture[0]) bgl.glTexImage2D(bgl.GL_TEXTURE_2D, 0, bgl.GL_RGB16F, resx, resy, 0, bgl.GL_RGB, bgl.GL_FLOAT, self.pixels) bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MIN_FILTER, bgl.GL_NEAREST) bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MAG_FILTER, bgl.GL_NEAREST) bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_WRAP_S, bgl.GL_CLAMP_TO_EDGE) bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_WRAP_T, bgl.GL_CLAMP_TO_EDGE) bgl.glBindTexture(bgl.GL_TEXTURE_2D, 0) # Bind shader that converts from scene linear to display space, # use the scene's color management settings. shader_program = bgl.Buffer(bgl.GL_INT, 1) bgl.glGetIntegerv(bgl.GL_CURRENT_PROGRAM, shader_program) # Generate vertex array self.vertex_array = bgl.Buffer(bgl.GL_INT, 1) bgl.glGenVertexArrays(1, self.vertex_array) bgl.glBindVertexArray(self.vertex_array[0]) texturecoord_location = bgl.glGetAttribLocation( shader_program[0], "texCoord") position_location = bgl.glGetAttribLocation(shader_program[0], "pos") bgl.glEnableVertexAttribArray(texturecoord_location) bgl.glEnableVertexAttribArray(position_location) # Generate geometry buffers for drawing textured quad position = [0.0, 0.0, width, 0.0, width, height, 0.0, 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) self.vertex_buffer = bgl.Buffer(bgl.GL_INT, 2) bgl.glGenBuffers(2, self.vertex_buffer) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vertex_buffer[0]) bgl.glBufferData(bgl.GL_ARRAY_BUFFER, 32, position, bgl.GL_STATIC_DRAW) bgl.glVertexAttribPointer(position_location, 2, bgl.GL_FLOAT, bgl.GL_FALSE, 0, None) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vertex_buffer[1]) bgl.glBufferData(bgl.GL_ARRAY_BUFFER, 32, texcoord, bgl.GL_STATIC_DRAW) bgl.glVertexAttribPointer(texturecoord_location, 2, bgl.GL_FLOAT, bgl.GL_FALSE, 0, None) bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, 0) bgl.glBindVertexArray(0)