def assign(self, varName, varValue):
assert varName in self.shaderVars, 'Variable %s not found' % varName
try:
v = self.shaderVars[varName]
q, l, t = v['qualifier'], v['location'], v['type']
if l == -1:
if not v['reported']:
dprint('ASSIGNING TO UNUSED ATTRIBUTE (%s): %s = %s' %
(self.name, varName, str(varValue)))
v['reported'] = True
return
if DEBUG_PRINT:
print('%s (%s,%d,%s) = %s' % (varName, q, l, t, str(varValue)))
if q in {'in', 'attribute'}:
if t == 'float':
bgl.glVertexAttrib1f(l, varValue)
elif t == 'int':
bgl.glVertexAttrib1i(l, varValue)
elif t == 'vec2':
bgl.glVertexAttrib2f(l, *varValue)
elif t == 'vec3':
bgl.glVertexAttrib3f(l, *varValue)
elif t == 'vec4':
bgl.glVertexAttrib4f(l, *varValue)
else:
assert False, 'Unhandled type %s for attrib %s' % (t,
varName)
if self.checkErrors:
self.drawing.glCheckError('assign attrib %s = %s' %
(varName, str(varValue)))
elif q in {'uniform'}:
# cannot set bools with BGL! :(
if t == 'float':
bgl.glUniform1f(l, varValue)
elif t == 'vec2':
bgl.glUniform2f(l, *varValue)
elif t == 'vec3':
bgl.glUniform3f(l, *varValue)
elif t == 'vec4':
bgl.glUniform4f(l, *varValue)
elif t == 'mat3':
bgl.glUniformMatrix3fv(l, 1, bgl.GL_TRUE, varValue)
elif t == 'mat4':
bgl.glUniformMatrix4fv(l, 1, bgl.GL_TRUE, varValue)
else:
assert False, 'Unhandled type %s for uniform %s' % (
t, varName)
if self.checkErrors:
self.drawing.glCheckError(
'assign uniform %s (%s %d) = %s' %
(varName, t, l, str(varValue)))
else:
assert False, 'Unhandled qualifier %s for variable %s' % (
q, varName)
except Exception as e:
print('ERROR Shader.assign(%s, %s)): %s' %
(varName, str(varValue), str(e)))
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 assign(self, varName, varValue):
assert varName in self.shaderVars, 'Variable %s not found' % varName
try:
v = self.shaderVars[varName]
q,l,t = v['qualifier'],v['location'],v['type']
if l == -1:
if not v['reported']:
dprint('ASSIGNING TO UNUSED ATTRIBUTE (%s): %s = %s' % (self.name, varName,str(varValue)))
v['reported'] = True
return
if DEBUG_PRINT:
print('%s (%s,%d,%s) = %s' % (varName, q, l, t, str(varValue)))
if q in {'in','attribute'}:
if t == 'float':
bgl.glVertexAttrib1f(l, varValue)
elif t == 'int':
bgl.glVertexAttrib1i(l, varValue)
elif t == 'vec2':
bgl.glVertexAttrib2f(l, *varValue)
elif t == 'vec3':
bgl.glVertexAttrib3f(l, *varValue)
elif t == 'vec4':
bgl.glVertexAttrib4f(l, *varValue)
else:
assert False, 'Unhandled type %s for attrib %s' % (t, varName)
if self.checkErrors:
self.drawing.glCheckError('assign attrib %s = %s' % (varName, str(varValue)))
elif q in {'uniform'}:
# cannot set bools with BGL! :(
if t == 'float':
bgl.glUniform1f(l, varValue)
elif t == 'vec2':
bgl.glUniform2f(l, *varValue)
elif t == 'vec3':
bgl.glUniform3f(l, *varValue)
elif t == 'vec4':
bgl.glUniform4f(l, *varValue)
elif t == 'mat3':
bgl.glUniformMatrix3fv(l, 1, bgl.GL_TRUE, varValue)
elif t == 'mat4':
bgl.glUniformMatrix4fv(l, 1, bgl.GL_TRUE, varValue)
else:
assert False, 'Unhandled type %s for uniform %s' % (t, varName)
if self.checkErrors:
self.drawing.glCheckError('assign uniform %s (%s %d) = %s' % (varName, t, l, str(varValue)))
else:
assert False, 'Unhandled qualifier %s for variable %s' % (q, varName)
except Exception as e:
print('ERROR (assign): ' + str(e))
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 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)
