コード例 #1
0
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()            
コード例 #2
0
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()
コード例 #3
0
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
コード例 #4
0
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()
コード例 #5
0
    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)
コード例 #6
0
    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)))
コード例 #7
0
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()
コード例 #8
0
ファイル: 3d_viewer.py プロジェクト: HBDLP/LearnOpenGL
    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()
コード例 #9
0
ファイル: 3d_viewer.py プロジェクト: F-Wehling/raceflection
    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()
コード例 #10
0
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()
コード例 #11
0
    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)))
コード例 #12
0
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()
コード例 #13
0
 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)
コード例 #14
0
 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
コード例 #15
0
ファイル: shaders.py プロジェクト: MaxwellEdison/PyMine
 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
コード例 #16
0
ファイル: threed.py プロジェクト: viron11111/software-common
 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)
コード例 #17
0
 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])
コード例 #18
0
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
コード例 #19
0
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
コード例 #20
0
ファイル: oglViewer.py プロジェクト: MrSmittyWerben/cg
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
コード例 #21
0
ファイル: mesh_canvas.py プロジェクト: lynch829/brachyprint
    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()
コード例 #22
0
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()
コード例 #23
0
    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)
コード例 #24
0
ファイル: pod_pyopengl.py プロジェクト: szf2020/software_core
    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()
コード例 #25
0
ファイル: 3d_viewer_py3.py プロジェクト: Madrich/assimp
    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)
コード例 #26
0
    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
コード例 #27
0
ファイル: shaders.py プロジェクト: MaxwellEdison/PyMine
 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
コード例 #28
0
    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)
コード例 #29
0
 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
コード例 #30
0
    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()