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, 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(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_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)
