def display(): ''' Objekte rendern ''' global scale, center, points, vbo # Clear framebuffer glClear(GL_COLOR_BUFFER_BIT) # Render Color glColor(1.0, 1.0, 1.0) # Reset modelview matrix glLoadIdentity() # Rotate glRotate(rotateX, 1, 0, 0) glRotate(rotateY, 0, 1, 0) glRotate(rotateZ, 0, 0, 1) # Scale glScale(scale, scale, scale) # move to center glTranslatef(-center[0], -center[1], -center[2]) # load points vbo.bind() glVertexPointerf(vbo) glEnableClientState(GL_VERTEX_ARRAY) glDrawArrays(GL_POINTS, 0, len(points)) vbo.unbind() glDisableClientState(GL_VERTEX_ARRAY) #swap buffer glutSwapBuffers()
def display(): """Render the geometry for the scene.""" # We tell OpenGL to use our compiled shader, this is a simple GLuint that is an opaque token that describes the shader for OpenGL. Until we Use the shader, the GL is using the fixed-function (legacy) rendering pipeline. shaders.glUseProgram(shader2) # Now we tell OpenGL that we want to enable our VBO as the source for geometric data. There are two VBO types that can be active at any given time, a geometric data buffer and an index buffer, the default here is the geometric buffer. try: vbo.bind() try: # Here we tell OpenGL to process vertex (location) data from our vertex pointer (here we pass the VBO). The VBO acts just like regular array data, save that it is stored on the card, rather than in main memory. The VBO object is actually passing in a void pointer (None) for the array pointer, as the start of the enabled VBO is taken as the 0 address for the arrays. # Note the use here of the "typed" glVertexPointerf function, while this is a convenient form for this particular tutorial, most VBO-based rendering will use the standard form which includes specifying offsets, data-types, strides, and the like for interpreting the array. We will see the more involved form in the next tutorial. glEnableClientState(GL_VERTEX_ARRAY); glVertexPointerf(vbo) # Finally we actually tell OpenGL to draw some geometry. Here we tell OpenGL to draw triangles using vertices, starting with the offset 0 and continuing for 9 vertices (that is, three triangles). glDrawArrays always draws "in sequence" from the vertex array. We'll look at using indexed drawing functions later. glDrawArrays(GL_TRIANGLES, 0, 9) # Having completed rendering our geometry, we clean up the OpenGL environment. We unbind our vbo, so that any traditional non-VBO-using code can operate, and unbind our shader so that geometry that uses the fixed-function (legacy) rendering behaviour will work properly. finally: vbo.unbind() glDisableClientState(GL_VERTEX_ARRAY); finally: shaders.glUseProgram( 0 ) pygame.display.flip()
def display(): """ Render all objects""" glClear(GL_COLOR_BUFFER_BIT) # clear screen glColor(0.0, 0.0, 1.0) # render stuff objMax = [ max(points, key=lambda x: x[0])[0], max(points, key=lambda x: x[1])[1], max(points, key=lambda x: x[2])[2] ] objMin = [ min(points, key=lambda x: x[0])[0], min(points, key=lambda x: x[1])[1], min(points, key=lambda x: x[2])[2] ] MITTELPUNKT = [(mi + ma) / 2.0 for mi, ma in zip(objMax, objMin)] SCALEFACTOR = 2 / max([(ma - mi) for ma, mi in zip(objMax, objMin)]) glScale(SCALEFACTOR, SCALEFACTOR, SCALEFACTOR) glTranslate(-MITTELPUNKT[0], -MITTELPUNKT[1], -MITTELPUNKT[2]) vbo.bind() glVertexPointerf(vbo) glEnableClientState(GL_VERTEX_ARRAY) glDrawArrays(GL_POINTS, 0, len(points)) vbo.unbind() glDisableClientState(GL_VERTEX_ARRAY) glutSwapBuffers() # swap buffer
def draw_lines_vbo(vbo, primitive): vbo.copied = False # TODO: We are copying the whole VBO every time!! vbo.bind() gl.glEnableClientState(gl.GL_VERTEX_ARRAY) gl.glVertexPointerf(vbo) gl.glDrawArrays(primitive, 0, len(vbo.data)) gl.glDisableClientState(gl.GL_VERTEX_ARRAY) vbo.unbind()
def recursive_render(self, node, shader): for mesh in node.meshes: stride = 32 diffuse = mesh.material.properties["diffuse"] if len(diffuse) == 3: diffuse.append(1.0) ambient = mesh.material.properties["ambient"] if len(ambient) == 3: ambient.append(1.0) specular = mesh.material.properties["specular"] if len(specular) == 3: specular.append(1.0) shininess = mesh.material.properties["shininess"] Material_diffuse = glGetUniformLocation(shader,"Material_diffuse") Material_ambient = glGetUniformLocation(shader,"Material_ambient") Material_specular = glGetUniformLocation(shader,"Material_specular") Material_shininess = glGetUniformLocation(shader, "shininess") glUniform4f(Material_diffuse, *diffuse) glUniform4f(Material_ambient, *ambient) glUniform4f(Material_specular, *specular) glUniform1f(Material_shininess, shininess) vbo = mesh.gl["vbo"] vbo.bind() glEnableVertexAttribArray(1); glEnableVertexAttribArray(2); glEnableVertexAttribArray(3); glVertexAttribPointer(1, 3, GL_FLOAT, False, stride, vbo ) glVertexAttribPointer(2, 3, GL_FLOAT, False, stride, vbo + 12 ) glVertexAttribPointer(3, 2, GL_FLOAT, False, stride, vbo + 24 ) if(('file', 1L) in mesh.material.properties): file_name = mesh.material.properties[('file', 1L)] texture_gl_id = (self.texture_files[file_name])[1] texture_slot = glGetUniformLocation(shader, "texture"); glBindTexture(GL_TEXTURE_2D, texture_gl_id) glUniform1i(texture_slot, texture_gl_id-1) glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mesh.gl["faces"]) glDrawElements(GL_TRIANGLES, len(mesh.faces) * 3, GL_UNSIGNED_INT, None) vbo.unbind(); glDisableVertexAttribArray(1) glDisableVertexAttribArray(2) glDisableVertexAttribArray(3) glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0) glBindTexture(GL_TEXTURE_2D, 0) for child in node.children: self.recursive_render(child, shader)
def recursive_render(self, node, shader): """ Main recursive rendering method. """ try: m = get_world_transform(self.scene, node) except AttributeError: #probably a new incoming node, that has not yet been converted to numpy self.glize(node) m = get_world_transform(self.scene, node) if node.type == MESH: # if the node has been recently turned into a mesh, we might not # have the mesh data yet. if not hasattr(node, "glmeshes"): self.glize(node) for id in node.glmeshes: stride = 12 # 3 * 4 bytes colorid = self.node2colorid[node] r,g,b= self.get_rgb_from_colorid(colorid) glUniform4f( shader.u_materialDiffuse, r/255.0,g/255.0,b/255.0,1.0 ) glUniformMatrix4fv( shader.u_modelMatrix, 1, GL_TRUE, m ) vbo = self.meshes[id]["vbo"] vbo.bind() glEnableVertexAttribArray( shader.a_vertex ) glVertexAttribPointer( shader.a_vertex, 3, GL_FLOAT,False, stride, vbo ) glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, self.meshes[id]["faces"]) glDrawElements(GL_TRIANGLES, self.meshes[id]["nbfaces"] * 3, GL_UNSIGNED_INT, None) vbo.unbind() glDisableVertexAttribArray( shader.a_vertex ) glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0) for child in node.children: try: self.recursive_render(self.scene.nodes[child], shader) except KeyError as ke: logger.warning("Node ID %s listed as child of %s, but it" " does not exist! Skipping it" % (child, repr(node)))
def display(): glClear(GL_COLOR_BUFFER_BIT) glColor3f(.75, .75, .75) glPolygonMode(GL_FRONT_AND_BACK, GL_LINE) vbo.bind() glVertexPointerf(vbo) glEnableClientState(GL_VERTEX_ARRAY) glDrawArrays(GL_LINES, 0, 14) # GL_TRIANGLES, GL_TRIANGLE_STRIP vbo.unbind() glDisableClientState(GL_VERTEX_ARRAY) glFlush()
def recursive_render(self, node, shader): """ Main recursive rendering method. """ # save model matrix and apply node transformation glPushMatrix() m = node.transformation.transpose() # OpenGL row major glMultMatrixf(m) for mesh in node.meshes: stride = 24 # 6 * 4 bytes diffuse = mesh.material.properties["diffuse"] if len(diffuse) == 3: diffuse.append(1.0) ambient = mesh.material.properties["ambient"] if len(ambient) == 3: ambient.append(1.0) glUniform4f( shader.Material_diffuse, *diffuse ) glUniform4f( shader.Material_ambient, *ambient ) vbo = mesh.gl["vbo"] vbo.bind() glEnableVertexAttribArray( shader.Vertex_position ) glEnableVertexAttribArray( shader.Vertex_normal ) glVertexAttribPointer( shader.Vertex_position, 3, GL_FLOAT,False, stride, vbo ) glVertexAttribPointer( shader.Vertex_normal, 3, GL_FLOAT,False, stride, vbo+12 ) glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mesh.gl["faces"]) glDrawElements(GL_TRIANGLES, len(mesh.faces) * 3, GL_UNSIGNED_INT, None) vbo.unbind() glDisableVertexAttribArray( shader.Vertex_position ) glDisableVertexAttribArray( shader.Vertex_normal ) glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0) for child in node.children: self.recursive_render(child, shader) glPopMatrix()
def display(): global vbo glClear(GL_COLOR_BUFFER_BIT) glColor3f(0.75, 0.75, 0.75) glPolygonMode(GL_FRONT_AND_BACK, GL_LINE) vbo.bind() glVertexPointerf(vbo) glEnableClientState(GL_VERTEX_ARRAY) glDrawArrays(GL_TRIANGLE_STRIP, 0, 16) vbo.unbind() glDisableClientState(GL_VERTEX_ARRAY) glFlush()
def display(): """ Render all objects""" glClear(GL_COLOR_BUFFER_BIT) # clear screen glColor3f(0.75, 0.75, 0.75) # render stuff glPolygonMode(GL_FRONT_AND_BACK, GL_LINE) vbo.bind() glVertexPointerf(vbo) glEnableClientState(GL_VERTEX_ARRAY) glDrawArrays(GL_TRIANGLES, 0, len(points)) vbo.unbind() glDisableClientState(GL_VERTEX_ARRAY) glFlush()
def use(self, vbo, vertex_array_type, n_vertices): try: vbo.bind() glEnableVertexAttribArray(self.position_loc) glEnableVertexAttribArray(self.vertexUV_loc) glVertexAttribPointer(self.position_loc, 3, GL_FLOAT, False, 20, vbo) glVertexAttribPointer(self.vertexUV_loc, 2, GL_FLOAT, False, 20, vbo + 12) glDrawArrays(vertex_array_type, 0, n_vertices) # TRIANGLES except GLerror as e: print("error in ShadedGeometry", e) # , self.modelMatrix finally: vbo.unbind() # Need to cleanup, as always. glDisableVertexAttribArray(self.position_loc) glDisableVertexAttribArray(self.vertexUV_loc)
def render(self, shader, mode, index): """Bind the actual uniform value""" location = shader.getLocation(mode, self.name, uniform=True) if location is not None and location != -1: value = self.currentValue(shader, mode) if value: self.baseFunction(location, index) glActiveTexture(GL_TEXTURE0 + index) glBindTexture(GL_TEXTURE_BUFFER, self.texture(mode)) vbo = value.vbo(mode) vbo.bind() try: glTexBuffer(GL_TEXTURE_BUFFER, self.get_format(), int(vbo)) finally: vbo.unbind() return True return False
def render( self, shader, mode, index ): """Bind the actual uniform value""" location = shader.getLocation( mode, self.name, uniform=True ) if location is not None and location != -1: value = self.currentValue( shader, mode ) if value: self.baseFunction( location, index ) glActiveTexture( GL_TEXTURE0 + index ) glBindTexture( GL_TEXTURE_BUFFER, self.texture( mode ) ) vbo = value.vbo(mode) vbo.bind() try: glTexBuffer( GL_TEXTURE_BUFFER, self.get_format(), int(vbo) ) finally: vbo.unbind() return True return False
def draw(): glDisable(GL_CULL_FACE) for mtl, (vbo, vbo_count) in vbos.iteritems(): mtl.apply() vbo.bind() glEnableClientState(GL_VERTEX_ARRAY) glEnableClientState(GL_NORMAL_ARRAY) glEnableClientState(GL_TEXTURE_COORD_ARRAY) glVertexPointer(3, GL_FLOAT, 36, vbo) glNormalPointer(GL_FLOAT, 36, vbo + 12) glTexCoordPointer(3, GL_FLOAT, 36, vbo + 24) glDrawArrays(GL_TRIANGLES, 0, vbo_count) glDisableClientState(GL_VERTEX_ARRAY) glDisableClientState(GL_NORMAL_ARRAY) glDisableClientState(GL_TEXTURE_COORD_ARRAY) vbo.unbind() glEnable(GL_CULL_FACE)
def draw(): glDisable(GL_CULL_FACE) for mtl, (vbo, vbo_count) in vbos.iteritems(): mtl.apply() vbo.bind() glEnableClientState(GL_VERTEX_ARRAY) glEnableClientState(GL_NORMAL_ARRAY) glEnableClientState(GL_TEXTURE_COORD_ARRAY) glVertexPointer(3, GL_FLOAT, 36, vbo) glNormalPointer(GL_FLOAT, 36, vbo + 12) glTexCoordPointer(3, GL_FLOAT, 36, vbo + 24) glDrawArrays(GL_TRIANGLES, 0, vbo_count) glDisableClientState(GL_VERTEX_ARRAY) glDisableClientState(GL_NORMAL_ARRAY) glDisableClientState(GL_TEXTURE_COORD_ARRAY) vbo.unbind() glEnable(GL_CULL_FACE) glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, [0, 0, 0, 1])
def display(): #print center """ Render all objects""" glClear(GL_COLOR_BUFFER_BIT) # clear screen glColor(color[0], color[1], color[2]) # render stuff glLoadIdentity() glTranslate(newX, newY, 0.0) glMultMatrixf(actOri * rotate(angle, axis)) glScale(scale, scale, scale) glTranslate(-center[0], -center[1], -center[2]) vbo.bind() glPolygonMode(GL_FRONT_AND_BACK, GL_LINE) glVertexPointerf(vbo) glEnableClientState(GL_VERTEX_ARRAY) glDrawArrays(GL_TRIANGLES, 0, len(points)) vbo.unbind() glDisableClientState(GL_VERTEX_ARRAY) glutSwapBuffers() # swap buffer
def display(): """ Render all objects""" glClear(GL_COLOR_BUFFER_BIT) # clear screen glColor(0.0, 0.0, 1.0) # render stuff glLoadIdentity() glRotate(angleX, 1, 0, 0) glRotate(angleY, 0, 1, 0) glRotate(angleZ, 0, 0, 1) glScale(scale, scale, scale) glTranslatef(-center[0], -center[1], -center[2]) glMultMatrixf(actOri * rotate(angle, axis)) vbo.bind() glVertexPointerf(vbo) glEnableClientState(GL_VERTEX_ARRAY) glDrawArrays(GL_POINTS, 0, len(points)) vbo.unbind() glDisableClientState(GL_VERTEX_ARRAY) glutSwapBuffers() # swap buffer
def display(): """ Render all objects""" glClear(GL_COLOR_BUFFER_BIT) # clear screen glColor(1.0, 0.0, 0.0) # render stuff glLoadIdentity() glRotate(rotX, 1, 0, 0) # rotate x glRotate(rotY, 0, 1, 0) # rotate y glRotate(rotZ, 0, 0, 1) # rotate z glScale(scale, scale, scale) # scale to window glTranslate(-center[0], -center[1], -center[2]) vbo.bind() glVertexPointerf(vbo) glEnableClientState(GL_VERTEX_ARRAY) glDrawArrays(GL_POINTS, 0, len(pointList)) vbo.unbind() glDisableClientState(GL_VERTEX_ARRAY) glutSwapBuffers() # swap buffer
def OnDraw(self): '''Redraw the widget. ''' # clear color and depth buffers glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) self.setupScene() for obj in self.displayObjects: glMatrixMode(obj["matrix_mode"]) style = obj["style"] if style == "Red": glColor3f(1.0, 0.7, 0.7) elif style == "Blue": glColor3f(0.7, 0.7, 1.0) else: glColor3f(1.0, 1.0, 1.0) visible = obj["visible"] if not visible: continue if "list" in obj: glCallList(obj["list"]) #if self.controller.showgrid: # self.drawXAxisGrid() # self.drawYAxisGrid() # self.drawZAxisGrid() shaders.glUseProgram(self.shader) try: glUniform4f( self.Global_ambient_loc, .3,.3, .3, 0.5) glUniform4f(self.Light_diffuse_loc, 0.5, 0.5, 0.5, 0.5) glUniform3f(self.Light_location_loc, 0, 1, 10) for obj in self.displayObjects: visible = obj["visible"] if not visible: continue if not "vbo" in obj: continue vbo = obj["vbo"] #vao = obj["vao"] num_triangles = obj["vbo_len"] if not self.highlight: highlight = False else: highlight = True highlight_index = self.highlight_index vbo.bind() ### #glBindVertexArray(vao) try: style = obj["style"] if style == "Grey": glUniform4f(self.Base_colour_loc, 0.7, 0.7, 0.7, 0.5) elif style == "Red": glUniform4f(self.Base_colour_loc, 0.7, 0.3, 0.3, 0.5) elif style == "Blue": glUniform4f(self.Base_colour_loc, 0.3, 0.3, 0.7, 0.5) else: glUniform4f(self.Base_colour_loc, 0.7, 0.7, 0.7, 0.5) glEnableVertexAttribArray( self.Vertex_position_loc ) glEnableVertexAttribArray( self.Vertex_normal_loc ) stride = 24 glVertexAttribPointer(self.Vertex_position_loc, 3, GL_FLOAT, False, stride, vbo) glVertexAttribPointer(self.Vertex_normal_loc, 3, GL_FLOAT, False, stride, vbo+12) if not highlight: glDrawArrays(GL_TRIANGLES, 0, num_triangles) ### #glDrawElements(GL_TRIANGLES, num_triangles, GL_UNSIGNED_INT, None) else: if highlight_index == 0: glUniform4f(self.Base_colour_loc, 0.2, 0.2, 0.2, 0.5) glDrawArrays(GL_TRIANGLES, 0, 3) glUniform4f(self.Base_colour_loc, 0.7, 0.7, 0.7, 0.5) glDrawArrays(GL_TRIANGLES, 3, num_triangles-3) elif highlight_index == num_triangles-2: glUniform4f(self.Base_colour_loc, 0.2, 0.2, 0.2, 0.5) glDrawArrays(GL_TRIANGLES, 0, num_triangles-3) glUniform4f(self.Base_colour_loc, 0.7, 0.7, 0.7, 0.5) glDrawArrays(GL_TRIANGLES, num_triangles-3, 3) else: glUniform4f(self.Base_colour_loc, 0.7, 0.7, 0.7, 0.5) glDrawArrays(GL_TRIANGLES, 0, highlight_index) glDrawArrays(GL_TRIANGLES, highlight_index+3, num_triangles-highlight_index-3) glUniform4f(self.Base_colour_loc, 0.2, 0.2, 0.2, 0.5) glDrawArrays(GL_TRIANGLES, highlight_index, 3) finally: vbo.unbind() glDisableVertexAttribArray( self.Vertex_position_loc ) glDisableVertexAttribArray( self.Vertex_normal_loc ) finally: shaders.glUseProgram(0) self.SwapBuffers()
def display(): ''' Display of object ''' global scaleFactor, center, vbo, actOri, angle, axis, data, newXPos, newYPos, zoomFactor, shadow, lightPos, wire, light # set color glColor(current_color) glMatrixMode(GL_MODELVIEW) # Clear framebuffer glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) # Reset modelview matrix glLoadIdentity() # set to solid view glPolygonMode(GL_FRONT_AND_BACK, GL_FILL) if light: glEnable(GL_LIGHTING) glEnable(GL_LIGHT0) glEnable(GL_DEPTH_TEST) glEnable(GL_COLOR_MATERIAL) glEnable(GL_DEPTH_TEST) glEnable(GL_NORMALIZE) glLightfv(GL_LIGHT0, GL_POSITION, [lightPos[0], lightPos[1], lightPos[2], 0.0]) else: glDisable(GL_LIGHTING) vbo.bind() glEnableClientState(GL_VERTEX_ARRAY) glEnableClientState(GL_NORMAL_ARRAY) glVertexPointer(3, GL_FLOAT, 24, vbo) glNormalPointer(GL_FLOAT, 24, vbo + 12) # Translate #print(newXPos, newYPos) glTranslate(newXPos, newYPos, 0.0) # Rotate glMultMatrixf(actOri * rotate(angle, axis)) # Scale glScale(scaleFactor, scaleFactor, scaleFactor) glDrawArrays(GL_TRIANGLES, 0, len(data)) if shadow: glDisable(GL_LIGHTING) glMatrixMode(GL_MODELVIEW) p = [ 1.0, 0, 0, 0, 0, 1.0, 0, -1.0 / lightPos[1], 0, 0, 1.0, 0, 0, 0, 0, 0 ] glTranslatef( 0.0, boundingBox[0][1] if boundingBox[0][1] < 0 else -boundingBox[0][1], 0.0) glPushMatrix() glTranslatef(lightPos[0], lightPos[1], lightPos[2]) glMultMatrixf(p) glTranslatef(-lightPos[0], -lightPos[1], -lightPos[2]) glColor(SHADOW) glTranslate( 0.0, -boundingBox[0][1] if boundingBox[0][1] < 0 else boundingBox[0][1], 0.0) glDrawArrays(GL_TRIANGLES, 0, len(data)) glColor(current_color) glPopMatrix() vbo.unbind() glDisableClientState(GL_VERTEX_ARRAY) glDisableClientState(GL_NORMAL_ARRAY) # swap buffer glutSwapBuffers()
def recursive_render(self, node, shader, mode=BASE, with_normals=True): """ Main recursive rendering method. """ normals = with_normals if mode == COLORS: normals = False if not hasattr(node, "selected"): node.selected = False m = get_world_transform(self.scene, node) # HELPERS mode ### if mode == HELPERS: # if node.type == ENTITY: self.render_axis( m, label=node.name if node != self.scene.rootnode else None, selected=node.selected if hasattr(node, "selected") else False) if node.type == CAMERA: self.render_camera(node, m) for child in node.children: self.recursive_render(child, shader, mode) return # Mesh rendering modes ### if node.type == MESH: for mesh in node.meshes: stride = 24 # 6 * 4 bytes if node.selected and mode == SILHOUETTE: glUniform4f(shader.u_materialDiffuse, 1.0, 0.0, 0.0, 1.0) glUniformMatrix4fv(shader.u_modelViewMatrix, 1, GL_TRUE, numpy.dot(self.view_matrix, m)) else: if mode == COLORS: colorid = self.node2colorid[node.name] r, g, b = self.get_rgb_from_colorid(colorid) glUniform4f(shader.u_materialDiffuse, r / 255.0, g / 255.0, b / 255.0, 1.0) elif mode == SILHOUETTE: glUniform4f(shader.u_materialDiffuse, .0, .0, .0, 1.0) else: if node.selected: diffuse = (1.0, 0.0, 0.0, 1.0 ) # selected nodes in red else: diffuse = mesh.material.properties["diffuse"] if len(diffuse) == 3: # RGB instead of expected RGBA diffuse.append(1.0) glUniform4f(shader.u_materialDiffuse, *diffuse) # if ambient: # glUniform4f( shader.Material_ambient, *mat["ambient"] ) if mode == BASE: # not in COLORS or SILHOUETTE normal_matrix = linalg.inv( numpy.dot(self.view_matrix, m)[0:3, 0:3]).transpose() glUniformMatrix3fv(shader.u_normalMatrix, 1, GL_TRUE, normal_matrix) glUniformMatrix4fv(shader.u_modelMatrix, 1, GL_TRUE, m) vbo = mesh.gl["vbo"] vbo.bind() glEnableVertexAttribArray(shader.a_vertex) if normals: glEnableVertexAttribArray(shader.a_normal) glVertexAttribPointer(shader.a_vertex, 3, GL_FLOAT, False, stride, vbo) if normals: glVertexAttribPointer(shader.a_normal, 3, GL_FLOAT, False, stride, vbo + 12) glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mesh.gl["faces"]) glDrawElements(GL_TRIANGLES, mesh.gl["nbfaces"] * 3, GL_UNSIGNED_INT, None) vbo.unbind() glDisableVertexAttribArray(shader.a_vertex) if normals: glDisableVertexAttribArray(shader.a_normal) glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0) for child in node.children: self.recursive_render(child, shader, mode)
def recursive_render(self, node, texture, shader, color): """ Main recursive rendering method. """ # save model matrix and apply node transformation glPushMatrix() m = node.transformation.transpose() # OpenGL row major glMultMatrixf(m) for mesh in node.meshes: stride = 32 # 8 * 4 bytes #diffuse = mesh.material.properties["diffuse"] #if len(diffuse) == 3: diffuse.append(1.0) #ambient = mesh.material.properties["ambient"] #if len(ambient) == 3: ambient.append(1.0) glUniform4f( shader.Material_diffuse, *color ) glUniform4f( shader.Material_ambient, *color ) # has been bound to texture #0 (i.e. texture #1... confusing) if texture: glBindTexture(GL_TEXTURE_2D, texture) glUniform1i(shader.thetexture,0) else: glBindTexture(GL_TEXTURE_2D, self.dummy_texture) glUniform1i(shader.thetexture,0) vbo = mesh.gl["vbo"] vbo.bind() glEnableVertexAttribArray( shader.Vertex_position ) glEnableVertexAttribArray( shader.Vertex_normal ) glEnableVertexAttribArray( shader.texcoords ) glVertexAttribPointer( shader.Vertex_position, 3, GL_FLOAT,False, stride, vbo ) glVertexAttribPointer( shader.Vertex_normal, 3, GL_FLOAT,False, stride, vbo+12 ) glVertexAttribPointer( shader.texcoords, 2, GL_FLOAT,False, stride, vbo+24 ) glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mesh.gl["faces"]) glDrawElements(GL_TRIANGLES, len(mesh.faces) * 3, GL_UNSIGNED_INT, None) vbo.unbind() glDisableVertexAttribArray( shader.Vertex_position ) glDisableVertexAttribArray( shader.Vertex_normal ) glDisableVertexAttribArray( shader.texcoords ) glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0) glBindTexture(GL_TEXTURE_2D, 0) for child in node.children: self.recursive_render(child, texture, shader, color) glPopMatrix()
def recursive_render(self, node, shader, mode=BASE, with_normals=True): """ Main recursive rendering method. """ normals = with_normals if mode == COLORS: normals = False if not hasattr(node, "selected"): node.selected = False m = get_world_transform(self.scene, node) # HELPERS mode ### if mode == HELPERS: # if node.type == ENTITY: self.render_axis(m, label=node.name if node != self.scene.rootnode else None, selected=node.selected if hasattr(node, "selected") else False) if node.type == CAMERA: self.render_camera(node, m) for child in node.children: self.recursive_render(child, shader, mode) return # Mesh rendering modes ### if node.type == MESH: for mesh in node.meshes: stride = 24 # 6 * 4 bytes if node.selected and mode == SILHOUETTE: glUniform4f(shader.u_materialDiffuse, 1.0, 0.0, 0.0, 1.0) glUniformMatrix4fv(shader.u_modelViewMatrix, 1, GL_TRUE, numpy.dot(self.view_matrix, m)) else: if mode == COLORS: colorid = self.node2colorid[node.name] r, g, b = self.get_rgb_from_colorid(colorid) glUniform4f(shader.u_materialDiffuse, r / 255.0, g / 255.0, b / 255.0, 1.0) elif mode == SILHOUETTE: glUniform4f(shader.u_materialDiffuse, .0, .0, .0, 1.0) else: if node.selected: diffuse = (1.0, 0.0, 0.0, 1.0) # selected nodes in red else: diffuse = mesh.material.properties["diffuse"] if len(diffuse) == 3: # RGB instead of expected RGBA diffuse.append(1.0) glUniform4f(shader.u_materialDiffuse, *diffuse) # if ambient: # glUniform4f( shader.Material_ambient, *mat["ambient"] ) if mode == BASE: # not in COLORS or SILHOUETTE normal_matrix = linalg.inv(numpy.dot(self.view_matrix, m)[0:3, 0:3]).transpose() glUniformMatrix3fv(shader.u_normalMatrix, 1, GL_TRUE, normal_matrix) glUniformMatrix4fv(shader.u_modelMatrix, 1, GL_TRUE, m) vbo = mesh.gl["vbo"] vbo.bind() glEnableVertexAttribArray(shader.a_vertex) if normals: glEnableVertexAttribArray(shader.a_normal) glVertexAttribPointer( shader.a_vertex, 3, GL_FLOAT, False, stride, vbo ) if normals: glVertexAttribPointer( shader.a_normal, 3, GL_FLOAT, False, stride, vbo + 12 ) glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mesh.gl["faces"]) glDrawElements(GL_TRIANGLES, mesh.gl["nbfaces"] * 3, GL_UNSIGNED_INT, None) vbo.unbind() glDisableVertexAttribArray(shader.a_vertex) if normals: glDisableVertexAttribArray(shader.a_normal) glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0) for child in node.children: self.recursive_render(child, shader, mode)
def draw_fbo_cube(self, planetdescriptor, face, synth_pass, facex, facey, level, tex_in): #debug code self.timer.start() w = h = self.fbo_tex_size ds_exp = 0 bord = 0 if synth_pass == 'pass_1': #setup for heightmap rendering #1 pixel border h += 2 w += 2 ds_exp = 1.0 / float(w) material = MaterialManager.Materials[ planetdescriptor.height_material] else: material = MaterialManager.Materials[ planetdescriptor.normal_material] #define rendering target: the texture to create texture = glGenTextures(1) glActiveTexture(GL_TEXTURE5) glBindTexture(GL_TEXTURE_2D, texture) glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE) glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0) glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, w, h, 0, GL_RGBA, GL_FLOAT, None) glBindTexture(GL_TEXTURE_2D, 0) #activate the rendering program glUseProgram(material) #standard dimensions for the scene cube ds = self.ds dz = np.cos(np.radians(45.0)) / np.sin(np.radians(45.0)) * ds #specific setup depending on pass (heightmap or normal) if synth_pass == 'pass_1': #setup for heightmap rendering #fov adapted to level glBindTexture(GL_TEXTURE_2D, 0) glDisable(GL_TEXTURE_2D) fov = 90.0 txindex = -1 #won't use texture coords matpass = '******' posattr = glGetAttribLocation(material, 'position') glEnableVertexAttribArray(posattr) glUniform1f(glGetUniformLocation(material, 'hmap_border_factor'), ds_exp / (2.0**level)) glUniform1f(glGetUniformLocation(material, 'hmap_dx'), facex * ds) glUniform1f(glGetUniformLocation(material, 'hmap_dy'), facey * ds) glUniform1f(glGetUniformLocation(material, 'patchscale'), 1.0 / (2.0**level)) glUniform1i(glGetUniformLocation(material, 'level'), level) fbo = self.hfbo vbo = self.p1vbo ibo = self.ibo stride = 4 * 3 if synth_pass == 'pass_2': glEnable(GL_TEXTURE_2D) glActiveTexture(GL_TEXTURE0) glBindTexture(GL_TEXTURE_2D, tex_in) fov = 90.0 txindex = 1 #will use texture coords #glGetAttribLocation(material,'texturecoord') faceindexlocation = glGetUniformLocation(material, 'cubefacedebug') glUniform1i(faceindexlocation, face) matpass = '******' posattr = glGetAttribLocation(material, 'position') texattr = glGetAttribLocation(material, 'texcoord') glEnableVertexAttribArray(posattr) glEnableVertexAttribArray(texattr) glUniform1f(glGetUniformLocation(material, 'planet_radius'), planetdescriptor.radius) glUniform1f(glGetUniformLocation(material, 'planet_height'), planetdescriptor.height) glUniform2f(glGetUniformLocation(material, 'patchcenter'), facex, facey) glUniform1f(glGetUniformLocation(material, 'patchscale'), 1.0 / (2.0**level)) glUniform1i(glGetUniformLocation(material, 'level'), level) fbo = self.nfbo vbo = self.p2vbo ibo = self.ibo stride = 4 * (2 + 3) #bind fbo and set render target glBindFramebuffer(GL_FRAMEBUFFER, fbo) glDrawBuffer(GL_COLOR_ATTACHMENT0) glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0) #set up virtual camera fov (position will be set up just before draw) glClearColor(1.0, 0.0, 0.0, 1.0) glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) glDisable(GL_LIGHTING) glShadeModel(GL_SMOOTH) glMatrixMode(GL_PROJECTION) glLoadIdentity() gluPerspective(fov, float(w) / float(h), 0.001, 100.0) glMatrixMode(GL_MODELVIEW) glLoadIdentity() #set up rotation matrix for the cube face matrotlocation = glGetUniformLocation(material, 'rotcubev') glUniformMatrix3fv(matrotlocation, 1, False, self.matcube[matpass][face]) glViewport(0, 0, w, h) glPolygonMode(GL_FRONT_AND_BACK, GL_FILL) glClearColor(0.0, 1.0, 0.0, 1.0) vbo.bind() ibo.bind() glVertexAttribPointer(posattr, 3, GL_FLOAT, GL_FALSE, stride, vbo) if txindex <> -1: glVertexAttribPointer(texattr, 2, GL_FLOAT, GL_FALSE, stride, vbo + (3 * 4)) glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, ibo) vbo.unbind() ibo.unbind() glFinish() #disable FBO st = glCheckFramebufferStatus(GL_FRAMEBUFFER) #ALternative 1 (works) # glReadBuffer(GL_COLOR_ATTACHMENT0) # data = None # data = glReadPixels(0,0,w, h, GL_RGBA, GL_UNSIGNED_BYTE) glBindTexture(GL_TEXTURE_2D, 0) glBindFramebuffer(GL_FRAMEBUFFER, 0) glUseProgram(0) #glDeleteFramebuffers([fbo]) #Alternative 2 (works, and the output type is not necessary) # if level == 4: if level == 99: glBindTexture(GL_TEXTURE_2D, texture) OpenGL.UNSIGNED_BYTE_IMAGES_AS_STRING = False data = glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_FLOAT, outputType='str') min = 99999 max = -99999 for row in data: for el in row: if el[3] > max: max = el[3] if el[3] < min: min = el[3] print min print max glBindTexture(GL_TEXTURE_2D, texture) #debug code #print 'fbo '+synth_pass+str(face)+' '+str(self.timer.stop()*1000)+' ms' #self.timer.start() #debug code: save textures # from PIL import Image # image = Image.frombytes('RGBA', (w,h), data, 'raw') # image = image.transpose(Image.FLIP_TOP_BOTTOM) # image.save ('Media/Textures/f'+str(face)+' x'+str(facex)+' y'+str(facey)+' l'+str(level)+' m'+str(material)+' fv'+str(fov)+' fb'+str(fbo)+' '+synth_pass+'.png') # #debug code #print 'fbo save txt '+synth_pass+str(face)+' '+str(self.timer.stop()*1000)+' ms' if synth_pass == 'pass_1': return texture else: return texture
def bind( self, mode ): """Bind this buffer so that we can perform e.g. mappings on it""" vbo = self.vbo(mode) vbo.bind() return vbo
def recursive_render(self, node, shader, mode=BASE, with_normals=True): """ Main recursive rendering method. """ normals = with_normals if mode == COLORS: normals = False if not hasattr(node, "selected"): node.selected = False m = get_world_transform(self.scene, node) # HELPERS mode ### if mode == HELPERS: # if node.type == ENTITY: self.render_axis(m, label=node.name if node != self.scene.rootnode else None, selected=node.selected if hasattr(node, "selected") else False) if node.type == CAMERA: self.render_camera(node, m) for child in node.children: self.recursive_render(child, shader, mode) return # Mesh rendering modes ### if node.type == MESH: for mesh in node.meshes: stride = 24 # 6 * 4 bytes if node.selected and mode == SILHOUETTE: glUniform4f(shader.u_materialDiffuse, 1.0, 0.0, 0.0, 1.0) glUniformMatrix4fv(shader.u_modelViewMatrix, 1, GL_TRUE, numpy.dot(self.view_matrix, m)) else: if mode == COLORS: colorid = self.node2colorid[node.name] r, g, b = self.get_rgb_from_colorid(colorid) glUniform4f(shader.u_materialDiffuse, r / 255.0, g / 255.0, b / 255.0, 1.0) elif mode == SILHOUETTE: glUniform4f(shader.u_materialDiffuse, .0, .0, .0, 1.0) else: if node.selected: diffuse = (1.0, 0.0, 0.0, 1.0) # selected nodes in red else: global part1ChangeIndex, part2ChangeIndex, part3ChangeIndex, part4ChangeIndex,\ part5ChangeIndex, tIndex, temperature, Tmin, Tmax, nt, diffuse1 # diffuse = mesh.material.properties["diffuse"] if tIndex < nt: if node.name == "Part1": part1ChangeIndex = 1 diffuse1[0] = (temperature[tIndex][0]-Tmin)/(Tmax - Tmin) diffuse1[1] = (temperature[tIndex][0]-Tmin)/(Tmax - Tmin) diffuse1[2] = (temperature[tIndex][0]-Tmin)/(Tmax - Tmin) # print("Part1:",temperature[tIndex][0]) elif node.name == "Part2": part2ChangeIndex = 1 diffuse2[0] = (temperature[tIndex][1]-Tmin) / (Tmax-Tmin) diffuse2[1] = (temperature[tIndex][1]-Tmin) / (Tmax-Tmin) diffuse2[2] = (temperature[tIndex][1]-Tmin) / (Tmax-Tmin) # print("Part2:",temperature[tIndex][1]) elif node.name == "Part3": part3ChangeIndex = 1 diffuse3[0] = (temperature[tIndex][2]-Tmin) / (Tmax-Tmin) diffuse3[1] = (temperature[tIndex][2]-Tmin) / (Tmax-Tmin) diffuse3[2] = (temperature[tIndex][2]-Tmin) / (Tmax-Tmin) # print("Part3:", temperature[tIndex][2]) elif node.name == "Part4": part4ChangeIndex = 1 diffuse4[0] = (temperature[tIndex][3]-Tmin) / (Tmax-Tmin) diffuse4[1] = (temperature[tIndex][3]-Tmin) / (Tmax-Tmin) diffuse4[2] = (temperature[tIndex][3]-Tmin) / (Tmax-Tmin) # print("Part4:", temperature[tIndex][3]) else: part5ChangeIndex = 1 diffuse5[0] = (temperature[tIndex][4]-Tmin) / (Tmax-Tmin) diffuse5[1] = (temperature[tIndex][4]-Tmin) / (Tmax-Tmin) diffuse5[2] = (temperature[tIndex][4]-Tmin) / (Tmax-Tmin) # print("Part5:", temperature[tIndex][1]) if part1ChangeIndex==1 and part2ChangeIndex==1 and part3ChangeIndex==1 and part4ChangeIndex==1 \ and part5ChangeIndex==1: part1ChangeIndex=0 part2ChangeIndex=0 part3ChangeIndex=0 part4ChangeIndex=0 part5ChangeIndex=0 print("Part1:", temperature[tIndex][0]," Part2:", temperature[tIndex][1]," Part3:", temperature[tIndex][2]," Part4:", temperature[tIndex][3]," Part5:", temperature[tIndex][4]) tIndex+=1 if node.name == "Part1": diffuse = diffuse1 elif node.name == "Part2": diffuse = diffuse2 elif node.name == "Part3": diffuse = diffuse3 elif node.name == "Part4": diffuse = diffuse4 else: diffuse = diffuse5 if len(diffuse) == 3: # RGB instead of expected RGBA diffuse.append(1.0) glUniform4f(shader.u_materialDiffuse, *diffuse) # if ambient: # glUniform4f( shader.Material_ambient, *mat["ambient"] ) if mode == BASE: # not in COLORS or SILHOUETTE normal_matrix = linalg.inv(numpy.dot(self.view_matrix, m)[0:3, 0:3]).transpose() # glUniformMatrix3fv(shader.u_normalMatrix, 1, GL_TRUE, normal_matrix) glUniformMatrix4fv(shader.u_modelMatrix, 1, GL_TRUE, m) vbo = mesh.gl["vbo"] vbo.bind() glEnableVertexAttribArray(shader.a_vertex) # if normals: # glEnableVertexAttribArray(shader.a_normal) glVertexAttribPointer( shader.a_vertex, 3, GL_FLOAT, False, stride, vbo ) # if normals: # glVertexAttribPointer( # shader.a_normal, # 3, GL_FLOAT, False, stride, vbo + 12 # ) glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mesh.gl["faces"]) glDrawElements(GL_TRIANGLES, mesh.gl["nbfaces"] * 3, GL_UNSIGNED_INT, None) vbo.unbind() glDisableVertexAttribArray(shader.a_vertex) # if normals: # glDisableVertexAttribArray(shader.a_normal) glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0) # self.DrawCircle(8, 100, False) for child in node.children: self.recursive_render(child, shader, mode)
def bind(self, mode): """Bind this buffer so that we can perform e.g. mappings on it""" vbo = self.vbo(mode) vbo.bind() return vbo
def recursive_render(self, node, kwargs): # Main recursive rendering method. # save model matrix and apply node transformation glPushMatrix() m = node.transformation.transpose() # OpenGL row major glMultMatrixf(m) for mesh in node.meshes: if mesh.gl["texture"]: stride = 36 # 9 * 4 bytes shader = GLModel.shaders["tex"] glUseProgram(shader) glBindTexture(GL_TEXTURE_2D, mesh.gl["texture"]) glEnableVertexAttribArray(shader.Vertex_position) glEnableVertexAttribArray(shader.Vertex_texcoords) vbo = mesh.gl["vbo"] vbo.bind() glVertexAttribPointer(shader.Vertex_position, 3, GL_FLOAT, False, stride, vbo) glVertexAttribPointer(shader.Vertex_texcoords, 3, GL_FLOAT, False, stride, vbo + 24) glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mesh.gl["faces"]) glDrawElements(GL_TRIANGLES, len(mesh.faces) * 3, GL_UNSIGNED_INT, None) vbo.unbind() glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0) glDisableVertexAttribArray(shader.Vertex_position) glDisableVertexAttribArray(shader.Vertex_texcoords) glBindTexture(GL_TEXTURE_2D, 0) else: stride = 24 # 6 * 4 bytes shader = GLModel.shaders["color"] glUseProgram(shader) diffuse = mesh.material.properties["diffuse"] if len(diffuse) == 3: diffuse.append(1.0) glUniform4f(shader.Material_diffuse, *diffuse) ambient = mesh.material.properties["ambient"] if len(ambient) == 3: ambient.append(1.0) glUniform4f(shader.Material_ambient, *ambient) glEnableVertexAttribArray(shader.Vertex_position) glEnableVertexAttribArray(shader.Vertex_normal) vbo = mesh.gl["vbo"] vbo.bind() glVertexAttribPointer(shader.Vertex_position, 3, GL_FLOAT, False, stride, vbo) glVertexAttribPointer(shader.Vertex_normal, 3, GL_FLOAT, False, stride, vbo + 12) glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mesh.gl["faces"]) glDrawElements(GL_TRIANGLES, len(mesh.faces) * 3, GL_UNSIGNED_INT, None) vbo.unbind() glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0) glDisableVertexAttribArray(shader.Vertex_position) glDisableVertexAttribArray(shader.Vertex_normal) glBindTexture(GL_TEXTURE_2D, 0) for child in node.children: self.recursive_render(child, kwargs) glPopMatrix()