def test_y_smoothscale(surface):
"""Scale y axis only"""
obj = _make_object()
transform.set_smoothscale_backend('GENERIC')
surface.blit(obj, (20, 20))
obj1 = transform.smoothscale(obj, (20, 25))
surface.blit(obj1, (80, 80))
obj2 = transform.smoothscale(obj, (20, 35))
surface.blit(obj2, (160, 160))
obj3 = transform.smoothscale(obj, (20, 55))
surface.blit(obj3, (240, 160))
obj4 = transform.smoothscale(obj, (20, 15))
surface.blit(obj4, (240, 240))
obj5 = transform.smoothscale(obj, (20, 100))
surface.blit(obj5, (320, 320))
def render(text, font, background, color, left, top, width, height) : text_rendered = font.render(text, 1, color) text_height = font.get_ascent() text_rendered = text_rendered.subsurface(Rect(0, (text_rendered.get_height() - text_height) / 2 , text_rendered.get_width(), text_height)) rect_rendered = text_rendered.get_rect() # final_rect = pygame.Rect(left, top, width, height).fit(rect_rendered) final_rect = rect_rendered.fit(Rect(left, top, width, height)) background.blit(transform.smoothscale(text_rendered, (final_rect.width, final_rect.height)), Rect(left, top, final_rect.width, final_rect.height))
def scale(self, size):
# Used for changing word size
pos = (self.rect.x, self.rect.y)
self.image = transform.smoothscale(self.image, (int(self.rect.width*size), int(self.rect.height*size)))
self.msf = transform.scale(self.msf, (int(self.rect.width*size), int(self.rect.height*size)))
self.rect = self.image.get_rect()
self.rect.x, self.rect.y = pos
self._update_mask()
def get_plant_thumbnail(plant, size): #print "get_plant_thumbnail:", plant, size ### thumb = plant._thumbnail if not thumb: #print "get_plant_thumbnail: generating thumbnail" ### buffer = render_plant(plant, (600, 600)) thumb = transform.smoothscale(buffer, size) plant._thumbnail = thumb return thumb
def __init__(self, model):
self.id = 'Projectile'
self.size = (model.radius*2, model.radius*2)
self.base_image = load_image('planet.png')
self.image = smoothscale(self.base_image, self.size)
self.model = model
def get_border(self):
'''if self.model.lockdown_frames > 180:
return smoothscale(self.border4, self.size)
elif self.model.lockdown_frames > 120:
return smoothscale(self.border3, self.size)
elif self.model.lockdown_frames > 60:
return smoothscale(self.border2, self.size)
else:
return smoothscale(self.border1, self.size)'''
return smoothscale(self.border4, self.size)
def set_height(self, height):
if height is not None:
self.height = int(height)
if self.width is None:
self.width = self.height
if self.picture is not None:
self.width = self.picture.get_width()
self.picture = smoothscale(self.picture, (self.width,self.height))
self.radius = ((self.width*self.width+self.height*self.height)**0.5)/2
else:
self.height = height
def set_width(self, width):
if width is not None:
self.width = int(width)
if self.height is None:
self.height = self.width
if self.picture is not None:
self.height = self.picture.get_height()
self.picture = smoothscale(self.picture, (self.width,self.height))
self.radius = ((self.width*self.width+self.height*self.height)**0.5)/2
else:
self.width = width
def set_pic(self, pic):
self.picture = pygame.image.load(pic).convert()
if (self.width is not None) and (self.height is not None):
self.picture = smoothscale(self.picture, (self.width,self.height))
else:
self.width = self.picture.get_width()
self.height = self.picture.get_height()
self.radius = ((self.width*self.width+self.height*self.height)**0.5)/2
self.shape = None
self.color = None
def test_subsurface_smoothscale(surface):
"""Test scaling a small subsurface"""
obj = _make_object()
transform.set_smoothscale_backend('GENERIC')
obj_sub = obj.subsurface((20, 20, 20, 25))
surface.blit(obj, (20, 20))
surface.blit(obj_sub, (60, 20))
obj1 = transform.smoothscale(obj_sub, (obj_sub.get_width(), obj_sub.get_height()))
surface.blit(obj1, (120, 20))
obj1 = transform.smoothscale(obj_sub, (20, 20))
surface.blit(obj1, (60, 60))
obj1 = transform.smoothscale(obj_sub, (40, 40))
surface.blit(obj1, (80, 80))
obj1 = transform.smoothscale(obj_sub, (60, 60))
surface.blit(obj1, (160, 160))
obj1 = transform.smoothscale(obj_sub, (120, 120))
surface.blit(obj1, (220, 220))
def __call__(self, x, y, w, h):
if not x in self.cache:
self.cache[x] = {}
if not y in self.cache[x]:
self.cache[x][y] = {}
if not w in self.cache[x][y]:
self.cache[x][y][w] = {}
if not h in self.cache[x][y][w]:
self.cache[x][y][w][h] = transform.smoothscale(self.sprites(x, y), (w, h))
return self.cache[x][y][w][h]
def init_map_titles(self, map_tile_setting):
tile_cache = weakref.WeakValueDictionary()
for y, tile_row in enumerate(map_tile_setting):
for x, tile_id in enumerate(tile_row):
tile_id = str(tile_id)
tile = tile_cache.get(tile_id)
if not tile:
tile = self.tile_images.get(tile_id).convert_alpha()
tile = smoothscale(tile, (tile.get_width(), tile.get_height() / 2))
tile_cache[tile_id] = tile
w, h = tile.get_width(), tile.get_height()
self.map_tiles[(w * x, h * y)] = tile
def render_back(size):
snake = prepare.GFX["pysnakeicon"]
rect = pygame.Rect((0, 0), size)
back = pygame.Surface(size)
back.fill(pygame.Color("dodgerblue"))
s_rect = snake.get_rect().fit(rect)
s_rect.midbottom = rect.midbottom
snake = smoothscale(snake, s_rect.size)
back.blit(snake, s_rect)
pygame.draw.rect(back, pygame.Color("gray95"), rect, 4)
pygame.draw.rect(back, pygame.Color("gray20"), rect, 1)
return back
def __init__(self, space, rect):
super(Ball, self).__init__()
radius = rect.width / 2
body = Body(ball_mass, moment_for_circle(ball_mass, 0, radius))
body.position = rect.center
self.shape = Circle(body, radius)
self.shape.elasticity = .5
self.shape.friction = 0
self.shape.layers = 1
self.shape.collision_type = ball_type
self.rect = pygame.Rect(0, 0, rect.width, rect.width)
image = smoothscale(prepare.GFX.get('ball-bearing'), self.rect.size)
self._original_image = image.convert_alpha()
def __init__(self, loc, sub_img, upgrade_box=False):
UIElement.__init__(self, util.enums.RES + "icons/towerbox.png", loc)
self.subImg = image.load(util.enums.RES + sub_img).convert_alpha()
self.upgrade = upgrade_box
if upgrade_box:
self.subImg = transform.smoothscale(self.subImg, (37, 32))
if upgrade_box:
self.sub_loc = (5, 5)
else:
self.sub_loc = (7, 8)
self.draw_subimg()
def update_image(self):
image = self.front_face if self._face_up else self.back_face
if self._rotation:
width, height = image.get_size()
value = 180 * cos(two_pi * self._rotation / 180.) + 180
width *= value / 360.0
width = int(round(max(1, abs(width)), 0))
image = smoothscale(image, (width, int(height)))
rect = image.get_rect(center=self.rect.center)
self._image = image
self.rect.size = rect.size
self.rect.center = rect.center
self.dirty = 1
def __init__(self, model):
self.id = 'Planet'
self.model = model
self.size = model.radius*2, model.radius*2
self.base_image = load_image('planet.png')
self.image = smoothscale(self.base_image, self.size)
self.border4 = load_image('border4.png')
self.border3 = load_image('border3.png')
self.border2 = load_image('border2.png')
self.border1 = load_image('border1.png')
def _render_interface(self, interface):
"""
:param engine.interface.Canvas interface: Interface to render
"""
for element in interface.get_children():
if isinstance(element, SpriteElement):
sprite = element.sprite
if sprite is not None:
try:
surface = transform.smoothscale(sprite, (element.width, element.height))
except ValueError:
surface = transform.scale(sprite, (element.width, element.height))
self.screen.blit(surface, surface.get_rect(x=element.position.x, y=element.position.y))
def draw_spectrum(self, f, x):
draw_area = Surface((1, len(f)), depth=24)
d = surfarray.pixels3d(draw_area)
self.peak = np.maximum(np.amax(f, axis=0), self.peak)
a = (255 * f / self.peak[np.newaxis, :]).astype(np.uint8)
d[0, :, 1:] = a[::-1]
d[0, :, 0] = a[::-1, 1] / 2 + a[::-1, 0] / 2
for m in self.markers:
im = int((2 * m / self.sample_rate) * len(f))
d[0, -im, 0] = 255
del d
it = int((2 * self.top_freq / self.sample_rate) * len(f))
self.surface.blit(smoothscale(draw_area.subsurface((0, len(f) - it - 1, 1, it)), (1, self.size[1])), (x, 0))
self.peak *= 2.0 ** (-1.0 / 100)
def renderer(text, native_ratio=native_ratio):
# Render the text
raw = font.render(text, False, color).convert_alpha()
# No native ratio case
if native_ratio is None:
return raw
# Ratio between native ratio and current ratio
current_ratio = float(self.settings.width)/self.settings.height
ratio = current_ratio/native_ratio
# Already native case
if ratio == 1:
return raw
# Scaling
img_size = int(raw.get_width() * ratio), raw.get_height()
return transform.smoothscale(raw, img_size)
def update(self):
delta = self.pow / 80.0
self.radius += self.step
self.pow -= 1
r = (int(self.radius),) * 2
self.img = transform.smoothscale(Torpedo0.Blast.img, r)
array = surfarray.pixels_alpha(self.img)
array[:] = array[:] * delta
self.size = r
self.center = self.pos
for f in enemi:
x, y = f.center
h2 = (self.centerx - x) ** 2 + (self.centery - y) ** 2
if h2 < (self.radius / 2.0) ** 2:
f.shield -= 1
def get_aa_ellipsis(size, color):
surface = Surface(size, flags=SRCALPHA).convert_alpha()
rect = Rect((0, 0), size)
color = Color(*color)
alpha = color.a
color.a = 0
#here 5 is an arbitrary multiplier, we will just rescale later
circle = Surface([size[0] * 5, size[1] * 5], SRCALPHA)
draw.ellipse(circle, (0,0,0), circle.get_rect(), 0)
circle = transform.smoothscale(circle, size)
#fill with color using blend_rgba_max
circle.fill(color, special_flags=BLEND_RGBA_MAX)
#fill with alpha-withe using blend_rgba_min in order to make transparent
circle.fill((255, 255, 255, alpha), special_flags=BLEND_RGBA_MIN)
return circle
def run(args):
tile_image = pygame.image.load(os.path.join("res", "image", "tiles", "1.png")).convert_alpha()
tile_image = transform.smoothscale(tile_image, (256, 128))
img = pygame.image.load(args.filepath).convert_alpha()
#img.fill((0, 128, 0), special_flags=BLEND_MULT)
#img = img.subsurface((0, 0, 256, 256))
img_rect = img.get_rect()
words_blit_pos = img_rect.topright
background_color = args.background_color or "black"
#mask = pygame.Surface((256, 256)).convert_alpha()
#mask.fill((0, 0, 0, 128))
clock = pygame.time.Clock()
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
return
if event.type == KEYDOWN and event.key == K_ESCAPE:
return
#for i in xrange(4):
# for j in xrange(6):
# screen.blit(tile_image, (i * 256, j * 128))
screen.fill(pygame.Color(background_color))
screen.blit(img, (0, 0))
#screen.fill(pygame.Color(background_color))
#mask = img.copy()
#mask.fill(pygame.Color(32, 32, 32), special_flags=BLEND_ADD)
#img.set_alpha(128)
#screen.blit(img, (0, 0))
#blit_pos = (randint(0, 10), randint(0, 10))
#blit_pos = (0, 0)
#screen.blit(mask, blit_pos)
mouse_pos = pygame.mouse.get_pos()
if mouse_pos[0] > img_rect.right or mouse_pos[1] > img_rect.bottom:
words = "outside the image"
else:
words = "(%s, %s)" % tuple(map(int, mouse_pos))
info = sfg.Font.ARIAL_32.render(words, True, pygame.Color("white"))
screen.blit(info, words_blit_pos)
pygame.display.update()
clock.tick(sfg.FPS)
def InterpolateToDimensions(surface, dimensions):
return transform.smoothscale(surface, tuple(dimensions))
def set_dimensions(self, w, h):
self.image_gloves = smoothscale(self.image_gloves, (w, h))
self.image_gloves_gif = [smoothscale(self.image_gloves_gif[i], (w, h)) for i in
range(len(self.image_gloves_gif))]
def update_subimage(self, subimg):
self.subImg = image.load(util.enums.RES + subimg).convert_alpha()
if self.upgrade:
self.subImg = transform.smoothscale(self.subImg, (37, 32))
else:
self.subImg = transform.smoothscale(self.subImg, (37, 32))
self.draw_subimg()
def update(self):
# First, shrink it to match res of lolshield:
smoothscale(self.surface, (SerialShield.width, SerialShield.height), self.lol_surface)
# clear screen (to paint leds)
self.surface.fill(Color('black'))
# extract value data to send:
for x in range(SerialShield.width):
for y in range(SerialShield.height):
h, s, v, a, = self.lol_surface.get_at((x, y, ))
self.set_pixel(x, y, v >= 50)
def test_varied_smoothscale(surface):
"""Scale with more varies factors"""
obj = _make_object()
transform.set_smoothscale_backend('GENERIC')
surface.blit(obj, (20, 20))
obj1 = transform.smoothscale(obj, (25, 55))
surface.blit(obj1, (80, 80))
obj1 = transform.smoothscale(obj, (14, 13))
surface.blit(obj1, (160, 160))
obj1 = transform.smoothscale(obj, (72, 68))
surface.blit(obj1, (320, 320))
def game_loop(self):
maquina_estados = self.fsm_loop()
for estado in maquina_estados:
for e in pygame.event.get():
self.input(e)
if Game.situacao[5] == -1: self.end_game()
estado()
if self.fullscreen:
smoothscale(self.screen, self.f_size, self.scaled)
self.f_screen.blit(self.scaled, (self.px,0))
else:
self.f_screen.blit(self.screen, (0,0))
pygame.display.flip()
pygame.time.wait(20)
def test_int_smoothscale(surface):
"""Simple integer scaling tests"""
obj = _make_object()
transform.set_smoothscale_backend('GENERIC')
surface.blit(obj, (20, 20))
obj1 = transform.smoothscale(obj, (20, 20))
surface.blit(obj1, (60, 60))
obj1 = transform.smoothscale(obj, (40, 40))
surface.blit(obj1, (80, 80))
obj1 = transform.smoothscale(obj, (60, 60))
surface.blit(obj1, (160, 160))
obj1 = transform.smoothscale(obj, (120, 120))
surface.blit(obj1, (320, 320))
def get_aa_round_rect(size, radius, color):
surface = Surface(size, flags=SRCALPHA).convert_alpha()
rect = Rect((0, 0), size)
color = Color(*color)
alpha = color.a
color.a = 0
rectangle = Surface(size, SRCALPHA)
#here 5 is an arbitrary multiplier, we will just rescale later
circle = Surface([min(size) * 5, min(size) * 5], SRCALPHA)
draw.ellipse(circle, (0,0,0), circle.get_rect(), 0)
circle = transform.smoothscale(circle, (2*radius, 2*radius))
#now circle is just a small circle of radius
#blit topleft circle:
radius_rect = rectangle.blit(circle, (0, 0))
#now radius_rect = Rect((0, 0), circle.size), rect=Rect((0, 0), size)
#blit bottomright circle:
radius_rect.bottomright = rect.bottomright #radius_rect is growing
rectangle.blit(circle, radius_rect)
#blit topright circle:
radius_rect.topright = rect.topright
rectangle.blit(circle, radius_rect)
#blit bottomleft circle:
radius_rect.bottomleft = rect.bottomleft
rectangle.blit(circle, radius_rect)
#black-fill of the internal rect
rectangle.fill((0, 0, 0), rect.inflate(-radius_rect.w, 0))
rectangle.fill((0, 0, 0), rect.inflate(0, -radius_rect.h))
#fill with color using blend_rgba_max
rectangle.fill(color, special_flags=BLEND_RGBA_MAX)
#fill with alpha-withe using blend_rgba_min in order to make transparent
#the
rectangle.fill((255, 255, 255, alpha), special_flags=BLEND_RGBA_MIN)
surface.blit(rectangle, rect.topleft)
return surface
def render(self):
# ~ draw magnetradius
if self.magnetradius:
# ~ gfxdraw.aacircle(scr,self.centerx,self.centery,int(self.magnetradius),(150,130,110,int(self.magnetradius)))
m = image.load("img/magnetichalo.png")
m = transform.smoothscale(m, [int(self.magnetradius * 2)] * 2)
scr.blit(m, m.get_rect(center=self.center))
# ~ draw shieldbar
r = draw.rect(scr, (50, 50, 50), (10, 500, 380, 18), 1)
osdlayer.fill((100, 100, 200, self.shieldfxttl * 4 + 150), (10, 0, self.shield_ / self.shieldmax * 380, 18))
# scr.blit(self.SHIELDTEXT,self.SHIELDRECT)
# ~ draw lazerstate
r = draw.rect(scr, (50, 50, 50), (10, 520, 380, 18), 1)
osdlayer.blit(self.lazertempfx, (10, 20), (0, 0, DoubleLazer.temper / DoubleLazer.tempmax * 380, 18))
# scr.blit(self.LAZERTEXT,self.LAZERRECT)
# ~ draw bonusbar
self.settingbonus_.render()
self.loader1_.render()
# ~ draw shieldcircle
if self.shieldfxttl:
self.shieldcolor.a = int(4 * self.shieldfxttl)
gfxdraw.filled_circle(scr, self.centerx, self.centery, self.w, self.shieldcolor)
self.shieldfxttl -= 1
if self.foo:
self.foo -= 1
scr.blit(self.img2, ship)
return
# ~ draw ship
scr.blit(self.img, ship)