Exemplo n.º 1
0
	def draw_translucent_fast(self):
		gl.glEnable(gl.GL_BLEND)
		gl.glDisable(gl.GL_CULL_FACE)
		gl.glDepthMask(gl.GL_FALSE)

		for render_chunk in self.sorted_chunks:
			render_chunk.draw_translucent(gl.GL_TRIANGLES)

		gl.glDepthMask(gl.GL_TRUE)
		gl.glEnable(gl.GL_CULL_FACE)
		gl.glDisable(gl.GL_BLEND)
Exemplo n.º 2
0
    def set_state(self):
        gl.glTexGeni( gl.GL_S, gl.GL_TEXTURE_GEN_MODE, gl.GL_OBJECT_LINEAR )
        gl.glTexGeni( gl.GL_T, gl.GL_TEXTURE_GEN_MODE, gl.GL_OBJECT_LINEAR )

        gl.glTexGenfv(gl.GL_S, gl.GL_OBJECT_PLANE, self.plane)
        gl.glTexGenfv(gl.GL_T, gl.GL_OBJECT_PLANE, self.plane)

        gl.glEnable( gl.GL_TEXTURE_GEN_S )
        gl.glEnable( gl.GL_TEXTURE_GEN_T )

        gl.glDepthMask( gl.GL_TRUE )
        gl.glBindTexture( gl.GL_TEXTURE_2D, self.texture.id )
Exemplo n.º 3
0
    def _use(self):
        """Internal use that do not change the global active framebuffer"""
        if self.ctx.active_framebuffer == self:
            return

        gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self._glo)
        # NOTE: gl.glDrawBuffer(GL_NONE) if no texture attachments (future)
        # NOTE: Default framebuffer currently has this set to None
        if self._draw_buffers:
            gl.glDrawBuffers(len(self._draw_buffers), self._draw_buffers)
        gl.glDepthMask(self._depth_mask)
        gl.glViewport(*self._viewport)
Exemplo n.º 4
0
 def draw_lem (self):
     with push_attrib(gl.GL_DEPTH_BUFFER_BIT | gl.GL_LIGHTING_BIT):
         gl.glDepthMask(gl.GL_TRUE)
         gl.glEnable(gl.GL_DEPTH_TEST)
         gl.glEnable(gl.GL_LIGHTING)
         gl.glEnable(gl.GL_LIGHT0)
         gl.glEnable(gl.GL_NORMALIZE)
         gl.glShadeModel(gl.GL_SMOOTH)
         gl.glLightModelfv(gl.GL_LIGHT_MODEL_AMBIENT, float_ctype_array(1.0, 1.0, 1.0, 1.0))
         gl.glLightfv(gl.GL_LIGHT0, gl.GL_AMBIENT, float_ctype_array(0.0, 0.0, 0.0, 1.0))
         gl.glLightfv(gl.GL_LIGHT0, gl.GL_DIFFUSE, float_ctype_array(1.0, 1.0, 1.0, 1.0))
         gl.glLightfv(gl.GL_LIGHT0, gl.GL_SPECULAR, float_ctype_array(0.5, 0.5, 0.5, 1.0))
         gl.glLightfv(gl.GL_LIGHT0, gl.GL_POSITION, float_ctype_array(1.0, 1.0, 1.0, 0.0))
         self.draw_lem_model()
Exemplo n.º 5
0
	def draw_translucent_fancy(self):
		gl.glDepthMask(gl.GL_FALSE)
		gl.glFrontFace(gl.GL_CW)
		gl.glEnable(gl.GL_BLEND)

		for render_chunk in self.sorted_chunks:
			render_chunk.draw_translucent(gl.GL_TRIANGLES)
		
		gl.glFrontFace(gl.GL_CCW)
		
		for render_chunk in self.sorted_chunks:
			render_chunk.draw_translucent(gl.GL_TRIANGLES)

		gl.glDisable(gl.GL_BLEND)
		gl.glDepthMask(gl.GL_TRUE)
Exemplo n.º 6
0
    def setBuffer(self, buffer, clear=True):
        """Set the eye buffer to draw to. Subsequent draw calls will be diverted
        to the specified eye.

        Parameters
        ----------
        buffer : str
            Eye buffer to draw to. Values can either be 'left' or 'right'.
        clear : bool
            Clear the buffer prior to drawing.

        """
        # check if the buffer name is valid
        if buffer not in ('left', 'right', 'back'):
            raise RuntimeError("Invalid buffer name specified.")

        # don't change the buffer if same, but allow clearing
        if buffer != self.buffer:
            if not self._directDraw:
                # handle when the back buffer is selected
                if buffer == 'back':
                    if self.useFBO:
                        GL.glBindFramebuffer(
                            GL.GL_FRAMEBUFFER,
                            self._eyeBuffers[buffer]['frameBuffer'])
                    else:
                        GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, 0)
                else:
                    GL.glBindFramebuffer(
                        GL.GL_FRAMEBUFFER, self._eyeBuffers[buffer]['frameBuffer'])

            self.viewport = self.scissor = self._bufferViewports[buffer]

            GL.glEnable(GL.GL_SCISSOR_TEST)
            self.buffer = buffer  # set buffer string

        if clear:
            self.setColor(self.color)  # clear the buffer to the window color
            GL.glClearDepth(1.0)
            GL.glDepthMask(GL.GL_TRUE)
            GL.glClear(
                GL.GL_COLOR_BUFFER_BIT |
                GL.GL_DEPTH_BUFFER_BIT |
                GL.GL_STENCIL_BUFFER_BIT)

        GL.glDisable(GL.GL_TEXTURE_2D)
        GL.glEnable(GL.GL_BLEND)
Exemplo n.º 7
0
 def draw_lem(self):
     with push_attrib(gl.GL_DEPTH_BUFFER_BIT | gl.GL_LIGHTING_BIT):
         gl.glDepthMask(gl.GL_TRUE)
         gl.glEnable(gl.GL_DEPTH_TEST)
         gl.glEnable(gl.GL_LIGHTING)
         gl.glEnable(gl.GL_LIGHT0)
         gl.glEnable(gl.GL_NORMALIZE)
         gl.glShadeModel(gl.GL_SMOOTH)
         gl.glLightModelfv(gl.GL_LIGHT_MODEL_AMBIENT,
                           float_ctype_array(1.0, 1.0, 1.0, 1.0))
         gl.glLightfv(gl.GL_LIGHT0, gl.GL_AMBIENT,
                      float_ctype_array(0.0, 0.0, 0.0, 1.0))
         gl.glLightfv(gl.GL_LIGHT0, gl.GL_DIFFUSE,
                      float_ctype_array(1.0, 1.0, 1.0, 1.0))
         gl.glLightfv(gl.GL_LIGHT0, gl.GL_SPECULAR,
                      float_ctype_array(0.5, 0.5, 0.5, 1.0))
         gl.glLightfv(gl.GL_LIGHT0, gl.GL_POSITION,
                      float_ctype_array(1.0, 1.0, 1.0, 0.0))
         self.draw_lem_model()
Exemplo n.º 8
0
    def on_draw(self):
        """F.on_draw()

        Renders the fog."""

        gl.glEnable(gl.GL_BLEND)
        gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)

        gl.glDepthMask(gl.GL_FALSE)

        x_rep, y_rep, z_rep = self.__config.glass_repetitions()
        w, h, d = self.__config.grid_size()

        for layer in self.__layers:

            with layer:

                self.__camera.clear()
                self.__camera.add(*self.__cam.gl_matrix())
                self.__camera.set()

                if not self.__color.filled():
                    self.__color.add(*self.__config.fog_color())
                self.__color.set()

                for x_copy in range(x_rep):
                    for y_copy in range(y_rep):
                        for z_copy in range(z_rep):

                            shift = (
                                w * x_copy,
                                h * y_copy,
                                d * z_copy)

                            self.__copy_shift.clear()
                            self.__copy_shift.add(*shift)
                            self.__copy_shift.set()

                            layer.draw()

        gl.glDepthMask(gl.GL_TRUE)
        gl.glDisable(gl.GL_BLEND)
Exemplo n.º 9
0
    def on_draw(self):

        gl.glDepthMask(gl.GL_TRUE)
        gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT
                   | gl.GL_STENCIL_BUFFER_BIT)
        gl.glDepthMask(gl.GL_FALSE)

        with push_matrix(gl.GL_PROJECTION):
            self.set_camera_projection()

            with push_matrix(gl.GL_MODELVIEW):
                gl.glLoadIdentity()
                gl.gluLookAt(self.camera_x, self.camera_y, self.camera_z,
                             self.camera_x, self.camera_y, 0.0, 0.0, 1.0, 0.0)

                with push_matrix(gl.GL_MODELVIEW):
                    gl.gluLookAt(0, 0, 0, 0, -1, 0, 0, 0, -1)
                    self.draw_ground_plane()
                    self.target.draw()
                    # self.shadow.draw()

                self.draw_shadow_lem()
                self.draw_lem()

                with push_attrib(gl.GL_COLOR_BUFFER_BIT
                                 | gl.GL_DEPTH_BUFFER_BIT):
                    gl.glEnable(gl.GL_BLEND)
                    gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE)
                    gl.glEnable(gl.GL_DEPTH_TEST)
                    with bound_texture(self.puff_texture.target,
                                       self.puff_texture.id):
                        Thruster.draw(self.particles)

        if self.simulator.crashed:
            self.crashed.draw()
        if self.simulator.landed:
            self.landed.draw()

        self.fps_display.draw()
Exemplo n.º 10
0
    def on_draw (self):

        gl.glDepthMask(gl.GL_TRUE)
        gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT | gl.GL_STENCIL_BUFFER_BIT)
        gl.glDepthMask(gl.GL_FALSE)

        with push_matrix(gl.GL_PROJECTION):
            self.set_camera_projection()

            with push_matrix(gl.GL_MODELVIEW):
                gl.glLoadIdentity()
                gl.gluLookAt (self.camera_x, self.camera_y, self.camera_z,
                              self.camera_x, self.camera_y, 0.0,
                              0.0, 1.0, 0.0)

                with push_matrix(gl.GL_MODELVIEW):
                    gl.gluLookAt(0, 0, 0, 0, -1, 0, 0, 0, -1)
                    self.draw_ground_plane()
                    self.target.draw()
                    # self.shadow.draw()

                self.draw_shadow_lem()
                self.draw_lem()

                with push_attrib(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT):
                    gl.glEnable(gl.GL_BLEND)
                    gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE)
                    gl.glEnable(gl.GL_DEPTH_TEST)
                    with bound_texture (self.puff_texture.target, self.puff_texture.id):
                        Thruster.draw(self.particles)

        if self.simulator.crashed:
            self.crashed.draw()
        if self.simulator.landed:
            self.landed.draw()

        self.fps_display.draw()
Exemplo n.º 11
0
    def render(self, position, chunk_meshes):

        gl.glViewport(0, 0, *self.size)
        gl.glDisable(gl.GL_BLEND)
        gl.glDisable(gl.GL_ALPHA_TEST)
        gl.glEnable(gl.GL_CULL_FACE)

        gl.glEnable(gl.GL_DEPTH_TEST)
        gl.glDepthFunc(gl.GL_LEQUAL)
        gl.glDepthMask(gl.GL_TRUE)

        x, y, z = position

        view_matrices = [
            Matrix4.new_scale(-1, -1, 1).rotatey(pi / 2).translate(-x, -y,
                                                                   -z),  # +X
            Matrix4.new_scale(-1, -1,
                              1).rotatey(-pi / 2).translate(-x, -y, -z),  # -X
            Matrix4.new_rotatex(-pi / 2).translate(-x, -y, -z),  # +Y
            Matrix4.new_rotatex(pi / 2).translate(-x, -y, -z),  # -Y
            Matrix4.new_scale(-1, -1, 1).rotatey(pi).translate(-x, -y,
                                                               -z),  # +Z
            Matrix4.new_scale(-1, -1, 1).translate(-x, -y, -z)  # -Z
        ]

        model_matrix = Matrix4.new_scale(
            1, 1, constants.WALL_TEXTURE_HEIGHT /
            (constants.WALL_TEXTURE_WIDTH / sqrt(2) * (sqrt(3))))
        gl.glUniformMatrix4fv(1, 1, gl.GL_FALSE, gl_matrix(model_matrix))
        with self.program, self.name:

            view_matrix = make_view_matrix_persp(position)
            gl.glUniformMatrix4fv(0, 1, gl.GL_FALSE, gl_matrix(view_matrix))

            for chunk, mesh in chunk_meshes.items():
                mesh.draw()
Exemplo n.º 12
0
 def depth_mask(self, value: bool):
     self._depth_mask = value
     # Set state if framebuffer is active
     if self._ctx.active_framebuffer == self:
         gl.glDepthMask(self._depth_mask)
Exemplo n.º 13
0
    def on_draw(self):

        # Prevent trying to draw before things have been set up
        if not hasattr(self, "offscreen_buffer"):
            return

        # Model matrix we'll use to position the main model
        suzanne_model_matrix = (Matrix4.new_identity().rotatex(
            -math.pi / 2).rotatez(time()))  # Rotate over time
        plane_model_matrix = Matrix4.new_rotatey(math.pi).translate(0, 0, 2)

        # Render to an offscreen buffer
        with self.offscreen_buffer, self.view_program, \
                enabled(gl.GL_DEPTH_TEST), disabled(gl.GL_CULL_FACE):

            gl.glDepthMask(gl.GL_TRUE)

            w, h = self.size
            aspect = h / w

            # Calculate a view frustum; this is basically our camera.
            near = 5
            far = 15
            width = 2
            height = 2 * aspect
            frustum = (Matrix4.new(near / width, 0, 0, 0, 0, near / height, 0,
                                   0, 0, 0, -(far + near) / (far - near), -1,
                                   0, 0, -2 * far * near / (far - near), 0))

            # The view matrix positions the camera in the scene
            view_matrix = (Matrix4.new_identity().translate(0, 0, -8))

            # Send the matrices to GL
            gl.glUniformMatrix4fv(0, 1, gl.GL_FALSE,
                                  gl_matrix(frustum * view_matrix))
            gl.glUniformMatrix4fv(1, 1, gl.GL_FALSE,
                                  gl_matrix(suzanne_model_matrix))

            gl.glUniform4f(2, 0.3, 0.3, 1,
                           1)  # Set the "color" uniform to blue
            self.suzanne.draw()

            # We'll also draw a simple plane behind the main model
            gl.glUniformMatrix4fv(1, 1, gl.GL_FALSE,
                                  gl_matrix(plane_model_matrix))
            gl.glUniform4f(2, 0.3, 1, 0.3,
                           1)  # Set the "color" uniform to green
            self.plane.draw(mode=gl.GL_TRIANGLE_STRIP)

        # Render shadow buffer
        # Basically the same scene as above, but to a different buffer and from a different view
        with self.shadow_buffer, self.view_program, enabled(
                gl.GL_DEPTH_TEST), disabled(gl.GL_CULL_FACE):
            gl.glDepthMask(gl.GL_TRUE)

            frustum = Matrix4.new_perspective(1, 1, 1, 12)
            view_matrix = (Matrix4.new_identity().translate(
                0, 0, -4).rotatey(0.5).rotatex(0.3))
            light_pos = (view_matrix.inverse() * Point3(0, 0, 0))
            light_view_matrix = frustum * view_matrix
            gl.glUniformMatrix4fv(0, 1, gl.GL_FALSE,
                                  gl_matrix(light_view_matrix))
            gl.glUniformMatrix4fv(1, 1, gl.GL_FALSE,
                                  gl_matrix(suzanne_model_matrix))
            gl.glUniform4f(2, 0.9, 0.3, 0.4, 1)
            self.suzanne.draw()

            gl.glUniformMatrix4fv(1, 1, gl.GL_FALSE,
                                  gl_matrix(plane_model_matrix))
            self.plane.draw(mode=gl.GL_TRIANGLE_STRIP)

        # Now draw the offscreen buffer to another buffer, combining it with the
        # lighting information to get a nice image.
        # Note: This step is pretty pointless here, as we might just draw directly to screen.
        # Just demonstrates how to do it.
        with self.vao, self.offscreen_buffer2, self.lighting_program, disabled(
                gl.GL_CULL_FACE, gl.GL_DEPTH_TEST):
            gl.glUniform3f(0, *light_pos)
            gl.glUniformMatrix4fv(1, 1, gl.GL_FALSE,
                                  gl_matrix(light_view_matrix))
            # Bind some of the offscreen buffer's textures so the shader can read them.
            with self.offscreen_buffer["color"], self.offscreen_buffer["normal"], \
                    self.offscreen_buffer["position"], self.shadow_buffer["depth"]:
                gl.glDrawArrays(gl.GL_TRIANGLES, 0, 6)

        # Now render the finished image to the screen
        with self.vao, self.copy_program, disabled(gl.GL_CULL_FACE,
                                                   gl.GL_DEPTH_TEST):
            with self.offscreen_buffer2["color"]:
                gl.glDrawArrays(gl.GL_TRIANGLES, 0, 6)