def test_lock_unlock_MUSTLOCK_surface(self):
colormods = ((0, 0, 0),
(32, 64, 128),
(10, 20, 30),
(1, 2, 4),
(255, 255, 255),
(128, 128, 128),
(127, 127, 127),
)
for fmt in pixels.ALL_PIXELFORMATS:
if pixels.SDL_ISPIXELFORMAT_FOURCC(fmt):
continue
bpp, rmask, gmask, bmask, amask = \
pixels.pixelformat_enum_to_masks(fmt)
sf = surface.create_rgb_surface(10, 10, bpp, rmask, gmask, bmask,
amask)
# TODO: locking seems to be only necessary for RLE surfaces...
if surface.SDL_MUSTLOCK(sf):
self.assertFalse(sf.locked)
surface.lock_surface(sf)
self.assertTrue(sf.locked)
surface.lock_surface(sf)
self.assertTrue(sf.locked)
surface.lock_surface(sf)
self.assertTrue(sf.locked)
surface.unlock_surface(sf)
self.assertTrue(sf.locked)
surface.unlock_surface(sf)
self.assertTrue(sf.locked)
surface.unlock_surface(sf)
self.assertFalse(sf.locked)
surface.free_surface(sf)
def test_render_draw_point(self):
points = ((-4, -3), (-4, 3), (4, -3),
(0, 0), (1, 1), (10, 10), (99, 99),
(4, 22), (57, 88), (45, 15),
(100, 100)
)
r, g, b, a = 0xAA, 0xBB, 0xCC, 0xDD
w, h = 100, 100
sf = surface.create_rgb_surface(w, h, 32, 0xFF000000, 0x00FF0000,
0x0000FF00, 0x000000FF)
color = pixels.map_rgba(sf.format, r, g, b, a)
renderer = render.create_software_renderer(sf)
render.set_render_draw_color(renderer, r, g, b, a)
for x, y in points:
render.render_draw_point(renderer, x, y)
render.render_present(renderer)
view = pvid.PixelView(sf)
for x, y in points:
npx = max(x + 1, w)
npy = max(y + 1, h)
ppx = max(x - 1, 0)
ppy = max(y - 1, 0)
if x < 0 or x >= w or y < 0 or y >= h:
continue
self.assertEqual(hex(view[y][x]), hex(color))
if (npx, npy) not in points:
self.assertNotEqual(hex(view[npy][npx]), hex(color))
if (ppx, ppy) not in points:
self.assertNotEqual(hex(view[ppy][ppx]), hex(color))
render.destroy_renderer(renderer)
del view
surface.free_surface(sf)
def test_get_set_color_key(self):
colorkeys = ((0, 0, 0),
(32, 64, 128),
(10, 20, 30),
(1, 2, 4),
(255, 255, 255),
(128, 128, 128),
(127, 127, 127),
)
for fmt in pixels.ALL_PIXELFORMATS:
if pixels.SDL_ISPIXELFORMAT_FOURCC(fmt):
continue
pformat = pixels.alloc_format(fmt)
bpp, rmask, gmask, bmask, amask = \
pixels.pixelformat_enum_to_masks(fmt)
sf = surface.create_rgb_surface(10, 10, bpp, rmask, gmask, bmask,
amask)
for r, g, b in colorkeys:
key = pixels.map_rgb(pformat, r, g, b)
surface.set_color_key(sf, 1, key)
skey = surface.get_color_key(sf)
self.assertEqual(skey, key,
"Could not set color key (%d, %d, %d)" % (r, g, b))
pixels.free_format(pformat)
surface.free_surface(sf)
def test_get_set_clip_rect(self):
rectlist = ((rect.SDL_Rect(0, 0, 0, 0), False, False),
(rect.SDL_Rect(2, 2, 0, 0), False, False),
(rect.SDL_Rect(2, 2, 5, 1), True, True),
(rect.SDL_Rect(6, 5, 10, 3), True, False),
(rect.SDL_Rect(0, 0, 10, 10), True, True),
(rect.SDL_Rect(0, 0, -10, 10), False, False),
(rect.SDL_Rect(0, 0, -10, -10), False, False),
(rect.SDL_Rect(-10, -10, 10, 10), False, False),
(rect.SDL_Rect(10, -10, 10, 10), False, False),
(rect.SDL_Rect(10, 10, 10, 10), True, False)
)
sf = surface.create_rgb_surface(15, 15, 32)
clip = surface.get_clip_rect(sf)
self.assertIsInstance(clip, rect.SDL_Rect)
self.assertEqual(clip, rect.SDL_Rect(0, 0, 15, 15))
for r, clipsetval, cmpval in rectlist:
retval = surface.set_clip_rect(sf, r)
clip = surface.get_clip_rect(sf)
self.assertEqual(retval, clipsetval,
"Could not set clip rect %s" % r)
self.assertEqual(clip == r, cmpval,
"Could not set clip rect %s" % r)
surface.free_surface(sf)
def __init__(self, w = None, h = None, data_ptr = None, surface = None,
filename = None, filedata = None):
self.do_free = True
if filedata is not None:
if type(filedata) is bytes:
imagedata = bytearray(filedata)
if type(filedata) is bytearray:
rwops = sdlrwops.rw_from_mem(bar2voidp(filedata).value, len(filedata))
elif hasattr(filedata, "seek"):
rwops = sdlrwops.rw_from_object(filedata)
else:
raise TypeError("unusable data type {}", str(type(filedata)))
self._surf = sdlimage.load_rw(rwops, 1)
elif isinstance(filename, str):
self._surf = sdlimage.load(filename)
elif isinstance(w, int) and isinstance(h, int):
masks = list(sdlpixels.pixelformat_enum_to_masks(self.sdl_pixel_fmt))
bpp = masks.pop(0)
if data_ptr is None:
self._surf = sdlsurface.create_rgb_surface(w, h, bpp, *masks)
else: # data_ptr == ABGR8888
self._surf = sdlsurface.create_rgb_surface_from(data_ptr, w, h, bpp, w*4, *masks)
elif isinstance(surface, SDL_Surface):
self.do_free = False
self._surf = surface
else:
raise TypeError("Crazy shit in parameters: ({} {} {} {} {})".format(type(w),
type(h), type(data_ptr), type(surface), type(filename)))
sdlsurface.set_surface_blend_mode(self._surf, sdlvideo.SDL_BLENDMODE_NONE)
def test_fill_rects(self):
rectlist = (rect.SDL_Rect(0, 0, 0, 0),
rect.SDL_Rect(0, 0, 10, 10),
rect.SDL_Rect(0, 0, -10, 10),
rect.SDL_Rect(0, 0, -10, -10),
rect.SDL_Rect(-10, -10, 10, 10),
rect.SDL_Rect(10, -10, 10, 10),
rect.SDL_Rect(10, 10, 10, 10),
)
for fmt in pixels.ALL_PIXELFORMATS:
if pixels.SDL_ISPIXELFORMAT_FOURCC(fmt):
continue
if pixels.SDL_BITSPERPIXEL(fmt) < 8:
continue # Skip < 8bpp, SDL_FillRect does not work on those
for w in range(1, 100, 5):
for h in range(1, 100, 5):
bpp, rmask, gmask, bmask, amask = \
pixels.pixelformat_enum_to_masks(fmt)
sf = surface.create_rgb_surface(w, h, bpp, rmask, gmask,
bmask, amask)
self.assertIsInstance(sf, surface.SDL_Surface)
# TODO: check for changed pixels
surface.fill_rects(sf, rectlist, 0xff00ff00)
surface.free_surface(sf)
def test_load_texture(self):
sf = surface.create_rgb_surface(10, 10, 32)
rd = render.create_software_renderer(sf)
fname = "surfacetest.%s"
for fmt in formats:
filename = RESOURCES.get_path(fname % fmt)
tex = sdlimage.load_texture(rd, filename)
self.assertIsInstance(tex, render.SDL_Texture)
render.destroy_texture(tex)
self.assertRaises(sdl.SDLError, sdlimage.load_texture, rd, RESOURCES.get_path("rwopstest.txt"))
self.assertRaises(sdl.SDLError, sdlimage.load_texture, rd, None)
self.assertRaises(sdl.SDLError, sdlimage.load_texture, rd, 1234)
self.assertRaises(
(AttributeError, TypeError), sdlimage.load_texture, None, RESOURCES.get_path("surfacetest.bmp")
)
self.assertRaises(
(AttributeError, TypeError), sdlimage.load_texture, "Test", RESOURCES.get_path("surfacetest.bmp")
)
self.assertRaises(
(AttributeError, TypeError), sdlimage.load_texture, 1234, RESOURCES.get_path("surfacetest.bmp")
)
render.destroy_renderer(rd)
surface.free_surface(sf)
def test_create_texture_from_surface(self):
sf = surface.create_rgb_surface(100, 100, 32, 0xFF000000, 0x00FF0000,
0x0000FF00, 0x000000FF)
window = video.create_window("Test", 10, 10, 10, 10,
video.SDL_WINDOW_HIDDEN)
self.assertIsInstance(window, video.SDL_Window)
renderer = render.create_renderer(window, -1,
render.SDL_RENDERER_SOFTWARE)
self.assertIsInstance(renderer, render.SDL_Renderer)
def test_create_rgb_surface(self):
for w in range(1, 100, 5):
for h in range(1, 100, 5):
for bpp in alldepths:
sf = surface.create_rgb_surface(w, h, bpp)
self.assertIsInstance(sf, surface.SDL_Surface)
surface.free_surface(sf)
for fmt in pixels.ALL_PIXELFORMATS:
if pixels.SDL_ISPIXELFORMAT_FOURCC(fmt):
continue
for w in range(1, 100, 5):
for h in range(1, 100, 5):
bpp, rmask, gmask, bmask, amask = \
pixels.pixelformat_enum_to_masks(fmt)
sf = surface.create_rgb_surface(w, h, bpp, rmask, gmask,
bmask, amask)
self.assertIsInstance(sf, surface.SDL_Surface)
surface.free_surface(sf)
# Broken ones
# sizes = [(0, 0), (65536, 65536)]
# for (w, h) in sizes:
# for bpp in alldepths:
# print w, h, bpp
# sf = surface.create_rgb_surface(w, h, bpp)
# self.assertIsInstance(sf, surface.SDL_Surface)
# surface.free_surface(sf)
# TODO: raises a SDL Out of memory error, but 65536 works?!
#
# sf = surface.create_rgb_surface(65535, 65535, 32)
# self.assertIsInstance(sf, surface.SDL_Surface)
self.assertRaises(sdl.SDLError, surface.create_rgb_surface, 1, 1, 66)
self.assertRaises(sdl.SDLError, surface.create_rgb_surface, 1, 1, 0)
self.assertRaises(sdl.SDLError, surface.create_rgb_surface, 1, 1, 8,
0xf0, 0x0f, 0x01, 0x02)
self.assertRaises(sdl.SDLError, surface.create_rgb_surface, 1, 1, 16,
0xf0, 0x0f, 0x01, 0x02)
self.assertRaises(sdl.SDLError, surface.create_rgb_surface, 1, 1, 24,
0xf0, 0x0f, 0x01, 0x02)
self.assertRaises(sdl.SDLError, surface.create_rgb_surface, 1, 1, 32,
0xf0, 0x0f, 0x01, 0x02)
def test_blit_surface(self):
bpp = 32
w, h = 10, 10
# no alpha to prevent blending
masks = (0xFF000000, 0x00FF0000, 0x0000FF00, 0x00000000)
dest = surface.create_rgb_surface(w, h, bpp, masks[0], masks[1],
masks[2], masks[3])
pixelsize = h * dest.pitch
rowlen = dest.pitch // 4
sources = []
for width, height in blitsizes:
src = surface.create_rgb_surface(width, height, bpp, masks[0],
masks[1], masks[2], masks[3])
surface.fill_rect(src, None, 0xFFFFFFFF) # fill with white
sources.append(src)
for src in sources:
for pos in blitpositions:
drect = pos.__copy__()
surface.fill_rect(dest, None, 0x0) # fill with black
surface.blit_surface(src, None, dest, drect)
buf = ctypes.cast(dest.pixels,
ctypes.POINTER(ctypes.c_ubyte * pixelsize))
pbuf = pgarray.CTypesView(buf.contents, itemsize=1,
objsize=pixelsize)
iview = pbuf.to_uint32()
pw = drect.x + drect.w
ph = drect.y + drect.h
for y in range(dest.size[1]):
for x in range(dest.size[0]):
col = iview[y * rowlen + x]
if y >= drect.y and y < ph and \
x >= drect.x and x < pw:
self.assertEqual(col, 0xFFFFFFFF, msg="""color
mismatch at %d,%d for %s: %d != %d""" % (y, x, pos, col, 0xFFFFFFFF))
else:
self.assertEqual(col, 0x0, msg="""color mismatch
at %d,%d for %s: %d != %d""" % (y, x, pos, col, 0x0))
while len(sources) > 0:
sf = sources.pop()
surface.free_surface(sf)
surface.free_surface(dest)
def test_create_software_renderer(self):
sf = surface.create_rgb_surface(100, 100, 32, 0xFF000000, 0x00FF0000,
0x0000FF00, 0x000000FF)
renderer = render.create_software_renderer(sf)
self.assertIsInstance(renderer, render.SDL_Renderer)
render.destroy_renderer(renderer)
surface.free_surface(sf)
self.assertRaises((AttributeError, TypeError),
render.create_software_renderer, None)
self.assertRaises((AttributeError, TypeError),
render.create_software_renderer, 1234)
def test_load_texture_typed_rw(self):
sf = surface.create_rgb_surface(10, 10, 32)
rd = render.create_software_renderer(sf)
fname = "surfacetest.%s"
for fmt in formats:
fp = RESOURCES.get(fname % fmt)
tex = sdlimage.load_texture_typed_rw(rd, rwops.rw_from_object(fp), False, fmt.upper())
self.assertIsInstance(tex, render.SDL_Texture)
render.destroy_texture(tex)
render.destroy_renderer(rd)
surface.free_surface(sf)
def test_SoftwareSprite_area(self):
sf = create_rgb_surface(10, 10, 32)
sprite = video.SoftwareSprite(sf, 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_SoftwareSprite_position_xy(self):
sf = create_rgb_surface(10, 10, 32)
sprite = video.SoftwareSprite(sf, True)
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 create_software_sprite(self, size=(0, 0), bpp=32, masks=None):
"""Creates a software sprite.
A size tuple containing the width and height of the sprite and a
bpp value, indicating the bits per pixel to be used, need to be
provided.
"""
if masks:
rmask, gmask, bmask, amask = masks
else:
rmask = gmask = bmask = amask = 0
surface = sdlsurface.create_rgb_surface(size[0], size[1], bpp, rmask, gmask, bmask, amask)
return SoftwareSprite(surface, True)
def test_SoftwareSprite(self):
self.assertRaises(TypeError, video.SoftwareSprite, None, None)
self.assertRaises(TypeError, video.SoftwareSprite, None, True)
self.assertRaises(TypeError, video.SoftwareSprite, None, False)
sf = create_rgb_surface(10, 10, 32)
sprite = video.SoftwareSprite(sf, False)
self.assertEqual(sprite.surface, sf)
self.assertFalse(sprite.free)
sprite = video.SoftwareSprite(sf, True)
self.assertEqual(sprite.surface, sf)
self.assertTrue(sprite.free)
def test_SoftwareSpriteRenderer_render(self):
sf1= create_rgb_surface(12, 7, 32)
sp1 = video.SoftwareSprite(sf1, True)
video.fill(sp1, 0xFF0000)
sf2 = create_rgb_surface(3, 9, 32)
sp2 = video.SoftwareSprite(sf2, True)
video.fill(sp2, 0x00FF00)
sprites = [sp1, sp2]
window = video.Window("Test", size=(20, 20))
renderer = video.SoftwareSpriteRenderer(window)
self.assertIsInstance(renderer, video.SpriteRenderer)
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 = video.PixelView(renderer.surface)
self.check_pixels(view, 20, 20, sp1, 0xFF0000, (0x0, ))
del view
video.fill(renderer.surface, 0x0)
sp1.position = 0, 0
sp2.position = 14, 1
renderer.render(sprites)
view = video.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
video.fill(renderer.surface, 0x0)
renderer.render(sprites, 1, 2)
view = video.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_SoftwareSpriteRenderer_process(self):
sf1= create_rgb_surface(5, 10, 32)
sp1 = video.SoftwareSprite(sf1, True)
sp1.depth = 0
video.fill(sp1, 0xFF0000)
sf2 = create_rgb_surface(5, 10, 32)
sp2 = video.SoftwareSprite(sf2, True)
sp2.depth = 99
video.fill(sp2, 0x00FF00)
sprites = [sp1, sp2]
window = video.Window("Test", size=(20, 20))
renderer = video.SoftwareSpriteRenderer(window)
renderer.process("fakeworld", sprites)
view = video.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)
def test_convert_surface(self):
pfmt = pixels.alloc_format(pixels.SDL_PIXELFORMAT_RGB444)
for fmt in pixels.ALL_PIXELFORMATS:
if pixels.SDL_ISPIXELFORMAT_FOURCC(fmt):
continue
if fmt in (pixels.SDL_PIXELFORMAT_RGB332,
pixels.SDL_PIXELFORMAT_ARGB2101010):
# SDL2 segfault in the DUFFS_LOOOP() macros
# http://bugzilla.libsdl.org/show_bug.cgi?id=1534
continue
bpp, rmask, gmask, bmask, amask = \
pixels.pixelformat_enum_to_masks(fmt)
sf = surface.create_rgb_surface(10, 20, bpp, rmask, gmask,
bmask, amask)
self.assertIsInstance(sf, surface.SDL_Surface)
csf = surface.convert_surface(sf, pfmt, 0)
self.assertIsInstance(csf, surface.SDL_Surface)
surface.free_surface(sf)
surface.free_surface(csf)
sf = surface.create_rgb_surface(10, 10, 32, 0, 0, 0)
self.assertRaises((AttributeError, TypeError),
surface.convert_surface, None, None, None)
self.assertRaises((AttributeError, TypeError),
surface.convert_surface, sf, None, None)
self.assertRaises((AttributeError, TypeError),
surface.convert_surface, sf, "Test", 0)
self.assertRaises((AttributeError, TypeError),
surface.convert_surface, sf, 12345, 0)
self.assertRaises((AttributeError, TypeError),
surface.convert_surface, None, pfmt, 0)
self.assertRaises((AttributeError, TypeError),
surface.convert_surface, "Test", pfmt, 0)
self.assertRaises((AttributeError, TypeError),
surface.convert_surface, 12345, pfmt, 0)
pixels.free_format(pfmt)
surface.free_surface(sf)
def test_get_set_surface_alpha_mod(self):
for fmt in pixels.ALL_PIXELFORMATS:
if pixels.SDL_ISPIXELFORMAT_FOURCC(fmt):
continue
bpp, rmask, gmask, bmask, amask = \
pixels.pixelformat_enum_to_masks(fmt)
sf = surface.create_rgb_surface(10, 10, bpp, rmask, gmask, bmask,
amask)
salpha = surface.get_surface_alpha_mod(sf)
self.assertEqual(salpha, 255)
for alpha in range(0, 255):
surface.set_surface_alpha_mod(sf, alpha)
salpha = surface.get_surface_alpha_mod(sf)
self.assertEqual(salpha, alpha)
surface.free_surface(sf)
def from_color(self, color, size=(0, 0), bpp=32, masks=None):
"""Creates a sprite with a certain color.
"""
color = convert_to_color(color)
if masks:
rmask, gmask, bmask, amask = masks
else:
rmask = gmask = bmask = amask = 0
sf = sdlsurface.create_rgb_surface(size[0], size[1], bpp, rmask, gmask, bmask, amask)
fmt = sf.format
if fmt.Amask != 0:
# Target has an alpha mask
c = pixels.map_rgba(fmt, color.r, color.g, color.b, color.a)
else:
c = pixels.map_rgb(fmt, color.r, color.g, color.b)
sdlsurface.fill_rect(sf, None, c)
return self.from_surface(sf, True)
def test_load_texture_rw(self):
sf = surface.create_rgb_surface(10, 10, 32)
rd = render.create_software_renderer(sf)
fname = "surfacetest.%s"
for fmt in formats:
if fmt == "tga":
# SDL_image does not support loading TGA via
# IMG_LoadTexture_RW()
continue
fp = RESOURCES.get(fname % fmt)
tex = sdlimage.load_texture_rw(rd, rwops.rw_from_object(fp), False)
self.assertIsInstance(tex, render.SDL_Texture)
render.destroy_texture(tex)
render.destroy_renderer(rd)
surface.free_surface(sf)
def test_set_window_icon(self):
sf = surface.create_rgb_surface(16, 16, 16, 0xF000, 0x0F00,
0x00F0, 0x000F)
self.assertIsInstance(sf, surface.SDL_Surface)
window = video.create_window("Test", 10, 10, 10, 10, 0)
video.set_window_icon(window, sf)
self.assertRaises((AttributeError, TypeError),
video.set_window_icon, None, None)
self.assertRaises((AttributeError, TypeError),
video.set_window_icon, window, None)
self.assertRaises((AttributeError, TypeError),
video.set_window_icon, None, sf)
self.assertRaises((AttributeError, TypeError),
video.set_window_icon, window, "Test")
self.assertRaises((AttributeError, TypeError),
video.set_window_icon, window, 123456)
def test_get_set_surface_blend_mode(self):
modes = (video.SDL_BLENDMODE_NONE,
video.SDL_BLENDMODE_BLEND,
video.SDL_BLENDMODE_ADD,
video.SDL_BLENDMODE_MOD
)
for fmt in pixels.ALL_PIXELFORMATS:
if pixels.SDL_ISPIXELFORMAT_FOURCC(fmt):
continue
bpp, rmask, gmask, bmask, amask = \
pixels.pixelformat_enum_to_masks(fmt)
sf = surface.create_rgb_surface(10, 10, bpp, rmask, gmask, bmask,
amask)
for mode in modes:
surface.set_surface_blend_mode(sf, mode)
smode = surface.get_surface_blend_mode(sf)
self.assertEqual(smode, mode)
surface.free_surface(sf)
def test_convert_surface_format(self):
pfmt = pixels.SDL_PIXELFORMAT_RGB444
for fmt in pixels.ALL_PIXELFORMATS:
if pixels.SDL_ISPIXELFORMAT_FOURCC(fmt):
continue
if fmt in (pixels.SDL_PIXELFORMAT_RGB332,
pixels.SDL_PIXELFORMAT_ARGB2101010):
# SDL2 segault in the DUFFS_LOOP() macros
# http://bugzilla.libsdl.org/show_bug.cgi?id=1534
continue
bpp, rmask, gmask, bmask, amask = \
pixels.pixelformat_enum_to_masks(fmt)
sf = surface.create_rgb_surface(10, 20, bpp, rmask, gmask,
bmask, amask)
self.assertIsInstance(sf, surface.SDL_Surface)
csf = surface.convert_surface_format(sf, pfmt, 0)
self.assertIsInstance(csf, surface.SDL_Surface)
surface.free_surface(sf)
surface.free_surface(csf)
def test_SpriteFactory_from_surface(self):
window = video.Window("Test", size=(1, 1))
renderer = video.RenderContext(window)
tfactory = video.SpriteFactory(video.TEXTURE, renderer=renderer)
sfactory = video.SpriteFactory(video.SOFTWARE)
sf = create_rgb_surface(10, 10, 32)
tsprite = tfactory.from_surface(sf)
self.assertIsInstance(tsprite, video.TextureSprite)
ssprite = sfactory.from_surface(sf)
self.assertIsInstance(ssprite, video.SoftwareSprite)
del sf
for factory in (tfactory, sfactory):
self.assertRaises((AttributeError, ArgumentError, TypeError),
factory.from_surface, None)
self.assertRaises((AttributeError, ArgumentError, TypeError),
factory.from_surface, "test")
self.assertRaises((AttributeError, ArgumentError, TypeError),
factory.from_surface, 1234)
def test_set_surface_palette(self):
invpalette = pixels.alloc_palette(10)
palette = pixels.alloc_palette(1 << 16)
sf = surface.create_rgb_surface(10, 10, 16)
self.assertRaises((AttributeError, TypeError),
surface.set_surface_palette, None, None)
self.assertRaises((AttributeError, TypeError),
surface.set_surface_palette, None, palette)
self.assertIsNone(sf.format.palette)
surface.set_surface_palette(sf, palette)
self.assertIsNotNone(sf.format.palette)
self.assertRaises(sdl.SDLError, surface.set_surface_palette, sf,
invpalette)
self.assertIsNotNone(sf.format.palette)
surface.set_surface_palette(sf, None)
self.assertIsNone(sf.format.palette)
surface.free_surface(sf)
pixels.free_palette(invpalette)
pixels.free_palette(palette)
def test_get_set_surface_color_mod(self):
colormods = ((0, 0, 0),
(32, 64, 128),
(10, 20, 30),
(1, 2, 4),
(255, 255, 255),
(128, 128, 128),
(127, 127, 127),
)
for fmt in pixels.ALL_PIXELFORMATS:
if pixels.SDL_ISPIXELFORMAT_FOURCC(fmt):
continue
bpp, rmask, gmask, bmask, amask = \
pixels.pixelformat_enum_to_masks(fmt)
sf = surface.create_rgb_surface(10, 10, bpp, rmask, gmask, bmask,
amask)
for r, g, b in colormods:
surface.set_surface_color_mod(sf, r, g, b)
sr, sg, sb = surface.get_surface_color_mod(sf)
self.assertEqual((sr, sg, sb), (r, g, b))
surface.free_surface(sf)
def test_free_surface(self):
self.assertRaises((AttributeError, TypeError),
surface.free_surface, None)
self.assertRaises((AttributeError, TypeError),
surface.free_surface, "Test")
self.assertRaises((AttributeError, TypeError),
surface.free_surface, 5)
formats = (pixels.SDL_PIXELFORMAT_INDEX1LSB,
pixels.SDL_PIXELFORMAT_RGB332,
pixels.SDL_PIXELFORMAT_RGBA4444,
pixels.SDL_PIXELFORMAT_BGR888,
pixels.SDL_PIXELFORMAT_ARGB8888,
pixels.SDL_PIXELFORMAT_ARGB2101010
)
for fmt in formats:
bpp, rmask, gmask, bmask, amask = \
pixels.pixelformat_enum_to_masks(fmt)
sf = surface.create_rgb_surface(5, 5, bpp, rmask, gmask, bmask,
amask)
surface.free_surface(sf)
def test_set_window_shape(self):
sf = surface.create_rgb_surface(10, 10, 32)
mode = shape.SDL_WindowShapeMode()
mode.mode = shape.ShapeModeDefault
mode.parameters = shape.SDL_WindowShapeParams()
mode.parameters.binarizationCutoff = 1
flags = (video.SDL_WINDOW_HIDDEN, )
for flag in flags:
# TODO: find out, how shaping is supposed to work :-)
# window = shape.create_shaped_window("Test", 10, 10, 10, 10, flag)
# self.assertIsInstance(window, video.SDL_Window)
# self.assertTrue(shape.is_shaped_window(window))
# self.assertRaises(TypeError, shape.set_window_shape,
# None, None, None)
# self.assertRaises(TypeError, shape.set_window_shape,
# window, None, None)
# self.assertRaises(TypeError, shape.set_window_shape,
# window, sf, None)
# self.assertRaises(TypeError, shape.set_window_shape,
# "Test", sf, mode)
# self.assertRaises(TypeError, shape.set_window_shape,
# window, 12345, mode)
# self.assertRaises(TypeError, shape.set_window_shape,
# window, sf, "Test")
# shape.set_window_shape(window, sf, mode)
# wmode = shape.get_shaped_window_mode(window)
# self.assertEqual(wmode.mode, mode.mode)
# self.assertEqual(wmode.parameters.binarizationCutoff,
# mode.parameters.binarizationCutoff)
# video.destroy_window(window)
window = video.create_window("Test", 10, 10, 10, 10, flag)
self.assertIsInstance(window, video.SDL_Window)
self.assertRaises(sdl.SDLError, shape.set_window_shape,
window, sf, mode)
video.destroy_window(window)
