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()
Ejemplo n.º 2
0
        def paintGL(self):
            self.mutex.lock()

            for i in range(NUMBER_OF_PLANETS):
                if (self.angles[i] < CIRCLE_ANGLE - INCREMENT[i]):
                    self.angles[i] += INCREMENT[i]
                else:
                    self.angles[i] = INCREMENT[i]

            glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

            glLoadIdentity()
            gluLookAt(-1.0, 8.0, 17.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)

            glColor(1.0, 1.0, 1.0)

            glTranslate(0, 0, 0)
            self.sun.draw()  # 0.0, 0.0, 0.0)

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

            for i in range(NUMBER_OF_PLANETS):
                pos = self.orbits[i].getOrbitPosition(int(self.angles[i]))
                glPushMatrix()
                glTranslate(pos[0], pos[1], pos[2])
                self.planets[i].draw()
                glPopMatrix()

            self.mutex.unlock()
Ejemplo n.º 3
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()
Ejemplo n.º 4
0
    class OpenGLView(ZOpenGLView):

        ## Constructor
        def __init__(self, parent=None):
            self.parent = parent
            super(ZOpenGLView, self).__init__(parent)

        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)

        def paintGL(self):
            glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
            glLoadIdentity()

            glTranslate(0.0, 0.0, -1.0)
            gluLookAt(2.0, 4.0, 6.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0)
            glClearColor(1.0, 0.8, 0.8, 1.0)

            state1 = ZOpenGLClientState(GL_VERTEX_ARRAY)
            state2 = ZOpenGLClientState(GL_COLOR_ARRAY)
            state3 = ZOpenGLClientState(GL_NORMAL_ARRAY)
            state1.enable()
            state2.enable()
            state3.enable()

            lightPosition = [5.0, 5.0, -8.0, 1.0]
            lightColor = [1.0, 0.0, 0.0, 1.0]
            materialColor = [0.8, 0.8, 0.4, 1.0]

            glEnable(GL_LIGHTING)
            self.light.positionv(lightPosition)
            self.light.diffusev(lightColor)
            self.light.enable()

            self.material.diffusev(materialColor)

            self.vertexBuffer.bind()
            self.indexBuffer.bind()

            glInterleavedArrays(GL_C4F_N3F_V3F, 0, None)
            glDrawElements(GL_QUADS, self.n_indices, GL_UNSIGNED_INT, None)

            state1.disable()
            state2.disable()
            state3.disable()

            self.vertexBuffer.unbind()
            self.indexBuffer.unbind()

        def resizeGL(self, w, h):
            if w == 0 or h == 0:
                return

            glMatrixMode(GL_PROJECTION)
            glLoadIdentity()
            gluPerspective(16.0, w / h, 0.5, 40.0)
            glMatrixMode(GL_MODELVIEW)