def paintGL(self):
            glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
            glClearColor(1.0, 1.0, 1.0, 0.0)
            glLoadIdentity()
            glEnable(GL_CULL_FACE)
            glCullFace(GL_BACK)

            gluLookAt(2.0, 2.0, 4.0, 0.0, 0.0, 0.0, 0.0, 10.0, 0.0)

            glEnable(GL_LIGHTING)

            glTranslatef(0.0, 0.0, 0.0)
            glRotate(self.angle, self.axis[0], self.axis[1], self.axis[2])
            light = ZOpenGLLight(GL_LIGHT0)
            lightPosition = [15.0, 25.0, -25.0, 1.0]
            light.positionv(lightPosition)

            white = [1.0, 1.0, 1.0, 1.0]
            blue = [0.0, 0.0, 1.0, 1.0]
            green = [0.0, 1.0, 0.0, 1.0]
            shininess = 100.0

            material = ZOpenGLMaterial(GL_FRONT)
            material.diffusev(white)
            material.specularv(blue)
            material.shininess(shininess)

            if self.torus != None:
                self.torus.draw()
Example #2
0
        def initializeGL(self):
            glEnable(GL_DEPTH_TEST)
            glMatrixMode(GL_PROJECTION)
            glLoadIdentity()
            glMatrixMode(GL_MODELVIEW)

            self.light = ZOpenGLLight()
            self.material = ZOpenGLMaterial(GL_FRONT)

            self.vertices = [
                [-1.0, -1.0, 1.0],
                [1.0, -1.0, 1.0],
                [1.0, -1.0, -1.0],
                [-1.0, -1.0, -1.0],
                [0.0, 1.0, 0.0],
            ]

            self.indices = [
                [0, 1, 4],  #Triangle: face1
                [1, 2, 4],  #Triangle: face2
                [2, 3, 4],  #Triangle: face3
                [3, 0, 4],  #Triangle] face4
            ]

            self.surfaces = ZOpenGLTriangleSurfaces(self.vertices,
                                                    self.indices)
            self.normals = self.surfaces.calculateSurfaceNormals()
        def initializeGL(self):
            glEnable(GL_DEPTH_TEST)
            glEnable(GL_TEXTURE_2D)

            self.light = ZOpenGLLight(GL_LIGHT0)
            self.light.position(-10.0, -10.0, 20.0, 1.0)
            #self.light.position(10.0, 20.0, 0.0, 1.0)
            glFrontFace(GL_CCW)

            self.material = ZOpenGLMaterial(GL_BACK)
            white = [1.0, 1.0, 1.0, 1.0]
            blue = [0.0, 0.0, 1.0, 1.0]
            shininess = 100

            self.material.diffusev(blue)
            self.material.specularv(white)
            self.material.shininess(shininess)

            self.sphere = None
            self.axis = [-10.0, -10.0, 80.0]

            filename = "../opengl/images/world.topo.bathy.200412.3x860x430.jpg"

            self.createTexture(filename)
            self.parent.set_filenamed_title(filename)
Example #4
0
        def paintGL(self):
            glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
            glLoadIdentity()
            gluLookAt(2.0, 4.0, 8.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0)

            glClearColor(0.0, 0.0, 0.0, 1.0)
            glEnable(GL_CULL_FACE)
            glEnable(GL_LIGHTING)

            glEnable(GL_DEPTH_TEST)
            light = ZOpenGLLight(GL_LIGHT0)
            light.position(10.0, 10.0, 10.0, 1.0)

            material = ZOpenGLMaterial(GL_FRONT)
            material.specular(1.0, 1.0, 1.0, 1.0)
            material.shininess(100.0)

            geometry = ZOpenGLGeometry(None)
            glPushMatrix()
            material.diffuse(0.0, 0.0, 1.0, 1.0)
            glTranslate(-2.0, 1.0, -6.0)
            glRotate(-40.0, 1.0, 0.0, 0.0)
            geometry.solidTorus(1.0, 1.8, 10, 50)
            glPopMatrix()

            glPushMatrix()
            material.diffuse(1.0, 0.0, 0.0, 1.0)
            glTranslate(-2.2, -6.0, -6.0)
            glRotate(10.0, 1.0, 0.0, 0.0)
            geometry.wireTorus(1.0, 1.8, 10, 40)
            glPopMatrix()
Example #5
0
        def initializeGL(self):
            glEnable(GL_DEPTH_TEST)
            glMatrixMode(GL_PROJECTION)
            glLoadIdentity()
            glMatrixMode(GL_MODELVIEW)

            self.vertices = [
                [0.0, 0.0, 0.0],
                [1.0, 0.0, 0.0],
                [1.0, 1.0, 0.0],
                [0.0, 1.0, 0.0],
                [0.0, 0.0, -1.0],
                [1.0, 0.0, -1.0],
                [1.0, 1.0, -1.0],
                [0.0, 1.0, -1.0],
            ]

            self.indices = [[0, 1, 2, 3], [1, 5, 6, 2], [5, 4, 7, 6],
                            [4, 0, 3, 7], [4, 5, 1, 0], [3, 2, 6, 7]]

            self.surfaces = ZOpenGLQuadSurfaces(self.vertices, self.indices)
            #Printf("calculateSurfaceNormals");
            self.normals = self.surfaces.calculateSurfaceNormals()
            #surfaces->displayNormals();

            self.light = ZOpenGLLight()
            self.material = ZOpenGLMaterial(GL_FRONT)
        def initializeGL(self):
            glEnable(GL_DEPTH_TEST)
            glMatrixMode(GL_PROJECTION)
            glLoadIdentity()
            glMatrixMode(GL_MODELVIEW)

            self.light = ZOpenGLLight()
            self.material = ZOpenGLMaterial(GL_FRONT)
            self.geometry = ZOpenGLGeometry(None)
Example #7
0
        def initializeGL(self):
            glEnable(GL_DEPTH_TEST)
            glMatrixMode(GL_PROJECTION)
            glLoadIdentity()
            glMatrixMode(GL_MODELVIEW)
            self.quadric = ZOpenGLQuadric()
            self.materia = ZOpenGLMateria()

            self.cylinder = ZOpenGLCylinder(self.quadric, self.materia)

            self.light = ZOpenGLLight(GL_LIGHT0)
            self.material = ZOpenGLMaterial(GL_FRONT)
Example #8
0
        def initializeGL(self):
            self.light = ZOpenGLLight(GL_LIGHT0)
            #self.light.position(-10.0, -10.0, -10.0, 1.0)
            self.light.position(0.0, 0.0, -20.0, 1.0)

            self.material = ZOpenGLMaterial(GL_FRONT)
            self.sphere = None

            filename = "./images/PIA07782_hires.jpg"
            self.createTexture(filename)
            self.parent.set_filenamed_title(filename)
            self.axis = [-10.0, -10.0, 80.0]
Example #9
0
        def initializeGL(self):
            glEnable(GL_DEPTH_TEST)
            glMatrixMode(GL_PROJECTION)
            glLoadIdentity()
            glMatrixMode(GL_MODELVIEW)
            self.quadric = ZOpenGLQuadric()
            self.materia = ZOpenGLMateria()

            self.sphere = ZOpenGLSphere(self.quadric, self.materia)
            self.sphere.reshape(1.0, 40, 40)

            self.light = ZOpenGLLight(GL_LIGHT0)
            self.material = ZOpenGLMaterial(GL_FRONT)
Example #10
0
        def initializeGL(self):
            glEnable(GL_DEPTH_TEST)
            glMatrixMode(GL_PROJECTION)
            glLoadIdentity()
            glMatrixMode(GL_MODELVIEW)
            self.CUBES = 4
            self.cubes = []
            for i in range(self.CUBES):
                self.cubes.append(
                    ZOpenGLIndexedCube(1.0, -2.0 + 1.2 * i, -2.0 + 1.2 * i,
                                       1.0 - 0.5 * i))

            self.light = ZOpenGLLight(GL_LIGHT0)
            self.material = ZOpenGLMaterial(GL_FRONT)
    def initializeGL(self):
      glEnable(GL_DEPTH_TEST)      
      glMatrixMode(GL_PROJECTION)
      glLoadIdentity()                    
      glMatrixMode(GL_MODELVIEW)

      self.quadric = ZOpenGLQuadric();
      self.quadric.drawStyle(GLU_FILL);
      self.quadric.normals(GLU_SMOOTH);
      self.materia  = ZOpenGLMateria()
      
      self.sphere = ZOpenGLSphere(self.quadric, self.materia)
      self.sphere.reshape(1.0, 40, 40)    
    
      self.light    = ZOpenGLLight()
      self.material = ZOpenGLMaterial(GL_FRONT);
Example #12
0
        def paintGL(self):
            self.mutex.lock()

            if (self.angle < (self.CIRCLE_ANGLE - self.INCREMENT)):
                self.angle += self.INCREMENT
            else:
                self.angle = self.INCREMENT

            if (self.sphere != None):
                pos = self.circle.getOrbitPosition(self.angle)

                glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

                glLoadIdentity()
                gluLookAt(-5.0, 10.0, 4.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0)

                glClearColor(0.0, 0.0, 0.0, 1.0)
                glEnable(GL_CULL_FACE)
                glEnable(GL_LIGHTING)

                glTranslate(0.0, 0.0, 0.0)
                glColor(1.0, 1.0, 1.0)
                #green

                self.circle.draw()

                glTranslate(pos[0], pos[1], pos[2])

                light = ZOpenGLLight(GL_LIGHT0)
                lightPosition = [-2.0, 0.0, -1.0, 1.0]
                light.positionv(lightPosition)

                white = [1.0, 1.0, 1.0, 1.0]
                blue = [0.0, 0.0, 1.0, 1.0]
                green = [0.0, 1.0, 0.0, 1.0]

                shininess = 100.0

                material = ZOpenGLMaterial(GL_FRONT)
                material.diffusev(green)
                material.specularv(white)
                material.shininess(shininess)

                self.sphere.draw()

            self.mutex.unlock()
Example #13
0
        def initializeGL(self):
            #glShadeModel(GL_FLAT)
            #glEnable(GL_DEPTH_TEST)
            #glMatrixMode(GL_PROJECTION)
            #glLoadIdentity()
            #glMatrixMode(GL_MODELVIEW)

            self.light = ZOpenGLLight(GL_LIGHT0)
            self.light.position(0.0, 0.0, 30.0, 1.0)

            self.material = ZOpenGLMaterial(GL_FRONT)

            filename = "./images/TokyoTower.png"

            self.createTexture(filename)
            self.parent.set_filenamed_title(filename)
            self.axis = [60.0, 10.0, 60.0]
Example #14
0
        def initializeGL(self):

            glMatrixMode(GL_PROJECTION)
            glLoadIdentity()

            glEnable(GL_DEPTH_TEST)

            #  ColorNormalVertex<float,4,3,3>
            vertices = [
                [0.5, 0.0, 0.0, 0.5, -0.6, 0.6, 0.6, -0.5, 0.5, 0.5],
                [0.5, 0.0, 0.0, 0.5, -0.6, -0.6, 0.6, -0.5, -0.5, 0.5],
                [0.5, 0.0, 0.0, 0.5, 0.6, 0.6, 0.6, 0.5, 0.5, 0.5],
                [0.5, 0.0, 0.0, 0.5, 0.6, -0.6, 0.6, 0.5, -0.5, 0.5],
                [0.5, 0.0, 0.0, 0.5, 0.6, 0.6, -0.6, 0.5, 0.5, -0.5],
                [0.5, 0.0, 0.0, 0.5, 0.6, -0.6, -0.6, 0.5, -0.5, -0.5],
                [0.5, 0.0, 0.0, 0.5, -0.6, 0.6, -0.6, -0.5, 0.5, -0.5],
                [0.5, 0.0, 0.0, 0.5, -0.6, -0.6, -0.6, -0.5, -0.5, -0.5],
            ]

            indices = [
                0,
                2,
                3,
                1,
                2,
                4,
                5,
                3,
                4,
                6,
                7,
                5,
                6,
                0,
                1,
                7,
                6,
                4,
                2,
                0,
                1,
                3,
                5,
                7,
            ]

            self.n_vertices = len(vertices)

            self.vertexBuffer = ZOpenGLVertexBufferARB()

            self.vertexBuffer.bind()
            float32_bsize = 4
            data_size = self.n_vertices * (4 + 3 + 3) * float32_bsize
            varray = np.array(vertices, dtype="float32")
            self.vertexBuffer.data(data_size, varray, GL_STATIC_DRAW_ARB)
            self.vertexBuffer.unbind()

            self.n_indices = len(indices)

            self.indexBuffer = ZOpenGLIndexBufferARB()
            self.indexBuffer.bind()
            iarray = np.array(indices, dtype="int32")
            self.indexBuffer.data(self.n_indices * 4, iarray,
                                  GL_STATIC_DRAW_ARB)

            self.indexBuffer.unbind()
            self.light = ZOpenGLLight(GL_LIGHT0)
            self.material = ZOpenGLMaterial(GL_FRONT_AND_BACK)