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)