def test_Renderer_draw_rect(self):
surface = SDL_CreateRGBSurface(0, 128, 128, 32, 0, 0, 0, 0).contents
sdl2ext.fill(surface, 0x0)
renderer = sdl2ext.Renderer(surface)
renderer.draw_rect((40, 50, 32, 32), 0x0000FF)
view = sdl2ext.PixelView(surface)
self.check_lines(view, 128, 128, [
((40, 50), (71, 50)),
((40, 50), (40, 81)),
((40, 81), (71, 81)),
((71, 50), (71, 81))], 0x0000FF, (0x0,))
del view
sdl2ext.fill(surface, 0x0)
renderer.draw_rect([(5, 5, 10, 10), (20, 15, 8, 10)], 0x0000FF)
view = sdl2ext.PixelView(surface)
self.check_lines(view, 128, 128, [
((5, 5), (14, 5)),
((5, 5), (5, 14)),
((5, 14), (14, 14)),
((14, 5), (14, 14)),
((20, 15), (27, 15)),
((20, 15), (20, 24)),
((20, 24), (27, 24)),
((27, 15), (27, 24))], 0x0000FF, (0x0,))
del view
def draw_vertical_stripes(surface, x1, x2, y1, y2):
sdl2ext.fill(surface, BLACK)
pixelview = sdl2ext.PixelView(surface)
for x in range(x1, x2, 4):
for y in range(y1, y2):
pixelview[y][x] = WHITE
del pixelview
def draw_horizontal_stripes(surface, x1, x2, y1, y2):
# Fill the entire surface with a black color. In contrast to
# colorpalettes.py we use a Color() value here, just to demonstrate that
# it really works.
sdl2ext.fill(surface, BLACK)
# Create a 2D view that allows us to directly access each individual pixel
# of the surface. The PixelView class is quite slow, since it uses an non-
# optimised read-write access to each individual pixel and offset. It works
# on every platform, though.
pixelview = sdl2ext.PixelView(surface)
# Loop over the area bounds, considering each fourth line and every column
# on the 2D view. The PixelView uses a y-x alignment to access pixels.
# This mkeans that the first accessible dimension of the PixelView denotes
# the horizontal lines of an image, and the second the vertical lines.
for y in range(y1, y2, 4):
for x in range(x1, x2):
# Change the color of each individual pixel. We can assign any
# color-like value here, since the assignment method of the
# PixelView will implicitly check and convert the value to a
# matching color for its target surface.
pixelview[y][x] = WHITE
# Explicitly delete the PixelView. Some surface types need to be locked
# in order to access their pixels directly. The PixelView will do that
# implicitly at creation time. Once we are done with all necessary
# operations, we need to unlock the surface, which will be done
# automatically at the time the PixelView is garbage-collected.
del pixelview
def test_fill(self):
# TODO: add exceptions and more bounding tests.
rects = ((0, 0, 3, 2),
(2, 3, 4, 2),
(5, -1, 2, 2),
(1, 7, 4, 8)
)
factory = sdl2ext.SpriteFactory(sdl2ext.SOFTWARE)
sprite = factory.create_sprite(size=(10, 10), bpp=32)
view = sdl2ext.PixelView(sprite)
for rect in rects:
sdl2ext.fill(sprite, 0)
colorval = sdl2ext.prepare_color(0xAABBCCDD, sprite)
sdl2ext.fill(sprite, 0xAABBCCDD, rect)
for y, row in enumerate(view):
for x, col in enumerate(row):
if y >= rect[1] and y < (rect[1] + rect[3]):
if x >= rect[0] and x < (rect[0] + rect[2]):
self.assertEqual(col, colorval,
"color mismatch at (x, y)")
else:
self.assertEqual(col, 0,
"color mismatch at (x, y)")
else:
self.assertEqual(col, 0, "color mismatch at (x, y)")
def test_Renderer_fill(self):
surface = SDL_CreateRGBSurface(0, 128, 128, 32, 0, 0, 0, 0).contents
sdl2ext.fill(surface, 0x0)
renderer = sdl2ext.Renderer(surface)
factory = sdl2ext.SpriteFactory(sdl2ext.TEXTURE, renderer=renderer)
w, h = 32, 32
sp = factory.from_color(0xFF0000, (w, h))
sp.x, sp.y = 40, 50
renderer.fill((sp.x, sp.y, w, h), 0x0000FF)
view = sdl2ext.PixelView(surface)
self.check_pixels(view, 128, 128, sp, 0x0000FF, (0x0, ))
del view
sdl2ext.fill(surface, 0x0)
renderer.fill([(5, 5, 10, 10), (20, 15, 8, 10)], 0x0000FF)
view = sdl2ext.PixelView(surface)
self.check_areas(view, 128, 128, [(5, 5, 10, 10), (20, 15, 8, 10)],
0x0000FF, (0x0, ))
del view
def test_Renderer_draw_line(self):
surface = SDL_CreateRGBSurface(0, 128, 128, 32, 0, 0, 0, 0).contents
sdl2ext.fill(surface, 0x0)
renderer = sdl2ext.Renderer(surface)
renderer.draw_line((20, 10, 20, 86), 0x0000FF)
view = sdl2ext.PixelView(surface)
self.check_lines(view, 128, 128, [((20, 10), (20, 86))], 0x0000FF,
(0x0, ))
del view
def test_Renderer_clear(self):
sf = SDL_CreateRGBSurface(0, 10, 10, 32, 0xFF000000, 0x00FF0000,
0x0000FF00, 0x000000FF)
renderer = sdl2ext.Renderer(sf.contents)
self.assertIsInstance(renderer.color, sdl2ext.Color)
self.assertEqual(renderer.color, sdl2ext.Color(0, 0, 0, 0))
renderer.color = 0x00FF0000
self.assertEqual(renderer.color, sdl2ext.Color(0xFF, 0, 0, 0))
renderer.clear()
view = sdl2ext.PixelView(sf.contents)
self.check_areas(view, 10, 10, [[0, 0, 10, 10]], 0xFF000000, (0x0, ))
del view
renderer.clear(0xAABBCCDD)
self.assertEqual(renderer.color, sdl2ext.Color(0xFF, 0, 0, 0))
view = sdl2ext.PixelView(sf.contents)
self.check_areas(view, 10, 10, [[0, 0, 10, 10]], 0xBBCCDDAA, (0x0, ))
del view
del renderer
SDL_FreeSurface(sf)
dogc()
def test_PixelView(self):
factory = sdl2ext.SpriteFactory(sdl2ext.SOFTWARE)
sprite = factory.create_sprite(size=(10, 10), bpp=32)
view = sdl2ext.PixelView(sprite)
view[1] = (0xAABBCCDD, ) * 10
rcolor = sdl2ext.prepare_color(0xAABBCCDD, sprite)
for index, row in enumerate(view):
if index == 1:
for col in row:
assert col == rcolor
else:
for col in row:
assert col == 0x0
def test_SoftwareSpriteRenderSystem_render(self):
sf1 = SDL_CreateRGBSurface(0, 12, 7, 32, 0, 0, 0, 0)
sp1 = sdl2ext.SoftwareSprite(sf1.contents, True)
sdl2ext.fill(sp1, 0xFF0000)
sf2 = SDL_CreateRGBSurface(0, 3, 9, 32, 0, 0, 0, 0)
sp2 = sdl2ext.SoftwareSprite(sf2.contents, True)
sdl2ext.fill(sp2, 0x00FF00)
sprites = [sp1, sp2]
window = sdl2ext.Window("Test", size=(20, 20))
renderer = sdl2ext.SoftwareSpriteRenderSystem(window)
assert isinstance(renderer, sdl2ext.SpriteRenderSystem)
with pytest.raises(AttributeError):
renderer.render(None, None, None)
with pytest.raises(AttributeError):
renderer.render([None, None], None, None)
for x, y in ((0, 0), (3, 3), (20, 20), (1, 12), (5, 6)):
sp1.position = x, y
renderer.render(sp1)
view = sdl2ext.PixelView(renderer.surface)
self.check_pixels(view, 20, 20, sp1, 0xFF0000, (0x0, ))
del view
sdl2ext.fill(renderer.surface, 0x0)
sp1.position = 0, 0
sp2.position = 14, 1
renderer.render(sprites)
view = sdl2ext.PixelView(renderer.surface)
self.check_pixels(view, 20, 20, sp1, 0xFF0000, (0x0, 0x00FF00))
self.check_pixels(view, 20, 20, sp2, 0x00FF00, (0x0, 0xFF0000))
del view
sdl2ext.fill(renderer.surface, 0x0)
renderer.render(sprites, 1, 2)
view = sdl2ext.PixelView(renderer.surface)
self.check_pixels(view, 20, 20, sp1, 0xFF0000, (0x0, 0x00FF00), 1, 2)
self.check_pixels(view, 20, 20, sp2, 0x00FF00, (0x0, 0xFF0000), 1, 2)
del view
def test_SoftwareSpriteRenderSystem_process(self):
sf1 = SDL_CreateRGBSurface(0, 5, 10, 32, 0, 0, 0, 0)
sp1 = sdl2ext.SoftwareSprite(sf1.contents, True)
sp1.depth = 0
sdl2ext.fill(sp1, 0xFF0000)
sf2 = SDL_CreateRGBSurface(0, 5, 10, 32, 0, 0, 0, 0)
sp2 = sdl2ext.SoftwareSprite(sf2.contents, True)
sp2.depth = 99
sdl2ext.fill(sp2, 0x00FF00)
sprites = [sp1, sp2]
window = sdl2ext.Window("Test", size=(20, 20))
renderer = sdl2ext.SoftwareSpriteRenderSystem(window)
renderer.process("fakeworld", sprites)
view = sdl2ext.PixelView(renderer.surface)
# Only sp2 wins, since its depth is higher
self.check_pixels(view, 20, 20, sp1, 0x00FF00, (0x0, ))
self.check_pixels(view, 20, 20, sp2, 0x00FF00, (0x0, ))
del view
self.assertRaises(TypeError, renderer.process, None, None)
