def test_SDL_SetSurfacePalette(self):
invpalette = pixels.SDL_AllocPalette(10)
palette = pixels.SDL_AllocPalette(1 << 16)
sf = surface.SDL_CreateRGBSurface(0, 10, 10, 16, 0, 0, 0, 0)
# self.assertRaises((AttributeError, TypeError),
# surface.set_surface_palette, None, None)
# self.assertRaises((AttributeError, TypeError),
# surface.set_surface_palette, None, palette)
self.assertFalse(sf.contents.format.contents.palette)
surface.SDL_SetSurfacePalette(sf, palette)
self.assertIsNotNone(sf.contents.format.contents.palette.contents)
# self.assertRaises(sdl.SDLError, surface.set_surface_palette, sf,
# invpalette)
self.assertIsNotNone(sf.contents.format.contents.palette.contents)
surface.SDL_SetSurfacePalette(sf, None)
self.assertFalse(sf.contents.format.contents.palette)
surface.SDL_FreeSurface(sf)
pixels.SDL_FreePalette(invpalette)
pixels.SDL_FreePalette(palette)
def test_SDL_GetSetSurfaceBlendMode(self):
modes = (blendmode.SDL_BLENDMODE_NONE, blendmode.SDL_BLENDMODE_BLEND,
blendmode.SDL_BLENDMODE_ADD, blendmode.SDL_BLENDMODE_MOD)
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 mode in modes:
smode = blendmode.SDL_BlendMode()
ret = surface.SDL_SetSurfaceBlendMode(sf, mode)
self.assertEqual(ret, 0)
surface.SDL_GetSurfaceBlendMode(sf, byref(smode))
self.assertEqual(smode.value, mode)
surface.SDL_FreeSurface(sf)
def test_SDL_ConvertSurface(self):
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') # for debug
fmt_name = pixels.SDL_GetPixelFormatName(fmt).decode(
'utf-8') # for debug
# 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))
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_ConvertSurface(sf, pfmt, 0)
assert csf, error.SDL_GetError()
assert isinstance(csf.contents, surface.SDL_Surface)
surface.SDL_FreeSurface(sf)
surface.SDL_FreeSurface(csf)
pixels.SDL_FreeFormat(pfmt)
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_SDL_GetSetSurfaceAlphaMod(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)
salpha = Uint8()
ret = surface.SDL_GetSurfaceAlphaMod(sf, byref(salpha))
self.assertEqual(ret, 0)
self.assertEqual(salpha.value, 255)
for alpha in range(0, 255):
ret = surface.SDL_SetSurfaceAlphaMod(sf, alpha)
self.assertEqual(ret, 0)
ret = surface.SDL_GetSurfaceAlphaMod(sf, byref(salpha))
self.assertEqual(ret, 0)
self.assertEqual(salpha.value, alpha)
surface.SDL_FreeSurface(sf)
def test_SDL_FreeSurface(self):
# self.assertRaises((AttributeError, TypeError),
# surface.SDL_FreeSurface, 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)
bpp = c_int()
rmask, gmask, bmask, amask = Uint32(), Uint32(), Uint32(), Uint32()
for fmt in formats:
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, 5, 5, bpp, rmask, gmask,
bmask, amask)
surface.SDL_FreeSurface(sf)
def test_IMG_LoadTextureTyped_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 == "webp":
# FIXME: crashew with SDL_image 2.0.2
continue
if fmt == "svg":
# FIXME: svg 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:
rw = rwops.rw_from_object(fp)
fmtx = fmt.upper().encode("utf-8")
tex = sdlimage.IMG_LoadTextureTyped_RW(rd, rw, 0, fmtx)
self.assertIsNotNone(tex)
self.assertIsInstance(tex.contents, render.SDL_Texture)
render.SDL_DestroyTexture(tex)
render.SDL_DestroyRenderer(rd)
surface.SDL_FreeSurface(sf)
def test_SDL_RenderGetSetLogicalSize(self):
w, h = 100, 100
sf = surface.SDL_CreateRGBSurface(0, w, h, 32, 0xFF000000, 0x00FF0000,
0x0000FF00, 0x000000FF)
renderer = render.SDL_CreateSoftwareRenderer(sf)
view = PixelView(sf.contents)
magenta = 255, 0, 255, 255
green = 0, 255, 0, 255
magenta_int = sum(c << (i * 8)
for i, c in enumerate(reversed(magenta)))
green_int = sum(c << (i * 8) for i, c in enumerate(reversed(green)))
def clear_green():
ret = render.SDL_SetRenderDrawColor(renderer, green[0], green[1],
green[2], green[3])
self.assertEqual(ret, 0)
ret = render.SDL_RenderClear(renderer)
self.assertEqual(ret, 0)
def draw_magenta_pixel(x, y):
ret = render.SDL_SetRenderDrawColor(renderer, magenta[0],
magenta[1], magenta[2],
magenta[3])
self.assertEqual(ret, 0)
ret = render.SDL_RenderDrawPoint(renderer, x, y)
self.assertEqual(ret, 0)
# Test 1
# If we set the logical renderer size to 1 x 1, drawing a point
# at 0, 0 should have the same effect as filling the entire
# (square) window with magenta - no green should show through.
got_width, got_height = c_int(), c_int()
ret = render.SDL_RenderSetLogicalSize(renderer, 1, 1)
self.assertEqual(ret, 0)
render.SDL_RenderGetLogicalSize(renderer, byref(got_width),
byref(got_height))
self.assertEqual(got_width.value, 1)
self.assertEqual(got_height.value, 1)
clear_green()
draw_magenta_pixel(0, 0)
for x, y in itertools.product(range(w), range(h)):
self.assertEqual(view[y][x], magenta_int,
'No pixel should be green')
# Test 2
# Reset the logical size to the original target by using 0, 0
# only the first and last pixel should be magenta. The rest
# should be green.
got_width, got_height = c_int(), c_int()
ret = render.SDL_RenderSetLogicalSize(renderer, 0, 0)
self.assertEqual(ret, 0)
render.SDL_RenderGetLogicalSize(renderer, byref(got_width),
byref(got_height))
self.assertEqual(got_width.value, 0)
self.assertEqual(got_height.value, 0)
clear_green()
draw_magenta_pixel(0, 0)
draw_magenta_pixel(w - 1, h - 1)
for x, y in itertools.product(range(w), range(h)):
if (x, y) == (0, 0) or (x, y) == (w - 1, h - 1):
self.assertEqual(view[y][x], magenta_int,
'First and last pixel should be magenta')
else:
self.assertEqual(view[y][x], green_int,
'All other pixels should be green')
# Test 3
# Set the logical size to 1/10, making a logical pixel draw be
# 10 x 10 real pixel blocks.
got_width, got_height = c_int(), c_int()
ret = render.SDL_RenderSetLogicalSize(renderer, w // 10, h // 10)
self.assertEqual(ret, 0)
render.SDL_RenderGetLogicalSize(renderer, byref(got_width),
byref(got_height))
self.assertEqual(got_width.value, w // 10)
self.assertEqual(got_height.value, h // 10)
clear_green()
draw_magenta_pixel(0, 0)
for x, y in itertools.product(range(w), range(h)):
if x < 10 and y < 10:
self.assertEqual(
view[y][x], magenta_int,
'Top-left 10 x 10 pixel block should be magenta')
else:
self.assertEqual(view[y][x], green_int,
'All other pixels should be green')
render.SDL_DestroyRenderer(renderer)
surface.SDL_FreeSurface(sf)
def test_SDL_SetWindowIcon(self):
sf = surface.SDL_CreateRGBSurface(0, 16, 16, 16, 0xF000, 0x0F00,
0x00F0, 0x000F)
assert isinstance(sf.contents, surface.SDL_Surface)
window = video.SDL_CreateWindow(b"Test", 10, 10, 10, 10, 0)
video.SDL_SetWindowIcon(window, sf)
