示例#1
0
 def load_texture(key, path, region=None, mipmap=False, wrap=None):
     texture_path = join(RESOURCES_DIR, path)
     texture = Image(texture_path, mipmap=mipmap).texture
     if region:
         texture = texture.get_region(*region)
 
     textures[key] = texture
示例#2
0
文件: main.py 项目: Jvatinsa/spylight
 def getTexture(self,name, size):
     filename = join('art', name+'.png')
     texture = Image(filename).texture
     texture.wrap = 'repeat'
     texture.uvsize = size
     self.logger.info(filename)
     return texture
示例#3
0
 def __init__(self, *args, **kw):
     super(RootWidget, self).__init__(*args, **kw)
     texture = Image('wood.png').texture
     texture.wrap = 'repeat'
     texture.uvsize = (8, 8)
     with self.canvas:
         Rectangle(size=(2048, 2048), texture=texture)
示例#4
0
    class Image(object):
        EMPTY_IMAGE = Kivy_Image(Texture.create(size=(0, 0)))

        width = 0
        height = 0
        filename = None
        is_sequence_image = False

        def __init__(self, image = None, sequence = False, width = None, height = None, mipmap = True):
            if image is None:
                self.image = self.EMPTY_IMAGE
                self.width = 0
                self.height = 0
                return
            if isinstance(image, str):
                self.filename = image
                try:
                    self.image = Kivy_Image(image, mipmap = mipmap)
                except:
                    raise MyrmidonError("Couldn't load image from " + image)
            else:
                self.image = Kivy_Image(image)
            self.width = self.image.width
            self.height = self.image.height

        def destroy(self):
            """
            Explicitly removes this image from the video memory and
            Kivy's cache.
            This functionality requires the custom kivy version at
            http://github.com/arcticshores/kivy
            """
            if self.image is None or self.image is self.EMPTY_IMAGE:
                return

            from kivy.cache import Cache
            from kivy.graphics.opengl import glBindTexture, glDeleteTextures
            from kivy.logger import Logger

            Logger.debug("MyrmidonGFX: Destroying {0}".format(self.filename if self.filename else self.image))

            # Remove from cache
            self.image.remove_from_cache()

            # Convert the ID to the right byte format for the GL method
            a1 = (self.image.texture.id >>  0) & 0xFF
            a2 = (self.image.texture.id >>  8) & 0xFF
            a3 = (self.image.texture.id >> 16) & 0xFF
            a4 = (self.image.texture.id >> 24) & 0xFF

            # Remove texture completely
            glBindTexture(self.image.texture.target, 0)
            glDeleteTextures(1, bytes(bytearray([a1, a2, a3, a4])))

            # Since we've done a manual removal kivy shouldn't do it's own removal later
            self.image.texture.nofree = 1

            # Stop this image from being used as a texture now
            self.image = None
示例#5
0
	def __init__(self, *args, **kwargs) :
		super(ScreenNexus, self).__init__(*args, **kwargs)
		texture = Image(os.path.join("res", "tile.png")).texture # Create background texture
		texture.wrap = "repeat"
		texture.uvsize = (12, 24)
		
		with self.canvas.before : # Draw background
			Color(1, 1, 1)
			Rectangle(texture = texture, size = (Window.width, Window.height), pos = self.pos)
示例#6
0
 def set_texture(self,path):
     #from kivy.core.image import Image
     tex = Image(path).texture
     tex.wrap = 'repeat'
     self.texture_sidebar = tex
     #tex = Image('style/1.png').texture
     if tex is not None:
         tex.wrap = 'repeat'
         self.texture = tex
示例#7
0
文件: walls.py 项目: foreverai/Walls
    def __init__(self, **kw):
        super(HelicopterGame, self).__init__(**kw)

        with self.canvas.before:
            texture = CoreImage('Images/background.png').texture
            texture.wrap = 'repeat'
            self.scroll_back = Rectangle(texture=texture, size=self.size, pos=self.pos)

            self.line=BezierLine()
            Clock.schedule_interval(self.update, 0)
示例#8
0
def grass_background(widget):
    bg_texture = Image('resources/grass/grass-texture.png', nocache=True).texture
    # get POT texture
    #bg_texture = bg_texture.get_region(0, 0, 64, 64)
    #bg_texture.uvpos = (0, 0)
    bg_texture.uvsize = (35, 35)
    bg_texture.wrap = 'repeat'
    # fill all the background
    with widget.canvas.before:
        Rectangle(pos=(0, 0), size=(2560, 2560), texture=bg_texture)
示例#9
0
	def build(self):

		Window.bind(on_draw=self.ondraw) 
		self.ui = MainUI()
		glb.root = self.ui
		glb.app = self
		self.texture_ruddertrim_wheel =  CoreImage.load('img/ruddertrimwheel.png').texture
		self.texture_ruddertrim_wheel.wrap = 'repeat'
		self.texture_elevatortrim_wheel = CoreImage.load('img/elevatortrimwheel.png').texture
		self.texture_elevatortrim_wheel.wrap = 'repeat'
		return self.ui #show it
示例#10
0
    def capture(self, event):
        if (self.camera.play):
            self.camera.play = False
            img = Image(self.camera.texture)
            img.save("capture.png")
            self.captureButton.text="Take another"
            self.classifyButton.disabled=False

        else:
            self.camera.play = True
            self.captureButton.text="Capture"
            self.classifyButton.disabled = True
    def print_png(self, filename, *args, **kwargs):
        '''Call the widget function to make a png of the widget.
        '''
        fig = FigureCanvasAgg(self.figure)
        FigureCanvasAgg.draw(fig)

        l, b, w, h = self.figure.bbox.bounds
        texture = Texture.create(size=(w, h))
        texture.blit_buffer(bytes(fig.get_renderer().buffer_rgba()),
                                colorfmt='rgba', bufferfmt='ubyte')
        texture.flip_vertical()
        img = Image(texture)
        img.save(filename)
 def _print_image(self, filename, *args, **kwargs):
     """Write out format png. The image is saved with the filename given.
     """
     l, b, w, h = self.figure.bbox.bounds
     img = None
     if self.img_texture is None:
         texture = Texture.create(size=(w, h))
         texture.blit_buffer(bytes(self.get_renderer().buffer_rgba()), colorfmt="rgba", bufferfmt="ubyte")
         texture.flip_vertical()
         img = Image(texture)
     else:
         img = Image(self.img_texture)
     img.save(filename)
示例#13
0
    def loadTileImages(self, ts):
        """
        Loads the images in filename into Kivy Images.
        This is a port of the code here: https://github.com/bitcraft/PyTMX/blob/master/pytmx/tmxloader.py

        :type ts: pytmx.TiledTileset
        """
        tile_image_path = self.map_dir + '/' + ts.source
        Logger.debug('KivyTiledMap: loading tile image at {}'.format(tile_image_path))
        texture = CoreImage(tile_image_path).texture

        ts.width, ts.height = texture.size
        tilewidth = ts.tilewidth + ts.spacing
        tileheight = ts.tileheight + ts.spacing
        Logger.debug('KivyTiledMap: TiledTileSet: {}x{} with {}x{} tiles'.format(ts.width, ts.height, tilewidth, tileheight))

        # some tileset images may be slightly larger than the tile area
        # ie: may include a banner, copyright, ect.  this compensates for that
        width = int((((ts.width - ts.margin * 2 + ts.spacing) / tilewidth) * tilewidth) - ts.spacing)
        height = int((((ts.height - ts.margin * 2 + ts.spacing) / tileheight) * tileheight) - ts.spacing)
        Logger.debug('KivyTiledMap: TiledTileSet: true size: {}x{}'.format(width, height))

        # initialize the image array
        Logger.debug('KivyTiledMap: initializing image array')
        self.images = [0] * self.maxgid

        p = itertools.product(
            xrange(ts.margin, height + ts.margin, tileheight),
            xrange(ts.margin, width + ts.margin, tilewidth)
        )

        # trim off any pixels on the right side that isn't a tile
        # this happens if extra graphics are included on the left, but they are not actually part of the tileset
        width -= (ts.width - ts.margin) % tilewidth

        for real_gid, (y, x) in enumerate(p, ts.firstgid):
            if x + ts.tilewidth - ts.spacing > width:
                continue

            gids = self.map_gid(real_gid)

            if gids:
                # invert y for OpenGL coordinates
                y = ts.height - y - ts.tileheight

                tile = texture.get_region(x, y, ts.tilewidth, ts.tileheight)

                for gid, flags in gids:
                    self.images[gid] = tile
示例#14
0
文件: app.py 项目: chip2n/sprite
    def __init__(self, **kwargs):
        super(CanvasWidget, self).__init__(**kwargs)
        self.size = (512, 512)
        self._keyboard = Window.request_keyboard(self._keyboard_closed, self)
        self._keyboard.bind(on_key_down=self._on_keyboard_down)


        self.img = Image.open('test.png')
        self.img = self.img =  self.img.transpose(Image.FLIP_TOP_BOTTOM)
        self.texture = Texture.create(size=(512,512))
        self.texture.mag_filter = 'nearest'
        size = 512*512*3
        buf = []
        for r,g,b,a in self.img.getdata():
            buf.extend([r,g,b,a])
        #buf = [int(x*255/size) for x in range(size)]
        #buf = self._flatten_list(self.pixels)
        self.arr = array('B', buf)
        self.texture.blit_buffer(self.arr, colorfmt='rgba', bufferfmt='ubyte')

        with self.canvas:
            self.test = InstructionGroup()
            #self.test.add(Color(1, 1, 0, mode='rgb'))
            self.test.add(Rectangle(texture=self.texture, pos=self.pos, size=self.size, group='heh'))

        #self.bind(texture=self.on_texture_update)
        self.bind(pos=self.on_texture_update)
        self.bind(size=self.on_texture_update)
示例#15
0
文件: main.py 项目: jalnanco/MerryMe
    def init_game(self):
        is_start = False

        # bring stage
        self.bring_stage()

        self.character.velocity = [self.block_size / self.speed_ratio, 0]

        # map init
        with self.background_widget.canvas:
            texture = CoreImage('data/blue_land.png').texture
            texture.wrap = 'repeat'
            self.rect_1 = Rectangle(
                texture=texture, size=self.size, pos=self.pos)
        self.character_pos_init()
        self.init_stage()
示例#16
0
 def __init__(self, image = None, sequence = False, width = None, height = None, mipmap = True):
     if image is None:
         self.image = self.EMPTY_IMAGE
         self.width = 0
         self.height = 0
         return
     if isinstance(image, str):
         self.filename = image
         try:
             self.image = Kivy_Image(image, mipmap = mipmap)
         except:
             raise MyrmidonError("Couldn't load image from " + image)
     else:
         self.image = Kivy_Image(image)
     self.width = self.image.width
     self.height = self.image.height
示例#17
0
	def populate_palette(self):
		if self.tileset != None:
			# Set image
			self.tilesetImage = Image(self.tileset).texture
			# Set background image:
			backgroundImagePath = join(globals.subDirectory['graphics'], "emptytile.png")
			backgroundImage = Image(backgroundImagePath).texture
			# Find the resolution of this image:
			yDiv = (self.res[1] / self.res[0]) / 4
			self.imageRes = [self.tilesetImage.width / 4 , self.tilesetImage.width * yDiv]
			# Set new dimensions
			self.width = self.res[0] * 4 + self.offset * 2
			self.height = self.res[1] * (self.tilesetImage.height / (self.tilesetImage.width * yDiv)) + self.offset * 2
			# Draw the background:
			with self.canvas.before:
				Color(1, 1, 1, 0.5)
				Rectangle(size = self.size, pos = (self.offset, self.offset))
			for x in range(4):
				for y in range(int(self.tilesetImage.height / (self.tilesetImage.width * yDiv))):
					with self.canvas.before:
						Color(1, 1, 1, 0.1)
						Rectangle(texture = backgroundImage, 
									size = self.res, 
									pos = (x * self.res[0] + self.offset, y * self.res[1] + self.offset ))
			# Draw the tileset in the palette
			for x in range(4):
				for y in range(int(self.tilesetImage.height / (self.tilesetImage.width * yDiv))):
					with self.canvas:
						Color(1, 1, 1, 1)
						Rectangle(texture = self.tilesetImage.get_region(x * self.imageRes[0], y * self.imageRes[1], self.imageRes[0], self.imageRes[1]), 
									size = self.res, 
									pos = (x * self.res[0] + self.offset, y * self.res[1] + self.offset ))		
示例#18
0
文件: imagebutton.py 项目: fresk/shs
 def on_source(self, *args):
     v = self.source.split(".")
     source_down = ''.join(v[:-1])+"_down"+v[-1]
     self._fname_normal = resource_find(self.source)
     self._fname_down = resource_find(source_down) or self._fname_normal
     self.image_size = CoreImage.load(self._fname_normal).size
     self.background_normal = self._fname_normal
     self.background_down = self._fname_down
示例#19
0
	def populate_lists(self):	
		for s in range(self.currentStory + 1):
			for l in range(len(self.renderList[s])):
				for i in range(self.iCount):
					for j in range(self.jCount):		
						tile = self.mapFile.stories[self.currentStory].matrix[i][j]
						type = tile.get_graphics_type(l)
						if type[0] != None:
							graphicsInfo = tile.graphics[l]
							image = Image(graphicsInfo[0]).texture
							x = (i - j) * self.tileWidth / 2 + self.offset[0] + self.jCount * self.tileWidth / 2 
							y = (i + j) * self.tileHeight / 2 + self.offset[1]
							if (type[0] == 'object' or type[0] == 'wall') and type[1] == False:
								# Object means a rectangle, not animated means it goes into renderList
								self.renderList[s][l][i][j] = Rectangle(texture = image.get_region(graphicsInfo[1][0][0][0], graphicsInfo[1][0][0][1], graphicsInfo[2][0], graphicsInfo[2][1]), 
																		size = (self.tileWidth, self.tileWidth * graphicsInfo[2][1] / graphicsInfo[2][0]), 
																		pos = (x - self.tileWidth / 2, y) )
示例#20
0
	def render_tile(self, i, j, layer, story):
		tile = self.mapFile.stories[self.currentStory].matrix[i][j]
		type = 	self.mapFile.stories[story].matrix[i][j].get_graphics_type(layer)
		if type[0] != None:
			graphicsInfo = tile.graphics[layer]
			image = Image(graphicsInfo[0]).texture
			x = (i - j) * self.tileWidth / 2 +  self.offset[0] + self.jCount * self.tileWidth/2 
			y = (i + j) * self.tileHeight / 2 + self.offset[1] 
			self.renderList[story][layer][i][j].texture =  image.get_region(graphicsInfo[1][0][0][0], graphicsInfo[1][0][0][1], graphicsInfo[2][0], graphicsInfo[2][1])
			print("Type is:", type[0])
			if type[0] == 'object'  and type[1] == False:
				# Object means a rectangle, not animated means it goes into renderList
				self.renderList[story][layer][i][j].size = (self.tileWidth, self.tileWidth * graphicsInfo[2][1] / graphicsInfo[2][0])
				self.renderList[story][layer][i][j].pos =  (x - self.tileWidth/2, y)
				self.canvas.before.add(Color(1, 1, 1, 1))
				for l in range(len(self.renderList[story])):
					if self.renderList[story][l][i][j] != [None]:
						self.canvas.before.add(self.renderList[story][l][i][j])
示例#21
0
文件: view.py 项目: nashr/The-Rooms
class Lamp(Widget):
    # Base variables
    TEXTURE = ObjectProperty(None)

    WIDTH = NumericProperty(1.0)
    HEIGHT = NumericProperty(1.0)

    X_UNIT = NumericProperty(1.0)
    Y_UNIT = NumericProperty(1.0)

    X = NumericProperty(1.0)
    Y = NumericProperty(1.0)

    # Run variables
    state = NumericProperty(1)

    xUnit = NumericProperty(1.0)
    yUnit = NumericProperty(1.0)

    curr_texture = ObjectProperty(None)

    x = NumericProperty(1.0)
    y = NumericProperty(1.0)

    def set_base(self, texture_dir, x, y):
        self.TEXTURE = Image(texture_dir).texture

        self.WIDTH = self.TEXTURE.width
        self.HEIGHT = self.TEXTURE.height

        self.X_UNIT = self.WIDTH / 3
        self.Y_UNIT = self.HEIGHT / 1

        self.X = x
        self.Y = y

    def reset(self):
        state = 1

    def is_pressed(self, x, y):
        if x > self.x and y > self.y:
            if x < self.x + self.xUnit and y < self.y + self.yUnit:
                return True
        return False

    def change_state(self):
        self.state += 1
        self.state %= 3

    def update(self, xScale, yScale):
        self.xUnit = self.X_UNIT * xScale
        self.yUnit = self.Y_UNIT * yScale

        self.x = self.X * xScale
        self.y = self.Y * yScale

        self.curr_texture = self.TEXTURE.get_region(self.state * self.X_UNIT, 0, self.X_UNIT, self.Y_UNIT)
示例#22
0
def start(win, ctx):
    # XXX use ctx !
    global pointer_image, pointer_scale, pointer_alpha
    pointer_fn = ctx.config.get('image',
            join(kivy_data_dir, 'images', 'ring.png'))
    pointer_scale = float(ctx.config.get('scale', 1.0))
    pointer_alpha = float(ctx.config.get('alpha', 1.0))
    pointer_image = Image(pointer_fn)
    win.bind(on_touch_down=_touch_down,
             on_touch_move=_touch_move,
             on_touch_up=_touch_up)
    def build(self):
        #wid = SpriteManager()

        root = BoxLayout(orientation='vertical')
        root.add_widget(self.wid)

        #Clock.schedule_interval(partial(self.add_rects, 1), 1)
        #self.add_rects(1)

        #self.addMovingRaindrop() #seems like a needed initialization step for future sprites to be added
        #Clock.schedule_interval(partial(self.addMovingRaindrop), 1.0/0.1)
        for img in os.listdir("./img"):
            if "atlas" in img:
                temp = img.split(".")
                Image(arg='atlas://img/' + temp[0] + '/frame0')
            elif "png" in img:
                Image(arg='img/' + img)
        Clock.schedule_interval(partial(self.wid.update), 1.0 / 60.0)

        return root
示例#24
0
文件: view.py 项目: nashr/The-Rooms
    def set_base(self, texture_dir, x, y):
        self.TEXTURE = Image(texture_dir).texture

        self.WIDTH = self.TEXTURE.width
        self.HEIGHT = self.TEXTURE.height

        self.X_UNIT = self.WIDTH / 1
        self.Y_UNIT = self.HEIGHT / 1

        self.X = x
        self.Y = y
示例#25
0
 def do_layout(self, *args):
     self.add_widget(Image('Transparent.png'))
     number_of_children = len(self.children)
     width = self.width
     width_per_child = width / number_of_children
     positions = range(0, width, width_per_child)
     for position, child in zip(positions, self.children):
         child.height = self.height
         child.x = self.x + position
         child.y = self.y
         child.width = width_per_child
示例#26
0
 def __init__(self, pos):
     super(ButtonDisplay, self).__init__()
     self.border_color = Color(1, 1, 1)
     self.pos = pos
     self.add(self.border_color)
     self.border = Rectangle(texture=Image("pictures/black.png").texture,
                             pos=pos,
                             size=(Window.width / 2, 20))
     self.add(self.border)
     self.time = 0
     self.darkened = True
示例#27
0
 def test_detect_qrcode_frame_one_qrcode(self):
     """
     Checks `_detect_qrcode_frame()` can detect one qrcode.
     """
     fixture_path = os.path.join(FIXTURE_DIR, 'one_qr_code.png')
     texture = Image(fixture_path).texture
     code_types = self.zbarcam.code_types
     symbols = self.zbarcam._detect_qrcode_frame(texture, code_types)
     assert symbols == [
         ZBarCam.Symbol(type='QRCODE', data=b'zbarlight test qr code')
     ]
示例#28
0
文件: touchring.py 项目: xyqgcs/kivy
def start(win, ctx):
    # XXX use ctx !
    global pointer_image, pointer_scale, pointer_alpha
    pointer_fn = ctx.config.get('image',
                                'atlas://data/images/defaulttheme/ring')
    pointer_scale = float(ctx.config.get('scale', 1.0))
    pointer_alpha = float(ctx.config.get('alpha', 1.0))
    pointer_image = Image(pointer_fn)
    win.bind(on_touch_down=_touch_down,
             on_touch_move=_touch_move,
             on_touch_up=_touch_up)
示例#29
0
文件: parser.py 项目: fajran/kivy
def parse_image(filename):
    '''Parse a filename to load an image ro svg'''
    filename = parse_filename(filename)
    if filename in (None, 'None', u'None'):
        return None
    if filename.endswith('.svg'):
        return Svg(filename)
    else:
        return Image(filename)
    raise Exception('Error trying to load image specified in css: %s' \
                    % filename)
示例#30
0
    def draw_keys(self):
        layout = self.available_layouts[self.layout]
        layout_rows = layout['rows']
        layout_geometry = self.layout_geometry
        layout_mode = self.layout_mode

        # draw background
        background = resource_find(self.background_disabled
                                   if self.disabled else
                                   self.background)
        texture = Image(background, mipmap=True).texture
        self.background_key_layer.clear()
        with self.background_key_layer:
            Color(*self.background_color)
            BorderImage(texture=texture, size=self.size,
                        border=self.background_border)

        # XXX separate drawing the keys and the fonts to avoid
        # XXX reloading the texture each time

        # first draw keys without the font
        key_normal = resource_find(self.key_background_disabled_normal
                                   if self.disabled else
                                   self.key_background_normal)
        texture = Image(key_normal, mipmap=True).texture
        with self.background_key_layer:
            for line_nb in range(1, layout_rows + 1):
                for pos, size in layout_geometry['LINE_%d' % line_nb]:
                        BorderImage(texture=texture, pos=pos, size=size,
                                    border=self.key_border)

        # then draw the text
        for line_nb in range(1, layout_rows + 1):
            key_nb = 0
            for pos, size in layout_geometry['LINE_%d' % line_nb]:
                # retrieve the relative text
                text = layout[layout_mode + '_' + str(line_nb)][key_nb][0]
                z = Label(text=text, font_size=self.font_size, pos=pos,
                           size=size, font_name=self.font_name)
                self.add_widget(z)
                key_nb += 1
示例#31
0
 def __init__(self, sType, app, **kwargs):
     self.sType = sType.lower()
     self.name = None
     self.app = app
     self.sOverlay = self.app.sOverlay
     self.players = self.app.overlay
     if self.sType in ("a", "c", "n", "r", "s", "b", "g", "q", "o"):
         self.texture = Image("crop/icons/{0}.png".format(
             self.sType)).texture
         self.texture_size = self.texture.size
         self.name = self.app.L.STR_BLOCK_A
     super(Special, self).__init__(**kwargs)
示例#32
0
文件: ui.py 项目: magj3k/instrumagic
    def __init__(self, shape, color=(1.0, 1.0, 1.0), texture_path=""):
        super(Obj, self).__init__()

        self.shape = shape
        self.color = Color(color[0], color[1], color[2])
        self.add(self.color)
        self.add(self.shape)

        # rectangles only
        self.texture_path = texture_path
        if isinstance(self.shape, Rectangle) and self.texture_path != "":
            self.shape.texture = Image(self.texture_path).texture
示例#33
0
 def test_detect_qrcode_frame_one_qrcode_one_ean(self):
     """
     Checks `_detect_qrcode_frame()` can detect one qrcode and one ean.
     """
     fixture_path = os.path.join(FIXTURE_DIR, 'one_qr_code_and_one_ean.png')
     texture = Image(fixture_path).texture
     code_types = self.zbarcam.code_types
     symbols = self.zbarcam._detect_qrcode_frame(texture, code_types)
     self.assertEqual(symbols, [
         ZBarCam.Symbol(type='QRCODE', data=b'zbarlight test qr code'),
         ZBarCam.Symbol(type='UPCA', data=b'012345678905')
     ])
示例#34
0
def simple_rect(i, j, color, canvas=canvas):
    global height
    color_name = ""
    if (color[0] > 0):
        color_name = fig_colors[color[0] - 1][0]
        return Rectangle(texture=Image(color_name + ".png").texture,
                         size=(size_factor, size_factor),
                         pos=(j * size_factor, height - (i + 1) * size_factor))
    else:
        canvas.add(Color(0, 0, 0))
        return Rectangle(size=(size_factor, size_factor),
                         pos=(j * size_factor, height - (i + 1) * size_factor))
示例#35
0
文件: parser.py 项目: wilsaj/kivy
def parse_image(filename):
    '''Parse a filename and load it in a Widget (Image or Svg).
    Svg is used only if the file extension is '.svg', otherwise Image.'''
    filename = parse_filename(filename)
    if filename in (None, 'None', u'None'):
        return None
    if filename.lower().endswith('.svg'):
        return Svg(filename)
    else:
        return Image(filename)
    raise Exception('Error trying to load image specified in css: %s' \
                    % filename)
示例#36
0
def simple_rect_for_n(i, j, color):
    if (color[0] > 0):
        color_name = fig_colors[color[0] - 1][0]

        return Rectangle(texture=Image(color_name + ".png").texture,
                         size=(size_factor, size_factor),
                         pos=(next_fig_l_pos[0] + j * size_factor,
                              150 - (i + 1) * size_factor))
    else:
        canvas.add(Color(0, 0, 0))
        return Rectangle(size=(size_factor, size_factor),
                         pos=(j * size_factor, height - (i + 1) * size_factor))
示例#37
0
 def __init__(self,
              image=None,
              sequence=False,
              width=None,
              height=None,
              mipmap=True):
     if image is None:
         self.image = self.EMPTY_IMAGE
         self.width = 0
         self.height = 0
         return
     if isinstance(image, str):
         self.filename = image
         try:
             self.image = Kivy_Image(image, mipmap=mipmap)
         except:
             raise MyrmidonError("Couldn't load image from " + image)
     else:
         self.image = Kivy_Image(image)
     self.width = self.image.width
     self.height = self.image.height
示例#38
0
        def _draw_element(m, texture='', texture1=''):
            #bind the texture BEFORE the draw (Mesh)
            if texture1:
                # here, we are binding a custom texture at index 1
                # this will be used as texture1 in shader.
                tex1 = Image(texture1).texture
                tex1.wrap = 'repeat'  #enable of uv support >1 or <0
                BindTexture(texture=tex1, index=1)
            #clear the texture if none
            else:
                BindTexture(source="", index=1)

            mesh = Mesh(
                vertices=m.vertices,
                indices=m.indices,
                fmt=m.vertex_format,
                mode='triangles',
                group='truc',
            )

            if texture:
                try:
                    texture = Image(texture).texture
                    texture.wrap = 'repeat'  #enable of uv support >1 or <0
                    mesh.texture = texture
                except:  #no texture if not found or not supported
                    pass
示例#39
0
    def __init__(self):
        super(HomeScreen, self).__init__()

        # Create Title Background
        title_img = Image('../images/title-screen.png').texture
        title_screen = Rectangle(pos=(0, 0),
                                 size=(Window.width, Window.height + 10),
                                 texture=title_img)
        self.canvas.add(title_screen)

        w = Window.width // 3
        buttonSize = (w, w // 3)
        buttonAnchor = (3 * Window.width // 4 - buttonSize[0] // 2,
                        Window.height // 4 - buttonSize[1] // 2)

        # Create start button
        start_text = 'Start Game'
        startButton = create_button(start_text, buttonSize, buttonAnchor)[0]
        startButton.bind(on_release=self.switch_to_game_screen)
        self.add_widget(startButton)

        # Create stats button
        stats_text = 'Statistics'
        statsButton = create_button(
            stats_text, buttonSize,
            (buttonAnchor[0], buttonAnchor[1] - buttonSize[1]))[0]
        statsButton.bind(on_release=self.switch_to_score_card)
        self.add_widget(statsButton)

        # Load patterns information and create dropdown
        self.patterns_dict = loadPatterns()
        self.pattern = None
        # Create dropdown for patterns
        ddp_anchor = (Window.width // 4 - buttonSize[0] // 2, buttonAnchor[1])
        self.mb_p, self.dd_p = create_dropdown(
            ['Select Pattern'] + list(self.patterns_dict), *buttonSize,
            ddp_anchor)
        self.add_widget(self.mb_p)
        self.dd_p.bind(on_select=self.set_pattern)

        # Load keys information and create dropdown
        self._generate_keys()

        self.key = None
        # Create dropdown for keys
        ddk_anchor = (ddp_anchor[0], ddp_anchor[1] - buttonSize[1])
        self.mb_k, self.dd_k = create_dropdown(
            ['Select Key'] + list(self.keys_dict), *buttonSize, ddk_anchor)
        self.add_widget(self.mb_k)
        self.dd_k.bind(on_select=self.set_key)

        print('homescreen buttons initialized')
示例#40
0
    def __init__(self, **kwargs):
        self.ratio = Metrics.dpi / 100

        self.texture_hard = Image('atlas://' + kivymd.images_path +
                                  'el_shadows.atlas/h_shadow',
                                  mipmap=True).texture
        self.texture_soft = Image('atlas://' + kivymd.images_path +
                                  'el_shadows.atlas/s_shadow',
                                  mipmap=True).texture
        super(ElevationBehaviour, self).__init__(**kwargs)

        with self.canvas.before:
            self._soft_col = Color(rgba=(1, 1, 1, .4))
            self.border_soft = BorderImage(texture=self.texture_soft)
            self._hard_col = Color(rgba=(1, 1, 1, .16))
            self.border_hard = BorderImage(texture=self.texture_hard)

        self.bind(pos=self.update_shadow,
                  size=self.update_shadow,
                  elevation=self.update_shadow)

        Clock.schedule_once(self.update_shadow, 0)
示例#41
0
 def test_detect_qrcode_frame_two_qrcodes(self):
     """
     Checks `_detect_qrcode_frame()` can detect two qrcodes.
     """
     fixture_path = os.path.join(FIXTURE_DIR, 'two_qr_codes.png')
     texture = Image(fixture_path).texture
     code_types = self.zbarcam.code_types
     symbols = self.zbarcam._detect_qrcode_frame(texture, code_types)
     Symbol = ZBarCam.Symbol
     self.assertEqual(symbols, [
         Symbol(type='QRCODE', data=b'second zbarlight test qr code'),
         Symbol(type='QRCODE', data=b'zbarlight test qr code'),
     ])
示例#42
0
    def __init__(self, norm, pos, callback):
        super(GravitySelect, self).__init__()
        self.norm = norm

        self.callback = callback
        self.pos = pos
        self.margin = self.norm.nv(20)
        self.check_size = self.norm.nt((50, 50))
        self.size = (
            self.norm.nv(210),
            2*self.margin + self.check_size[1]
        )

        self.border_color = Color(50/255, 147/255, 140/255) # bluegreen
        self.border = Line(rectangle=(*self.pos, *self.size), width=2)
        self.add(self.border_color)
        self.add(self.border)

        self.check_color = Color(1, 1, 1)
        self.off = Rectangle(
            pos=(self.pos[0] + self.margin, self.pos[1] + self.margin),
            size=self.check_size,
            texture=Image('ui/buttons/unchecked.png').texture
        )
        self.on = Rectangle(
            pos=(self.pos[0] + self.margin, self.pos[1] + self.margin),
            size=self.check_size,
            texture=Image('ui/buttons/checked.png').texture
        )
        self.add(self.check_color)
        self.add(self.off)

        title_pos = (
            self.pos[0] + self.norm.nv(140),
            self.pos[1] + self.check_size[1]/2 + self.margin
        )
        self.title = CLabelRect(cpos=title_pos, text='gravity', font_size='18')
        self.add(Color(1, 1, 1))
        self.add(self.title)
示例#43
0
文件: view.py 项目: nashr/The-Rooms
    def set_base(self, game):
        self.game = game

        # Get resources
        self.imageManager = ImageManager()

        # Set background
        self.TEXTURE = Image(self.imageManager.roomdir).texture

        self.WIDTH = self.TEXTURE.width
        self.HEIGHT = self.TEXTURE.height

        self.X = 0.0
        self.Y = 0.0

        # Instantiate children
        self.navi.set_base(self.imageManager.navigatordir, 700.0, 525.0)

        self.back.set_base(self.imageManager.backdir, 350.0, 0.0)

        self.leftDoor.set_base(self.imageManager.leftdoordir, 45.0, 25.0)
        self.centerDoor.set_base(self.imageManager.centerdoordir, 325.0, 102.0)
        self.rightDoor.set_base(self.imageManager.rightdoordir, 640.0, 27.0)

        self.leftLamp.set_base(self.imageManager.leftlampdir, 80.0, 437.5)
        self.centerLamp.set_base(self.imageManager.centerlampdir, 375.0, 410.0)
        self.rightLamp.set_base(self.imageManager.rightlampdir, 668.0, 437.5)

        self.plant.set_base(self.imageManager.plantdir, 368.0, 268.0)

        self.bomb = Bomb()
        self.bomb.set_base(self.imageManager.bombdir, 368.0, 268.0)

        # Is there a door (at) [ahead, right, back, left]
        # Code: -1: no door; 0: door with green light; 1: door with grey light; 2: door with red light
        # and [number of bombs nearby, plant direction]
        # Code: -1: data not available; 0..n: number of bombs or direction of arrow
        self.roomProperty = [-1, -1, -1, -1, -1, -1]

        self.remove_widget(self.nBomb)
        self.remove_widget(self.gameTime)
        self.remove_widget(self.navi)
        self.remove_widget(self.back)
        self.remove_widget(self.leftDoor)
        self.remove_widget(self.centerDoor)
        self.remove_widget(self.rightDoor)
        self.remove_widget(self.leftLamp)
        self.remove_widget(self.centerLamp)
        self.remove_widget(self.rightLamp)
        self.remove_widget(self.plant)
        self.remove_widget(self.pause)
示例#44
0
    def take_not_window_screenshot(self, shouldWholeWindowIfNone=False, *args):
        if globals.baseSysConfig.get("background_image", "see_through"):
            img = ImageGrab.grab()

            try:
                im = CoreImage(self.ids["ParentScreenImage"].texture)

            except Exception:
                Logger.warning(
                    globals.baseSysConfig.get("main", "parent_name") +
                    ": Window background image does not have a texture")

                if shouldWholeWindowIfNone:
                    self.minimize_screenshot()

                return

            data = BytesIO()
            im.save(data, fmt="png")
            data.seek(0)
            im = PILImage.open(data)

            wx, wy, ww, wh = CoreWindow.left, CoreWindow.top, CoreWindow.width, CoreWindow.height
            remAmount = globals.baseSysConfig.get("background_image",
                                                  "crop_distance")
            remAmountTop = globals.baseSysConfig.get("background_image",
                                                     "crop_distance_top")
            x, y, x2, y2 = wx - remAmount, wy - remAmountTop, wx + ww + remAmount, wy + wh + remAmount
            im = im.crop((x, y, x2, y2))

            img.paste(im, (x, y))

            data = BytesIO()
            img.save(data, format="png")
            data.seek(0)
            img = CoreImage(BytesIO(data.read()), ext='png')

            self.ids["ParentScreenImage"].texture = img.texture
示例#45
0
    def do_load(self):
        """Load the image."""
        # This is the method that's actually called to load the asset from
        # disk. It's called by the loader thread so it's ok to block. However
        # since it's a separate thread, don't update any other attributes.

        # When you're done loading and return, the asset will be processed and
        # the various load status attributes will be updated automatically,
        # and anything that was waiting for it to load will be called. So
        # all you have to do here is load and return.

        if self.config.get('image_template'):
            try:
                template = self.machine.machine_config['image_templates'][self.config['image_template']]
                self.config = Util.dict_merge(template, self.config)
            except KeyError:
                raise KeyError("Image template '{}' was not found, referenced in image config {}".format(
                               self.config['image_template'], self.config))

        if self.machine.machine_config['mpf-mc']['zip_lazy_loading']:
            # lazy loading for zip file image sequences
            ImageLoader.zip_loader = KivyImageLoaderPatch.lazy_zip_loader

        self._image = Image(self.config['file'],
                            keep_data=False,
                            scale=1.0,
                            mipmap=False,
                            anim_delay=-1,
                            nocache=True)

        self._image.anim_reset(False)

        if self.config.get('frame_skips'):
            # Frames are provided in 1-index values, but the image animates in zero-index values
            self.frame_skips = {s['from'] - 1: s['to'] - 1 for s in self.config['frame_skips']}

        # load first texture to speed up first display
        self._callbacks.add(lambda x: self._image.texture)
示例#46
0
    def refresh_active_keys_layer(self):
        self.active_keys_layer.clear()

        active_keys = self.active_keys
        layout_geometry = self.layout_geometry
        background = resource_find(self.key_background_down)
        texture = Image(background, mipmap=True).texture

        with self.active_keys_layer:
            Color(*self.key_background_color)
            for line_nb, index in active_keys.values():
                pos, size = layout_geometry['LINE_%d' % line_nb][index]
                BorderImage(texture=texture, pos=pos, size=size,
                            border=self.key_border)
示例#47
0
    def do_load(self):
        """Load the image."""
        # This is the method that's actually called to load the asset from
        # disk. It's called by the loader thread so it's ok to block. However
        # since it's a separate thread, don't update any other attributes.

        # When you're done loading and return, the asset will be processed and
        # the various load status attributes will be updated automatically,
        # and anything that was waiting for it to load will be called. So
        # all you have to do here is load and return.

        if self.machine.machine_config['mpf-mc']['zip_lazy_loading']:
            # lazy loading for zip file image sequences
            ImageLoader.zip_loader = KivyImageLoaderPatch.lazy_zip_loader

        self._image = Image(self.config['file'],
                            keep_data=False,
                            scale=1.0,
                            mipmap=False,
                            anim_delay=-1,
                            nocache=True)

        self._image.anim_reset(False)
示例#48
0
文件: enemy.py 项目: dxsun/BeaTS
 def on_kill(self, is_pass=False):
     #self.size_anim = KFAnim((0,2*self.r),(.8,5*self.r))
     self.is_pass = is_pass
     self.explosion_anim = Rectangle(
         pos=(self.image_texture.pos[0], self.image_texture.pos[1]),
         size=(self.image_texture.size[0], self.image_texture.size[1]),
         texture=Image("assets/explosion01.png").texture)
     self.add(self.explosion_anim)
     self.size_anim = KFAnim(
         (0, self.image_texture.size[0], self.image_texture.size[1]),
         (0.9, self.image_texture.size[0], self.image_texture.size[1]))
     self.color_anim = KFAnim((0, 0.8), (.3, 1), (0.8, 0))
     self.time = 0
     self.is_dead = True
示例#49
0
def _mouse_move(win, pos, *args):
    global cursor_size
    if hasattr(win, '_cursor'):
        c = win._cursor
    else:
        with win.canvas.after:
            img = Image(cursor_image)
            Color(1, 1, 1, 1, mode='rgba')
            size = (cursor_size[0] or img.texture.size[0], cursor_size[1]
                    or img.texture.size[1])
            print(size)
            win._cursor = c = Rectangle(texture=img.texture, size=size)

    c.pos = pos[0] + cursor_offset[0], pos[1] - c.size[1] + cursor_offset[1]
示例#50
0
def load_sprite(folder_path: Path, sp: str) -> Optional[SpriteConfig]:
    if sp.rsplit('.', 1)[-1] != 'png':
        return  # It is probably a config file, not loading it

    config_file = (folder_path /
                   sp.rsplit('.', 1)[0]).as_posix() + '_config.toml'
    sp_path = folder_path / sp

    if not os.path.exists(config_file):
        Logger.error(
            f"Engine: No configuration file found for {sp}, not loading it.")
        return

    texture = CoreImage(sp_path.as_posix()).texture
    texture.mag_filter = 'nearest'

    with open(config_file) as f:
        config_dict = toml.load(f)

    config = SpriteConfig(sp_path, texture, config_dict['size'],
                          len(config_dict['animation']),
                          [an['length'] for an in config_dict['animation']])
    return config
示例#51
0
    def _parse_config(self, config):
        self._config = parse_xml(config)

        texture_path = self._parse_data('texture', 'name')
        config_dir_path = os.path.dirname(os.path.abspath(config))
        path = os.path.join(config_dir_path, texture_path)
        if os.path.exists(path):
            self.texture_path = path
        else:
            self.texture_path = texture_path

        self.texture = Image(self.texture_path).texture
        self.emitter_x = float(self._parse_data('sourcePosition', 'x'))
        self.emitter_y = float(self._parse_data('sourcePosition', 'y'))
        self.emitter_x_variance = float(self._parse_data('sourcePositionVariance', 'x'))
        self.emitter_y_variance = float(self._parse_data('sourcePositionVariance', 'y'))
        self.gravity_x = float(self._parse_data('gravity', 'x'))
        self.gravity_y = float(self._parse_data('gravity', 'y'))
        self.emitter_type = int(self._parse_data('emitterType'))
        self.max_num_particles = int(float(self._parse_data('maxParticles')))
        self.life_span = max(0.01, float(self._parse_data('particleLifeSpan')))
        self.life_span_variance = float(self._parse_data('particleLifespanVariance'))
        self.start_size = float(self._parse_data('startParticleSize'))
        self.start_size_variance = float(self._parse_data('startParticleSizeVariance'))
        self.end_size = float(self._parse_data('finishParticleSize'))
        self.end_size_variance = float(self._parse_data('FinishParticleSizeVariance'))
        self.emit_angle = math.radians(float(self._parse_data('angle')))
        self.emit_angle_variance = math.radians(float(self._parse_data('angleVariance')))
        self.start_rotation = math.radians(float(self._parse_data('rotationStart')))
        self.start_rotation_variance = math.radians(float(self._parse_data('rotationStartVariance')))
        self.end_rotation = math.radians(float(self._parse_data('rotationEnd')))
        self.end_rotation_variance = math.radians(float(self._parse_data('rotationEndVariance')))
        self.speed = float(self._parse_data('speed'))
        self.speed_variance = float(self._parse_data('speedVariance'))
        self.radial_acceleration = float(self._parse_data('radialAcceleration'))
        self.radial_acceleration_variance = float(self._parse_data('radialAccelVariance'))
        self.tangential_acceleration = float(self._parse_data('tangentialAcceleration'))
        self.tangential_acceleration_variance = float(self._parse_data('tangentialAccelVariance'))
        self.max_radius = float(self._parse_data('maxRadius'))
        self.max_radius_variance = float(self._parse_data('maxRadiusVariance'))
        self.min_radius = float(self._parse_data('minRadius'))
        self.rotate_per_second = math.radians(float(self._parse_data('rotatePerSecond')))
        self.rotate_per_second_variance = math.radians(float(self._parse_data('rotatePerSecondVariance')))
        self.start_color = self._parse_color('startColor')
        self.start_color_variance = self._parse_color('startColorVariance')
        self.end_color = self._parse_color('finishColor')
        self.end_color_variance = self._parse_color('finishColorVariance')
        self.blend_factor_source = self._parse_blend('blendFuncSource')
        self.blend_factor_dest = self._parse_blend('blendFuncDestination')
示例#52
0
class PixelPerfectCollisionBehavior(object):
    collision_source = StringProperty(None, allownone=True)
    '''The collision source is the file to load the collision
    mask from. The collision mask should be a png or other image
    file that supports the alpha layer. Any transparent pixels
    will count as no collision. Any opaque pixels will trigger
    a collision. The mask is scaled to fit the widget.
        '''

    __collision_mask = ObjectProperty(None, allownone=True)
    '''The collision mask is used to detect the collision point against.
    If the collision mask is None then no collision will be possible.
        '''
    def __init__(self, **kwargs):
        super(PixelPerfectCollisionBehavior, self).__init__(**kwargs)

    def on_collision_source(self, instance, value):
        if value is None:
            return
        try:
            self.__collision_mask = CoreImage(value, keep_data=True)
        except:
            self.__collision_mask = None

    def collide_point(self, x, y):
        if self.__collision_mask is None:
            # print("No collision mask")
            return False
        if not super().collide_point(x, y):
            # print("Not inside the widget")
            return False
        try:
            # print(x, y)
            # print(self.x, self.y, self.right, self.top)
            wscale = (self.__collision_mask.width / self.width)
            hscale = (self.__collision_mask.height / self.height)
            # print(wscale, hscale)
            # print(x, self.x)
            # print(y, self.y)
            # print((x - self.x) * wscale, (self.height - (y - self.y)) * hscale)
            # print(self.__collision_mask.width, self.__collision_mask.height)
            color = self.__collision_mask.read_pixel(
                (x - self.x) * wscale, (self.height - (y - self.y)) * hscale)
            # print(color)
        except Exception as e:
            color = 0, 0, 0, 0
        if color[-1] > 0:
            print(self.x, self.y, 'collide')
            return True
示例#53
0
    def test_save_into_bytesio(self):
        Image = self.cls

        if setupconfig.PLATFORM == "darwin":
            # XXX on OSX CI Builder, img_sdl2 is not used
            # therefore the test below wont work yet with imageio only.
            return

        # load kivy logo
        img = Image.load("data/logo/kivy-icon-512.png")
        self.assertIsNotNone(img)

        # try to save without any format
        with self.assertRaises(Exception) as context:
            bio = io.BytesIO()
            img.save(bio)

        # save it in png
        bio = io.BytesIO()
        # if False, then there is no provider
        self.assertTrue(img.save(bio, fmt="png"))
        pngdata = bio.read()
        self.assertTrue(len(pngdata) > 0)

        # try to save in a filename
        try:
            _, filename = tempfile.mkstemp(suffix=".png")
            self.assertTrue(img.save(filename, fmt="png"))
        finally:
            os.unlink(filename)

        # XXX Test wrote but temporary commented
        # XXX because of the issue #6123 on OSX
        # XXX https://github.com/kivy/kivy/issues/6123
        # with open(filename, "rb") as fd2:
        #     pngdatafile = fd2.read()
        # # check the png file data is the same as bytesio
        # self.assertTrue(pngdata == pngdatafile)

        # save it in jpeg
        bio = io.BytesIO()
        # if False, then there is no provider
        self.assertTrue(img.save(bio, fmt="jpg"))
        self.assertTrue(len(bio.read()) > 0)

        with tempfile.NamedTemporaryFile(suffix=".jpg") as fd:
            self.assertTrue(img.save(fd.name))
示例#54
0
文件: view.py 项目: nashr/The-Rooms
class Navigator(Widget):
    # Base variables
    TEXTURE = ObjectProperty(None)

    WIDTH = NumericProperty(1.0)
    HEIGHT = NumericProperty(1.0)

    X_UNIT = NumericProperty(1.0)
    Y_UNIT = NumericProperty(1.0)

    X = NumericProperty(1.0)
    Y = NumericProperty(1.0)

    # Run variables
    angle = NumericProperty(0.0)

    xUnit = NumericProperty(1.0)
    yUnit = NumericProperty(1.0)

    curr_texture = ObjectProperty(None)

    x = NumericProperty(1.0)
    y = NumericProperty(1.0)

    def set_base(self, texture_dir, x, y):
        self.TEXTURE = Image(texture_dir).texture

        self.WIDTH = self.TEXTURE.width
        self.HEIGHT = self.TEXTURE.height

        self.X_UNIT = self.WIDTH / 1
        self.Y_UNIT = self.HEIGHT / 1

        self.X = x
        self.Y = y

    def update(self, xScale, yScale):
        self.xUnit = self.X_UNIT * xScale
        self.yUnit = self.Y_UNIT * yScale

        self.x = self.X * xScale
        self.y = self.Y * yScale

        self.curr_texture = self.TEXTURE.get_region(0, 0, self.X_UNIT, self.Y_UNIT)
示例#55
0
    def on_paths(self, *args):
        """Make textures from the images in ``paths``, and assign them at the
        same index in my ``texs`` as in my ``paths``.

        """
        for i, path in enumerate(self.paths):
            if path in self.pathtexs:
                if (
                        self.pathtexs[path] in self.texs and
                        self.texs.index(self.pathtexs[path])== i
                ):
                    continue
            else:
                self.pathimgs[path] = img = Image.load(
                    resource_find(path), keep_data=True
                )
                self.pathtexs[path] = img.texture
            if i == len(self.texs):
                self.texs.append(self.pathtexs[path])
            else:
                self.texs[i] = self.pathtexs[path]
示例#56
0
 def load_tileable(self, name):
     t = Image('%s.png' % name).texture
     t.wrap = 'repeat'
     setattr(self, 'tx_%s' % name, t)
示例#57
0
文件: main.py 项目: mariahc/KivyKyra
 def loadBackground(self):
     print 'loading bg', self.bg
     tex = CImage.load(self.bg, keep_data=True).texture
     self.buildBackground(tex)
 def on_source(self, *largs):
     if os.path.exists(self.source):
         self.texture = Image.load(self.source).texture
         self.texture.wrap = 'repeat'
         self._calc_tex_coords()
示例#59
0
文件: main.py 项目: rhema/kivy-games
from kivy.app import App
from kivy.uix.widget import Widget
from kivy.uix.image import Image
from kivy.core.image import Image as ImageForTest
from kivy.properties import NumericProperty, ReferenceListProperty, ObjectProperty
from kivy.vector import Vector
from kivy.factory import Factory
from kivy.clock import Clock
from kivy.core.window import Window

from kivy.lang import Builder
from kivy.graphics import Color
import math


m = ImageForTest.load('testme.png',keep_data=True)

Builder.load_string("""
<PongBall>:
    size: 50, 50 
""")

class Mazy(Image):    
    def on_touch_down(self,touch):
        print "Testing...",touch.x,touch.y
        print m.read_pixel(touch.x,touch.y)

class PongBall(Image):
    r = NumericProperty(.5)
    g = NumericProperty(.5)
    b = NumericProperty(.5)
示例#60
0
文件: main.py 项目: biank88/kivyteach
 def load_tileable(self, name):
     t = Image('images/{}.png'.format(name)).texture
     t.wrap = 'repeat'
     setattr(self, 'tx_{}'.format(name), t)