def test_SDL_ConvertSurfaceFormat(self):
tenbit = [
pixels.SDL_PACKEDLAYOUT_2101010, pixels.SDL_PACKEDLAYOUT_1010102
]
for pfmt in pixels.ALL_PIXELFORMATS:
for fmt in pixels.ALL_PIXELFORMATS:
# SDL2 doesn't support converting fancier formats (e.g YUV, 10bit)
if pixels.SDL_ISPIXELFORMAT_FOURCC(
pfmt) or pixels.SDL_PIXELLAYOUT(pfmt) in tenbit:
continue
if pixels.SDL_ISPIXELFORMAT_FOURCC(
fmt) or pixels.SDL_PIXELLAYOUT(fmt) in tenbit:
continue
# SDL2 doesn't support converting to formats w/ less than 8 bpp
if pixels.SDL_BITSPERPIXEL(pfmt) < 8:
continue
# SDL2 doesn't support converting from indexed formats w/ 4 bpp
if pixels.SDL_PIXELTYPE(fmt) == pixels.SDL_PIXELTYPE_INDEX4:
continue
bpp = c_int()
rmask, gmask, bmask, amask = Uint32(), Uint32(), Uint32(
), Uint32()
ret = pixels.SDL_PixelFormatEnumToMasks(
fmt, byref(bpp), byref(rmask), byref(gmask), byref(bmask),
byref(amask))
assert ret == SDL_TRUE
sf = surface.SDL_CreateRGBSurface(0, 10, 20, bpp, rmask, gmask,
bmask, amask)
assert isinstance(sf.contents, surface.SDL_Surface)
csf = surface.SDL_ConvertSurfaceFormat(sf, pfmt, 0)
assert csf, error.SDL_GetError()
assert isinstance(csf.contents, surface.SDL_Surface)
surface.SDL_FreeSurface(sf)
surface.SDL_FreeSurface(csf)
def test_rotateSurface90Degrees(self):
w, h = 470, 530
sf = surface.SDL_CreateRGBSurface(0, w, h, 32, 0, 0, 0, 0)
assert isinstance(sf.contents, surface.SDL_Surface)
rotsf = sdlgfx.rotateSurface90Degrees(sf, 1)
assert isinstance(rotsf.contents, surface.SDL_Surface)
assert rotsf.contents.w == h
assert rotsf.contents.h == w
surface.SDL_FreeSurface(rotsf)
surface.SDL_FreeSurface(sf)
def test_rotateSurface90Degrees(self):
w, h = 470, 530
sf = surface.SDL_CreateRGBSurface(0, w, h, 32, 0, 0, 0, 0)
self.assertIsInstance(sf.contents, surface.SDL_Surface)
rotsf = sdlgfx.rotateSurface90Degrees(sf, 1)
self.assertIsInstance(rotsf.contents, surface.SDL_Surface)
self.assertEqual(rotsf.contents.w, h)
self.assertEqual(rotsf.contents.h, w)
surface.SDL_FreeSurface(rotsf)
surface.SDL_FreeSurface(sf)
def test_IMG_LoadTexture_RW(self):
sf = surface.SDL_CreateRGBSurface(0, 10, 10, 32, 0, 0, 0, 0)
rd = render.SDL_CreateSoftwareRenderer(sf)
fname = "surfacetest.%s"
for fmt in formats:
if fmt == "tga":
# SDL_image does not support loading TGA via
# IMG_LoadTexture_RW()
continue
if fmt in ("svg", "webp"):
# FIXME: svg and webp crashes with SDL2_image 2.0.2
continue
filename = os.path.join(os.path.dirname(os.path.abspath(__file__)),
"resources", fname % fmt)
print(filename)
with open(filename, "rb") as fp:
tex = sdlimage.IMG_LoadTexture_RW(rd, rwops.rw_from_object(fp),
0)
self.assertIsNotNone(tex)
self.assertIsInstance(tex.contents, render.SDL_Texture)
render.SDL_DestroyTexture(tex)
render.SDL_DestroyRenderer(rd)
surface.SDL_FreeSurface(sf)
def test_IMG_LoadXV_RW(self):
testdir = os.path.dirname(os.path.abspath(__file__))
fp = open(os.path.join(testdir, "resources", "surfacetest.xv"), "rb")
sf = sdlimage.IMG_LoadXV_RW(rwops.rw_from_object(fp))
fp.close()
self.assertIsInstance(sf.contents, surface.SDL_Surface)
surface.SDL_FreeSurface(sf)
def test_SDL_RenderDrawPoint(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.SDL_CreateRGBSurface(0, w, h, 32, 0xFF000000, 0x00FF0000,
0x0000FF00, 0x000000FF)
color = pixels.SDL_MapRGBA(sf.contents.format, r, g, b, a)
renderer = render.SDL_CreateSoftwareRenderer(sf)
self.assertIsInstance(renderer.contents, render.SDL_Renderer)
ret = render.SDL_SetRenderDrawColor(renderer, r, g, b, a)
self.assertEqual(ret, 0)
for x, y in points:
ret = render.SDL_RenderDrawPoint(renderer, x, y)
self.assertEqual(ret, 0)
render.SDL_RenderPresent(renderer)
view = PixelView(sf.contents)
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.SDL_DestroyRenderer(renderer)
del view
surface.SDL_FreeSurface(sf)
def test_SDL_LoadBMP_RW(self):
fp = open(self.testfile, "rb")
imgrw = rwops.rw_from_object(fp)
imgsurface = surface.SDL_LoadBMP_RW(imgrw, 0)
self.assertIsInstance(imgsurface.contents, surface.SDL_Surface)
surface.SDL_FreeSurface(imgsurface)
imgrw.close(imgrw)
def test_SDL_FillRects(self):
rectlist = to_ctypes([
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)
], rect.SDL_Rect)
bpp = c_int()
rmask, gmask, bmask, amask = Uint32(), Uint32(), Uint32(), Uint32()
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
ret = pixels.SDL_PixelFormatEnumToMasks(fmt, byref(bpp),
byref(rmask), byref(gmask),
byref(bmask), byref(amask))
self.assertEqual(ret, SDL_TRUE)
for w in range(1, 100, 5):
for h in range(1, 100, 5):
sf = surface.SDL_CreateRGBSurface(0, w, h, bpp, rmask,
gmask, bmask, amask)
# TODO: check for changed pixels
surface.SDL_FillRects(sf, rectlist, 7, 0xff00ff00)
surface.SDL_FreeSurface(sf)
def test_SDL_HasColorKey(self):
sf = surface.SDL_CreateRGBSurface(0, 10, 10, 32, 0, 0, 0, 0)
assert surface.SDL_HasColorKey(sf) == SDL_FALSE
key = pixels.SDL_MapRGB(sf.contents.format, 255, 255, 255)
surface.SDL_SetColorKey(sf, 1, key)
assert surface.SDL_HasColorKey(sf) == SDL_TRUE
surface.SDL_FreeSurface(sf)
def test_SDL_GetSetColorKey(self):
colorkeys = (
(0, 0, 0),
(32, 64, 128),
(10, 20, 30),
(1, 2, 4),
(255, 255, 255),
(128, 128, 128),
(127, 127, 127),
)
bpp = c_int()
rmask, gmask, bmask, amask = Uint32(), Uint32(), Uint32(), Uint32()
for fmt in pixels.ALL_PIXELFORMATS:
if pixels.SDL_ISPIXELFORMAT_FOURCC(fmt):
continue
pformat = pixels.SDL_AllocFormat(fmt)
self.assertIsInstance(pformat.contents, pixels.SDL_PixelFormat)
ret = pixels.SDL_PixelFormatEnumToMasks(fmt, byref(bpp),
byref(rmask), byref(gmask),
byref(bmask), byref(amask))
self.assertEqual(ret, SDL_TRUE)
sf = surface.SDL_CreateRGBSurface(0, 10, 10, bpp, rmask, gmask,
bmask, amask)
for r, g, b in colorkeys:
key = pixels.SDL_MapRGB(pformat, r, g, b)
surface.SDL_SetColorKey(sf, 1, key)
skey = Uint32()
ret = surface.SDL_GetColorKey(sf, byref(skey))
self.assertEqual(ret, 0)
self.assertEqual(
skey.value, key,
"Could not set color key (%d, %d, %d)" % (r, g, b))
pixels.SDL_FreeFormat(pformat)
surface.SDL_FreeSurface(sf)
def test_SDL_CreateSoftwareRenderer(self):
sf = surface.SDL_CreateRGBSurface(0, 100, 100, 32, 0xFF000000,
0x00FF0000, 0x0000FF00, 0x000000FF)
renderer = render.SDL_CreateSoftwareRenderer(sf)
self.assertIsInstance(renderer.contents, render.SDL_Renderer)
render.SDL_DestroyRenderer(renderer)
surface.SDL_FreeSurface(sf)
def test_SDL_GetSetSurfaceColorMod(self):
colormods = (
(0, 0, 0),
(32, 64, 128),
(10, 20, 30),
(1, 2, 4),
(255, 255, 255),
(128, 128, 128),
(127, 127, 127),
)
bpp = c_int()
rmask, gmask, bmask, amask = Uint32(), Uint32(), Uint32(), Uint32()
for fmt in pixels.ALL_PIXELFORMATS:
if pixels.SDL_ISPIXELFORMAT_FOURCC(fmt):
continue
ret = pixels.SDL_PixelFormatEnumToMasks(fmt, byref(bpp),
byref(rmask), byref(gmask),
byref(bmask), byref(amask))
self.assertEqual(ret, SDL_TRUE)
sf = surface.SDL_CreateRGBSurface(0, 10, 10, bpp, rmask, gmask,
bmask, amask)
for r, g, b in colormods:
sr, sg, sb = Uint8(), Uint8(), Uint8()
surface.SDL_SetSurfaceColorMod(sf, r, g, b)
ret = surface.SDL_GetSurfaceColorMod(sf, byref(sr), byref(sg),
byref(sb))
self.assertEqual(ret, 0)
self.assertEqual((sr.value, sg.value, sb.value), (r, g, b))
surface.SDL_FreeSurface(sf)
def test_SDL_GetSetClipRect(self):
rectlist = ((rect.SDL_Rect(0, 0, 0, 0), SDL_FALSE,
True), (rect.SDL_Rect(2, 2, 0, 0), SDL_FALSE, False),
(rect.SDL_Rect(2, 2, 5, 1), SDL_TRUE,
True), (rect.SDL_Rect(6, 5, 10, 3), SDL_TRUE, False),
(rect.SDL_Rect(0, 0, 10, 10), SDL_TRUE,
True), (rect.SDL_Rect(0, 0, -10, 10), SDL_FALSE,
False), (rect.SDL_Rect(0, 0, -10,
-10), SDL_FALSE, False),
(rect.SDL_Rect(-10, -10, 10, 10), SDL_FALSE,
False), (rect.SDL_Rect(10, -10, 10, 10), SDL_FALSE,
False), (rect.SDL_Rect(10, 10, 10,
10), SDL_TRUE, False))
clip = rect.SDL_Rect()
sf = surface.SDL_CreateRGBSurface(0, 15, 15, 32, 0, 0, 0, 0)
assert isinstance(sf.contents, surface.SDL_Surface)
surface.SDL_GetClipRect(sf, byref(clip))
assert clip == rect.SDL_Rect(0, 0, 15, 15)
for r, clipsetval, cmpval in rectlist:
retval = surface.SDL_SetClipRect(sf, r)
surface.SDL_GetClipRect(sf, byref(clip))
err = "Could not set clip rect %s" % r
assert retval == clipsetval, "retval: " + err
assert (clip == r) == cmpval, "clip: " + err
surface.SDL_FreeSurface(sf)
def test_SDL_GetSetClipRect(self):
rectlist = ((rect.SDL_Rect(0, 0, 0, 0), SDL_FALSE,
True), (rect.SDL_Rect(2, 2, 0, 0), SDL_FALSE, False),
(rect.SDL_Rect(2, 2, 5, 1), SDL_TRUE,
True), (rect.SDL_Rect(6, 5, 10, 3), SDL_TRUE, False),
(rect.SDL_Rect(0, 0, 10, 10), SDL_TRUE,
True), (rect.SDL_Rect(0, 0, -10, 10), SDL_FALSE,
False), (rect.SDL_Rect(0, 0, -10,
-10), SDL_FALSE, False),
(rect.SDL_Rect(-10, -10, 10, 10), SDL_FALSE,
False), (rect.SDL_Rect(10, -10, 10, 10), SDL_FALSE,
False), (rect.SDL_Rect(10, 10, 10,
10), SDL_TRUE, False))
clip = rect.SDL_Rect()
sf = surface.SDL_CreateRGBSurface(0, 15, 15, 32, 0, 0, 0, 0)
self.assertIsInstance(sf.contents, surface.SDL_Surface)
surface.SDL_GetClipRect(sf, byref(clip))
self.assertEqual(clip, rect.SDL_Rect(0, 0, 15, 15))
for r, clipsetval, cmpval in rectlist:
retval = surface.SDL_SetClipRect(sf, r)
surface.SDL_GetClipRect(sf, byref(clip))
self.assertEqual(retval, clipsetval,
"retval: Could not set clip rect %s" % r)
self.assertEqual(clip == r, cmpval,
"clip: Could not set clip rect %s" % r)
surface.SDL_FreeSurface(sf)
def test_IMG_LoadTexture(self):
sf = surface.SDL_CreateRGBSurface(0, 10, 10, 32, 0, 0, 0, 0)
rd = render.SDL_CreateSoftwareRenderer(sf)
fname = "surfacetest.%s"
for fmt in formats:
filename = os.path.join(os.path.dirname(os.path.abspath(__file__)),
"resources", fname % fmt)
tex = sdlimage.IMG_LoadTexture(rd, filename.encode("utf-8"))
self.assertIsInstance(tex.contents, render.SDL_Texture)
render.SDL_DestroyTexture(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.SDL_DestroyRenderer(rd)
surface.SDL_FreeSurface(sf)
def test_SDL_LockUnlockMUSTLOCKSurface(self):
bpp = c_int()
rmask, gmask, bmask, amask = Uint32(), Uint32(), Uint32(), Uint32()
for fmt in pixels.ALL_PIXELFORMATS:
if pixels.SDL_ISPIXELFORMAT_FOURCC(fmt):
continue
ret = pixels.SDL_PixelFormatEnumToMasks(fmt, byref(bpp),
byref(rmask), byref(gmask),
byref(bmask), byref(amask))
self.assertEqual(ret, SDL_TRUE)
sf = surface.SDL_CreateRGBSurface(0, 10, 10, bpp, rmask, gmask,
bmask, amask)
# TODO: locking seems to be only necessary for RLE surfaces...
if surface.SDL_MUSTLOCK(sf.contents):
self.assertFalse(sf.contents.locked)
surface.SDL_LockSurface(sf)
self.assertTrue(sf.contents.locked)
surface.SDL_LockSurface(sf)
self.assertTrue(sf.contents.locked)
surface.SDL_LockSurface(sf)
self.assertTrue(sf.contents.locked)
surface.SDL_LockSurface(sf)
self.assertTrue(sf.contents.locked)
surface.SDL_LockSurface(sf)
self.assertTrue(sf.contents.locked)
surface.SDL_UnlockSurface(sf)
self.assertFalse(sf.contents.locked)
surface.SDL_FreeSurface(sf)
def test_SDL_ConvertSurface(self):
bad_combos = []
good_combos = []
tenbit = [
pixels.SDL_PACKEDLAYOUT_2101010, pixels.SDL_PACKEDLAYOUT_1010102
]
for idx in pixels.ALL_PIXELFORMATS:
pfmt = pixels.SDL_AllocFormat(idx)
for fmt in pixels.ALL_PIXELFORMATS:
idx_name = pixels.SDL_GetPixelFormatName(idx).decode('utf-8')
fmt_name = pixels.SDL_GetPixelFormatName(fmt).decode('utf-8')
# SDL2 doesn't support converting fancier formats (e.g YUV, 10bit)
if pixels.SDL_ISPIXELFORMAT_FOURCC(
idx) or pixels.SDL_PIXELLAYOUT(idx) in tenbit:
continue
if pixels.SDL_ISPIXELFORMAT_FOURCC(
fmt) or pixels.SDL_PIXELLAYOUT(fmt) in tenbit:
continue
# SDL2 doesn't support converting to formats w/ less than 8 bpp
if pixels.SDL_BITSPERPIXEL(idx) < 8:
continue
# SDL2 doesn't support converting from indexed formats w/ 4 bpp
if pixels.SDL_PIXELTYPE(fmt) == pixels.SDL_PIXELTYPE_INDEX4:
continue
bpp = c_int()
rmask, gmask, bmask, amask = Uint32(), Uint32(), Uint32(
), Uint32()
ret = pixels.SDL_PixelFormatEnumToMasks(
fmt, byref(bpp), byref(rmask), byref(gmask), byref(bmask),
byref(amask))
self.assertEqual(ret, SDL_TRUE)
sf = surface.SDL_CreateRGBSurface(0, 10, 20, bpp, rmask, gmask,
bmask, amask)
self.assertIsInstance(sf.contents, surface.SDL_Surface)
csf = surface.SDL_ConvertSurface(sf, pfmt, 0)
self.assertTrue(csf)
if error.SDL_GetError() == b'Blit combination not supported':
bad_combos.append('{0} -> {1}'.format(fmt_name, idx_name))
error.SDL_ClearError()
else:
good_combos.append('{0} -> {1}'.format(fmt_name, idx_name))
self.assertIsInstance(csf.contents, surface.SDL_Surface)
surface.SDL_FreeSurface(sf)
surface.SDL_FreeSurface(csf)
pixels.SDL_FreeFormat(pfmt)
self.assertEqual(len(bad_combos), 0)
def test_IMG_Load(self):
fname = "surfacetest.%s"
for fmt in formats:
filename = os.path.join(os.path.dirname(os.path.abspath(__file__)),
"resources", fname % fmt)
sf = sdlimage.IMG_Load(filename.encode("utf-8"))
self.assertIsInstance(sf.contents, surface.SDL_Surface)
surface.SDL_FreeSurface(sf)
def test_SDL_BlitSurface(self):
bpp = 32
w, h = 10, 10
# no alpha to prevent blending
masks = (0xFF000000, 0x00FF0000, 0x0000FF00, 0x00000000)
dest = surface.SDL_CreateRGBSurface(0, w, h, bpp, masks[0], masks[1],
masks[2], masks[3])
pixelsize = h * dest.contents.pitch
rowlen = dest.contents.pitch // 4
sources = []
for width, height in blitsizes:
src = surface.SDL_CreateRGBSurface(0, width, height, bpp, masks[0],
masks[1], masks[2], masks[3])
surface.SDL_FillRect(src, None, 0xFFFFFFFF) # fill with white
sources.append(src)
for src in sources:
for pos in blitpositions:
drect = pos.__copy__()
surface.SDL_FillRect(dest, None, 0x0) # fill with black
surface.SDL_BlitSurface(src, None, dest, drect)
buf = cast(dest.contents.pixels, POINTER(Uint8 * pixelsize))
pbuf = 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.contents.h):
for x in range(dest.contents.w):
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.SDL_FreeSurface(sf)
surface.SDL_FreeSurface(dest)
def _createTexture(self): textSurface = TTF_RenderText_Shaded(self.font, self._text, self.textColor, self.backgroundColor) if textSurface is None: raise TTF_GetError() texture = render.SDL_CreateTextureFromSurface(self.renderer, textSurface) if texture is None: raise sdl2ext.SDLError() surface.SDL_FreeSurface(textSurface) return texture
def test_SDL_CreateRGBSurfaceWithFormat(self):
for w in range(1, 100, 5):
for h in range(1, 100, 5):
for bpp in alldepths:
for fmt in pixels.ALL_PIXELFORMATS:
if pixels.SDL_ISPIXELFORMAT_FOURCC(fmt):
continue
sf = surface.SDL_CreateRGBSurfaceWithFormat(
0, w, h, bpp, fmt)
self.assertIsInstance(sf.contents, surface.SDL_Surface)
surface.SDL_FreeSurface(sf)
def test_IMG_LoadTyped_RW(self):
fname = "surfacetest.%s"
for fmt in formats:
filename = os.path.join(os.path.dirname(os.path.abspath(__file__)),
"resources", fname % fmt)
fp = open(filename, "rb")
sf = sdlimage.IMG_LoadTyped_RW(rwops.rw_from_object(fp), False,
fmt.upper().encode("utf-8"))
fp.close()
self.assertIsInstance(sf.contents, surface.SDL_Surface)
surface.SDL_FreeSurface(sf)
def test_SDL_CreateRGBSurfaceWithFormatFrom(self):
for buf, bpp, pitch, masks, fmt in rgba_pixelations_16x16:
if bpp == 32:
arflag = "I"
elif bpp == 16:
arflag = "H"
bytebuf = CTypesView(array.array(arflag, buf))
bufptr = cast(bytebuf.to_bytes(), POINTER(Uint8))
sf = surface.SDL_CreateRGBSurfaceWithFormatFrom(
bufptr, 16, 16, bpp, pitch, fmt)
self.assertIsInstance(sf.contents, surface.SDL_Surface)
surface.SDL_FreeSurface(sf)
def test_IMG_Load_RW(self):
fname = "surfacetest.%s"
for fmt in formats:
if fmt in ("tga", "webp"):
# FIXME: tga and webp crashes with SDL2_image 2.0.2
continue
filename = os.path.join(os.path.dirname(os.path.abspath(__file__)),
"resources", fname % fmt)
with open(filename, "rb") as fp:
sf = sdlimage.IMG_Load_RW(rwops.rw_from_object(fp), False)
self.assertIsInstance(sf.contents, surface.SDL_Surface)
surface.SDL_FreeSurface(sf)
def test_IMG_Load_RW(self):
skip = ['tga']#, 'webp']
fname = "surfacetest.%s"
for fmt in formats:
if fmt in skip:
continue
testdir = os.path.dirname(os.path.abspath(__file__))
filename = os.path.join(testdir, "resources", fname % fmt)
with open(filename, "rb") as fp:
sf = sdlimage.IMG_Load_RW(rwops.rw_from_object(fp), False)
self.assertIsInstance(sf.contents, surface.SDL_Surface)
surface.SDL_FreeSurface(sf)
def test_IMG_LoadTyped_RW(self):
skip = []
fname = "surfacetest.%s"
for fmt in formats:
if fmt in skip:
continue
testdir = os.path.dirname(os.path.abspath(__file__))
filename = os.path.join(testdir, "resources", fname % fmt)
with open(filename, "rb") as fp:
sf = sdlimage.IMG_LoadTyped_RW(rwops.rw_from_object(fp), False,
fmt.upper().encode("utf-8"))
assert isinstance(sf.contents, surface.SDL_Surface)
surface.SDL_FreeSurface(sf)
def test_SDL_ConvertSurfaceFormat(self):
for pfmt in pixels.ALL_PIXELFORMATS:
if pixels.SDL_ISPIXELFORMAT_FOURCC(pfmt):
continue
for fmt in pixels.ALL_PIXELFORMATS:
if pixels.SDL_ISPIXELFORMAT_FOURCC(fmt):
continue
bpp = c_int()
rmask, gmask, bmask, amask = Uint32(), Uint32(), Uint32(
), Uint32()
ret = pixels.SDL_PixelFormatEnumToMasks(
fmt, byref(bpp), byref(rmask), byref(gmask), byref(bmask),
byref(amask))
self.assertEqual(ret, SDL_TRUE)
sf = surface.SDL_CreateRGBSurface(0, 10, 20, bpp, rmask, gmask,
bmask, amask)
self.assertIsInstance(sf.contents, surface.SDL_Surface)
csf = surface.SDL_ConvertSurfaceFormat(sf, pfmt, 0)
self.assertTrue(csf, error.SDL_GetError())
self.assertIsInstance(csf.contents, surface.SDL_Surface)
surface.SDL_FreeSurface(sf)
surface.SDL_FreeSurface(csf)
def test_IMG_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
filename = os.path.join(os.path.dirname(os.path.abspath(__file__)),
"resources", fname % fmt)
fp = open(filename, "rb")
sf = sdlimage.IMG_Load_RW(rwops.rw_from_object(fp), False)
fp.close()
self.assertIsInstance(sf.contents, surface.SDL_Surface)
surface.SDL_FreeSurface(sf)
def test_SDL_RenderGetSetIntegerScale(self):
sf = surface.SDL_CreateRGBSurface(0, 100, 100, 32, 0xFF000000,
0x00FF0000, 0x0000FF00, 0x000000FF)
renderer = render.SDL_CreateSoftwareRenderer(sf)
assert isinstance(renderer.contents, render.SDL_Renderer)
assert render.SDL_RenderGetIntegerScale(renderer) == SDL_FALSE
assert render.SDL_RenderSetIntegerScale(renderer, SDL_FALSE) == 0
assert render.SDL_RenderGetIntegerScale(renderer) == SDL_FALSE
assert render.SDL_RenderSetIntegerScale(renderer, SDL_TRUE) == 0
assert render.SDL_RenderGetIntegerScale(renderer) == SDL_TRUE
assert render.SDL_RenderSetIntegerScale(renderer, SDL_FALSE) == 0
assert render.SDL_RenderGetIntegerScale(renderer) == SDL_FALSE
render.SDL_DestroyRenderer(renderer)
surface.SDL_FreeSurface(sf)
def test_SDL_CreateRGBSurface(self):
for w in range(1, 100, 5):
for h in range(1, 100, 5):
for bpp in alldepths:
sf = surface.SDL_CreateRGBSurface(0, w, h, bpp, 0, 0, 0, 0)
self.assertIsInstance(sf.contents, surface.SDL_Surface)
surface.SDL_FreeSurface(sf)
bpp = c_int()
rmask, gmask, bmask, amask = Uint32(), Uint32(), Uint32(), Uint32()
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):
ret = pixels.SDL_PixelFormatEnumToMasks(
fmt, byref(bpp), byref(rmask), byref(gmask),
byref(bmask), byref(amask))
self.assertEqual(ret, SDL_TRUE)
sf = surface.SDL_CreateRGBSurface(0, 10, 20, bpp, rmask,
gmask, bmask, amask)
self.assertIsInstance(sf.contents, surface.SDL_Surface)
surface.SDL_FreeSurface(sf)
