def LoadAtlas(self) -> None: """ Loads the atlas picture file(s) """ oAtlas: Atlas try: Logger.debug(u'TheScreen: Loading Skin Atlas') if not Globals.bIgnoreAtlas: if Globals.oFnAtlasSkin.Exists(): oAtlas = Atlas(Globals.oFnAtlasSkin.string) Cache.append('kv.atlas', Globals.oFnAtlasSkin.string, oAtlas) Logger.debug(u'TheScreen: Loading Definition Atlas') if Globals.oDefinitionPathes.oFnDefinitionAtlas.Exists(): oAtlas = Atlas( Globals.oDefinitionPathes.oFnDefinitionAtlas.string) Cache.append( 'kv.atlas', Globals.oDefinitionPathes.oFnDefinitionAtlas.string, oAtlas) except ParseError as e: ShowErrorPopUp(uTitle="Fatal Error", uMessage=LogError( uMsg=u'TheScreen: Fatal Error:Load Atlas', oException=e), bAbort=True) return None
def __init__(self, **kwargs): super(HexGrid, self).__init__(do_rotation=False, scale_min=.5, scale_max=3., auto_bring_to_front=False) self.gridsize = kwargs['gridsize'] self.gametype = kwargs['gametype'] self.gui = kwargs['gui'] # Preparem atlas d'imatges pels tiles self.baseatlas = Atlas('assets/basetiles.atlas') self.playeratlas = Atlas('assets/playertiles.atlas') self.uiatlas = Atlas('assets/uitiles.atlas') # Nomes gridsize inparell assert (self.gridsize % 2 != 0) # Preparem store self.store = DictStore('hexland.dict') self.grid = [] self.deads = {1: 0, 2: 0} self.resetScore() self.setup() # Si ens construeixen amb estat, el carreguem if kwargs['state']: self.loadState(kwargs['state'], True) self.reloadGridGraphics() # Si estem vs cpu, creem el jugador CPU if not self.gametype == GAMETYPE["PVP"]: self.cpu = CpuPlayer(self.gametype)
def on_filename(self, *args): if not self.filename: return resource = resource_find(self.filename) if not resource: raise ValueError("Couldn't find atlas: {}".format(self.filename)) self.atlas = Atlas(resource)
def CreateAtlas(oPicPath,oAtlasFile,uDebugMsg): ''' creates an atlas file from all picture files in a folder ''' if oORCA.bIgnoreAtlas: return #can\'t get JPEG lib included in package, so just ignore atlas #if oORCA.uPlatform=='macosx' or oORCA.uPlatform=="ios" or oORCA.uPlatform=="win": if oORCA.uPlatform=='macosx' or oORCA.uPlatform=="ios": return try: if not FileExists(oAtlasFile): Logger.debug(uDebugMsg) #aExtensions=[u'.png',u'.jpg',u'.bmp',u'.gif'] # we exclude gifs as they might be animated aExtensions=[u'.png',u'.jpg',u'.bmp'] aPicFiles=[] oDirList=GetFileList(oPicPath, bSubDirs=True,bFullPath=True) for uFileName in oDirList: uExtension = os.path.splitext(uFileName)[1].lower() if uExtension in aExtensions: if uFileName.find( AdjustPathToOs(oORCA.uSkinPath+u'/atlas/'))==-1: aPicFiles.append(uFileName) try: Atlas.create(oAtlasFile[:-6],aPicFiles,1024) except Exception: pass except Exception as e: LogError(u'Error creating Atlas File:',e)
def __init__(self, **kwargs): super().__init__(**kwargs) self.rec_shadow = Atlas(f"{images_path}rec_shadow.atlas") self.rec_st_shadow = Atlas(f"{images_path}rec_st_shadow.atlas") self.quad_shadow = Atlas(f"{images_path}quad_shadow.atlas") self.round_shadow = Atlas(f"{images_path}round_shadow.atlas") Clock.schedule_once(lambda x: self.on_theme_style(0, self.theme_style)) self._determine_device_orientation(None, Window.size) Window.bind(size=self._determine_device_orientation)
def __init__(self, **kwargs): super(RenderWidget, self).__init__(**kwargs) self.size = 608, 608 self.tile_size = 32 self.atlas = Atlas(ATLAS_FILE) self.atlas_trees = Atlas(ATLAS_TREE_FILE) self.char_atlas = Atlas(ATLAS_CHAR_FILE) self.map_width = 50 self.map_height = 50 # Load Particle Textures self.particle_tex = CoreImage('{}/assets/twirl_01.png'.format( os.getcwd())).texture # self.add_widget(self.kivy_particle) ind = -1 for name, tex in self.atlas.textures.items(): if '_' in name: tile_name, tile_number = name.split('_') else: tile_name, tile_number = name, '0' # tex.flip_vertical() if self.data.get(tile_name): self.data[tile_name].append(tex) else: ind += 1 self.data[tile_name] = [tex] self.data_size[tile_name] = tex.size if not self.tile_enum.get(ind): self.tile_enum[ind] = tile_name # Tree Textures ind = 1 for name, tex in self.atlas_trees.textures.items(): self.tree_data[name] = tex self.tree_enum[ind] = name ind += 1 # Entity Textures for name, tex in self.char_atlas.textures.items(): self.char_data[name] = tex with self.canvas.before: Callback(self._set_blend_func) with self.canvas.after: Callback(self._reset_blend_func) self.initialize_tiles() Window.bind(on_key_down=self._keydown) Window.bind(on_key_up=self._keyup) Clock.schedule_interval(self.check_for_keys, 60**-1) self.tile_clock = Clock.schedule_interval(self.update_tiles, 60**-1)
class Pallet(StackLayout): """Many :class:`SwatchButton`, gathered from an :class:`kivy.atlas.Atlas`.""" atlas = ObjectProperty() """:class:`kivy.atlas.Atlas` object I'll make :class:`SwatchButton` from.""" filename = StringProperty() """Path to an atlas; will construct :class:`kivy.atlas.Atlas` when set""" swatches = DictProperty({}) """:class:`SwatchButton` widgets here, keyed by name of their graphic""" swatch_width = NumericProperty(100) """Width of each and every :class:`SwatchButton` here""" swatch_height = NumericProperty(75) """Height of each and every :class:`SwatchButton` here""" swatch_size = ReferenceListProperty(swatch_width, swatch_height) """Size of each and every :class:`SwatchButton` here""" selection = ListProperty([]) """List of :class:`SwatchButton`s that are selected""" selection_mode = OptionProperty('single', options=['single', 'multiple']) """Whether to allow only a 'single' selected :class:`SwatchButton` (default), or 'multiple'""" def on_selection(self, *args): Logger.debug('Pallet: {} got selection {}'.format( self.filename, self.selection)) def on_filename(self, *args): if not self.filename: return resource = resource_find(self.filename) if not resource: raise ValueError("Couldn't find atlas: {}".format(self.filename)) self.atlas = Atlas(resource) def on_atlas(self, *args): if self.atlas is None: return self.upd_textures() self.atlas.bind(textures=self.upd_textures) def upd_textures(self, *args): """Create one :class:`SwatchButton` for each texture""" if self.canvas is None: Clock.schedule_once(self.upd_textures, 0) return for name in list(self.swatches.keys()): if name not in self.atlas.textures: self.remove_widget(self.swatches[name]) del self.swatches[name] for (name, tex) in self.atlas.textures.items(): if name in self.swatches and self.swatches[name] != tex: self.remove_widget(self.swatches[name]) if name not in self.swatches or self.swatches[name] != tex: self.swatches[name] = SwatchButton(name=name, tex=tex, size_hint=(None, None), size=self.swatch_size) self.add_widget(self.swatches[name])
def __init__(self,atlas,name,frames,**kwargs): self.atlas = atlas self.atlas_str = str('atlas://' + atlas + '/') self.name = name self.frames = frames self.update_now = False try: self.icon = Atlas(atlas)[name] self.icon_str = str(self.atlas_str + name) except KeyError: self.icon = Atlas(atlas)[name + "-1"] self.icon_str = str(self.atlas_str + name + '-1') super(WorldObject,self).__init__(**kwargs)
def create(folder): cwd = getcwd() images = [] for root, dirname, filenames in walk(folder): for filename in filenames: image = join(root, filename)[len(folder) + 1:] print image images.append(image) chdir(folder) outfn = None size = DEFAULT_SIZE while not outfn: try: fname = join('..', basename(folder)) outfn=Atlas.create(fname, images, size, use_path=True) except: pass if not outfn or ((size<1024) and (len(outfn)>1 and len(outfn[1])>2)): numfiles = len(outfn[1]) if outfn else 0 for i in range (0, numfiles): outf = '%s-%d.png' % (fname, i) try: remove(outf) except: pass outfn = None size *= 2 chdir(cwd)
def build(self): label = Label(text="Testing going on.") atlas = Atlas("player_sheet.atlas") image1 = Image(allow_stretch=True) image1.texture = atlas["walkleft4"] label.add_widget(image1) return label
def __init__(self, source, scale, pos, angle): super().__init__(pos=pos) self.scale = scale self.images = Atlas('images/hat.atlas') ## Atlas initialization self.keys = list( self.images.textures.keys()) ## atlas keys into a list print('keys in Hat', self.keys) self.kys = ('hat_burnt0', 'hat_burnt1', 'hat_burnt2', 'hat_burnt3', 'hat_burnt4', 'hat_burnt-final') print('hat keys list', self.kys) self.image = Sprite(texture=self.images['hat'], scale=self.scale, pos=pos) #self.image = Sprite(source=source, scale=self.scale, pos=pos) self.size = self.image.size self.add_widget(self.image) self.inhand = False self.onhead = False self.onhead_timer = 0 self.moving = False #burning status self.burning = False self.burnt = False self.burn_counter = 0 self.sprite = 0 self.animation_value = int(200 / (len(self.kys) - 1)) print('animation value', self.animation_value) self.vy = 0 self.combust = SoundLoader.load('audio/combust-both.wav')
def __init__(self): super(Player, self).__init__() self.new_frame = True self.direction = "idle" self.stopping = False self.anim_timer = 0 self.atlas = Atlas("images/player_sheet.atlas") self.image = Image(allow_stretch=True, source='atlas://images/player_sheet/idle1') self.image.size = (64, 64) self.size = (32, 64) self.speech = SpeechBubble() self.speech.size = (0, 50) self.add_widget(self.speech) self.add_widget(self.image) self.target = [0, 0] self.speed = 3 self.anim = 0 self.world = (0, 0) self.moves = { "up": False, "down": False, "left": False, "right": False } self.dirs = { "up": (0, self.speed), "down": (0, -self.speed), "left": (-self.speed, 0), "right": (self.speed, 0) }
def __init__(self, *args, **kwargs): super(MiniMapBox, self).__init__(**kwargs) self.spritesheet = Atlas('spritesheet.atlas') # print(self.spritesheet.textures.keys()) self.decal_x = -88 self.decal_y = -76 self.reveal_map((0, 0))
def __init__(self, source, scale, **kwargs): super().__init__() self.images = Atlas('images/background.atlas') #self.keys = self.images.keys() #list( self.images.textures.keys( ) ) self.keys = ('top', 'back', 'mid') print('bg keys', self.keys) self.scale = scale self.size = (self.scale * 1600, self.scale * 640) #self.image.size x0 = -self.width / 2 print('x0 in Background is', x0) print('initial x position', x0) self.image_bot = Sprite(texture=self.images['back'], scale=self.scale, x=x0) self.add_widget(self.image_bot) #self.image = Sprite( source=source, scale=self.scale) #source2 = 'images/backgroundMAC.png' self.image_mid = Sprite(texture=self.images['mid'], scale=self.scale, x=x0) self.add_widget(self.image_mid) self.image_top = Sprite(texture=self.images['top'], scale=self.scale, x=x0) self.add_widget(self.image_top)
def __init__(self,atlas,material_name,position,frames,subtile_id=None): self.atlas = atlas self.material_name = material_name self.position = [[True,True],[True,True]] if position is None else position self.frames = frames self.subtile_id = subtile_id # Caution: this parses the atlas URL and may or may not be compatible with windows. I do not know. This code ought to be refactored to be the same as WorldObject anyway atlas_stripped = atlas[8:].rpartition('/')[0]+'.atlas' try: self.icon = Atlas(atlas_stripped)['Tile-' + material_name] self.icon_str = str(atlas + 'Tile-' + material_name) except KeyError: self.icon = Atlas(atlas_stripped)['Tile-' + material_name + "-1"] self.icon_str = str(atlas + 'Tile-' + material_name + '-1')
class Notificator(Factory.BoxLayout, Factory.StencilView): default_font_size = NumericProperty(16) color = ListProperty((1, 1, 1, 1, )) icon_texture_dict = DictProperty() def __init__(self, **kwargs): super().__init__(**kwargs) self.icon_texture_dict = Atlas(ATLAS_PATH).textures def add_notification( self, *, text, font_size=None, icon_key='', duration='4'): item = NotificatorItem( text=text, icon_texture=self.icon_texture_dict.get(icon_key), font_size=( self.default_font_size if font_size is None else font_size), color=self.color, x=self.x, top=self.y, width=self.width,) magnet = Magnet( transitions={'pos': 'linear', }, duration=0.5, size_hint_y=None) item.bind(height=magnet.setter('height')) magnet.add_widget(item) self.add_widget(magnet) Clock.schedule_once( lambda __: fadeout_widget(magnet, duration=2), duration)
def __init__(self, **kwargs): self.uiatlas = Atlas('assets/uitiles.atlas') self.store = DictStore('hexland.dict') super(Menu, self).__init__(**kwargs) self.logo_img.size_hint = 0.1, 0.1 Animation(size_hint=(0.8, 0.3), t='out_bounce').start(self.logo_img)
def __init__(self, pos, size, block_type): self.pos = pos self.size = size self.block_type = block_type self.atlas = Atlas(os.path.join(ROOT_FOLDER, 'textures', 'special_blocks.atlas')) self.texture = self.atlas[self.block_type] super(HitBlock, self).__init__(self.pos, self.size, self.texture)
def set_textures(self, atlas, board): self.atlas = atlas + '.atlas' self.board = board dir = path.dirname(sys.argv[0]) if not path.isabs(self.atlas): self.atlas = path.join(dir, self.atlas) if not path.isabs(self.board): self.board = path.join(dir, self.board) self.atlas = Atlas(self.atlas)
def layout(self): self.charge = False self.amount = '' self.ready = False def on_text_charge(instance, value): self.amount = value if len(value) >= 1: self.ready = True else: self.ready = False setButtonColor() layout = BoxLayout(orientation='vertical', padding=(2 * dp(48), 2 * dp(48))) #Charge Box chargeField = MDTextField() chargeField.hint_text = "Enter Amount to Charge" chargeField.input_filter = "int" chargeField.bind(text=on_text_charge) layout.add_widget(chargeField) proceedButton = MDRaisedButton(text='Proceed', size_hint=(None, None), size=(4 * dp(48), dp(48))) proceedButton.md_bg_color = [0.9, 0, 0, 0.9] app = App.get_running_app() def setButtonColor(): if self.ready: proceedButton.md_bg_color = app.theme_cls.primary_color proceedButton.bind(on_press=lambda x: self.createCharge()) proceedAnchor = AnchorLayout(anchor_x='center', anchor_y='bottom', padding=[60]) proceedAnchor.add_widget(proceedButton) layout.add_widget(proceedAnchor) content = Builder.load_string(spinner) self.stripepopup = Popup(title='Charging Card', title_align='center', size_hint=(None, None), size=(dp(200), dp(200))) self.stripepopup.add_widget(content) self.stripepopup.title_font = 'data/fonts/Roboto-Bold.ttf' self.stripepopup.title_color = App.get_running_app( ).theme_cls.primary_color self.stripepopup.separator_color = App.get_running_app( ).theme_cls.primary_color self.stripepopup.background = str( Atlas('{}round_shadow.atlas'.format(images_path))) return layout
def bulk_load(self, path_glob): """ Bulk load YAML files into storage :param path_glob: array of paths """ for file in path_glob: for doc in yaml.load_all(open(file, mode='r')): if 'imagedb' not in doc: logging.warning('%s does not contains images' % file) else: # locale and priority of current document locale = doc['imagedb'].get('locale', self._def_locale) priority = doc['imagedb'].get('priority', 0) # iterate over each string for k, v in doc['imagedb'].get('images', {}).items(): v = path.join(path.dirname(file), v) # if key of this string exists in db if k in self._db: # if locale exists, select image with greater prio if locale in self._db[k]: if self._db[k][locale]['priority'] < priority: self._db[k][locale] = dict( priority=priority, file=v) else: self._db[k] = {locale: dict(priority=priority, file=v)} # apply atlases found in yaml for k, v in doc['imagedb'].get('atlases', {}).items(): atl = Atlas(path.join(path.dirname(file), v)) for k, v in atl.textures.items(): atl_path = 'atlas://%s/%s' % ( str(atl.filename).split('.atlas')[0].strip('./'), k) # if key of this string exists in db if k in self._db: # if locale exists, select image with greater prio if self._db[k][locale]['priority'] < priority: self._db[k][locale] = dict( priority=priority, file=atl_path) else: self._db[k] = {locale: dict(priority=priority, file=atl_path)} return self
def get_atlas(atlas_path): """ Get atlas from the Kivy cache if present, otherwise initialize it """ from kivy.atlas import Atlas from kivy.cache import Cache atlas = Cache.get('kv.atlas', atlas_path.replace('atlas://', '')) if not atlas: logger.info(f'Initializing atlas "{atlas_path}"') atlas = Atlas(f'{atlas_path}.atlas') Cache.append('kv.atlas', atlas_path, atlas) return atlas
def __init__(self, *args, **kwargs): super(MiniMapBox, self).__init__(**kwargs) self.spritesheet = Atlas('spritesheet.atlas') # print(self.spritesheet.textures.keys()) self.decal_x = -88 self.decal_y = -76 for i in range(0, 8): for j in range(0, 7): self.reveal_map( ('(' + str(i) + ',' + str(j) + ')'), ((i * 25) + self.decal_x, (j * 25) + self.decal_y))
def main(argv=None): try: cwd = getcwd() for path in glob('*.atlas'): a = Atlas(path) print 'Atlas %s:' % basename(path) for key in a.textures.keys(): print '\t', key except Exception, e: print e
def __init__(self, pos, size, type): self.pos = pos self.size = size self.type = type super(Item, self).__init__() self.atlas = Atlas(os.path.join(ROOT_FOLDER, 'textures', 'items.atlas')) self.texture = self.atlas[self.type] with self.canvas: self.platform = Rectangle(pos=self.pos, size=self.size, texture=self.texture)
def __init__(self, *, atlasfilepath, **kwargs): super().__init__(**kwargs) self.clock_event = None atlas = Atlas(atlasfilepath) x, y, = self.pos width, height, = self.size for texture in atlas.textures.values(): sprite = MostxTitleSprite(texture=texture) sprite.x = x + random() * width sprite.y = y + random() * height sprite.velocity_x_base = sprite.velocity_x = random() * 5 sprite.velocity_y_base = sprite.velocity_y = random() * 5 sprite.velocity_rotation = random() * 5 self.add_widget(sprite)
def spawn_entity(self, coord, euid, skin, size=(1, 1)): size = (size[0] * self.scale, size[1] * self.scale) entity = Entity( source='{}/{}'.format(ENTITY_PATH, skin), pos=self.coord_to_pos(coord), size=size, coord=coord, ) # ToDo: somehow it doesn't set the texture, so it is set manually # figure out why that is, fix it and delete the next two lines atlas = Atlas('content/entities/entities.atlas') entity.texture = atlas[skin] self.entities[euid] = entity self.add_widget(entity)
def CreateAtlas(oPicPath, oAtlasFile, uDebugMsg): """ creates an atlas file from all picture files in a folder :param cPath oPicPath: The Path to a Picture Folder :param cFileName oAtlasFile: The Atlas Files to Create :param string uDebugMsg: A Debug Message for the function :return: """ if Globals.bIgnoreAtlas: return #can\'t get JPEG lib included in package, so just ignore atlas if Globals.uPlatform == 'macosx' or Globals.uPlatform == "ios": return try: if not oAtlasFile.Exists(): Logger.debug(uDebugMsg) #aExtensions=[u'.png',u'.jpg',u'.bmp',u'.gif'] # we exclude gifs as they might be animated aExtensions = [u'.png', u'.jpg', u'.bmp'] aPicFiles = [] aFileList = oPicPath.GetFileList(bSubDirs=False, bFullPath=True) for uFileName in aFileList: uExtension = os.path.splitext(uFileName)[1].lower() if uExtension in aExtensions: if uFileName.find(Globals.oPathSkin.string + u'/atlas/') == -1: aPicFiles.append(uFileName) try: Atlas.create(oAtlasFile[:-6], aPicFiles, 1024) except Exception: pass except Exception as e: LogError(u'Error creating Atlas File:', e)
def build_atlas(image_paths, src_x, src_y, atlas_name, padding=2, **limit_kwarg): """Build a Kivy Kivy :py:class:`~kivy.atlas.Atlas` Args: image_paths (list): Paths to images and/or image directories src_x: Max width of source images src_y: Max height of source images atlas_name: Name of atlas file to create \\*\\*limit_kwarg: At most one limit to provide to :py:func:`.get_atlas_dimensions` """ from kivy.atlas import Atlas # Allow smallest dimension to be as low as half the max. This this works because each thumbnail # size category is over twice the size of the next smallest one min_x = ceil(src_x / 2) min_y = ceil(src_y / 2) logger.info(f'Atlas: Searching for images of dimensions ({min_x}-{src_x}) x ({min_y}-{src_y})...') image_paths = list(filter_images_by_size(image_paths, src_x, src_y, min_x, min_y)) logger.info(f'Atlas: {len(image_paths)} images found') atlas_size = get_atlas_dimensions(len(image_paths), src_x, src_y, padding=padding, **limit_kwarg) logger.info(f'Atlas: Calculated atlas size: {atlas_size}') if atlas_size != (0, 0): Atlas.create(atlas_name, image_paths, atlas_size, padding=padding)
def __init__(self, pos, size): self.x = pos[0] self.y = pos[1] self.pos = pos self.size = size super(Hero, self).__init__() self.atlas = Atlas(os.path.join(ROOT_FOLDER, 'textures', 'trump.atlas')) self.texture = self.atlas['stand'] with self.canvas: self.rect = Rectangle(pos=self.pos, size=self.size, texture=self.texture) self.run_frames = ['run1', 'run2', 'run3', 'run4', 'run5', 'run6', 'run7', 'run8'] self.run_frame_cycle = cycle(self.run_frames)
def __init__(self, **kwargs): super(ParticleEmitter, self).__init__(**kwargs) # create list of textures basename = 'VFX_SmokeParticle' atlas = Atlas('VFX/smoke_particles.atlas') all_keys = atlas.textures.keys() wanted_keys = filter(lambda x: x.startswith(basename), all_keys) if len(wanted_keys) > 1: pattern = re.compile(r'[0-9]+$') print wanted_keys wanted_keys.sort(key=lambda x: int(pattern.search(x).group())) self.texture_list = [atlas[key] for key in wanted_keys] Clock.schedule_interval(self.emit_particle, 0.1)
#print join(i, "include") print " [ ] Copying included images...", if exists(join(i, "include")): for img in (join(i, "include", f) for f in os.listdir(join(i, "include"))): #print img shutil.copy(img, tmp) print "\r [x] Images copied. " # All done, pack everything into an atlas print " [ ] Generating the atlas...", fnames = [] tot_size = 0 for i in (join(tmp, f) for f in os.listdir(tmp)): if i.lower().endswith(".png"): fnames.append(i) tot_size += os.stat(i).st_size data = Atlas.create(atlasname, fnames, get_atlas_best_size(fnames)) if not data: print "\r [!] Atlas not generated." continue else: fn, meta = data atl_size = 0 for i in meta.keys(): atl_size += os.stat(i).st_size print "\r [x] Atlas \"{0}\" generated ({1} image{2}, {3} saved).".format(fn, len(meta), 's' if len(meta) > 1 else '', hr_size(tot_size - atl_size)) shutil.rmtree(tmp) print "All done."
def make_atlas(folder): fold = Path(folder) subdirs = fold.dirs() for dirc in subdirs: Atlas.create("images/{}".format(dirc.basename()), dirc.files("*.png"), [160,256])