Python renderer.Renderer类代码示例

	def render_led(self, led, color):

		# as a very basic quad for now!
		glPushMatrix()
		glTranslatef(led['x'], led['y'], self.config['size']['thickness']/2.0 + 0.1)  # 0.1mm in front of front face
		Renderer.quad(color, led['w'], led['h'])
		glPopMatrix()

def test_draw_action_method():
    renderer = Renderer()
    cmd = {"action": "draw", "magnitude": "100", "direction": "bd"}
    x, y = 230, 230
    renderer.draw_action(cmd, x, y)
    assert renderer.position == QPoint(230, 330)
    assert renderer.paths[-1].path_type == "line"

def render(template, context=None, **kwargs):
    """
    Return the given template string rendered using the given context.

    """
    renderer = Renderer()
    return renderer.render(template, context, **kwargs)

 def __init__(self, pd):
     """Creates a new renderer based on a QPaintDevice pd
     """
     self._defpose = Pose() # The pose in the bottom-left corner
     self._zoom = 1 # The zooming factor
     self._zoom_c = False # Whether the scaling is done from center
     Renderer.__init__(self, (pd.width(), pd.height()), pd)

class Game():
    
    def __init__(self):
        SDL_Init(SDL_INIT_VIDEO)

        self.evtMngr = EventManager()
        self.scene = Scene(self.evtMngr)
        self.renderer = Renderer(self.evtMngr, 1000, 800)

        self.evtMngr.attachHandler(E_SDL_EVENT, self.onSDLEvent)

    def run(self):
        self.running = True
        while self.running:
            self.queueSDLEvents()

            self.evtMngr.handleEvents()
            self.scene.update()
            self.renderer.draw(self.scene)

        return 0

    def onSDLEvent(self, eType, e):
        if eType == SDL_QUIT:
            self.running = False
        if eType == SDL_KEYDOWN and e.key.keysym.sym == SDLK_ESCAPE:
            self.running = False

    def queueSDLEvents(self):
        events = sdl2ext.get_events()
        newEvents = dict()
        for event in events:
            self.evtMngr.queueEvent(E_SDL_EVENT, event.type, event)

class Argon(object):
    def __init__(self, width, height):
        self.width  = width
        self.height = height

        self.load = ImageCache([in_module('assets'), os.getcwd(), '.'])
        self.default_font = self.load.font('AnonymousPro_17')

        self.running = False
        self.flags = HWSURFACE | OPENGL | DOUBLEBUF
        self.listeners = {}
        self.frame_latency = []

        pygame.display.set_mode((self.width, self.height), self.flags)
        glEnable(GL_TEXTURE_2D)
        glEnable(GL_BLEND)
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)

        self.render = Renderer(self, self.default_font)

    def listen(self, fn):
        self.listeners[fn.__name__] = fn
        return fn

    def run(self):
        self.running = True
        while self.running:
            now = time.time()
            self.listeners["on_frame"](now)
            pygame.display.flip()
            self.frame_latency.append(time.time() - now)
            while len(self.frame_latency) > 100:
                self.frame_latency.pop(0)
            for event in pygame.event.get():
                if event.type == QUIT:
                    self.running = False
                event_dispatch(event, self.listeners)

    def clear(self, color):
        r, g, b, a = color
        glClearColor(r/255.0, g/255.0, b/255.0, a/255.0)
        glClear(GL_COLOR_BUFFER_BIT)

    def bind(self):
        glBindFramebuffer(GL_FRAMEBUFFER, 0)

    def unbind(self):
        pass

    def show_performance_log(self):
        latency = self.frame_latency
        font = self.default_font
        if len(latency) > 0:
            avg  = sum(latency) / len(latency)
            high = max(latency) 
            text = "avg=%.2fms high=%.2fms" % (avg * 1000, high * 1000)
            self.render.text((0, self.height - font.height + font.baseline), text)

 def clear_screen(self):
     """Erases the current screen with a white brush"""
     self._painter.save()
     self._painter.resetTransform()
     self.set_pen(0xFFFFFF)
     self.set_brush(0xFFFFFF)
     self.draw_rectangle(0,0,self.size[0],self.size[1])
     self._painter.restore()
     Renderer.clear_screen(self)

class PhysicsGame(Widget):
    def __init__(self, **kwargs):
        super(PhysicsGame, self).__init__(**kwargs)

        self.renderer = Renderer(self)
        self.game_state = RUNNING

        self.renderer.init_physics()
        self.bind(size=self.renderer.update_bounds, pos=self.renderer.update_bounds)

        self.tools = {}
        for t in all_tools:
            self.tools[t.name] = t(self)

        self.current_tool = self.tools["Circle"]
        self.help_scheduled = False

        Clock.schedule_once(self.remove_help_text, HELP_MESSAGE_TIME)
        Clock.schedule_interval(self.step, 1 / 30.0)

    def step(self, dt):
        if self.game_state == RUNNING:
            self.renderer.space.step(1 / 30.0)
        self.renderer.update_objects()

    def on_touch_down(self, touch):
        self.current_tool.on_touch_down(touch)

    def on_touch_up(self, touch):
        self.current_tool.on_touch_up(touch)

    def on_touch_move(self, touch):
        self.current_tool.on_touch_move(touch)

    def set_tool(self, tool_name):
        self.current_tool = self.tools[tool_name]

    def toggle_game_state(self):
        self.game_state = RUNNING if self.game_state == PAUSED else PAUSED

    def game_paused(self):
        return self.game_state

    def get_space(self):
        return self.renderer.space

    def remove_help_text(self, dt, *args):
        self.parent.ids.help_text_label.opacity = 0
        self.help_scheduled = False

    def show_help_text(self, text):
        self.parent.ids.help_text_label.text = text
        self.parent.ids.help_text_label.opacity = 1
        if self.help_scheduled:
            Clock.unschedule(self.remove_help_text)
        self.help_scheduled = True
        Clock.schedule_once(self.remove_help_text, HELP_MESSAGE_TIME)

def main():
    app = Application()
    renderer = Renderer()
    renderer.register_with_app(app)
    #app.request_update_on_draw(Test(renderer).update)

    mainWindow = ui.Window(renderer, 50, 50, 300, 400)
    mainWindow.addWidget(ui.Button, x=20, y=20, width=50, height=60, color=(1, 0, 1, 1), text="Example Text")

    app.run()

 def render(self):
     logger = self.logger
     if logger: logger.renderStart()
     
     Renderer.begin(self)
     for m in self.managers:
         m.render()
     Renderer.end(self)
     
     if logger: logger.renderEnd()

	def __init__(self, name, id):
		self.id = id
		self.name = name

		with file("boards/%s.yaml" % name) as config_file:
			self.config = yaml.load(config_file)

		# Load textures
		self.front = Renderer.load_image("boards/"+self.config['front'])[0]
		self.back = Renderer.load_image("boards/"+self.config['back'])[0]

    def main_menu():
        img = libtcod.image_load('img/menu_background1.png')

        while not libtcod.console_is_window_closed():
            Renderer.render_main_screen(img)

            choice = Renderer.menu('', ['Play a new game', 'Continue current game', 'Quit'], 24, 0)

            if choice == 0:
                Renderer.render_main_screen(img)

                races = race_decoder.decode_all_races()
                race = Renderer.menu('Pick a race', races, 15, 0)
                if race is None:
                    continue

                Renderer.render_main_screen(img)

                jobs = job_decoder.decode_all_jobs()
                job = Renderer.menu('Pick a job', jobs, 15, 0)
                if job is None:
                    continue

                Game.new_game(races[race].lower(), jobs[job].lower())
                Game.run()
            elif choice == 1:
                try:
                    Game.run()
                except:
                    Game.msgbox('\n No saved game to load.\n', 24)
                    continue
            elif choice == 2:
                break

    def get(self):
        """Handle a GET request for the page."""

        if IS_CACHING_ON and self.is_cached:
            with open(self.cached_name) as cachefile:
                page = cachefile.read()
        else:
            renderer = Renderer(view=self)
            page = renderer.render()
            if IS_CACHING_ON:
                self.write_page_to_cache(page)
        print "Content-type:text/html\n", page

def main():
    app = Application()
    renderer = Renderer()
    renderer.register_with_app(app)
    app.request_update_on_draw(Test(renderer).update)

    r = Renderer.Rectangle(1, 2, 20, 30, renderer=renderer)
    try:
        r = Renderer.Rectangle(40, 40, 20, 30)
    except:
        pass

    app.run()

    def next_level():
        Game.message('You take a moment to rest, and recover your strength.', libtcod.light_violet)
        Game.player.fighter.heal(.5)
        Game.player.job.regen_mana(.5)

        Game.message('You descend deeper into the heart of the dungeon...', libtcod.red)
        Game.dungeon_level += 1
        Game.map = Map(Game.MAP_WIDTH, Game.MAP_HEIGHT)
        Game.player.x = Game.map.origin[0]
        Game.player.y = Game.map.origin[1]
        Game.map.add_object(Game.player)

        Renderer.clear_console()
        Game.renderer.map = Game.map