コード例 #1
0
ファイル: garbage.py プロジェクト: pdevine/suburbia
    def __init__(self):
        self.image_opened = image.load(data_file('garbagecan-open.png'))
        self.image_closed = image.load(data_file('garbagecan-closed.png'))
        self.image_lid = image.load(data_file('garbagecan-lid.png'))

        self.image_opened.anchor_x = self.image_opened.width/2
        self.image_opened.anchor_y = self.image_opened.height/2
        self.image_closed.anchor_x = self.image_opened.width/2
        self.image_closed.anchor_y = self.image_opened.height/2

        self.candidateLeaves = {}

        self.opened = True
        self.lid_active = False
        self.can_active = False
        self.fallen = False
        self.can_highlighted = False
        self.lid_highlighted = True

        self.can_rect = Rect(0, 0, self.image_closed)
        self.can_rect.center = (80, 90)

        self.can_sprite = Sprite(self.image_opened)
        self.can_sprite.set_position(self.can_rect.x, self.can_rect.y)

        self.lid_rect = Rect(20, 40, self.image_lid)

        window.game_window.push_handlers(self.on_mouse_release)
        window.game_window.push_handlers(self.on_mouse_press)
        window.game_window.push_handlers(self.on_mouse_drag)
        window.game_window.push_handlers(self.on_mouse_motion)

        events.AddListener(self)
コード例 #2
0
ファイル: tictactoe.py プロジェクト: jamgaroo1/python-games
    def __init__(self):
        super(GameLayer, self).__init__()

        # Lista de sprites (X's e O's)
        self.sprites = [None]*9

        # Intância do jogo
        self.game = None

        # Variavel para verificar se o usuário está habilitado à jogador. A 
        # variável estará falsa somente no caso de alguém ganhar ou o jogo 
        # empatar, esperando a finalização dos efeitos para habilitar o jogo 
        # novamente
        self.ableToPlay = True

        # Lista de imagens do jogo, elas são definidas separadamente para não
        # fiarem duplicadas em vários sprites.
        self.imageEmpty = image.load('resources/cell.png')
        self.imageX = image.load('resources/cell-x.png')
        self.imageO = image.load('resources/cell-o.png')
        
        # Imagem de fundo
        self.background = cocos.sprite.Sprite('background.png', (150, 150))
        self.add(self.background)

        # Inicia um novo jogo
        self.newGame()
コード例 #3
0
ファイル: base_save.py プロジェクト: bitcraft/pyglet
    def load_texture(self):
        if self.texture_file:
            self.texture_file = join(dirname(__file__), self.texture_file)
            self.original_texture = image.load(self.texture_file).texture

            file = BytesIO()
            self.original_texture.save(self.texture_file, file,
                                       encoder=self.encoder)
            file.seek(0)
            self.saved_texture = image.load(self.texture_file, file).texture
コード例 #4
0
ファイル: explosion.py プロジェクト: phantomxc/KrackedForc
    def __init__(self, x, y):

        spark_tex = image.load(os.path.join(os.path.dirname(__file__), 'images/flare3.png')).get_texture()

        sparks = ParticleGroup(
            controllers=[
                Lifetime(2),
                Movement(damping=0.93),
                Fader(fade_out_start=0, fade_out_end=1.8),
            ],

            renderer=BillboardRenderer(SpriteTexturizer(spark_tex.id)))

        spark_emitter = StaticEmitter(
            template=Particle(
                position=(x,y),
                color=(1,1,1)),
            deviation=Particle(
                position=(1,1,0),
                velocity=(300,300,0),
                age=1.5),
            size=[(1,1,0), (2,2,0), (2,2,0), (2,2,0), (3,3,0), (4,4,0)])
        spark_emitter.emit(50, sparks)

        fire_tex = image.load(os.path.join(os.path.dirname(__file__), 'images/puff.png')).get_texture()

        fire = ParticleGroup(
            controllers=[
            Lifetime(4),
            Movement(damping=0.95),
            Growth(10),
            Fader(fade_in_start=0, start_alpha=0, fade_in_end=0.5, max_alpha=0.4,
                fade_out_start=1.0, fade_out_end=1.0)
            ],
            renderer=BillboardRenderer(SpriteTexturizer(fire_tex.id)))

        fire_emitter = StaticEmitter(
            template=Particle(
                position=(x, y),
                size=(10,10,0)),
            deviation=Particle(
                position=(2,2,0),
                velocity=(70,70,0),
                size=(5,5,0),
                up=(0,0,pi*2),
                rotation=(0,0,pi*0.06),
                age=.3,),
            color=[(0.5,0,0), (0.5,0.5,0.5), (0.4,0.1,0.1), (0.85,0.3,0)],
        )
        fire_emitter.emit(200, fire)
コード例 #5
0
 def test_set_icon_sizes(self):
     self.width, self.height = 200, 200
     self.w = w = window.Window(self.width, self.height)
     w.set_icon(image.load(icon_file1),
                image.load(icon_file2),
                image.load(icon_file3),
                image.load(icon_file4),
                image.load(icon_file5))
     glClearColor(1, 1, 1, 1)
     while not w.has_exit:
         glClear(GL_COLOR_BUFFER_BIT)
         w.flip()
         w.dispatch_events()
     w.close()
コード例 #6
0
ファイル: terrain.py プロジェクト: Dejmas/Terrain
    def loadTexture( self ):
        textureSurface = image.load('data/multicolor512.png')
        self.text0 = textureSurface.get_mipmapped_texture()

        textureSurface = image.load('data/grass512.jpg')
        self.text1 = textureSurface.get_mipmapped_texture()

        textureSurface = image.load('data/sand512.png')
        self.text2 = textureSurface.get_mipmapped_texture()

        textureSurface = image.load('data/stone512.jpg')
        self.text3 = textureSurface.get_mipmapped_texture()

        textureSurface = image.load('data/water1024.jpg')
        self.sea_tex = textureSurface.get_mipmapped_texture()
コード例 #7
0
ファイル: obj.py プロジェクト: raycode/pybilliard
 def __init__(self, filename):
     """Read data from the file"""
     self.contents = {}
     mtl = None
     for line in open(filename, "r"):
         if line.startswith('#'):
             continue
         values = line.split()
         if not values:
             continue
         if values[0] == 'newmtl':
             if len(values) == 1:
                 values.append('NoNameMat')
             mtl = self.contents[values[1]] = {}
         elif mtl is None:
             raise ValueError("mtl file doesn't start with newmtl stmt")
         elif values[0] == 'map_Kd':
             pos = filename.find('/') + 1
             mtl['map_Kd'] = filename[0:pos] + values[1]
             mtl['image'] = image.load(mtl['map_Kd'])
         elif values[0] == 'Ns':
             # Map from range 0-1000 to the range 0-128 of GL_SHININESS
             mtl['Ns'] = float(values[1]) * .128
         else:
             mtl[values[0]] = map(float, values[1:])
コード例 #8
0
ファイル: fmain.py プロジェクト: egeoz/pycraft
    def __init__(self):

        # A Batch is a collection of vertex lists for batched rendering.
        self.batch = pyglet.graphics.Batch()

        # A TextureGroup manages an OpenGL texture.
        self.group = TextureGroup(image.load(TEXTURE_PATH).get_texture())

        # A mapping from position to the texture of the block at that position.
        # This defines all the blocks that are currently in the world.
        self.world = {}

        # Same mapping as `world` but only contains blocks that are shown.
        self.shown = {}

        # Mapping from position to a pyglet `VertextList` for all shown blocks.
        self._shown = {}

        # Mapping from sector to a list of positions inside that sector.
        self.sectors = {}

        # Simple function queue implementation. The queue is populated with
        # _show_block() and _hide_block() calls
        self.queue = deque()

        self._initialize()
コード例 #9
0
ファイル: main.py プロジェクト: GerardoGR/piecraft
    def __init__(self):

        # A Batch is a collection of vertex lists for batched rendering.
        self.batch = pyglet.graphics.Batch()

        # A TextureGroup manages an OpenGL texture.
        self.group = TextureGroup(image.load(TEXTURE_PATH).get_texture())

        # A mapping from position to the texture of the block at that position.
        # This defines all the blocks that are currently in the world.
        self.world = {}

        # Same mapping as `world` but only contains blocks that are shown.
        self.shown = {}

        # Mapping from position to a pyglet `VertextList` for all shown blocks.
        self._shown = {}

        # Mapping from sector to a list of positions inside that sector.
        self.sectors = {}

        # Simple function queue implementation. The queue is populated with
        # _show_block() and _hide_block() calls
        self.queue = deque()
        #22222222222222
        try: 
            with open(WORLD_FILE, 'r') as f:
                json_representation = json.load(f)
                json_world = json_representation['world']
                for c in json_world:
                    self.add_block(tuple([int(d) for d in c.split(',')]), json_world[c], immediate=False)
        except IOError:
            self._initialize()
コード例 #10
0
def init_textures(texture_file):
	"""Initializes textures."""
	global textures

	image = load(texture_file)
	texture_group = TextureGroup(image.get_texture())
	width_ratio = 1.0 / (float(image.width) / settings.texture_size)
	height_ratio = 1.0 / (float(image.height) / settings.texture_size)

	for name, coords in texture_mappings.texture_map.iteritems():
		master_x = coords[0] * width_ratio
		master_y = coords[1] * height_ratio
		x = coords[0] * settings.texture_size
		y = coords[1] * settings.texture_size

		#region = image.get_region(x, y, settings.texture_size, settings.texture_size).get_texture()

		# The vertices for the 2d texture, as percentages of the overall texture
		#textures[name]['coordinates'] = [x+width_ratio, y+height_ratio, x, y+height_ratio, x, y, x+width_ratio, y]
		textures[name] = {}
		textures[name]['coordinates'] = [1, 1, 0, 1, 0, 0, 1, 0]
		textures[name]['coordinates_for'] = lambda x, y: [x, y, 0, y, 0, 0, x, 0]
		textures[name]['master_coordinates'] = [master_x+width_ratio, master_y+height_ratio, master_x, master_y+height_ratio, master_x, master_y, master_x+width_ratio, master_y]
		#textures[name]['texture'] = region
		#textures[name]['group'] = TextureGroup(region)

	textures['master'] = {}
	textures['master']['group'] = texture_group
コード例 #11
0
ファイル: splash.py プロジェクト: mmilewski/pyWorm
 def __init__(self, app, camera, showTime):
     self.__theApp = app
     self.__camera = camera
     splashImage = image.load( join('..','gfx','splash.png') )
     self.__texture = splashImage.texture
     self.__alpha = 0.0
     self.__showTime = showTime
コード例 #12
0
ファイル: NeHe 09-Stars Animation.py プロジェクト: msarch/py
def load_textures():
	global texture
	textureSurface = image.load('star.bmp')
	texture=textureSurface.texture
	glBindTexture(GL_TEXTURE_2D, texture.id)
	glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR )
	glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR )
コード例 #13
0
ファイル: rcube.py プロジェクト: idobatter/HatsuneMiku
 def LoadTextures(self):
   '''texture 0-5: faces, 6-11: hints, 12: blending screen, 13: char'''
   i = self.loading
   if i < len(self.textures): # for i in xrange(len(self.textures)):
     if i < len(self.ary_norm): imgfile = TEXIMG_FACE % i # bmp24 256x256
     elif i <= len(self.ary_norm) * 2: imgfile = TEXIMG_HINT
     else: imgfile = TEXIMG_CHAR[i - len(self.ary_norm) * 2 - 1]
     img = image.load(imgfile)
     self.textures[i] = img.get_texture()
     ix, iy = img.width, img.height
     rawimage = img.get_image_data()
     formatstr = 'RGBA'
     pitch = rawimage.width * len(formatstr)
     dat = rawimage.get_data(formatstr, pitch)
     self.dat[i] = (dat, ix, iy)
     if i > len(self.ary_norm): # skip face(0-5) and hint(6:white)
       j = i - len(self.ary_norm)
       d = []
       it = iter(dat)
       while it.__length_hint__():
         r, g, b, a = [ord(it.next()) for k in xrange(4)]
         if i < len(self.ary_norm) * 2 and r >= 128 and g >= 128 and b >= 128:
           r, g, b = r if j & 1 else 0, g if j & 2 else 0, b if j & 4 else 0
         elif i == len(self.ary_norm) * 2:
           r, g, b, a = [int(self.instbgc[k] * 255) for k in xrange(4)]
         else:
           r, g, b, a = r, g, b, 255 * (r + g + b) / (255 * 3)
         d.append('%c%c%c%c' % (r, g, b, a))
       dat = ''.join(d)
     glEnable(self.textures[i].target)
     glBindTexture(self.textures[i].target, self.textures[i].id)
     glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
     glTexImage2D(GL_TEXTURE_2D, 0, 3, ix, iy, 0,
       GL_RGBA, GL_UNSIGNED_BYTE, dat)
     self.loading = i + 1
コード例 #14
0
ファイル: try_sprite_box.py プロジェクト: fyabc/MiniGames
    def __init__(self):
        super().__init__()

        self.scale = 0.8
        self.position = -50, -50

        explosion_animation = image.Animation.from_image_sequence(
            image.ImageGrid(image.load('explosion.png'), 1, 8), 0.1,
        )

        self.explosion = sprite.Sprite(
            explosion_animation,
            position=(320, 240),
            scale=1.5,
        )
        self.explosion2 = sprite.Sprite(
            explosion_animation,
            position=(160, 120),
            scale=1.7,
        )
        self.explosion3 = sprite.Sprite(
            explosion_animation,
            position=(32, 32),
        )
        self.add(self.explosion)
        self.explosion.add(self.explosion2)
        self.explosion2.add(self.explosion3)
コード例 #15
0
ファイル: texture.py プロジェクト: freneticmonkey/Epsilon
 def load(self):
     self._pyglet_image = image.load(self._filename)
     self._size_x = self._pyglet_image.width
     self._size_y = self._pyglet_image.height
     
     self._opengl_id = self._pyglet_image.get_texture().id
     self._loaded = True
コード例 #16
0
ファイル: grill.py プロジェクト: pdevine/suburbia
    def __init__(self):
        self.images = [
            image.load(data_file('fire0.png')),
            image.load(data_file('fire2.png')),
            image.load(data_file('fire1.png')),
        ]

        self.image = self.images[0]
        pos = (randint(140, 350), randint(270, 400))
        self.rect = Rect(pos[0], pos[1], self.image)

        self.lives = 3

        self.delay = 0.2
        self.timer = self.delay
        self.image_count = 0
コード例 #17
0
 def __init__(self, pos, angle):
     super( Pellet, self ).__init__(image.load(os.path.normpath(r'../assets/Graphics/Pellet.png')))
     self.initialPosition = pos
     self.position = (pos)
     self.angle = angle
     self.time_alive = 0
     self.cshape = CircleShape(Vector2(self.get_rect().center[0], self.get_rect().center[1]), self.width/2)
コード例 #18
0
    def __init__(self):
        super( Ship, self ).__init__(image.load(os.path.normpath(r'../assets/Graphics/BookCraft.png')))

        self.drawModules()

        self.position = (250,250)
        self.heath = 100
        self.bulletList = []
        self.centerPoint = self.get_rect().center
        self.midline = (self.centerPoint, self.get_rect().midtop)
        self.cshape = CircleShape(Vector2(self.centerPoint[0],self.centerPoint[1]),self.width/2)

        # Constants for craft movement
        self.CRAFT_MAX_VELOCITY = 1000
        self.CRAFT_ACCELERATION = 100
        self.CRAFT_MAX_TURNRATE = 1

        # Keep track of the current move speed of the ship. These are accessed
        # directly by the scene controlling the ship
        self.craftMovingUp = False
        self.craftMovingDown = False
        self.craftMovingRight = False
        self.craftMovingLeft = False
        self.craft_x_velocity = 0
        self.craft_y_velocity = 0
コード例 #19
0
ファイル: globe.py プロジェクト: holocronweaver/globe
    def __init__(
        self,
        radius=1,
        position=[0, 0, 0],
        velocity=[0, 0, 0],
        rotate=None,
        visible=False,
        slices=0,
        stacks=0,
        color=None,
        texture=None,
    ):
        self.radius = radius
        self.position = position
        self.velocity = velocity
        self.rotate = rotate

        self.visible = visible
        self.slices = slices
        self.stacks = stacks
        self.color = color
        self.texture = texture

        self.quadric = gluNewQuadric()

        if self.texture:
            self.image = image.load(self.texture)
            self.texture = self.image.get_texture()
            gluQuadricTexture(self.quadric, GL_TRUE)

            glEnable(self.texture.target)
            glBindTexture(self.texture.target, self.texture.id)

            glDisable(self.texture.target)
コード例 #20
0
ファイル: texture.py プロジェクト: Xyene/Pycraft
def load_texture(file):
    raw = image.load(file)
    width, height = raw.width, raw.height
    texture = image.load(file).get_data('RGBA', width * 4) # 4bpp, RGBA format

    buffer = [0] # Buffer to hold the returned texture id
    glGenTextures(1, (GLuint * len(buffer))(*buffer))

    glBindTexture(GL_TEXTURE_2D, buffer[0])
    
    #Load textures with no filtering. Filtering generally makes the texture blur.
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, texture)
    
    return buffer[0]
コード例 #21
0
ファイル: tablettask.py プロジェクト: MennoNij/DrivePy
    def __init__(self, show=-1):
        self.started = False

        self.condition = ''
        self.fullCondition = '?'

        self.preselectedShow = show

        self.clip = 0
        self.lastClip = 0
        self.conversation = 0

        self.clipLines = []
        self.minLineIdx = 0
        self.maxLineIdx = 0
        self.clipDuration = 0
        self.lineInterval = 0
        self.clipStartTime = 0
        self.currentClip = None
        self.curShow = None
        self.clipQuestion = None

        self.tabletTexture = image.load('img/dashboard-tablet.png').texture
        self.hh = 1.0
        self.ww = 1.0
        self.tabletDisplayText = ''
        self.maxDisplayLength = 10 # max num of lines displayed
        self.tabletLineWidth = 40

        self.allShows = ['show1', 'show2'] # easy / hard
        self.allNumFragments = [32,34]
        self.shows = self.allShows
        self.numFragments = self.allNumFragments

        self.answers = []

        self.questionOrder = []
        self.questionIndx = 0
        self.correctAnswer = 0

        self.responded = False
        self.playedLetter = False
        self.playedRepeat = False
        self.phase = 0

        self.responseCountdown = 0.0
        self.responseLimit = 15.0
        self.clipInterval = 1.5
        self.lastLineTime = 0.0
        self.isi = 0.0

        self.run = -1
        self.doPractice = False
        self.roadCond = 'simple'

        #self.incorrectSound = pyglet.resource.media('incorrect.wav')
        #self.correctSound = pyglet.resource.media('correct.wav')

        self.db = None
コード例 #22
0
ファイル: logic.py プロジェクト: Kelossus/King-of-the-Dungeon
    def __init__(self, parent):
        super().__init__()

        self.images = [load("resources/gold_" + str(i + 1) + '.png') for i in range(4)]
        self.current_index = None
        self.parent = None
        self.update_turn = False
        self.parent = parent
コード例 #23
0
ファイル: nehe-lesson06.py プロジェクト: msarch/py
def load_textures():
	global texture
	texturefile = os.path.join('data','nehe.bmp')
	textureSurface = image.load(texturefile)
	texture=textureSurface.texture
	glBindTexture(GL_TEXTURE_2D, texture.id)
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
コード例 #24
0
ファイル: texture.py プロジェクト: mariuz/pyGLox
 def load_image(self, filename):
     img = image.load(filename)
     return (
         img.width,
         img.height,
         img.format,
         img.get_image_data().get_data(img.format, img.width * len(img.format)),
     )
コード例 #25
0
ファイル: main.py プロジェクト: Dejmas/Terrain
    def __init__(self, terrain):
        self.position   = [25, 0, 25]
        self._direction = [ 1, 0, 0 ]
        self.speed      =   0
        self.t          =   terrain
        self.yrot       =   90.
        self.input      = [ False, False ]

        textureSurface = image.load('data/rockbump.jpg')
        self.text0 = textureSurface.get_mipmapped_texture()

        textureSurface = image.load('data/rockbump.tga')
        self.nmap = textureSurface.get_mipmapped_texture()

        self.model = cube();

        self.loadShader()
コード例 #26
0
 def __init__(self, pos, angle, speed):
     super( Enemy, self ).__init__(image.load(os.path.normpath(r'../assets/Graphics/IAmABall.png')))
     self.position = pos
     self.health = 100
     self.angle = angle
     self.speed = speed
     self.time_alive = 0
     self.cshape = CircleShape(Vector2(self.get_rect().center[0], self.get_rect().center[1]), self.width/1.5)
コード例 #27
0
ファイル: sky.py プロジェクト: pdevine/suburbia
    def __init__(self):
        self.current_phase = 0
        self.days_until_phasechange = 2
        self.phases = [image.load(data_file('moon-full.png')),
                      ]
        self.deg = 0

        OrbitingObject.__init__(self)
コード例 #28
0
ファイル: teapot.py プロジェクト: khzaw/louvre
 def load_textures(self):
     texture_file = os.getcwd() + os.path.join('/images', self.image_file)
     texture_surface = image.load(texture_file)
     texture = texture_surface.image_data.create_texture(image.Texture)
     glBindTexture(GL_TEXTURE_2D, texture.id)
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
     self.texture = texture
コード例 #29
0
ファイル: grill.py プロジェクト: pdevine/suburbia
    def __init__(self):
        GrillObject.__init__(self)
        self.image = image.load(data_file('beef.png'))
        self.rect = Rect(520, 230, self.image)

        self.cooking = False

        self.reset()
コード例 #30
0
ファイル: accessory.py プロジェクト: myatnoe/Exhibition-Hall
 def load_textures(self):
     file = os.path.join('img','metal.png')
     surface = image.load(file)
     
     t1 = surface.image_data.create_texture(image.Texture)
     glBindTexture(GL_TEXTURE_2D, t1.id)
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
     self.texture = t1
コード例 #31
0
ファイル: conveyorBelt.py プロジェクト: dbingema/FactorySpiel
 def load_animation(self, imgage, delay):
     seq = ImageGrid(load(imgage), 4, 1)
     return Animation.from_image_sequence(seq, delay)
コード例 #32
0
 def __init__(self, image_file, anchor_x=0, anchor_y=0):
     self._image = image.load(image_file)
     self._image.anchor_x = self._image.width / 2
     self._image.anchor_y = self._image.height
コード例 #33
0
 def __init__(self):
     super(CrateModule, self).__init__(
         image.load(
             os.path.normpath(r'../assets/Graphics/CrateModule.png')))
     pass
コード例 #34
0
 def __init__(self, logger, parent_viewport):
     super().__init__(logger, parent_viewport)
     self.inactive_image = load(
         'img/game_progress_bars/progress_bar_inactive.png')
     self.active_image = load(
         'img/game_progress_bars/progress_bar_money_active.png')
コード例 #35
0
ファイル: test_image.py プロジェクト: tritruong9201/C4T16
 def copy_left_to_right(self, encoder=None):
     buf = BytesIO()
     self.left_texture.save("file.png", buf, encoder=encoder)
     buf.seek(0)
     self.right_texture = image.load("file.png", buf).texture
コード例 #36
0
def run(ScreenCls, width=1024, height=768, core=False):
    '''
    config = pyglet.gl.Config(
        double_buffer=True,
        sample_buffers=1, samples=16,
        stencil_size=8,
    )
    '''
    icons = [
        image.load(os.path.join(ICON_PATH, 'icon%i.png' % x))
        for x in (16, 32, 64, 128)
    ]

    window = Window(caption=system.__name__,
                    resizable=True,
                    vsync=True,
                    width=width,
                    height=height)
    window.set_icon(*icons)

    try:
        screen = ScreenCls(window)
    except Exception as e:
        print(e)
        sys.exit(-2)

    @window.event
    def on_draw():
        screen.draw()

    @window.event
    def on_key_press(symbol, modifiers):
        screen.on_key_press(symbol, modifiers)

    @window.event
    def on_key_release(symbol, modifiers):
        screen.on_key_release(symbol, modifiers)

    @window.event
    def on_mouse_motion(x, y, dx, dy):
        screen.on_mouse_motion(x, y, dx, dy)

    @window.event
    def on_mouse_press(x, y, button, modifiers):
        screen.on_mouse_press(x, y, button, modifiers)

    @window.event
    def on_mouse_drag(x, y, dx, dy, button, modifiers):
        screen.on_mouse_drag(x, y, dx, dy, button, modifiers)

    @window.event
    def on_mouse_scroll(x, y, scroll_x, scroll_y):
        screen.on_mouse_scroll(x, y, scroll_x, scroll_y)

    @window.event
    def on_resize(width, height):
        screen.resize(width, height)

    pyglet.clock.schedule_interval(screen.update, 1 / 60.)
    pyglet.clock.schedule_interval(screen.clock, 1.)

    pyglet.app.run()
コード例 #37
0
ファイル: test_image.py プロジェクト: tritruong9201/C4T16
 def load_left(self, image_file, decoder=None):
     self.left_texture = image.load(image_file, decoder=decoder).texture
コード例 #38
0
BLOCK_MAP['tnt'] = pyglet.image.load(TNT_SIDE)
BLOCK_MAP['planks_oak'] = pyglet.image.load(PLANKS_OAK)
BLOCK_MAP['redstone_ore'] = pyglet.image.load(REDSTONE_ORE)
BLOCK_MAP['stonebrick_carved'] = pyglet.image.load(STONEBRICK_CARVED)
BLOCK_MAP['brick'] = pyglet.image.load(BRICK)
BLOCK_MAP['cobblestone'] = pyglet.image.load(COBBLESTONE)
BLOCK_MAP['cobblestone_mossy'] = pyglet.image.load(COBBLESTONE_MOSSY)
BLOCK_MAP['grass_side'] = pyglet.image.load(GRASS_SIDE)
BLOCK_MAP['gravel'] = pyglet.image.load(GRAVEL)
BLOCK_MAP['diamond'] = pyglet.image.load(DIAMOND)
BLOCK_MAP['cactus'] = pyglet.image.load(CACTUS_SIDE)
BLOCK_MAP['cactus_top'] = pyglet.image.load(CACTUS_TOP)

# A TextureGroup manages an OpenGL texture.
TEXTURE_MAP = {}
TEXTURE_MAP['tnt_top'] = TextureGroup(image.load(TNT_TOP).get_texture())
TEXTURE_MAP['tnt_bottom'] = TextureGroup(image.load(TNT_BOTTOM).get_texture())
TEXTURE_MAP['tnt'] = TextureGroup(image.load(TNT_SIDE).get_texture())
TEXTURE_MAP['planks_oak'] = TextureGroup(image.load(PLANKS_OAK).get_texture())
TEXTURE_MAP['redstone_ore'] = TextureGroup(
    image.load(REDSTONE_ORE).get_texture())
TEXTURE_MAP['stonebrick_carved'] = TextureGroup(
    image.load(STONEBRICK_CARVED).get_texture())
TEXTURE_MAP['brick'] = TextureGroup(image.load(BRICK).get_texture())
TEXTURE_MAP['cobblestone'] = TextureGroup(
    image.load(COBBLESTONE).get_texture())
TEXTURE_MAP['cobblestone_mossy'] = TextureGroup(
    image.load(COBBLESTONE_MOSSY).get_texture())
TEXTURE_MAP['grass_side'] = TextureGroup(image.load(GRASS_SIDE).get_texture())
TEXTURE_MAP['grass_top'] = TextureGroup(image.load(GRASS_TOP).get_texture())
TEXTURE_MAP['gravel'] = TextureGroup(image.load(GRAVEL).get_texture())
コード例 #39
0
def preview(expr,
            output='png',
            viewer=None,
            euler=True,
            packages=(),
            **latex_settings):
    r"""
    View expression or LaTeX markup in PNG, DVI, PostScript or PDF form.

    If the expr argument is an expression, it will be exported to LaTeX and
    then compiled using available the TeX distribution.  The first argument,
    'expr', may also be a LaTeX string.  The function will then run the
    appropriate viewer for the given output format or use the user defined
    one. By default png output is generated.

    By default pretty Euler fonts are used for typesetting (they were used to
    typeset the well known "Concrete Mathematics" book). For that to work, you
    need the 'eulervm.sty' LaTeX style (in Debian/Ubuntu, install the
    texlive-fonts-extra package). If you prefer default AMS fonts or your
    system lacks 'eulervm' LaTeX package then unset the 'euler' keyword
    argument.

    To use viewer auto-detection, lets say for 'png' output, issue

    >>> from sympy import symbols, preview, Symbol
    >>> x, y = symbols("x,y")

    >>> preview(x + y, output='png') # doctest: +SKIP

    This will choose 'pyglet' by default. To select a different one, do

    >>> preview(x + y, output='png', viewer='gimp') # doctest: +SKIP

    The 'png' format is considered special. For all other formats the rules
    are slightly different. As an example we will take 'dvi' output format. If
    you would run

    >>> preview(x + y, output='dvi') # doctest: +SKIP

    then 'view' will look for available 'dvi' viewers on your system
    (predefined in the function, so it will try evince, first, then kdvi and
    xdvi). If nothing is found you will need to set the viewer explicitly.

    >>> preview(x + y, output='dvi', viewer='superior-dvi-viewer') # doctest: +SKIP

    This will skip auto-detection and will run user specified
    'superior-dvi-viewer'. If 'view' fails to find it on your system it will
    gracefully raise an exception. You may also enter 'file' for the viewer
    argument. Doing so will cause this function to return a file object in
    read-only mode.

    Currently this depends on pexpect, which is not available for windows.

    Additional keyword args will be passed to the latex call, e.g., the
    symbol_names flag.

    >>> phidd = Symbol('phidd')
    >>> preview(phidd, symbol_names={phidd:r'\ddot{\varphi}'}) # doctest: +SKIP

    """

    # we don't want to depend on anything not in the
    # standard library with SymPy by default
    import pexpect

    special = ['pyglet']

    if viewer is None:
        if output == "png":
            viewer = "pyglet"
        else:
            # sorted in order from most pretty to most ugly
            # very discussable, but indeed 'gv' looks awful :)
            candidates = {
                "dvi": ["evince", "okular", "kdvi", "xdvi"],
                "ps": ["evince", "okular", "gsview", "gv"],
                "pdf": ["evince", "okular", "kpdf", "acroread", "xpdf", "gv"],
            }

            try:
                for candidate in candidates[output]:
                    if pexpect.which(candidate):
                        viewer = candidate
                        break
                else:
                    raise SystemError(
                        "No viewers found for '%s' output format." % output)
            except KeyError:
                raise SystemError("Invalid output format: %s" % output)
    else:
        if viewer not in special and not pexpect.which(viewer):
            raise SystemError("Unrecognized viewer: %s" % viewer)

    actual_packages = packages + ("amsmath", "amsfonts")
    if euler:
        actual_packages += ("euler", )
    package_includes = "\n".join(
        ["\\usepackage{%s}" % p for p in actual_packages])

    format = r"""\documentclass[12pt]{article}
                 %s
                 \begin{document}
                 \pagestyle{empty}
                 %s
                 \vfill
                 \end{document}
              """ % (package_includes, "%s")

    if isinstance(expr, str):
        latex_string = expr
    else:
        latex_string = latex(expr, mode='inline', **latex_settings)

    tmp = tempfile.mktemp()

    with open(tmp + ".tex", "w") as tex:
        tex.write(format % latex_string)

    cwd = os.getcwd()
    os.chdir(tempfile.gettempdir())

    if os.system("latex -halt-on-error %s.tex" % tmp) != 0:
        raise SystemError("Failed to generate DVI output.")

    os.remove(tmp + ".tex")
    os.remove(tmp + ".aux")
    os.remove(tmp + ".log")

    if output != "dvi":
        command = {
            "ps"  : "dvips -o %s.ps %s.dvi",
            "pdf" : "dvipdf %s.dvi %s.pdf",
            "png" : "dvipng -T tight -z 9 " + \
                    "--truecolor -o %s.png %s.dvi",
        }

        try:
            if os.system(command[output] % (tmp, tmp)) != 0:
                raise SystemError("Failed to generate '%s' output." % output)
            else:
                os.remove(tmp + ".dvi")
        except KeyError:
            raise SystemError("Invalid output format: %s" % output)

    src = "%s.%s" % (tmp, output)
    src_file = None

    if viewer == "file":
        src_file = open(src, 'rb')
    elif viewer == "pyglet":
        try:
            from pyglet import window, image, gl
            from pyglet.window import key
        except ImportError:
            raise ImportError(
                "pyglet is required for plotting.\n visit http://www.pyglet.org/"
            )

        if output == "png":
            from pyglet.image.codecs.png import PNGImageDecoder
            img = image.load(src, decoder=PNGImageDecoder())
        else:
            raise SystemError("pyglet preview works only for 'png' files.")

        offset = 25

        win = window.Window(width=img.width + 2 * offset,
                            height=img.height + 2 * offset,
                            caption="sympy",
                            resizable=False)

        win.set_vsync(False)

        try:

            def on_close():
                win.has_exit = True

            win.on_close = on_close

            def on_key_press(symbol, modifiers):
                if symbol in [key.Q, key.ESCAPE]:
                    on_close()

            win.on_key_press = on_key_press

            def on_expose():
                gl.glClearColor(1.0, 1.0, 1.0, 1.0)
                gl.glClear(gl.GL_COLOR_BUFFER_BIT)

                img.blit((win.width - img.width) / 2,
                         (win.height - img.height) / 2)

            win.on_expose = on_expose

            while not win.has_exit:
                win.dispatch_events()
                win.flip()
        except KeyboardInterrupt:
            pass

        win.close()
    else:
        os.system("%s %s &> /dev/null &" % (viewer, src))
        time.sleep(2)  # wait for the viewer to read data

    os.remove(src)
    os.chdir(cwd)

    if src_file is not None:
        return src_file
コード例 #40
0
ファイル: pytron.py プロジェクト: ThibaultNocchi/PytronAI
    def __init__(self,
                 arena_width: int,
                 arena_height: int,
                 arena_border: int,
                 square_size: int,
                 draw: bool,
                 fps_limit: int = 12,
                 single_life: bool = False):

        self.single_life = single_life

        self.screen_width = arena_width + 2 * arena_border
        self.screen_height = arena_height + 70
        self.arena_width = arena_width
        self.arena_height = arena_height
        self.arena_border = arena_border
        self.square_size = square_size

        self.grid_width = int(self.arena_width / self.square_size)
        self.grid_height = int(self.arena_height / self.square_size)

        if self.grid_width < 1 or self.grid_height < 1:
            raise ValueError("Square size too big or arena size too small.")

        self.iteration = 0

        self.draw = draw
        self.fps = fps_limit

        self.win = window.Window(width=self.screen_width,
                                 height=self.screen_height,
                                 visible=False)
        self.colors = []
        self.squares_verts = []
        if draw:
            self.header_img = image.load("header.png").texture
            clock.set_fps_limit(self.fps)
            self.font = font.load("Arial", 12, bold=True, italic=False)
            self.arena_verts = [(self.arena_border - 1, self.arena_border - 2),
                                (self.arena_border + self.arena_width + 1,
                                 self.arena_border - 2),
                                (self.arena_border + self.arena_width + 1,
                                 self.arena_border + self.arena_height),
                                (self.arena_border - 1,
                                 self.arena_border + self.arena_height),
                                (self.arena_border - 1, self.arena_border - 2)]
            self.points_coord = [(150, self.screen_height - 20),
                                 (150, self.screen_height - 40),
                                 (420, self.screen_height - 20),
                                 (420, self.screen_height - 40)]
            self.colors = [(0, 0, 0), (0, 0, 1), (1, 1, 0), (1, 0, 1),
                           (0, 1, 1), (0.5, 0.5, 0), (0.5, 0, 0.5),
                           (0, 0.5, 0.5), (1, 1, 1), (1, 1, 1), (1, 1, 1),
                           (0, 1, 0), (1, 0, 0)]
            self.square_verts = [(0, 0), (self.square_size - 1, 0),
                                 (self.square_size - 1, self.square_size - 1),
                                 (0, self.square_size - 1)]
            for y in range(self.grid_height):
                self.squares_verts.append([])
                for x in range(self.grid_width):
                    self.squares_verts[y].append([])
                    for vx, vy in self.square_verts:
                        self.squares_verts[y][x].append(vx +
                                                        self.arena_border +
                                                        (x * self.square_size))
                        self.squares_verts[y][x].append(vy +
                                                        self.arena_border +
                                                        (y * self.square_size))

        self.grid = Grid(self.grid_width, self.grid_height)
コード例 #41
0
    def __init__(self, game_class, x, y, w, h, sprite_sheet=None, sprite_width=32, sprite_height=32):
        """
        To add an object to a map:
        map.objects['object name'] = object

        Object states:
        Each state has a name (consider using integers if you want to advance through them sequentially)
        Each state is a dict of properties that the object will update to when state_index is changed to that state name
        Ensure that these properties are spelt correctly!
        To change state elsewhere, just set object.state_index = <state_name_here>, properties will automatically update

        Flair:
        Flair is a dict of 'name': (surface, position (relative to object centre)) to additionally render attached to sprite
        E.g. Hats, speech bubbles.

        Collision:
        Each object has a collision_weight.
        Objects can only push objects with equal or less weight.
        Objects can only push a chain of objects up to their own weight.
        If an objects' collision weight is 0, it does not collide with objects.
        Collision rectangle updates automatically if you change obj dimensions (or coord).
        """
        self.game_class = game_class

        self.states = {'state1': {'max_speed': 1, 'fear_radius': 50},
                       'state2': {'max_speed': 5, 'fear_radius': 150}}
        self._state_index = 'state1'

        self._coord = (x, y)  # top left
        self._dimensions = (w, h)
        self.velocity = (0, 0)
        self.min_speed = 0
        self.current_speed = 0
        self.normal_speed = 0
        self.feared_speed = 0
        self.fear_radius = 50
        self.scared_of = []
        self.fears = FearsList(self)
        self.rect = rect.Rect(self.coord, self.dimensions)
        self.update_timer = 40
        self.fear_timer = 0
        self.scream_timer = 0
        self.fear = 0
        self.scream_thresh = 50

        #variables for animation
        if sprite_sheet is not None:
            self.sprite_sheet_name = sprite_sheet
        else:
            self.sprite_sheet_name = 'DudeSheet.png'
        self.sprite_sheet = image.load(os.path.join(CHARACTERS_DIR, self.sprite_sheet_name))

        # disable texture filtering
        texture = self.sprite_sheet.get_texture()
        gl.glBindTexture(texture.target, texture.id)
        gl.glTexParameteri(texture.target, gl.GL_TEXTURE_MAG_FILTER, gl.GL_NEAREST)
        gl.glBindTexture(texture.target, 0)

        self._animation_state = 0
        self.sprite_height = sprite_height
        self.sprite_width = sprite_width
        self._animations = []
        self._create_animations()
        self.sprite = sprite.Sprite(self._animations[self._animation_state], x=self._coord[0], y=self._coord[1])

        #trigger functions
        self.has_touched_function = []
        self.is_touched_function = []
        self.has_untouched_function = []
        self.is_untouched_function = []

        self.move_up = False
        self.move_down = False
        self.move_left = False
        self.move_right = False

        self.highlight_radius = 20

        self.flair = {}
        self.collision_weight = 1  # set to 0 for no collision, can only push things that are lighter, or same weight

        self.cutscene_controlling = []

        self.path = []
コード例 #42
0
ファイル: preview.py プロジェクト: abiswas20/codewars_code
def preview(expr,
            output='png',
            viewer=None,
            euler=True,
            packages=(),
            filename=None,
            outputbuffer=None,
            preamble=None,
            dvioptions=None,
            outputTexFile=None,
            **latex_settings):
    r"""
    View expression or LaTeX markup in PNG, DVI, PostScript or PDF form.

    If the expr argument is an expression, it will be exported to LaTeX and
    then compiled using the available TeX distribution.  The first argument,
    'expr', may also be a LaTeX string.  The function will then run the
    appropriate viewer for the given output format or use the user defined
    one. By default png output is generated.

    By default pretty Euler fonts are used for typesetting (they were used to
    typeset the well known "Concrete Mathematics" book). For that to work, you
    need the 'eulervm.sty' LaTeX style (in Debian/Ubuntu, install the
    texlive-fonts-extra package). If you prefer default AMS fonts or your
    system lacks 'eulervm' LaTeX package then unset the 'euler' keyword
    argument.

    To use viewer auto-detection, lets say for 'png' output, issue

    >>> from sympy import symbols, preview, Symbol
    >>> x, y = symbols("x,y")

    >>> preview(x + y, output='png')

    This will choose 'pyglet' by default. To select a different one, do

    >>> preview(x + y, output='png', viewer='gimp')

    The 'png' format is considered special. For all other formats the rules
    are slightly different. As an example we will take 'dvi' output format. If
    you would run

    >>> preview(x + y, output='dvi')

    then 'view' will look for available 'dvi' viewers on your system
    (predefined in the function, so it will try evince, first, then kdvi and
    xdvi). If nothing is found you will need to set the viewer explicitly.

    >>> preview(x + y, output='dvi', viewer='superior-dvi-viewer')

    This will skip auto-detection and will run user specified
    'superior-dvi-viewer'. If 'view' fails to find it on your system it will
    gracefully raise an exception.

    You may also enter 'file' for the viewer argument. Doing so will cause
    this function to return a file object in read-only mode, if 'filename'
    is unset. However, if it was set, then 'preview' writes the genereted
    file to this filename instead.

    There is also support for writing to a BytesIO like object, which needs
    to be passed to the 'outputbuffer' argument.

    >>> from io import BytesIO
    >>> obj = BytesIO()
    >>> preview(x + y, output='png', viewer='BytesIO',
    ...         outputbuffer=obj)

    The LaTeX preamble can be customized by setting the 'preamble' keyword
    argument. This can be used, e.g., to set a different font size, use a
    custom documentclass or import certain set of LaTeX packages.

    >>> preamble = "\\documentclass[10pt]{article}\n" \
    ...            "\\usepackage{amsmath,amsfonts}\\begin{document}"
    >>> preview(x + y, output='png', preamble=preamble)

    If the value of 'output' is different from 'dvi' then command line
    options can be set ('dvioptions' argument) for the execution of the
    'dvi'+output conversion tool. These options have to be in the form of a
    list of strings (see subprocess.Popen).

    Additional keyword args will be passed to the latex call, e.g., the
    symbol_names flag.

    >>> phidd = Symbol('phidd')
    >>> preview(phidd, symbol_names={phidd:r'\ddot{\varphi}'})

    For post-processing the generated TeX File can be written to a file by
    passing the desired filename to the 'outputTexFile' keyword
    argument. To write the TeX code to a file named
    "sample.tex" and run the default png viewer to display the resulting
    bitmap, do

    >>> preview(x + y, outputTexFile="sample.tex")


    """
    special = ['pyglet']

    if viewer is None:
        if output == "png":
            viewer = "pyglet"
        else:
            # sorted in order from most pretty to most ugly
            # very discussable, but indeed 'gv' looks awful :)
            # TODO add candidates for windows to list
            candidates = {
                "dvi": ["evince", "okular", "kdvi", "xdvi"],
                "ps": ["evince", "okular", "gsview", "gv"],
                "pdf": ["evince", "okular", "kpdf", "acroread", "xpdf", "gv"],
            }

            try:
                for candidate in candidates[output]:
                    path = find_executable(candidate)
                    if path is not None:
                        viewer = path
                        break
                else:
                    raise SystemError(
                        "No viewers found for '%s' output format." % output)
            except KeyError:
                raise SystemError("Invalid output format: %s" % output)
    else:
        if viewer == "StringIO":
            viewer = "BytesIO"
            if outputbuffer is None:
                raise ValueError("outputbuffer has to be a BytesIO "
                                 "compatible object if viewer=\"StringIO\"")
        elif viewer == "BytesIO":
            if outputbuffer is None:
                raise ValueError("outputbuffer has to be a BytesIO "
                                 "compatible object if viewer=\"BytesIO\"")
        elif viewer not in special and not find_executable(viewer):
            raise SystemError("Unrecognized viewer: %s" % viewer)

    if preamble is None:
        actual_packages = packages + ("amsmath", "amsfonts")
        if euler:
            actual_packages += ("euler", )
        package_includes = "\n" + "\n".join(
            ["\\usepackage{%s}" % p for p in actual_packages])

        preamble = r"""\documentclass[varwidth,12pt]{standalone}
%s

\begin{document}
""" % (package_includes)
    else:
        if packages:
            raise ValueError("The \"packages\" keyword must not be set if a "
                             "custom LaTeX preamble was specified")
    latex_main = preamble + '\n%s\n\n' + r"\end{document}"

    if isinstance(expr, str):
        latex_string = expr
    else:
        latex_string = ('$\\displaystyle ' +
                        latex(expr, mode='plain', **latex_settings) + '$')

    try:
        workdir = tempfile.mkdtemp()

        with io.open(join(workdir, 'texput.tex'), 'w', encoding='utf-8') as fh:
            fh.write(unicode(latex_main) % u_decode(latex_string))

        if outputTexFile is not None:
            shutil.copyfile(join(workdir, 'texput.tex'), outputTexFile)

        if not find_executable('latex'):
            raise RuntimeError("latex program is not installed")

        try:
            # Avoid showing a cmd.exe window when running this
            # on Windows
            if os.name == 'nt':
                creation_flag = 0x08000000  # CREATE_NO_WINDOW
            else:
                creation_flag = 0  # Default value
            check_output([
                'latex', '-halt-on-error', '-interaction=nonstopmode',
                'texput.tex'
            ],
                         cwd=workdir,
                         stderr=STDOUT,
                         creationflags=creation_flag)
        except CalledProcessError as e:
            raise RuntimeError(
                "'latex' exited abnormally with the following output:\n%s" %
                e.output)

        if output != "dvi":
            defaultoptions = {
                "ps": [],
                "pdf": [],
                "png": ["-T", "tight", "-z", "9", "--truecolor"],
                "svg": ["--no-fonts"],
            }

            commandend = {
                "ps": ["-o", "texput.ps", "texput.dvi"],
                "pdf": ["texput.dvi", "texput.pdf"],
                "png": ["-o", "texput.png", "texput.dvi"],
                "svg": ["-o", "texput.svg", "texput.dvi"],
            }

            if output == "svg":
                cmd = ["dvisvgm"]
            else:
                cmd = ["dvi" + output]
            if not find_executable(cmd[0]):
                raise RuntimeError("%s is not installed" % cmd[0])
            try:
                if dvioptions is not None:
                    cmd.extend(dvioptions)
                else:
                    cmd.extend(defaultoptions[output])
                cmd.extend(commandend[output])
            except KeyError:
                raise SystemError("Invalid output format: %s" % output)

            try:
                # Avoid showing a cmd.exe window when running this
                # on Windows
                if os.name == 'nt':
                    creation_flag = 0x08000000  # CREATE_NO_WINDOW
                else:
                    creation_flag = 0  # Default value
                check_output(cmd,
                             cwd=workdir,
                             stderr=STDOUT,
                             creationflags=creation_flag)
            except CalledProcessError as e:
                raise RuntimeError(
                    "'%s' exited abnormally with the following output:\n%s" %
                    (' '.join(cmd), e.output))

        src = "texput.%s" % (output)

        if viewer == "file":
            if filename is None:
                buffer = BytesIO()
                with open(join(workdir, src), 'rb') as fh:
                    buffer.write(fh.read())
                return buffer
            else:
                shutil.move(join(workdir, src), filename)
        elif viewer == "BytesIO":
            with open(join(workdir, src), 'rb') as fh:
                outputbuffer.write(fh.read())
        elif viewer == "pyglet":
            try:
                from pyglet import window, image, gl
                from pyglet.window import key
            except ImportError:
                raise ImportError(
                    "pyglet is required for preview.\n visit http://www.pyglet.org/"
                )

            if output == "png":
                from pyglet.image.codecs.png import PNGImageDecoder
                img = image.load(join(workdir, src), decoder=PNGImageDecoder())
            else:
                raise SystemError("pyglet preview works only for 'png' files.")

            offset = 25

            config = gl.Config(double_buffer=False)
            win = window.Window(width=img.width + 2 * offset,
                                height=img.height + 2 * offset,
                                caption="sympy",
                                resizable=False,
                                config=config)

            win.set_vsync(False)

            try:

                def on_close():
                    win.has_exit = True

                win.on_close = on_close

                def on_key_press(symbol, modifiers):
                    if symbol in [key.Q, key.ESCAPE]:
                        on_close()

                win.on_key_press = on_key_press

                def on_expose():
                    gl.glClearColor(1.0, 1.0, 1.0, 1.0)
                    gl.glClear(gl.GL_COLOR_BUFFER_BIT)

                    img.blit((win.width - img.width) / 2,
                             (win.height - img.height) / 2)

                win.on_expose = on_expose

                while not win.has_exit:
                    win.dispatch_events()
                    win.flip()
            except KeyboardInterrupt:
                pass

            win.close()
        else:
            try:
                # Avoid showing a cmd.exe window when running this
                # on Windows
                if os.name == 'nt':
                    creation_flag = 0x08000000  # CREATE_NO_WINDOW
                else:
                    creation_flag = 0  # Default value
                check_output([viewer, src],
                             cwd=workdir,
                             stderr=STDOUT,
                             creationflags=creation_flag)
            except CalledProcessError as e:
                raise RuntimeError(
                    "'%s %s' exited abnormally with the following output:\n%s"
                    % (viewer, src, e.output))
    finally:
        try:
            shutil.rmtree(workdir)  # delete directory
        except OSError as e:
            if e.errno != 2:  # code 2 - no such file or directory
                raise
コード例 #43
0
ファイル: block.py プロジェクト: muriplz/Minecraft
 def __init__(self, name):
     self.color_data = image.load(join(path['texture'], 'colormap', name + '.png'))
     if self.color_data is None:
         return
     self.color_data = self.color_data.get_data('RGB', self.color_data.width * 3)
コード例 #44
0
ファイル: block.py プロジェクト: muriplz/Minecraft
def get_block_icon(block, size):
    # 显示 3D 方块的缩略图
    global _fbo
    if hasattr(block, 'img'):
        if not isinstance(block, Block):
            pass
        else:
            return image.load(join(path['texture'], 'block', block.name + '.png'))
    block_icon = block.group.texture.get_region(
            int(block.texture_data[2 * 8] * 16) * size,
            int(block.texture_data[2 * 8 + 1]) * size,
            size, size)
    if _fbo == None:
        _fbo = GLuint(0)
        glGenFramebuffers(1, byref(_fbo))
    glBindFramebuffer(GL_FRAMEBUFFER, _fbo)
    icon_texture = pyglet.image.Texture.create(size, size, GL_RGBA)
    glBindTexture(GL_TEXTURE_2D, icon_texture.id)
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, size, size, 0, GL_RGBA, GL_FLOAT, None)
    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, icon_texture.id, 0)
    viewport = (GLint * 4)()
    glGetIntegerv(GL_VIEWPORT, viewport)
    glViewport(0, 0, size, size)
    glClearColor(1.0, 1.0, 1.0, 0.0)
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
    glMatrixMode(GL_PROJECTION)
    glPushMatrix()
    glLoadIdentity()
    glOrtho(-1.5, 1.5, -1.5, 1.5, -10, 10)
    glMatrixMode(GL_MODELVIEW)
    glPushMatrix()
    glLoadIdentity()
    glColor4f(1.0, 1.0, 1.0, 1.0)
    glRotatef(-45.0, 0.0, 1.0, 0.0)
    glRotatef(-30.0, -1.0, 0.0, 1.0)
    glScalef(1.5, 1.5, 1.5)
    glEnable(GL_BLEND)
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
    vertex_data = block.get_vertices(0, 0, 0)
    texture_data = block.texture_data
    count = len(texture_data) // 2
    batch = pyglet.graphics.Batch()
    if hasattr(block, 'get_item_color'):
        batch.add(count, GL_QUADS, block.group,
                ('v3f/static', vertex_data),
                ('t2f/static', texture_data),
                ('c3f/static', block.get_item_color()))
    else:
        batch.add(count, GL_QUADS, block.group,
                  ('v3f/static', vertex_data),
                  ('t2f/static', texture_data))
    batch.draw()
    glMatrixMode(GL_PROJECTION)
    glPopMatrix()
    glMatrixMode(GL_MODELVIEW)
    glPopMatrix()
    glBindFramebuffer(GL_FRAMEBUFFER, 0)
    glViewport(*viewport)
    glClearColor(0.0, 0.0, 0.0, 1.0)
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
    return icon_texture.get_image_data()
コード例 #45
0
KEYS = {
    'up': UP,
    'down': DOWN,
    'left': LEFT,
    'right': RIGHT,
    'focus': LSHIFT,
    'shoot': Z,
    'bomb': X,
}

KEY_PRESSED = 2

IMAGES = {
    'ui': {
        'borders': load('resources/graphics/ui/borders.png'),
        'mainmenu_bg': load('resources/graphics/ui/mainmenu_bg.png'),
        'mainmenu_bg2': load('resources/graphics/ui/mainmenu_bg2.png'),
        'mainmenu_left': load('resources/graphics/ui/mainmenu_left.png')
    },
    'bullets': {
        'round': load('resources/graphics/bullets/round.png')
    },
    'player': {
        'player1': load('resources/graphics/player/player1.png')
    },
    'enemies': {},
    'backgrounds': {
        'clouds': load('resources/graphics/backgrounds/clouds.png'),
        'grass': load('resources/graphics/backgrounds/grass.png')
    }
コード例 #46
0
ファイル: test_image.py プロジェクト: tritruong9201/C4T16
 def load_right_arb(self, image_file, pixel_format):
     img = image.load(image_file)
     img.format = pixel_format
     img.data  # forces conversion
     self.right_texture = img.texture
コード例 #47
0
    glMatrixMode(GL_PROJECTION)
    glLoadIdentity()
    gluPerspective(70, 1.0 * width / height, 0.1, 1000.0)
    glMatrixMode(GL_MODELVIEW)
    glLoadIdentity()


win.on_resize = on_resize

glEnable(GL_BLEND)
glShadeModel(GL_SMOOTH)
glBlendFunc(GL_SRC_ALPHA, GL_ONE)
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST)
glDisable(GL_DEPTH_TEST)

spark_tex = image.load(os.path.join(os.path.dirname(__file__),
                                    'flare3.png')).get_texture()

sparks = ParticleGroup(controllers=[
    Lifetime(3),
    Movement(damping=0.93),
    Fader(fade_out_start=0.75, fade_out_end=3.0),
],
                       renderer=BillboardRenderer(
                           SpriteTexturizer(spark_tex.id)))

spark_emitter = StaticEmitter(template=Particle(position=(0, 0, -100),
                                                color=(1, 1, 1),
                                                size=(2, 2, 0)),
                              deviation=Particle(position=(1, 1, 1),
                                                 velocity=(75, 75, 75),
                                                 size=(0.2, 0.2, 0),
コード例 #48
0
ファイル: texture.py プロジェクト: icebreaker/pyGLox
 def load_image(self, filename):
     img = image.load(filename)
     return (img.width, img.height, img.format,
             img.get_image_data().get_data(img.format,
                                           img.width * len(img.format)))
コード例 #49
0
ファイル: object_main.py プロジェクト: severokST/Pack
import random
import numpy
from pyglet import image, sprite

images = [image.load('./images/circle.png')]
time_scale = 1


class Basic:
    def __init__(self, position, target, team, batch_set, order_group):
        self.position = position
        self.team = team
        self.speed = 1
        self.range = 5
        self.target_position = self.position
        self.target_grid = target
        self.sprite = sprite.Sprite(images[0],
                                    batch=batch_set,
                                    group=order_group,
                                    x=position[0],
                                    y=position[1])

    def move(self):
        if self.position[0] != self.target_position[0] and self.position[
                1] != self.target_position[1]:
            direction = random.randint(0, 1)
        else:
            if self.position[0] != self.target_position[0]: direction = 0
            else: direction = 1
        if self.position[direction] > self.target_position[direction]:
            self.position[direction] -= self.speed / time_scale
コード例 #50
0
ファイル: tool.py プロジェクト: dbingema/FactorySpiel
 def load_animation(self, imgage, delay):
     seq = ImageGrid(load(imgage), 1, self.num_frames)
     return Animation.from_image_sequence(seq, delay, loop=False)
コード例 #51
0
# Imported modules
import os
from pyglet.image import load, ImageGrid, Animation
from itertools import cycle


# Constant values
WINDOW_WIDTH = 1200
WINDOW_HEIGHT = 400
GENERATIONS = 25
FONT_NAME = os.path.join(os.path.dirname(__file__), "data/fonts/press_start_2p.ttf") 


# Sprites
GAME_SPRITES = load(os.path.join(os.path.dirname(__file__), "data/images/sprites.png"))
TERRAIN_IMG = GAME_SPRITES.get_region(2, 0, 2402, 27)
DINOSAUR_RUN_ANIMATION = Animation.from_image_sequence(
    ImageGrid(GAME_SPRITES.get_region(1854, 33, 176, 95), 1, 2, item_width=88, item_height=96),
    0.3,
    loop=True
)
DINOSAUR_DUCK_ANIMATION = Animation.from_image_sequence(
    ImageGrid(GAME_SPRITES.get_region(2203, 33, 240, 61), 1, 2, item_width=118, item_height=62),
    0.3,
    loop=True
)
DINOSAUR_JUMP_IMG = GAME_SPRITES.get_region(1678, 33, 88, 95)
DINOSAUR_COLLISION_IMG = GAME_SPRITES.get_region(2030, 33, 88, 95)
CACTI_IMGS = (
    GAME_SPRITES.get_region(446, 58, 34, 70),  # Small cacti 1
コード例 #52
0
def load_image(*filename):
    filename = os.path.join(*filename)
    if filename not in _data:
        _data[filename] = image.load(filename)
    return _data[filename]
コード例 #53
0
class Window(pyglet.window.Window):
    worldsize=80
    batch=pyglet.graphics.Batch()
    group=TextureGroup(image.load(TEXTURE_PATH).get_texture())
    world={}
    shown={}
    _shown={}
    sectors={}
    queue=deque()
    
    def __init__(self,*args,**kwargs):
        super().__init__(*args,**kwargs)
        self.exclusive = False
        
        self.strafe = [0, 0]
        self.label = pyglet.text.Label('', font_name='Arial', font_size=18,
            x=10, y=self.height - 10, anchor_x='left', anchor_y='top',
            color=(0, 0, 0, 255))
        self.myworld=World(self.worldsize,
                        self.batch,
                        self.group,
                        self.world,
                        self.shown,
                        self._shown,
                        self.sectors,
                        self.queue)
        self.player=Player()
        self.player.setRotation((0,0))
        self.player.setPosition((0,0,0))
        self.player.setSector(None)
        pyglet.clock.schedule_interval(self.update, 1.0 / TICKS_PER_SEC)
        
        
    def update(self,dt):
        self.myworld.processQueue()
        sector=self.myworld.sectorize(self.player.position)
        if sector!=self.player.sector:
            self.myworld.changeSectors(self.player.sector,sector)
            if self.player.sector is None:
                self.myworld.processEntireQueue()
            self.player.setSector(sector)
        m=8
        dt=min(dt,0.2)
        for _ in range(m):
            self.player.updatePlayer(dt/m,self.strafe)
            position=self.collide(self.player.position,self.player.PLAYER_HEIGHT)
            self.player.setPosition(position)
            
    def collide(self, position, height):
        """ Checks to see if the player at the given `position` and `height`
        is colliding with any blocks in the world.

        Parameters
        ----------
        position : tuple of len 3
            The (x, y, z) position to check for collisions at.
        height : int or float
            The height of the player.

        Returns
        -------
        position : tuple of len 3
            The new position of the player taking into account collisions.

        """
        # How much overlap with a dimension of a surrounding block you need to
        # have to count as a collision. If 0, touching terrain at all counts as
        # a collision. If .49, you sink into the ground, as if walking through
        # tall grass. If >= .5, you'll fall through the ground.
        pad = 0.25
        p = list(position)  #当前位置
        np = self.myworld.normalize(position)    #把位置数据整数化
        for face in self.myworld.FACES:  # check all surrounding blocks
            for i in range(3):  # check each dimension independently
                if not face[i]: #检测到1跳过
                    continue
                # How much overlap you have with this dimension.检测在这个方向上有多少重叠的部分
                d = (p[i] - np[i]) * face[i]    #face控制前后
                
                if d < pad:
                    continue
                for dy in range(height):  # check each height
                    op = list(np)
                    op[1] -= dy
                    op[i] += face[i]
                    if tuple(op) not in self.world:
                        continue
                    p[i] -= (d - pad) * face[i]
                    if face == (0, -1, 0) or face == (0, 1, 0):
                        # You are colliding with the ground or ceiling, so stop
                        # falling / rising.把速度将为0
                        self.player.setDy(0)
                    break
        return tuple(p)
        
    
    def on_mouse_press(self, x, y, button, modifiers):
        if self.exclusive:
#            vector = self.get_sight_vector()
#            block, previous = self.model.hit_test(self.position, vector)    #返回视线矢量方向上的检测到的块
#            if (button == mouse.RIGHT) or \
#                    ((button == mouse.LEFT) and (modifiers & key.MOD_CTRL)):
#                # ON OSX, control + left click = right click.
#                if previous:
#                    self.model.add_block(previous, self.block)
#            elif button == pyglet.window.mouse.LEFT and block:
#                texture = self.model.world[block]
#                if texture != STONE:
#                    self.model.remove_block(block)
            pass
        else:
            self.set_exclusive_mouse(True)
    
    def on_mouse_motion(self, x, y, dx, dy):
        if self.exclusive:
            m = 0.15    #鼠标灵敏度
            x, y = self.player.rotation
            x, y = x + dx * m, y + dy * m
            y = max(-90, min(90, y))    #限制y的范围
            self.player.rotation = (x, y)
    
    def on_key_press(self, symbol, modifiers):
        if symbol == key.W:
            self.strafe[0] -= 1
        elif symbol == key.S:
            self.strafe[0] += 1
        elif symbol == key.A:
            self.strafe[1] -= 1
        elif symbol == key.D:
            self.strafe[1] += 1
        elif symbol == key.SPACE:
            if self.player.dy == 0:
                self.player.setDy(self.player.JUMP_SPEED)
        elif symbol == key.ESCAPE:
            self.set_exclusive_mouse(False)
        elif symbol == key.TAB:
            self.player.flying = not self.player.flying
        
    
    def on_key_release(self, symbol, modifiers):
        if symbol == key.W:
            self.strafe[0] += 1
        elif symbol == key.S:
            self.strafe[0] -= 1
        elif symbol == key.A:
            self.strafe[1] += 1
        elif symbol == key.D:
            self.strafe[1] -= 1
    
    def on_resize(self, width, height):
        pass
    
    def draw_label(self):
        """ Draw the label in the top left of the screen.

        """
#        x, y, z = self.position
        xx,yy=self.player.rotation
        x,y,z=self.player.position
        self.label.text = '%02d  (%.2f, %.2f, %.2f)  %0.2f / %0.2f' % (
            pyglet.clock.get_fps(),x,y,z,xx,yy
            )
        self.label.draw()
    
    def on_draw(self):
        self.clear()
        self.set3d()
        pyglet.gl.glColor3d(1, 1, 1)
        self.batch.draw()
#        self.draw_focused_block()
        self.set2d()
        self.draw_label()
#        self.draw_reticle()
    
    def set_exclusive_mouse(self, exclusive):
        """ If `exclusive` is True, the game will capture the mouse, if False
        the game will ignore the mouse.

        """
        super().set_exclusive_mouse(exclusive)
        self.exclusive = exclusive
        
    def setupFog(self):
        """ Configure the OpenGL fog properties.
    
        """
        # Enable fog. Fog "blends a fog color with each rasterized pixel fragment's
        # post-texturing color."
        pyglet.gl.glEnable(pyglet.gl.GL_FOG)
        # Set the fog color.
        pyglet.gl.glFogfv(pyglet.gl.GL_FOG_COLOR, (pyglet.gl.GLfloat * 4)(0.5, 0.69, 1.0, 1))
        # Say we have no preference between rendering speed and quality.
        pyglet.gl.glHint(pyglet.gl.GL_FOG_HINT, pyglet.gl.GL_DONT_CARE)
        # Specify the equation used to compute the blending factor.
        pyglet.gl.glFogi(pyglet.gl.GL_FOG_MODE, pyglet.gl.GL_LINEAR)
        # How close and far away fog starts and ends. The closer the start and end,
        # the denser the fog in the fog range.
        pyglet.gl.glFogf(pyglet.gl.GL_FOG_START, 20.0)
        pyglet.gl.glFogf(pyglet.gl.GL_FOG_END, 60.0)
    
    def set2d(self):
        """ Configure OpenGL to draw in 2d.

        """
        width, height = self.get_size()
        pyglet.gl.glDisable(pyglet.gl.GL_DEPTH_TEST)
        pyglet.gl.glViewport(0, 0, width, height)
        pyglet.gl.glMatrixMode(pyglet.gl.GL_PROJECTION)
        pyglet.gl.glLoadIdentity()
        pyglet.gl.glOrtho(0, width, 0, height, -1, 1)
        pyglet.gl.glMatrixMode(pyglet.gl.GL_MODELVIEW)
        pyglet.gl.glLoadIdentity()
        
    def set3d(self):
        """ Configure OpenGL to draw in 3d.

        """
        width, height = self.get_size()
        pyglet.gl.glEnable(pyglet.gl.GL_DEPTH_TEST)
        pyglet.gl.glViewport(0, 0, width, height)
        pyglet.gl.glMatrixMode(pyglet.gl.GL_PROJECTION)
        pyglet.gl.glLoadIdentity()
        pyglet.gl.gluPerspective(65.0, width / height, 0.1, 60.0)
        pyglet.gl.glMatrixMode(pyglet.gl.GL_MODELVIEW)
        pyglet.gl.glLoadIdentity()
        x, y = self.player.rotation
#        x, y = 120, -50
        pyglet.gl.glRotatef(x, 0, 1, 0)
        pyglet.gl.glRotatef(-y, math.cos(math.radians(x)), 0, math.sin(math.radians(x)))
#        x, y, z = self.position
        x,y,z= self.player.position
        pyglet.gl.glTranslatef(-x, -y, -z)
        
    def setUp(self):
        """ Basic OpenGL configuration.
    
        """
        # Set the color of "clear", i.e. the sky, in rgba.
        pyglet.gl.glClearColor(0.5, 0.69, 1.0, 1)
        # Enable culling (not rendering) of back-facing facets -- facets that aren't
        # visible to you.
        pyglet.gl.glEnable(pyglet.gl.GL_CULL_FACE)
        # Set the texture minification/magnification function to GL_NEAREST (nearest
        # in Manhattan distance) to the specified texture coordinates. GL_NEAREST
        # "is generally faster than GL_LINEAR, but it can produce textured images
        # with sharper edges because the transition between texture elements is not
        # as smooth."
        pyglet.gl.glTexParameteri(pyglet.gl.GL_TEXTURE_2D, pyglet.gl.GL_TEXTURE_MIN_FILTER, pyglet.gl.GL_NEAREST)
        pyglet.gl.glTexParameteri(pyglet.gl.GL_TEXTURE_2D, pyglet.gl.GL_TEXTURE_MAG_FILTER, pyglet.gl.GL_NEAREST)
        self.setupFog()
コード例 #54
0
"""
Module's main purpose is to store some values.
It is shared to all modules.

"""
from os.path import join
from pyglet import image
from pyglet import media
from pyglet import font

VERSION = "v0.1"
WIDTH = 800
HEIGHT = 600
num_second_windows = 0

icon1 = image.load(join("gfx", "icon1.png"))
icon2 = image.load(join("gfx", "icon2.png"))
background = image.load(join("gfx", "table2.png"))
img1 = image.load(join("gfx", "start_stop_button.png"))
img2 = image.load(join("gfx", "restart_button.png"))
img3 = image.load(join("gfx", "time_out_button.png"))
img4 = image.load(join("gfx", "arrow_button.png"))
img5 = image.load(join("gfx", "arrow_button2.png"))

ring_sound = media.load(join("sounds", "sound.wav"), streaming=False)
font.add_file(join("fonts", "open-sans", "OpenSans-Regular.ttf"))

# del join, image, media, font
コード例 #55
0
 def load_animation(imgage): #加載動畫窗格的規範
     seq = ImageGrid(load(imgage), 2, 1)
     return Animation.from_image_sequence(seq, 0.5)
コード例 #56
0
ファイル: test_image.py プロジェクト: tritruong9201/C4T16
 def save_and_load_depth_buffer(self):
     stream = BytesIO()
     image.get_buffer_manager().get_depth_buffer().save(
         'buffer.png', stream)
     stream.seek(0)
     self.right_texture = image.load('buffer.png', stream)
コード例 #57
0
 def __init__(self, *args, **kwargs):
     super().__init__(*args, **kwargs)
     # 窗口是否捕获鼠标
     self.exclusive = False
     # 玩家
     self.player = Player(self)
     # 拓展功能
     self.debug = {}
     self.debug['debug'] = False
     self.debug['enable'] = False
     self.debug['running'] = False
     # 天气(现在天气, 持续时间)
     self.weather = {'now': 'clear', 'duration': 0}
     # 游戏世界(秒)
     self.time = 0
     # rotation = (水平角 x, 俯仰角 y)
     self.player['rotation'] = (0, 0)
     # 玩家所处的区域
     self.sector = None
     # 这个十字在屏幕中央
     self.reticle = None
     # 显示在 debug 区域的 info
     self._info_ext = []
     self._info_ext.append('pyglet' + pyglet.version)
     # 玩家可以放置的方块, 使用数字键切换
     self.inventory = [
         'grass', 'dirt', 'log', 'brick', 'leaf', 'plank', 'craft_table',
         'glass'
     ]
     # 数字键列表
     self.num_keys = [
         key._1, key._2, key._3, key._4, key._5, key._6, key._7, key._8,
         key._9, key._0
     ]
     # 这个标签在画布的上方显示
     self.label = {}
     self.label['top'] = ColorLabel('',
                                    x=2,
                                    y=self.height - 5,
                                    width=self.width // 2,
                                    multiline=True,
                                    anchor_x='left',
                                    anchor_y='top',
                                    font_size=12,
                                    font_name='minecraftia')
     self.is_init = True
     # 设置图标
     self.set_icon(image.load(os.path.join(path['texture'], 'icon.png')))
     # 这个标签在画布正中偏上显示
     self.label['center'] = ColorLabel('',
                                       x=self.width // 2,
                                       y=self.height // 2 + 50,
                                       anchor_x='center',
                                       anchor_y='center',
                                       font_name='minecraftia')
     # 死亡信息
     self.die_info = ColorLabel('',
                                color='white',
                                x=self.width // 2,
                                y=self.height // 2,
                                anchor_x='center',
                                anchor_y='center',
                                font_size=24,
                                font_name='minecraftia')
     # 这个标签在画布正中偏下显示
     self.label['actionbar'] = ColorLabel('',
                                          x=self.width // 2,
                                          y=self.height // 2 - 100,
                                          anchor_x='center',
                                          anchor_y='center',
                                          font_name='minecraftia')
     # 加载窗口
     self.loading = Loading()
     # 覆盖屏幕的矩形
     self.full_screen = Rectangle(0, 0, self.width, self.height)
     # 聊天区
     self.dialogue = Dialogue()
     # 将 self.upgrade() 方法每 1.0 / TICKS_PER_SEC 调用一次, 它是游戏的主事件循环
     pyglet.clock.schedule_interval(self.update, 1.0 / TICKS_PER_SEC)
     # 检测玩家是否应该死亡
     pyglet.clock.schedule_interval(self.check_die, 1.0 / TICKS_PER_SEC)
     # 每10秒更新一次方块数据
     pyglet.clock.schedule_interval(self.update_status, 0.1)
     # 每30秒保存一次进度
     pyglet.clock.schedule_interval(self.save, 30.0)
     # 天空颜色变换
     pyglet.clock.schedule_interval(change_sky_color, 7.5)
     log_info('welcome %s' % player['name'])
     for lib in libs:
         if hasattr(lib, 'init'):
             lib.init()
コード例 #58
0
                and self.texture.id == other.texture.id
                and self.texture.target == other.texture.target
                and self.parent == other.parent)

    def __hash__(self):
        return hash((self.texture.id, self.texture.target))


scene_init()
ball = pyglet.graphics.Batch()
delta = [0, 0, 0]
position = [0, 0, 0]

mouse_orig_pos = [0, 0]
rx, ry = 0, 0

window.push_handlers(GameEventHandler())
pyglet.app.event_loop.clock.schedule(update)
text_image = image.load('paperbag.png')

for m in scene.meshes:  # 导入模型数据
    text_bind_group = TextureBindGroup(text_image.get_texture(),
                                       TextureEnableGroup())

    ball.add(m.vertices.shape[0], GL_TRIANGLES, text_bind_group,
             ('v3f/static', m.vertices.reshape(-1).tolist()),
             ('t3f/static', m.texturecoords.reshape(-1).tolist()))
    pass

pyglet.app.run()
コード例 #59
0
ファイル: textures.py プロジェクト: robin-weiland/pMC
 def loadSprites(path):
     collection = Collection()
     collection.exception = SpriteNotFound
     for name, file, in path.get().items():
         collection[file.name] = load(str(file.path))
     return collection
コード例 #60
0
ファイル: render.py プロジェクト: zhangjw-THU/RLSchool
    def __init__(self,
                 drone_3d_model,
                 horizon_view_size=8,
                 init_drone_z=5,
                 task='no_collision'):
        self.task = task

        # When increase this, show more blocks in current view window
        self.horizon_view_size = horizon_view_size

        # A Batch is a collection of vertex lists for batched rendering
        self.batch = Batch()

        # Manages an OpenGL texture
        self.group = TextureGroup(image.load(TEXTURE_PATH).get_texture())

        # A mapping from position to the texture for whole, global map
        self.whole_map = dict()

        # Same as `whole_map` but only contains the positions to show
        self.partial_map = dict()

        # A mapping from position to a pyglet `VertextList` in `partial_map`
        self._partial_map = dict()

        # A mapping from sector to a list of positions (contiguous sub-region)
        # using sectors for fast rendering
        self.sectors = dict()

        # Use deque to populate calling of `_show_block` and `_hide_block`
        self.queue = deque()

        # A graphics batch to draw drone 3D model
        self.drone_batch = pyglet.graphics.Batch()
        # Load drone triangular mesh and scene
        self.drone_name = os.path.basename(drone_3d_model)
        self.drone_mesh = trimesh.load(drone_3d_model)
        self.drone_scene = self.drone_mesh.scene()
        # Drawer stores drone scene geometry as vertex list in its model space
        self.drone_drawer = None
        # Store drone geometry hashes for easy retrival
        self.drone_vertex_list_hash = ''
        # Store drone geometry rendering mode, default gl.GL_TRIANGLES
        self.drone_vertex_list_mode = gl.GL_TRIANGLES
        # Store drone geometry texture
        self.drone_texture = None

        black = np.array([0, 0, 0, 255], dtype=np.uint8)
        red = np.array([255, 0, 0, 255], dtype=np.uint8)
        green = np.array([0, 255, 0, 255], dtype=np.uint8)
        blue = np.array([0, 0, 255, 255], dtype=np.uint8)
        for i, facet in enumerate(self.drone_mesh.facets):
            if i < 30:
                self.drone_mesh.visual.face_colors[facet] = black
            elif i < 42:
                self.drone_mesh.visual.face_colors[facet] = red
            elif i < 54:
                self.drone_mesh.visual.face_colors[facet] = green
            elif i < 66:
                self.drone_mesh.visual.face_colors[facet] = blue
            else:
                self.drone_mesh.visual.face_colors[facet] = black

        # Mark positions of bounding wall and obstacles in the map
        self._initialize(init_drone_z)