716 lines
29 KiB
Python
716 lines
29 KiB
Python
import sys
|
|
import unittest
|
|
from ctypes import ArgumentError, POINTER, byref
|
|
from ..ext.resources import Resources
|
|
from .. import ext as sdl2ext
|
|
from ..surface import SDL_Surface, SDL_CreateRGBSurface, SDL_FreeSurface
|
|
from sdl2.video import SDL_Window, SDL_WINDOW_HIDDEN, SDL_DestroyWindow
|
|
from sdl2.render import SDL_Renderer, SDL_CreateWindowAndRenderer, \
|
|
SDL_DestroyRenderer, SDL_CreateTexture, SDL_Texture, \
|
|
SDL_TEXTUREACCESS_STATIC, SDL_TEXTUREACCESS_STREAMING, \
|
|
SDL_TEXTUREACCESS_TARGET
|
|
|
|
_ISPYPY = hasattr(sys, "pypy_version_info")
|
|
|
|
RESOURCES = Resources(__file__, "resources")
|
|
|
|
if _ISPYPY:
|
|
import gc
|
|
dogc = gc.collect
|
|
else:
|
|
dogc = lambda: None
|
|
|
|
class MSprite(sdl2ext.Sprite):
|
|
def __init__(self, w=0, h=0):
|
|
super(MSprite, self).__init__()
|
|
self._size = w, h
|
|
|
|
@property
|
|
def size(self):
|
|
return self._size
|
|
|
|
|
|
class SDL2ExtSpriteTest(unittest.TestCase):
|
|
__tags__ = ["sdl", "sdl2ext"]
|
|
|
|
def setUp(self):
|
|
sdl2ext.init()
|
|
|
|
def tearDown(self):
|
|
sdl2ext.quit()
|
|
|
|
def check_pixels(self, view, w, h, sprite, c1, c2, cx=0, cy=0):
|
|
msg = "color mismatch at %d,%d: %d not in %s"
|
|
cx = cx + sprite.x
|
|
cy = cy + sprite.y
|
|
cw, ch = sprite.size
|
|
cmy = cy + ch
|
|
cmx = cx + cw
|
|
for y in range(w):
|
|
for x in range(h):
|
|
if cy <= y < cmy and cx <= x < cmx:
|
|
self.assertEqual(view[y][x], c1,
|
|
msg % (x, y, view[y][x], c1))
|
|
else:
|
|
self.assertTrue(view[y][x] in c2,
|
|
msg % (x, y, view[y][x], c2))
|
|
|
|
def check_areas(self, view, w, h, rects, c1, c2):
|
|
def _inarea(x, y, rs):
|
|
for r in rs:
|
|
if (x >= r[0] and x < (r[0] + r[2]) and
|
|
y >= r[1] and y < (r[1] + r[3])):
|
|
return True
|
|
return False
|
|
msg = "color mismatch at %d,%d: %d not in %s"
|
|
for y in range(w):
|
|
for x in range(h):
|
|
if _inarea(x, y, rects):
|
|
self.assertEqual(view[y][x], c1,
|
|
msg % (x, y, view[y][x], c1))
|
|
else:
|
|
self.assertTrue(view[y][x] in c2,
|
|
msg % (x, y, view[y][x], c2))
|
|
|
|
def check_lines(self, view, w, h, points, c1, c2):
|
|
def _online(x, y, pts):
|
|
for p1, p2 in pts:
|
|
if sdl2ext.point_on_line(p1, p2, (x, y)):
|
|
return True
|
|
return False
|
|
msg = "color mismatch at %d,%d: %d not in %s"
|
|
for y in range(w):
|
|
for x in range(h):
|
|
if _online(x, y, points):
|
|
self.assertEqual(view[y][x], c1,
|
|
msg % (x, y, view[y][x], c1))
|
|
else:
|
|
self.assertTrue(view[y][x] in c2,
|
|
msg % (x, y, view[y][x], c2))
|
|
|
|
def test_SpriteFactory(self):
|
|
factory = sdl2ext.SpriteFactory(sdl2ext.SOFTWARE)
|
|
self.assertIsInstance(factory, sdl2ext.SpriteFactory)
|
|
self.assertEqual(factory.default_args, {})
|
|
|
|
factory = sdl2ext.SpriteFactory(sdl2ext.SOFTWARE, bananas="tasty")
|
|
self.assertIsInstance(factory, sdl2ext.SpriteFactory)
|
|
self.assertEqual(factory.default_args, {"bananas": "tasty"})
|
|
|
|
window = sdl2ext.Window("Test", size=(1, 1))
|
|
renderer = sdl2ext.Renderer(window)
|
|
|
|
factory = sdl2ext.SpriteFactory(sdl2ext.TEXTURE, renderer=renderer)
|
|
self.assertIsInstance(factory, sdl2ext.SpriteFactory)
|
|
|
|
factory = sdl2ext.SpriteFactory(sdl2ext.TEXTURE, renderer=renderer)
|
|
self.assertIsInstance(factory, sdl2ext.SpriteFactory)
|
|
self.assertEqual(factory.default_args, {"renderer": renderer})
|
|
|
|
self.assertRaises(ValueError, sdl2ext.SpriteFactory, "Test")
|
|
self.assertRaises(ValueError, sdl2ext.SpriteFactory, -456)
|
|
self.assertRaises(ValueError, sdl2ext.SpriteFactory, 123)
|
|
self.assertRaises(ValueError, sdl2ext.SpriteFactory, sdl2ext.TEXTURE)
|
|
dogc()
|
|
|
|
def test_SpriteFactory_create_sprite(self):
|
|
window = sdl2ext.Window("Test", size=(1, 1))
|
|
renderer = sdl2ext.Renderer(window)
|
|
tfactory = sdl2ext.SpriteFactory(sdl2ext.TEXTURE, renderer=renderer)
|
|
sfactory = sdl2ext.SpriteFactory(sdl2ext.SOFTWARE)
|
|
|
|
for w in range(0, 100):
|
|
for h in range(0, 100):
|
|
for bpp in (1, 4, 8, 12, 15, 16, 24, 32):
|
|
sprite = sfactory.create_sprite(size=(w, h), bpp=bpp)
|
|
self.assertIsInstance(sprite, sdl2ext.SoftwareSprite)
|
|
|
|
if w == 0 or h == 0:
|
|
self.assertRaises(sdl2ext.SDLError, tfactory.create_sprite,
|
|
size=(w, h))
|
|
continue
|
|
sprite = tfactory.create_sprite(size=(w, h))
|
|
self.assertIsInstance(sprite, sdl2ext.TextureSprite)
|
|
dogc()
|
|
|
|
def test_SpriteFactory_create_software_sprite(self):
|
|
factory = sdl2ext.SpriteFactory(sdl2ext.SOFTWARE)
|
|
for w in range(0, 100):
|
|
for h in range(0, 100):
|
|
for bpp in (1, 4, 8, 12, 15, 16, 24, 32):
|
|
sprite = factory.create_software_sprite((w, h), bpp)
|
|
self.assertIsInstance(sprite, sdl2ext.SoftwareSprite)
|
|
|
|
#self.assertRaises(ValueError, factory.create_software_sprite, (-1,-1))
|
|
#self.assertRaises(ValueError, factory.create_software_sprite, (-10,5))
|
|
#self.assertRaises(ValueError, factory.create_software_sprite, (10,-5))
|
|
self.assertRaises(TypeError, factory.create_software_sprite, size=None)
|
|
self.assertRaises(sdl2ext.SDLError, factory.create_software_sprite,
|
|
size=(10, 10), bpp=-1)
|
|
self.assertRaises(TypeError, factory.create_software_sprite, masks=5)
|
|
self.assertRaises((ArgumentError, TypeError),
|
|
factory.create_software_sprite, size=(10, 10),
|
|
masks=(None, None, None, None))
|
|
self.assertRaises((ArgumentError, TypeError),
|
|
factory.create_software_sprite, size=(10, 10),
|
|
masks=("Test", 1, 2, 3))
|
|
dogc()
|
|
|
|
def test_SpriteFactory_create_texture_sprite(self):
|
|
window = sdl2ext.Window("Test", size=(1, 1))
|
|
renderer = sdl2ext.Renderer(window)
|
|
factory = sdl2ext.SpriteFactory(sdl2ext.TEXTURE, renderer=renderer)
|
|
for w in range(1, 100):
|
|
for h in range(1, 100):
|
|
sprite = factory.create_texture_sprite(renderer, size=(w, h))
|
|
self.assertIsInstance(sprite, sdl2ext.TextureSprite)
|
|
del sprite
|
|
|
|
# Test different access flags
|
|
for flag in (SDL_TEXTUREACCESS_STATIC, SDL_TEXTUREACCESS_STREAMING,
|
|
SDL_TEXTUREACCESS_TARGET):
|
|
sprite = factory.create_texture_sprite(renderer, size=(64, 64),
|
|
access=flag)
|
|
self.assertIsInstance(sprite, sdl2ext.TextureSprite)
|
|
del sprite
|
|
dogc()
|
|
|
|
def test_SpriteFactory_from_image(self):
|
|
window = sdl2ext.Window("Test", size=(1, 1))
|
|
renderer = sdl2ext.Renderer(window)
|
|
tfactory = sdl2ext.SpriteFactory(sdl2ext.TEXTURE, renderer=renderer)
|
|
sfactory = sdl2ext.SpriteFactory(sdl2ext.SOFTWARE)
|
|
|
|
for suffix in ("tif", "png", "jpg"):
|
|
imgname = RESOURCES.get_path("surfacetest.%s" % suffix)
|
|
tsprite = tfactory.from_image(imgname)
|
|
self.assertIsInstance(tsprite, sdl2ext.TextureSprite)
|
|
ssprite = sfactory.from_image(imgname)
|
|
self.assertIsInstance(ssprite, sdl2ext.SoftwareSprite)
|
|
|
|
for factory in (tfactory, sfactory):
|
|
self.assertRaises((ArgumentError, ValueError),
|
|
factory.from_image, None)
|
|
#self.assertRaises((IOError, SDLError),
|
|
# factory.from_image, "banana")
|
|
if not _ISPYPY:
|
|
self.assertRaises(ArgumentError, factory.from_image, 12345)
|
|
dogc()
|
|
|
|
@unittest.skip("not implemented")
|
|
def test_SpriteFactory_from_object(self):
|
|
window = sdl2ext.Window("Test", size=(1, 1))
|
|
renderer = sdl2ext.Renderer(window)
|
|
tfactory = sdl2ext.SpriteFactory(sdl2ext.TEXTURE, renderer=renderer)
|
|
sfactory = sdl2ext.SpriteFactory(sdl2ext.SOFTWARE)
|
|
|
|
def test_SpriteFactory_from_surface(self):
|
|
window = sdl2ext.Window("Test", size=(1, 1))
|
|
renderer = sdl2ext.Renderer(window)
|
|
tfactory = sdl2ext.SpriteFactory(sdl2ext.TEXTURE, renderer=renderer)
|
|
sfactory = sdl2ext.SpriteFactory(sdl2ext.SOFTWARE)
|
|
|
|
sf = SDL_CreateRGBSurface(0, 10, 10, 32, 0, 0, 0, 0)
|
|
tsprite = tfactory.from_surface(sf.contents)
|
|
self.assertIsInstance(tsprite, sdl2ext.TextureSprite)
|
|
ssprite = sfactory.from_surface(sf.contents)
|
|
self.assertIsInstance(ssprite, sdl2ext.SoftwareSprite)
|
|
SDL_FreeSurface(sf)
|
|
|
|
for factory in (tfactory, sfactory):
|
|
self.assertRaises((sdl2ext.SDLError, AttributeError, ArgumentError,
|
|
TypeError), factory.from_surface, None)
|
|
self.assertRaises((AttributeError, ArgumentError, TypeError),
|
|
factory.from_surface, "test")
|
|
# TODO: crashes pypy 2.0
|
|
#self.assertRaises((AttributeError, ArgumentError, TypeError),
|
|
# factory.from_surface, 1234)
|
|
dogc()
|
|
|
|
def test_SpriteFactory_from_text(self):
|
|
sfactory = sdl2ext.SpriteFactory(sdl2ext.SOFTWARE)
|
|
fm = sdl2ext.FontManager(RESOURCES.get_path("tuffy.ttf"))
|
|
|
|
# No Fontmanager passed
|
|
self.assertRaises(KeyError, sfactory.from_text, "Test")
|
|
|
|
# Passing various keywords arguments
|
|
sprite = sfactory.from_text("Test", fontmanager=fm)
|
|
self.assertIsInstance(sprite, sdl2ext.SoftwareSprite)
|
|
|
|
sprite = sfactory.from_text("Test", fontmanager=fm, alias="tuffy")
|
|
self.assertIsInstance(sprite, sdl2ext.SoftwareSprite)
|
|
|
|
# Get text from a texture sprite factory
|
|
window = sdl2ext.Window("Test", size=(1, 1))
|
|
renderer = sdl2ext.Renderer(window)
|
|
tfactory = sdl2ext.SpriteFactory(sdl2ext.TEXTURE,
|
|
renderer=renderer,
|
|
fontmanager=fm)
|
|
sprite = tfactory.from_text("Test", alias="tuffy")
|
|
self.assertIsInstance(sprite, sdl2ext.TextureSprite)
|
|
dogc()
|
|
|
|
def test_SpriteRenderSystem(self):
|
|
renderer = sdl2ext.SpriteRenderSystem()
|
|
self.assertIsInstance(renderer, sdl2ext.SpriteRenderSystem)
|
|
self.assertIsNotNone(renderer.sortfunc)
|
|
self.assertTrue(sdl2ext.Sprite in renderer.componenttypes)
|
|
|
|
def test_SpriteRenderSystem_sortfunc(self):
|
|
def func(p):
|
|
pass
|
|
|
|
renderer = sdl2ext.SpriteRenderSystem()
|
|
self.assertIsNotNone(renderer.sortfunc)
|
|
renderer.sortfunc = func
|
|
self.assertEqual(renderer.sortfunc, func)
|
|
|
|
def setf(x, f):
|
|
x.sortfunc = f
|
|
self.assertRaises(TypeError, setf, renderer, None)
|
|
self.assertRaises(TypeError, setf, renderer, "Test")
|
|
self.assertRaises(TypeError, setf, renderer, 1234)
|
|
|
|
@unittest.skip("not implemented")
|
|
def test_SpriteRenderSystem_render(self):
|
|
pass
|
|
|
|
@unittest.skip("not implemented")
|
|
def test_SpriteRenderSystem_process(self):
|
|
pass
|
|
|
|
def test_SoftwareSpriteRenderSystem(self):
|
|
self.assertRaises(TypeError, sdl2ext.SoftwareSpriteRenderSystem)
|
|
self.assertRaises(TypeError, sdl2ext.SoftwareSpriteRenderSystem, None)
|
|
self.assertRaises(TypeError, sdl2ext.SoftwareSpriteRenderSystem,
|
|
"Test")
|
|
self.assertRaises(TypeError, sdl2ext.SoftwareSpriteRenderSystem,
|
|
12345)
|
|
|
|
window = sdl2ext.Window("Test", size=(1, 1))
|
|
renderer = sdl2ext.SoftwareSpriteRenderSystem(window)
|
|
self.assertIsInstance(renderer, sdl2ext.SpriteRenderSystem)
|
|
self.assertEqual(renderer.window, window.window)
|
|
self.assertIsInstance(renderer.surface, SDL_Surface)
|
|
|
|
renderer = sdl2ext.SoftwareSpriteRenderSystem(window.window)
|
|
self.assertIsInstance(renderer, sdl2ext.SpriteRenderSystem)
|
|
self.assertEqual(renderer.window, window.window)
|
|
self.assertIsInstance(renderer.surface, SDL_Surface)
|
|
|
|
self.assertIsNotNone(renderer.sortfunc)
|
|
self.assertFalse(sdl2ext.Sprite in renderer.componenttypes)
|
|
self.assertTrue(sdl2ext.SoftwareSprite in renderer.componenttypes)
|
|
dogc()
|
|
|
|
@unittest.skipIf(_ISPYPY, "PyPy's ctypes can't do byref(value, offset)")
|
|
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)
|
|
self.assertIsInstance(renderer, sdl2ext.SpriteRenderSystem)
|
|
|
|
self.assertRaises(AttributeError, renderer.render, None, None, None)
|
|
self.assertRaises(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
|
|
|
|
@unittest.skipIf(_ISPYPY, "PyPy's ctypes can't do byref(value, offset)")
|
|
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)
|
|
|
|
@unittest.skip("not implemented")
|
|
def test_TextureSpriteRenderSystem(self):
|
|
pass
|
|
|
|
@unittest.skip("not implemented")
|
|
def test_TextureSpriteRenderSystem_render(self):
|
|
pass
|
|
|
|
@unittest.skip("not implemented")
|
|
def test_TextureSpriteRenderSystem_process(self):
|
|
pass
|
|
|
|
def test_Sprite(self):
|
|
sprite = MSprite()
|
|
self.assertIsInstance(sprite, MSprite)
|
|
self.assertIsInstance(sprite, sdl2ext.Sprite)
|
|
|
|
def test_Sprite_position_xy(self):
|
|
sprite = MSprite()
|
|
positions = [(x, y) for x in range(-50, 50) for y in range(-50, 50)]
|
|
for x, y in positions:
|
|
sprite.position = x, y
|
|
self.assertEqual(sprite.position, (x, y))
|
|
sprite.x = x + 1
|
|
sprite.y = y + 1
|
|
self.assertEqual(sprite.position, (x + 1, y + 1))
|
|
|
|
def test_Sprite_area(self):
|
|
for w in range(0, 200):
|
|
for h in range(0, 200):
|
|
sprite = MSprite(w, h)
|
|
self.assertEqual(sprite.size, (w, h))
|
|
self.assertEqual(sprite.area, (0, 0, w, h))
|
|
sprite.position = w, h
|
|
self.assertEqual(sprite.area, (w, h, 2 * w, 2 * h))
|
|
|
|
def test_SoftwareSprite(self):
|
|
self.assertRaises(TypeError, sdl2ext.SoftwareSprite, None, None)
|
|
self.assertRaises(TypeError, sdl2ext.SoftwareSprite, None, True)
|
|
self.assertRaises(TypeError, sdl2ext.SoftwareSprite, None, False)
|
|
|
|
sf = SDL_CreateRGBSurface(0, 10, 10, 32, 0, 0, 0, 0)
|
|
sprite = sdl2ext.SoftwareSprite(sf.contents, False)
|
|
# TODO: the following assert fails...
|
|
# self.assertEqual(sprite.surface, sf.contents)
|
|
self.assertFalse(sprite.free)
|
|
|
|
sprite = sdl2ext.SoftwareSprite(sf.contents, True)
|
|
# TODO: the following assert fails...
|
|
# self.assertEqual(sprite.surface, sf.contents)
|
|
self.assertTrue(sprite.free)
|
|
|
|
def test_SoftwareSprite_repr(self):
|
|
sf = SDL_CreateRGBSurface(0, 10, 10, 32, 0, 0, 0, 0)
|
|
sprite = sdl2ext.SoftwareSprite(sf.contents, True)
|
|
self.assertEqual(repr(sprite), "SoftwareSprite(size=(10, 10), bpp=32)")
|
|
|
|
def test_SoftwareSprite_position_xy(self):
|
|
sf = SDL_CreateRGBSurface(0, 10, 10, 32, 0, 0, 0, 0)
|
|
sprite = sdl2ext.SoftwareSprite(sf.contents, True)
|
|
self.assertIsInstance(sprite, sdl2ext.SoftwareSprite)
|
|
self.assertEqual(sprite.position, (0, 0))
|
|
positions = [(x, y) for x in range(-50, 50) for y in range(-50, 50)]
|
|
for x, y in positions:
|
|
sprite.position = x, y
|
|
self.assertEqual(sprite.position, (x, y))
|
|
sprite.x = x + 1
|
|
sprite.y = y + 1
|
|
self.assertEqual(sprite.position, (x + 1, y + 1))
|
|
|
|
def test_SoftwareSprite_size(self):
|
|
for w in range(0, 200):
|
|
for h in range(0, 200):
|
|
sf = SDL_CreateRGBSurface(0, w, h, 32, 0, 0, 0, 0)
|
|
sprite = sdl2ext.SoftwareSprite(sf.contents, True)
|
|
self.assertIsInstance(sprite, sdl2ext.SoftwareSprite)
|
|
self.assertEqual(sprite.size, (w, h))
|
|
|
|
def test_SoftwareSprite_area(self):
|
|
sf = SDL_CreateRGBSurface(0, 10, 10, 32, 0, 0, 0, 0)
|
|
sprite = sdl2ext.SoftwareSprite(sf.contents, True)
|
|
self.assertEqual(sprite.area, (0, 0, 10, 10))
|
|
|
|
def setarea(s, v):
|
|
s.area = v
|
|
self.assertRaises(AttributeError, setarea, sprite, (1, 2, 3, 4))
|
|
|
|
sprite.position = 7, 3
|
|
self.assertEqual(sprite.area, (7, 3, 17, 13))
|
|
sprite.position = -22, 99
|
|
self.assertEqual(sprite.area, (-22, 99, -12, 109))
|
|
|
|
def test_TextureSprite(self):
|
|
window = POINTER(SDL_Window)()
|
|
renderer = POINTER(SDL_Renderer)()
|
|
SDL_CreateWindowAndRenderer(10, 10, SDL_WINDOW_HIDDEN,
|
|
byref(window), byref(renderer))
|
|
|
|
tex = SDL_CreateTexture(renderer, 0, 0, 10, 10)
|
|
self.assertIsInstance(tex.contents, SDL_Texture)
|
|
sprite = sdl2ext.TextureSprite(tex.contents)
|
|
self.assertIsInstance(sprite, sdl2ext.TextureSprite)
|
|
SDL_DestroyRenderer(renderer)
|
|
SDL_DestroyWindow(window)
|
|
dogc()
|
|
|
|
def test_TextureSprite_position_xy(self):
|
|
window = POINTER(SDL_Window)()
|
|
renderer = POINTER(SDL_Renderer)()
|
|
SDL_CreateWindowAndRenderer(10, 10, SDL_WINDOW_HIDDEN,
|
|
byref(window), byref(renderer))
|
|
tex = SDL_CreateTexture(renderer, 0, 0, 10, 10)
|
|
self.assertIsInstance(tex.contents, SDL_Texture)
|
|
sprite = sdl2ext.TextureSprite(tex.contents)
|
|
self.assertIsInstance(sprite, sdl2ext.TextureSprite)
|
|
self.assertEqual(sprite.position, (0, 0))
|
|
positions = [(x, y) for x in range(-50, 50) for y in range(-50, 50)]
|
|
for x, y in positions:
|
|
sprite.position = x, y
|
|
self.assertEqual(sprite.position, (x, y))
|
|
sprite.x = x + 1
|
|
sprite.y = y + 1
|
|
self.assertEqual(sprite.position, (x + 1, y + 1))
|
|
SDL_DestroyRenderer(renderer)
|
|
SDL_DestroyWindow(window)
|
|
dogc()
|
|
|
|
def test_TextureSprite_size(self):
|
|
window = POINTER(SDL_Window)()
|
|
renderer = POINTER(SDL_Renderer)()
|
|
SDL_CreateWindowAndRenderer(10, 10, SDL_WINDOW_HIDDEN,
|
|
byref(window), byref(renderer))
|
|
for w in range(1, 200):
|
|
for h in range(1, 200):
|
|
tex = SDL_CreateTexture(renderer, 0, 0, w, h)
|
|
self.assertIsInstance(tex.contents, SDL_Texture)
|
|
sprite = sdl2ext.TextureSprite(tex.contents)
|
|
self.assertIsInstance(sprite, sdl2ext.TextureSprite)
|
|
self.assertEqual(sprite.size, (w, h))
|
|
del sprite
|
|
SDL_DestroyRenderer(renderer)
|
|
SDL_DestroyWindow(window)
|
|
dogc()
|
|
|
|
def test_TextureSprite_area(self):
|
|
window = POINTER(SDL_Window)()
|
|
renderer = POINTER(SDL_Renderer)()
|
|
SDL_CreateWindowAndRenderer(10, 10, SDL_WINDOW_HIDDEN,
|
|
byref(window), byref(renderer))
|
|
tex = SDL_CreateTexture(renderer, 0, 0, 10, 20)
|
|
self.assertIsInstance(tex.contents, SDL_Texture)
|
|
sprite = sdl2ext.TextureSprite(tex.contents)
|
|
self.assertIsInstance(sprite, sdl2ext.TextureSprite)
|
|
self.assertEqual(sprite.area, (0, 0, 10, 20))
|
|
|
|
def setarea(s, v):
|
|
s.area = v
|
|
|
|
self.assertRaises(AttributeError, setarea, sprite, (1, 2, 3, 4))
|
|
sprite.position = 7, 3
|
|
self.assertEqual(sprite.area, (7, 3, 17, 23))
|
|
sprite.position = -22, 99
|
|
self.assertEqual(sprite.area, (-22, 99, -12, 119))
|
|
SDL_DestroyRenderer(renderer)
|
|
SDL_DestroyWindow(window)
|
|
dogc()
|
|
|
|
def test_Renderer(self):
|
|
sf = SDL_CreateRGBSurface(0, 10, 10, 32, 0, 0, 0, 0).contents
|
|
|
|
renderer = sdl2ext.Renderer(sf)
|
|
self.assertEqual(renderer.rendertarget, sf)
|
|
self.assertIsInstance(renderer.sdlrenderer.contents, SDL_Renderer)
|
|
del renderer
|
|
|
|
# Deprecated
|
|
renderer = sdl2ext.Renderer(sf)
|
|
self.assertEqual(renderer.rendertarget, sf)
|
|
self.assertIsInstance(renderer.renderer.contents, SDL_Renderer)
|
|
del renderer
|
|
|
|
|
|
sprite = sdl2ext.SoftwareSprite(sf, True)
|
|
renderer = sdl2ext.Renderer(sprite)
|
|
self.assertEqual(renderer.rendertarget, sprite.surface)
|
|
self.assertEqual(renderer.rendertarget, sf)
|
|
self.assertIsInstance(renderer.sdlrenderer.contents, SDL_Renderer)
|
|
del renderer
|
|
dogc()
|
|
|
|
window = sdl2ext.Window("Test", size=(1, 1))
|
|
renderer = sdl2ext.Renderer(window)
|
|
self.assertEqual(renderer.rendertarget, window.window)
|
|
self.assertIsInstance(renderer.sdlrenderer.contents, SDL_Renderer)
|
|
del renderer
|
|
dogc()
|
|
|
|
sdlwindow = window.window
|
|
renderer = sdl2ext.Renderer(sdlwindow)
|
|
self.assertEqual(renderer.rendertarget, sdlwindow)
|
|
self.assertEqual(renderer.rendertarget, window.window)
|
|
self.assertIsInstance(renderer.sdlrenderer.contents, SDL_Renderer)
|
|
del renderer
|
|
del window
|
|
|
|
self.assertRaises(TypeError, sdl2ext.Renderer, None)
|
|
self.assertRaises(TypeError, sdl2ext.Renderer, 1234)
|
|
self.assertRaises(TypeError, sdl2ext.Renderer, "test")
|
|
dogc()
|
|
|
|
@unittest.skipIf(_ISPYPY, "PyPy's ctypes can't do byref(value, offset)")
|
|
def test_Renderer_color(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.color = 0xAABBCCDD
|
|
self.assertEqual(renderer.color, sdl2ext.Color(0xBB, 0xCC, 0xDD, 0xAA))
|
|
renderer.clear()
|
|
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()
|
|
|
|
@unittest.skip("not implemented")
|
|
def test_Renderer_blendmode(self):
|
|
pass
|
|
|
|
@unittest.skipIf(_ISPYPY, "PyPy's ctypes can't do byref(value, offset)")
|
|
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()
|
|
|
|
@unittest.skipIf(_ISPYPY, "PyPy's ctypes can't do byref(value, offset)")
|
|
def test_Renderer_copy(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.copy(sp, (0, 0, w, h), (sp.x, sp.y, w, h))
|
|
view = sdl2ext.PixelView(surface)
|
|
self.check_pixels(view, 128, 128, sp, 0xFF0000, (0x0,))
|
|
del view
|
|
|
|
@unittest.skipIf(_ISPYPY, "PyPy's ctypes can't do byref(value, offset)")
|
|
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
|
|
|
|
@unittest.skip("not implemented")
|
|
def test_Renderer_draw_point(self):
|
|
pass
|
|
|
|
@unittest.skipIf(_ISPYPY, "PyPy's ctypes can't do byref(value, offset)")
|
|
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
|
|
|
|
@unittest.skipIf(_ISPYPY, "PyPy's ctypes can't do byref(value, offset)")
|
|
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
|
|
|
|
|
|
if __name__ == '__main__':
|
|
sys.exit(unittest.main())
|