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