def img (self, filename, size = None, cache = True):
"""Load or scale an image, or retrieve it from cache.
img(filename[, size], cache = True) -> surface
filename: a filename to load. Can be a tuple of path sections to join.
size: scale the image. Can be an (x, y) size, a rect (in which case its
dimension is used), or a number to scale by. If (x, y), either x or y
can be None to scale to the other with aspect ratio preserved.
cache: whether to store this image in the cache if not already stored.
"""
# get standardised cache key
if size is not None:
if isinstance(size, (int, float)):
size = float(size)
else:
if len(size) == 4:
# rect
size = size[2:]
size = tuple(size)
# standardise path
if not isinstance(filename, basestring):
filename = os.path.join(*filename)
filename = os.path.normpath(filename)
key = (filename, size)
if key in self.img_cache:
return self.img_cache[key]
# else new: load/render
filename = conf.IMG_DIR + filename
# also cache loaded images to reduce file I/O
if filename in self.file_cache:
img = self.file_cache[filename]
else:
img = convert_sfc(pg.image.load(filename))
if cache:
self.file_cache[filename] = img
# scale
if size is not None and size != 1:
current_size = img.get_size()
if not isinstance(size, tuple):
size = (ir(size * current_size[0]), ir(size * current_size[1]))
# handle None
for i in (0, 1):
if size[i] is None:
size = list(size)
scale = float(size[not i]) / current_size[not i]
size[i] = ir(current_size[i] * scale)
img = pg.transform.smoothscale(img, size)
# speed up blitting (if not resized, this is already done)
img = convert_sfc(img)
if cache:
# add to cache (if not resized, this is in the file cache)
self.img_cache[key] = img
return img
def set_overlay (self, overlay, convert = True):
"""Set up an overlay for the current backend.
This draws over the screen every frame after the backend draws. It takes a
single argument, which is a Pygame-style colour tuple, with or without alpha,
or a pygame.Surface, or False for no overlay.
The overlay is for the current backend only: if another backend is started and
then stopped, the overlay will be restored for the original backend.
The backend's draw method will not be called at all if the overlay to be drawn
this frame is opaque.
"""
if isinstance(overlay, pg.Surface):
# surface
if convert:
overlay = convert_sfc(overlay)
elif overlay is not False:
# colour
overlay = tuple(overlay)
# turn RGBA into RGB if no alpha
if len(overlay) == 4 and overlay[3] == 255:
overlay = overlay[:3]
self.overlay = overlay
def render_text (self, *args, **kwargs):
"""Render text and cache the result.
Takes the same arguments as fonthandler.Fonts.render, plus a keyword-only
'cache' argument. If passed, the text is cached under this hashable value, and
can be retrieved from cache by calling this function with the same value for
this argument.
Returns the same value as fonthandler.Fonts
"""
if self.fonts is None:
raise ValueError('conf.USE_FONTS is False: text rendering isn\'t'
'supported')
cache = 'cache' in kwargs
if cache:
key = kwargs['cache']
del kwargs['cache']
if key in self.text_cache:
return self.text_cache[key]
# else new: render
img, lines = self.fonts.render(*args, **kwargs)
img = convert_sfc(img)
result = (img, lines)
if cache:
self.text_cache[key] = result
return result
