Python gloo.set_state函数代码示例

    def draw_distortion(self, *Contexts):
        '''Distorter.draw(list_of_drawables)
        Draw the drawables to the right and left-eye render buffers,
        then apply the distortion and display these buffers to the screen
        TODO:
        How can we globally handle view?
        Should we even bother trying to find the 'right' way to do this?
        '''
        gloo.set_clear_color('black')
        gloo.set_state(depth_test=True)

        with self.left_eye:
            gloo.clear(color=True, depth=True)
            for context in Contexts:
                context.translate(0, self.IPD / 2, 0)
                context.set_projection(self.L_projection)
                context.draw()

        with self.right_eye:
            gloo.clear(color=True, depth=True)
            for context in Contexts:
                context.translate(0, -self.IPD / 2, 0)
                context.set_projection(self.R_projection)
                context.draw()

        gloo.clear(color=True, depth=True)
        self.left_eye_program.draw('triangles', self.left_eye_indices)
        self.right_eye_program.draw('triangles', self.right_eye_indices)

    def __init__(self):
        app.Canvas.__init__(self, keys='interactive', size=(800, 600))

        self.vertices, self.filled, self.outline = cube()
        self.filled_buf = gloo.IndexBuffer(self.filled)
        self.outline_buf = gloo.IndexBuffer(self.outline)

        self.program = gloo.Program(vert, frag)
        self.program.bind(gloo.VertexBuffer(self.vertices))

        self.view = translate((0, 0, -5))
        self.model = np.eye(4, dtype=np.float32)

        gloo.set_viewport(0, 0, self.physical_size[0], self.physical_size[1])
        self.projection = perspective(45.0, self.size[0] /
                                      float(self.size[1]), 2.0, 10.0)

        self.program['u_projection'] = self.projection

        self.program['u_model'] = self.model
        self.program['u_view'] = self.view

        self.theta = 0
        self.phi = 0

        gloo.set_clear_color('white')
        gloo.set_state('opaque')
        gloo.set_polygon_offset(1, 1)

        self._timer = app.Timer('auto', connect=self.on_timer, start=True)

        self.show()

    def __init__(self):
        app.Canvas.__init__(self, size=(512, 512), title='Rotating cube',
                            keys='interactive')
        self.timer = app.Timer('auto', self.on_timer)

        # Build cube data
        V, I, outline = create_cube()
        vertices = VertexBuffer(V)
        self.faces = IndexBuffer(I)
        self.outline = IndexBuffer(outline)

        # Build program
        # --------------------------------------
        self.program = Program(vertex, fragment)
        self.program.bind(vertices)

        # Build view, model, projection & normal
        # --------------------------------------
        view = translate((0, 0, -5))
        model = np.eye(4, dtype=np.float32)

        self.program['u_model'] = model
        self.program['u_view'] = view
        self.phi, self.theta = 0, 0

        self.activate_zoom()

        # OpenGL initialization
        # --------------------------------------
        gloo.set_state(clear_color=(0.30, 0.30, 0.35, 1.00), depth_test=True,
                       polygon_offset=(1, 1), line_width=0.75,
                       blend_func=('src_alpha', 'one_minus_src_alpha'))
        self.timer.start()

        self.show()

    def __init__(self):
        app.Canvas.__init__(self, size=(512, 512), title='Colored cube',
                            keys='interactive')

        # Build cube data
        V, I, _ = create_cube()
        vertices = VertexBuffer(V)
        self.indices = IndexBuffer(I)

        # Build program
        self.program = Program(vertex, fragment)
        self.program.bind(vertices)

        # Build view, model, projection & normal
        view = translate((0, 0, -5))
        model = np.eye(4, dtype=np.float32)
        self.program['model'] = model
        self.program['view'] = view
        self.phi, self.theta = 0, 0
        gloo.set_state(clear_color=(0.30, 0.30, 0.35, 1.00), depth_test=True)

        self.activate_zoom()

        self.timer = app.Timer('auto', self.on_timer, start=True)

        self.show()

    def on_initialize(self, event):
        # Build cube data
        V, F, O = create_cube()
        vertices = VertexBuffer(V)
        self.faces = IndexBuffer(F)
        self.outline = IndexBuffer(O)

        # Build view, model, projection & normal
        # --------------------------------------
        self.view = np.eye(4, dtype=np.float32)
        model = np.eye(4, dtype=np.float32)
        translate(self.view, 0, 0, -5)
        normal = np.array(np.matrix(np.dot(self.view, model)).I.T)

        # Build program
        # --------------------------------------
        self.program = Program(vertex, fragment)
        self.program.bind(vertices)
        self.program["u_light_position"] = 2, 2, 2
        self.program["u_light_intensity"] = 1, 1, 1
        self.program["u_model"] = model
        self.program["u_view"] = self.view
        self.program["u_normal"] = normal
        self.phi, self.theta = 0, 0

        # OpenGL initalization
        # --------------------------------------
        gloo.set_state(clear_color=(0.30, 0.30, 0.35, 1.00), depth_test=True,
                       polygon_offset=(1, 1),
                       blend_func=('src_alpha', 'one_minus_src_alpha'),
                       line_width=0.75)
        self.timer.start()

    def __init__(self,controller, **kwargs):
        app.Canvas.__init__(self, **kwargs)
        self._controller = controller
        self.geometry = 0, 0, 400, 400

        self.program = gloo.Program("shaders/raytracingalgo.vertexshader", "shaders/raytracingalgo.fragmentshader")

        self.program['a_position'] = [(-1., -1.), (-1., +1.),(+1., -1.), (+1., +1.)]
        self.program['sphere_position_0'] = (.75, .1, 1.)
        self.program['sphere_radius_0'] = .6
        self.program['sphere_color_0'] = (1., 1., 1.)
        self.program['sphere_position_1'] = (-.75, .1, 2.25)
        self.program['sphere_radius_1'] = .6
        self.program['sphere_color_1'] = (1., 1., 1.)
        self.program['plane_position'] = (0., -.5, 0.)
        self.program['plane_normal'] = (0., 1., 0.)
        self.program['light_intensity'] = 1.
        self.program['light_specular'] = (1., 50.)
        self.program['light_position'] = (5., 5., -10.)
        self.program['light_color'] = (1., 1., 1.)
        self.program['ambient'] = .05
        self.program['O'] = (0., 0., -1.)

        gloo.set_clear_color((1, 1, 1, 1))
        gloo.set_state(depth_test=True)

        #self.program.draw('triangle_strip')

        #self.active = True
        self._timer = app.Timer('auto', connect=self.timedUpdate, start=True)

        self._fps = 1
        self._timerfps = 24
        self._softFPS = []

    def __init__(self):
        app.Canvas.__init__(self, size=(512, 512), title='Textured cube',
                            keys='interactive')
        self.timer = app.Timer('auto', self.on_timer)

        # Build cube data
        V, I, _ = create_cube()
        vertices = VertexBuffer(V)
        self.indices = IndexBuffer(I)

        # Build program
        self.program = Program(vertex, fragment)
        self.program.bind(vertices)

        # Build view, model, projection & normal
        view = np.eye(4, dtype=np.float32)
        model = np.eye(4, dtype=np.float32)
        translate(view, 0, 0, -5)
        self.program['model'] = model
        self.program['view'] = view
        self.program['texture'] = checkerboard()

        self.phi, self.theta = 0, 0

        # OpenGL initalization
        gloo.set_state(clear_color=(0.30, 0.30, 0.35, 1.00), depth_test=True)
        self.timer.start()

  def on_draw(self, event):
    gloo.clear()

    # Filled cube

    gloo.set_state(blend=False, depth_test=True, polygon_offset_fill=True)
    self.program.draw('triangles', self.filled_buf)

    def __init__(self, svbrdf, mesh, camera, size):
        super().__init__(size, 0, 1000, camera, show=True)

        gloo.set_state(depth_test=True)
        gloo.set_viewport(0, 0, *self.size)

        self.lights = [
                Light((20, 30, 100), 2000),
                Light((20, 30, -100), 2000),
                Light((0, 100, 10), 2000),
                ]

        vertex_positions = mesh.expand_face_vertices()
        vertex_normals = mesh.expand_face_normals()
        vertex_tangents, vertex_bitangents = mesh.expand_tangents()
        vertex_uvs = mesh.expand_face_uvs()

        material = SVBRDFMaterial(svbrdf)
        self.renderables = [Renderable(material, {
            'a_position': vertex_positions,
            'a_normal': vertex_normals,
            'a_tangent': vertex_tangents,
            'a_bitangent': vertex_bitangents,
            'a_uv': vertex_uvs,
            }, len(self.lights))]

    def __init__(self, *args, **kwargs):
        self.exit = kwargs.pop('exit', False)
        self.inputs_path = kwargs.pop('inputs_path', None)
        super(StillCanvas, self).__init__(*args, **kwargs)
        gloo.set_state(clear_color='black', blend=True, blend_func=('src_alpha', 'one_minus_src_alpha'))

        self.inputs = None

        if self.inputs_path is not None:
            self.input_manager = FileStoredInput(self.inputs_path)
            self.time = self.input_manager.stored_time
            definition = Definitions[self.input_manager.stored_definition_name]
        else:
            self.input_manager = RandomInput()
            self.time = float(random.randint(0, 345212312))
            definition = Definitions[random.choice(Definitions.keys())]

        self.fractal = FractalProgram(definition, mask=False)

        self.apply_zoom()
        self._timer = app.Timer(1.0 / 5, connect=self.update, start=True)
        if self.exit:
            app.Timer(1, connect=self.write_and_exit, start=True, iterations=1)
        # self.update(None)
        # self.update(None)
        self.show()

    def __init__(self):
        app.Canvas.__init__(self, keys='interactive')
        self.size = 800, 600

        self.vertices, self.filled, self.outline = cube()
        self.filled_buf = gloo.IndexBuffer(self.filled)
        self.outline_buf = gloo.IndexBuffer(self.outline)

        self.program = gloo.Program(vert, frag)
        self.program.bind(gloo.VertexBuffer(self.vertices))

        self.view = np.eye(4, dtype=np.float32)
        self.model = np.eye(4, dtype=np.float32)
        self.projection = np.eye(4, dtype=np.float32)

        translate(self.view, 0, 0, -5)
        self.program['u_model'] = self.model
        self.program['u_view'] = self.view

        self.theta = 0
        self.phi = 0

        gloo.set_clear_color('white')
        gloo.set_state('opaque')
        gloo.set_polygon_offset(1, 1)

        self._timer = app.Timer('auto', connect=self.on_timer, start=True)

	def __init__(self, atoms, radius=6.):
		app.Canvas.__init__(self, title='Molecular viewer', keys='interactive', size=(1200, 800))
		self.ps = self.pixel_scale

		self.zoom = .5/numpy.amax(numpy.linalg.norm(atoms['zyx'], axis=1))

		self.program = gloo.Program(vertex, fragment)
		self.view = scale(self.zoom*numpy.ones(3))
		self.model = numpy.eye(4, dtype=numpy.float32)
		self.projection = numpy.eye(4, dtype=numpy.float32)

		data = numpy.zeros(atoms.size, [('a_position', numpy.float32, 3),
							('a_color', numpy.float32, 4),
							('a_radius', numpy.float32, 1)])

		data['a_position'] = atoms['zyx']
		data['a_color'] = 1,0,0,1
		data['a_color'][atoms['Z']==16] = 1,1,0,1
		data['a_color'][atoms['Z']==74] = 0,.5,1,1
		data['a_radius'] = atoms['Z']**(1/3)*radius/self.zoom

		self.program.bind(gloo.VertexBuffer(data))

		self.program['u_zoom'] = self.zoom
		self.program['u_model'] = self.model
		self.program['u_view'] = self.view
		self.program['u_light_position'] = 0., 0., 2.
		self.program['u_light_spec_position'] = -5., 5., -5.
		self.apply_zoom()

		self.program['u_model'] = self.model
		self.program['u_view'] = self.view

		gloo.set_state(depth_test=True, clear_color='white')
		self.show()

    def __init__(self, *args, **kwargs):
        self.fake_inputs = kwargs.pop('fake_inputs', False)
        self.draw_bones = kwargs.pop('draw_bones', False)
        self.kiosk_interval = kwargs.pop('kiosk_interval', 0)
        self.start_definition = kwargs.pop('start_definition', 0)
        self.start_input = kwargs.pop('start_input', 0)
        self.show_mask = kwargs.pop('mask', False)
        super(MainCanvas, self).__init__(*args, **kwargs)
        gloo.set_state(clear_color='black', blend=True, blend_func=('src_alpha', 'one_minus_src_alpha'))

        self.skeleton_bones = SkeletonBonesProgram()
        self.mask = MaskProgram()

        self.inputs = None
        self.input_manager = None

        self._starttime = time.time()

        self.definition_position = self.start_definition
        self.input_position = self.start_input
        self.rotate()
        if self.kiosk_interval > 0:
            self.kiosk_timer = app.Timer(self.kiosk_interval, connect=self.rotate, start=True)

        self._timer = app.Timer('auto', connect=self.update, start=True)
        self.show()

    def __init__(self):
        app.Canvas.__init__(self, keys='interactive')
        self.size = 800, 800
        self.title = "D'oh ! A big donut"

        self.program = gloo.Program(vert, frag)
        self.view = np.eye(4, dtype=np.float32)
        self.model = np.eye(4, dtype=np.float32)
        self.projection = np.eye(4, dtype=np.float32)
        self.translate = 5
        translate(self.view, 0, 0, -self.translate)

        self.program.bind(gloo.VertexBuffer(data))
        self.program['u_linewidth'] = u_linewidth
        self.program['u_antialias'] = u_antialias
        self.program['u_model'] = self.model
        self.program['u_view'] = self.view
        self.program['u_size'] = 5 / self.translate

        self.theta = 0
        self.phi = 0
        self.clock = 0
        self.stop_rotation = False

        gloo.set_state('translucent', clear_color='white')
        self.program['u_clock'] = 0.0

        self._timer = app.Timer('auto', connect=self.on_timer, start=True)

    def __init__(self):
        app.Canvas.__init__(self, size=(512, 512),
                            keys='interactive')

        self.image = Program(image_vertex, image_fragment, 4)
        self.image['position'] = (-1, -1), (-1, +1), (+1, -1), (+1, +1)
        self.image['texcoord'] = (0, 0), (0, +1), (+1, 0), (+1, +1)
        self.image['vmin'] = +0.0
        self.image['vmax'] = +1.0
        self.image['cmap'] = 0  # Colormap index to use
        self.image['colormaps'] = colormaps
        self.image['n_colormaps'] = colormaps.shape[0]
        self.image['image'] = I.astype('float32')
        self.image['image'].interpolation = 'linear'

        set_viewport(0, 0, *self.physical_size)

        self.lines = Program(lines_vertex, lines_fragment)
        self.lines["position"] = np.zeros((4+4+514+514, 2), np.float32)
        color = np.zeros((4+4+514+514, 4), np.float32)
        color[1:1+2, 3] = 0.25
        color[5:5+2, 3] = 0.25
        color[9:9+512, 3] = 0.5
        color[523:523+512, 3] = 0.5
        self.lines["color"] = color

        set_state(clear_color='white', blend=True,
                  blend_func=('src_alpha', 'one_minus_src_alpha'))

        self.show()