691 lines
31 KiB
Python
691 lines
31 KiB
Python
import os
|
|
import sys
|
|
import array
|
|
import unittest
|
|
from ctypes import c_int, byref, cast, POINTER, c_void_p
|
|
from ..ext import CTypesView
|
|
from .. import SDL_Init, SDL_Quit, SDL_INIT_EVERYTHING
|
|
from ..stdinc import Uint8, Uint32, SDL_TRUE, SDL_FALSE
|
|
from .. import blendmode, pixels, rect, surface, rwops, error
|
|
|
|
to_ctypes = lambda seq, dtype: (dtype * len(seq))(*seq)
|
|
|
|
alldepths = (1, 4, 8, 12, 15, 16, 24, 32)
|
|
indexdepths = (1, 4, 8)
|
|
rgbdepths = (8, 12, 15, 16)
|
|
rgbadepths = (16, 24, 32)
|
|
|
|
rgba_pixelations_16x16 = (
|
|
# 32-bit 16x16 RGBA surface
|
|
([x << 24 for x in range(16 * 16)], 32, 16,
|
|
(0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF),
|
|
pixels.SDL_PIXELFORMAT_RGBA8888),
|
|
# 16-bit 16x16 RGBA surface
|
|
([x << 8 for x in range(16 * 16)], 16, 16,
|
|
(0xF000, 0x0F00, 0x00F0, 0x000F),
|
|
pixels.SDL_PIXELFORMAT_RGB444),
|
|
)
|
|
|
|
blitsizes = ((2, 2), (5, 5), (10, 10), (20, 20),
|
|
(2, 4), (5, 3), (8, 12), (27, 9),
|
|
)
|
|
|
|
blitpositions = (
|
|
rect.SDL_Rect(0, 0),
|
|
rect.SDL_Rect(4, 4),
|
|
rect.SDL_Rect(10, 10),
|
|
rect.SDL_Rect(15, 15),
|
|
rect.SDL_Rect(-2, 1),
|
|
rect.SDL_Rect(3, -4),
|
|
rect.SDL_Rect(0, 3),
|
|
rect.SDL_Rect(4, 0),
|
|
rect.SDL_Rect(12, 6),
|
|
rect.SDL_Rect(13, 22),
|
|
)
|
|
|
|
|
|
# TODO: mostly covers positive tests right now - fix this!
|
|
class SDLSurfaceTest(unittest.TestCase):
|
|
__tags__ = ["sdl"]
|
|
|
|
def setUp(self):
|
|
self.testfile = os.path.join(os.path.dirname
|
|
(os.path.abspath(__file__)),
|
|
"resources", "surfacetest.bmp")
|
|
SDL_Init(SDL_INIT_EVERYTHING)
|
|
|
|
def tearDown(self):
|
|
SDL_Quit()
|
|
|
|
def test_SDL_Surface(self):
|
|
sf = surface.SDL_Surface()
|
|
self.assertIsInstance(sf, surface.SDL_Surface)
|
|
# TODO: property checks
|
|
|
|
def test_SDL_ConvertPixels(self):
|
|
for buf, bpp, pitch, masks, fmt in rgba_pixelations_16x16:
|
|
bytecount = bpp // 8
|
|
arflag = None
|
|
if bpp == 32:
|
|
arflag = "I"
|
|
elif bpp == 16:
|
|
arflag = "H"
|
|
src = CTypesView(array.array(arflag, buf), bytecount)
|
|
srcp = cast(src.to_bytes(), POINTER(Uint8))
|
|
dst = (Uint8 * len(src))()
|
|
dstp = cast(dst, POINTER(Uint8))
|
|
ret = surface.SDL_ConvertPixels(16, 16, fmt, srcp, 16 * bytecount,
|
|
fmt, dstp, 16 * bytecount)
|
|
self.assertEqual(ret, 0)
|
|
for index, val in enumerate(dst):
|
|
self.assertEqual(val, src.view[index])
|
|
|
|
def test_SDL_ConvertSurface(self):
|
|
for idx in pixels.ALL_PIXELFORMATS:
|
|
if pixels.SDL_ISPIXELFORMAT_FOURCC(idx):
|
|
continue
|
|
pfmt = pixels.SDL_AllocFormat(idx)
|
|
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_ConvertSurface(sf, pfmt, 0)
|
|
self.assertTrue(csf, error.SDL_GetError())
|
|
self.assertIsInstance(csf.contents, surface.SDL_Surface)
|
|
surface.SDL_FreeSurface(sf)
|
|
surface.SDL_FreeSurface(csf)
|
|
pixels.SDL_FreeFormat(pfmt)
|
|
|
|
#######################################################################
|
|
# 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)
|
|
# surface.free_surface(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_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)
|
|
|
|
# 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_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_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_SDL_CreateRGBSurfaceFrom(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_CreateRGBSurfaceFrom(bufptr, 16, 16, bpp,
|
|
pitch, masks[0], masks[1],
|
|
masks[2], masks[3])
|
|
self.assertIsInstance(sf.contents, surface.SDL_Surface)
|
|
surface.SDL_FreeSurface(sf)
|
|
|
|
def test_SDL_FillRect(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),
|
|
)
|
|
|
|
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)
|
|
for r in rectlist:
|
|
# TODO: check for changed pixels
|
|
ret = surface.SDL_FillRect(sf, r, 0xff00ff00)
|
|
self.assertEqual(ret, 0)
|
|
surface.SDL_FreeSurface(sf)
|
|
|
|
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_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_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_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_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_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_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_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_LowerBlit(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_LowerBlit(src, src.contents.clip_rect, 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)
|
|
|
|
@unittest.skip("not implemented")
|
|
def test_SDL_LowerBlitScaled(self):
|
|
pass
|
|
|
|
def test_SDL_UpperBlit(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_UpperBlit(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""" % (x, y, pos, col, 0xFFFFFFFF))
|
|
else:
|
|
self.assertEqual(col, 0x0, msg="""color mismatch
|
|
at %d,%d for %s: %d != %d""" % (x, y, pos, col, 0x0))
|
|
|
|
while len(sources) > 0:
|
|
sf = sources.pop()
|
|
surface.SDL_FreeSurface(sf)
|
|
surface.SDL_FreeSurface(dest)
|
|
|
|
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)
|
|
|
|
@unittest.skip("not implemented")
|
|
def test_SDL_UpperBlitScaled(self):
|
|
pass
|
|
|
|
@unittest.skip("not implemented")
|
|
def test_SDL_SoftStretch(self):
|
|
pass
|
|
|
|
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)
|
|
|
|
@unittest.skip("not implemented")
|
|
def test_SDL_SetSurfaceRLE(self):
|
|
pass
|
|
|
|
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)
|
|
|
|
# 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_SDL_LoadBMP(self):
|
|
imgsurface = surface.SDL_LoadBMP(self.testfile.encode("utf-8"))
|
|
self.assertIsInstance(imgsurface.contents, surface.SDL_Surface)
|
|
surface.SDL_FreeSurface(imgsurface)
|
|
|
|
# self.assertRaises(sdl.SDLError, surface.load_bmp, "invalid path")
|
|
# self.assertRaises(sdl.SDLError, surface.load_bmp, None)
|
|
# self.assertRaises(sdl.SDLError, surface.load_bmp, 1234)
|
|
|
|
@unittest.skip("not implemented")
|
|
def test_SDL_SaveBMP_RW(self):
|
|
pass
|
|
|
|
@unittest.skip("not implemented")
|
|
def test_SDL_SaveBMP(self):
|
|
pass
|
|
|
|
|
|
if __name__ == '__main__':
|
|
sys.exit(unittest.main())
|