def from_object(self, obj):
"""Creates a Sprite from an arbitrary object."""
if self.sprite_type == TEXTURE:
rw = rwops.rw_from_object(obj)
# TODO: support arbitrary objects.
surface = sdlsurface.load_bmp_rw(rw, True)
s = self.from_surface(surface, True)
elif self.sprite_type == SOFTWARE:
rw = rwops.rw_from_object(obj)
s = SoftwareSprite(sdlsurface.load_bmp_rw(rw, True), True)
return s
def test_rw_seek_tell(self):
data = byteify("A Teststring of length 25", "utf-8")
buf = BytesIO(data)
rw = rwops.rw_from_object(buf)
self.assertIsInstance(rw, rwops.SDL_RWops)
pos = rwops.rw_seek(rw, 0, rwops.RW_SEEK_END)
self.assertTrue(pos == buf.tell() == len(data))
pos = rwops.rw_seek(rw, 0, rwops.RW_SEEK_SET)
self.assertTrue(pos == buf.tell() == 0)
pos = rwops.rw_seek(rw, 15, rwops.RW_SEEK_CUR)
self.assertTrue(pos == buf.tell() == 15)
pos = rwops.rw_seek(rw, -3, rwops.RW_SEEK_CUR)
self.assertTrue(pos == buf.tell() == 12)
pos = rwops.rw_seek(rw, 7, rwops.RW_SEEK_CUR)
self.assertTrue(pos == buf.tell() == 19)
pos = rwops.rw_seek(rw, -11, rwops.RW_SEEK_END)
self.assertTrue(pos == buf.tell() == 14)
pos = rwops.rw_seek(rw, 8, rwops.RW_SEEK_SET)
self.assertTrue(pos == buf.tell() == 8)
pos = rwops.rw_seek(rw, -2, rwops.RW_SEEK_SET)
self.assertEqual(pos, -1)
self.assertTrue(buf.tell() == 8)
pos = rwops.rw_seek(rw, 12, rwops.RW_SEEK_END)
self.assertTrue(pos == buf.tell() == len(data) + 12)
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_load_typed_rw(self):
fname = "surfacetest.%s"
for fmt in formats:
fp = RESOURCES.get(fname % fmt)
sf = sdlimage.load_typed_rw(rwops.rw_from_object(fp), False, fmt.upper())
self.assertIsInstance(sf, surface.SDL_Surface)
surface.free_surface(sf)
def test_read_be_64(self):
data = byteify("A Teststring 64b", "utf-8")
buf = BytesIO(data)
rw = rwops.rw_from_object(buf)
self.assertIsInstance(rw, rwops.SDL_RWops)
ch = rwops.read_be_64(rw)
self.assertEqual(chr(ch & 0x00000000000000FF), "t")
self.assertEqual(chr((ch & 0x000000000000FF00) >> 8), "s")
self.assertEqual(chr((ch & 0x0000000000FF0000) >> 16), "t")
self.assertEqual(chr((ch & 0x00000000FF000000) >> 24), "s")
self.assertEqual(chr((ch & 0x000000FF00000000) >> 32), "e")
self.assertEqual(chr((ch & 0x0000FF0000000000) >> 40), "T")
self.assertEqual(chr((ch & 0x00FF000000000000) >> 48), " ")
self.assertEqual(chr((ch & 0xFF00000000000000) >> 56), "A")
pos = rwops.rw_seek(rw, 8, rwops.RW_SEEK_SET)
self.assertEqual(pos, 8)
ch = rwops.read_be_64(rw)
self.assertEqual(chr(ch & 0x00000000000000FF), "b")
self.assertEqual(chr((ch & 0x000000000000FF00) >> 8), "4")
self.assertEqual(chr((ch & 0x0000000000FF0000) >> 16), "6")
self.assertEqual(chr((ch & 0x00000000FF000000) >> 24), " ")
self.assertEqual(chr((ch & 0x000000FF00000000) >> 32), "g")
self.assertEqual(chr((ch & 0x0000FF0000000000) >> 40), "n")
self.assertEqual(chr((ch & 0x00FF000000000000) >> 48), "i")
self.assertEqual(chr((ch & 0xFF00000000000000) >> 56), "r")
def test_is_pnm(self):
fname = "surfacetest.%s"
for fmt in formats:
imgrw = rwops.rw_from_object(RESOURCES.get(fname % fmt))
if fmt in ("pnm", "pbm", "ppm", "pgm"):
self.assertTrue(sdlimage.is_pnm(imgrw))
else:
self.assertFalse(sdlimage.is_pnm(imgrw))
def test_is_xv(self):
fname = "surfacetest.%s"
for fmt in formats:
imgrw = rwops.rw_from_object(RESOURCES.get(fname % fmt))
if fmt == "xv":
self.assertTrue(sdlimage.is_xv(imgrw))
else:
self.assertFalse(sdlimage.is_xv(imgrw))
def test_rw_close(self):
data = byteify("A Teststring", "utf-8")
buf = BytesIO(data)
rw = rwops.rw_from_object(buf)
self.assertIsInstance(rw, rwops.SDL_RWops)
self.assertEqual(buf.getvalue(), data)
rwops.rw_close(rw)
self.assertRaises(ValueError, buf.getvalue)
def test_load_bmp_rw(self):
imgfile = RESOURCES.get("surfacetest.bmp")
imgrw = rwops.rw_from_object(imgfile)
imgsurface = surface.load_bmp_rw(imgrw, False)
self.assertIsInstance(imgsurface, surface.SDL_Surface)
surface.free_surface(imgsurface)
self.assertRaises(TypeError, surface.load_bmp_rw, "Test")
self.assertRaises(TypeError, surface.load_bmp_rw, None)
self.assertRaises(TypeError, surface.load_bmp_rw, 1234)
def test_load_rw(self):
fname = "surfacetest.%s"
for fmt in formats:
if fmt == "tga":
# SDL_image does not support loading TGA via IMG_Load_RW()
continue
fp = RESOURCES.get(fname % fmt)
sf = sdlimage.load_rw(rwops.rw_from_object(fp), False)
self.assertIsInstance(sf, surface.SDL_Surface)
surface.free_surface(sf)
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_open_font_rw(self):
fp = RESOURCES.get("tuffy.ttf")
fontrw = rwops.rw_from_object(fp)
for x in range(-10, 15):
fp.seek(0)
font = sdlttf.open_font_rw(fontrw, False, x)
self.assertIsInstance(font, sdlttf.TTF_Font)
sdlttf.close_font(font)
fp.seek(0)
self.assertRaises(TypeError, sdlttf.open_font_rw, None, False, None)
self.assertRaises((AttributeError, TypeError),
sdlttf.open_font_rw, None, False, 10)
self.assertRaises(TypeError, sdlttf.open_font_rw, fontrw, False, None)
def test_write_be_16(self):
data = byteify("A Teststring", "utf-8")
buf = BytesIO(data)
rw = rwops.rw_from_object(buf)
self.assertIsInstance(rw, rwops.SDL_RWops)
value = ((ord("q") << 8) | (ord("%")))
rwops.write_be_16(rw, value)
self.assertEqual(stringify(buf.getvalue(), "utf-8"), "q%Teststring")
rwops.rw_seek(rw, 6, rwops.RW_SEEK_SET)
rwops.write_be_16(rw, value)
self.assertEqual(stringify(buf.getvalue(), "utf-8"), "q%Testq%ring")
def test_rw_from_object(self):
buf = BytesIO()
rw = rwops.rw_from_object(buf)
self.assertIsInstance(rw, rwops.SDL_RWops)
for s in("Test", "Test", "Test", "Banana"):
buf.write(byteify(s, "utf-8"))
length = rwops.rw_seek(rw, 0, rwops.RW_SEEK_END)
rwops.rw_seek(rw, 0, rwops.RW_SEEK_SET)
self.assertEqual(len(buf.getvalue()), length)
rwops.rw_close(rw)
self.assertTrue(buf.closed)
self.assertRaises(ValueError, buf.write, "Test")
self.assertRaises(ValueError, buf.getvalue)
def test_read_be_16(self):
data = byteify("A Teststring", "utf-8")
buf = BytesIO(data)
rw = rwops.rw_from_object(buf)
self.assertIsInstance(rw, rwops.SDL_RWops)
ch = rwops.read_be_16(rw)
self.assertEqual(chr(ch & 0x00FF), " ")
self.assertEqual(chr(ch >> 8), "A")
pos = rwops.rw_seek(rw, 8, rwops.RW_SEEK_SET)
self.assertEqual(pos, 8)
ch = rwops.read_be_16(rw)
self.assertEqual(chr(ch & 0x00FF), "i")
self.assertEqual(chr(ch >> 8), "r")
def test_write_be_32(self):
data = byteify("A Teststring", "utf-8")
buf = BytesIO(data)
rw = rwops.rw_from_object(buf)
self.assertIsInstance(rw, rwops.SDL_RWops)
value = ((ord("a") << 24) |
(ord("c") << 16) |
(ord("f") << 8) |
(ord("z"))
)
rwops.write_be_32(rw, value)
self.assertEqual(stringify(buf.getvalue(), "utf-8"), "acfzststring")
rwops.rw_seek(rw, 6, rwops.RW_SEEK_SET)
rwops.write_be_32(rw, value)
self.assertEqual(stringify(buf.getvalue(), "utf-8"), "acfzstacfzng")
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_write_be_64(self):
data = byteify("A Teststring", "utf-8")
buf = BytesIO(data)
rw = rwops.rw_from_object(buf)
self.assertIsInstance(rw, rwops.SDL_RWops)
value = ((ord("q") << 56) |
(ord("w") << 48) |
(ord("b") << 40) |
(ord("k") << 32) |
(ord("a") << 24) |
(ord("c") << 16) |
(ord("f") << 8) |
(ord("z"))
)
rwops.write_be_64(rw, value)
self.assertEqual(stringify(buf.getvalue(), "utf-8"), "qwbkacfzring")
rwops.rw_seek(rw, 4, rwops.RW_SEEK_SET)
rwops.write_be_64(rw, value)
self.assertEqual(stringify(buf.getvalue(), "utf-8"), "qwbkqwbkacfz")
def test_load_xv_rw(self):
fp = RESOURCES.get("surfacetest.xv")
sf = sdlimage.load_xpm_rw(rwops.rw_from_object(fp))
self.assertIsInstance(sf, surface.SDL_Surface)
surface.free_surface(sf)
