def test_SDL_GetSetTextureAlphaMod(self):
window = video.SDL_CreateWindow(b"Test", 10, 10, 10, 10,
video.SDL_WINDOW_HIDDEN)
self.assertIsInstance(window.contents, video.SDL_Window)
renderer = render.SDL_CreateRenderer(window, -1, self._RENDERFLAGS)
self.assertIsInstance(renderer.contents, render.SDL_Renderer)
tex = render.SDL_CreateTexture(renderer,
pixels.SDL_PIXELFORMAT_ARGB8888,
render.SDL_TEXTUREACCESS_STREAMING, 10,
10)
self.assertIsInstance(tex.contents, render.SDL_Texture)
for alpha in range(0, 255):
ret = render.SDL_SetTextureAlphaMod(tex, alpha)
self.assertEqual(ret, 0)
talpha = Uint8()
ret = render.SDL_GetTextureAlphaMod(tex, byref(talpha))
self.assertEqual(ret, 0)
self.assertEqual(talpha.value, alpha)
render.SDL_DestroyTexture(tex)
#self.assertRaises(sdl.SDLError, render.SDL_SetTextureColorMod, tex,
# 10, 20, 30)
#self.assertRaises(sdl.SDLError, render.SDL_GetTextureColorMod, tex)
render.SDL_DestroyRenderer(renderer)
video.SDL_DestroyWindow(window)
dogc()
def test_SDL_GetSetTextureBlendMode(self):
window = video.SDL_CreateWindow(b"Test", 10, 10, 10, 10,
video.SDL_WINDOW_HIDDEN)
self.assertIsInstance(window.contents, video.SDL_Window)
renderer = render.SDL_CreateRenderer(window, -1, self._RENDERFLAGS)
self.assertIsInstance(renderer.contents, render.SDL_Renderer)
tex = render.SDL_CreateTexture(renderer,
pixels.SDL_PIXELFORMAT_ARGB8888,
render.SDL_TEXTUREACCESS_STREAMING, 10,
10)
self.assertIsInstance(tex.contents, render.SDL_Texture)
modes = (
blendmode.SDL_BLENDMODE_NONE,
blendmode.SDL_BLENDMODE_ADD,
blendmode.SDL_BLENDMODE_BLEND,
blendmode.SDL_BLENDMODE_MOD,
)
for mode in modes:
ret = render.SDL_SetTextureBlendMode(tex, mode)
self.assertEqual(ret, 0)
tmode = blendmode.SDL_BlendMode()
ret = render.SDL_GetTextureBlendMode(tex, byref(tmode))
self.assertEqual(ret, 0)
self.assertEqual(tmode.value, mode)
render.SDL_DestroyTexture(tex)
#self.assertRaises(sdl.SDLError, render.SDL_SetTextureBlendMode, tex,
# modes[2])
#self.assertRaises(sdl.SDLError, render.SDL_GetTextureBlendMode, tex)
render.SDL_DestroyRenderer(renderer)
video.SDL_DestroyWindow(window)
dogc()
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 _updateTexture(self):
textureToDelete = self.texture
texture = self._createTexture()
super(TextSprite, self).__init__(texture)
render.SDL_DestroyTexture(textureToDelete)
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_SDL_GetSetTextureScaleMode(self):
window = video.SDL_CreateWindow(b"Test", 10, 10, 10, 10,
video.SDL_WINDOW_HIDDEN)
assert isinstance(window.contents, video.SDL_Window)
renderer = render.SDL_CreateRenderer(window, -1, self._RENDERFLAGS)
assert isinstance(renderer.contents, render.SDL_Renderer)
tex = render.SDL_CreateTexture(renderer,
pixels.SDL_PIXELFORMAT_ARGB8888,
render.SDL_TEXTUREACCESS_STREAMING, 10,
10)
assert isinstance(tex.contents, render.SDL_Texture)
modes = (render.SDL_ScaleModeNearest, render.SDL_ScaleModeLinear,
render.SDL_ScaleModeBest)
for mode in modes:
ret = render.SDL_SetTextureScaleMode(tex, mode)
assert ret == 0
tmode = render.SDL_ScaleMode()
ret = render.SDL_GetTextureScaleMode(tex, byref(tmode))
assert ret == 0
assert tmode.value == mode
render.SDL_DestroyTexture(tex)
render.SDL_DestroyRenderer(renderer)
video.SDL_DestroyWindow(window)
dogc()
def test_SDL_CreateDestroyTexture(self):
window = video.SDL_CreateWindow(b"Test", 10, 10, 10, 10,
video.SDL_WINDOW_HIDDEN)
self.assertIsInstance(window.contents, video.SDL_Window)
renderer = render.SDL_CreateRenderer(window, -1, self._RENDERFLAGS)
self.assertIsInstance(renderer.contents, render.SDL_Renderer)
formats = (pixels.SDL_PIXELFORMAT_ARGB8888,
pixels.SDL_PIXELFORMAT_RGB555,
pixels.SDL_PIXELFORMAT_RGBA4444,
pixels.SDL_PIXELFORMAT_RGBA8888,
pixels.SDL_PIXELFORMAT_ARGB2101010,
pixels.SDL_PIXELFORMAT_YUY2
)
access = (render.SDL_TEXTUREACCESS_STATIC,
render.SDL_TEXTUREACCESS_STREAMING,
render.SDL_TEXTUREACCESS_TARGET)
for fmt in formats:
for acc in access:
for w in range(1, 300, 5):
for h in range(1, 300, 5):
tex = render.SDL_CreateTexture(renderer, fmt, acc,
w, h)
self.assertIsInstance(tex.contents, render.SDL_Texture)
render.SDL_DestroyTexture(tex)
if (w % 50) == 0:
dogc()
#self.assertRaises(sdl.SDLError, render.SDL_CreateTexture, renderer,
# pixels.SDL_PIXELFORMAT_RGB555, 1, -10, 10)
#self.assertRaises(sdl.SDLError, render.SDL_CreateTexture, renderer,
# pixels.SDL_PIXELFORMAT_RGB555, 1, 10, -10)
#self.assertRaises(sdl.SDLError, render.SDL_CreateTexture, renderer,
# pixels.SDL_PIXELFORMAT_RGB555, 1, -10, -10)
#self.assertRaises(ValueError, render.SDL_CreateTexture, renderer,
# pixels.SDL_PIXELFORMAT_RGB555, -5, 10, 10)
#self.assertRaises(ValueError, render.SDL_CreateTexture, renderer,
# - 10, 1, 10, 10)
#self.assertRaises((AttributeError, TypeError),
# render.SDL_CreateTexture, None,
# pixels.SDL_PIXELFORMAT_RGB555, 1, 10, 10)
#self.assertRaises((AttributeError, TypeError),
# render.SDL_CreateTexture, "Test",
# pixels.SDL_PIXELFORMAT_RGB555, 1, 10, 10)
#self.assertRaises(ValueError, render.SDL_CreateTexture, renderer,
# "Test", 1, 10, 10)
#self.assertRaises(ValueError, render.SDL_CreateTexture, renderer,
# pixels.SDL_PIXELFORMAT_RGB555, None, 10, 10)
#self.assertRaises(ValueError, render.SDL_CreateTexture, renderer,
# pixels.SDL_PIXELFORMAT_RGB555, "Test", 10, 10)
render.SDL_DestroyRenderer(renderer)
#self.assertRaises(sdl.SDLError, render.SDL_CreateTexture, renderer,
# pixels.SDL_PIXELFORMAT_RGB555, 1, 10, 10)
video.SDL_DestroyWindow(window)
dogc()
def test_SDL_GetSetRenderTarget(self):
skipcount = 0
failed = 0
rcount = render.SDL_GetNumRenderDrivers()
for i in range(rcount):
window = video.SDL_CreateWindow(b"Test", 10, 10, 10, 10,
video.SDL_WINDOW_HIDDEN)
self.assertIsInstance(window.contents, video.SDL_Window)
renderer = render.SDL_CreateRenderer(window, i, self._RENDERFLAGS)
if not (renderer and renderer.contents):
failed += 1
video.SDL_DestroyWindow(window)
continue
self.assertIsInstance(renderer.contents, render.SDL_Renderer)
supported = render.SDL_RenderTargetSupported(renderer)
if not supported:
skipcount += 1
render.SDL_DestroyRenderer(renderer)
continue
ret = render.SDL_SetRenderTarget(renderer, None)
self.assertEqual(ret, 0)
self.assertFalse(render.SDL_GetRenderTarget(renderer))
tex = render.SDL_CreateTexture(renderer,
pixels.SDL_PIXELFORMAT_ARGB8888,
render.SDL_TEXTUREACCESS_TARGET, 10,
10)
ret = render.SDL_SetRenderTarget(renderer, tex)
self.assertEqual(ret, 0)
tgt = render.SDL_GetRenderTarget(renderer)
self.assertIsInstance(tgt.contents, render.SDL_Texture)
render.SDL_DestroyTexture(tex)
# TODO: Check in the SDL codebase, why the code below does
# not fail...
# tex2 = render.SDL_CreateTexture(renderer,
# pixels.SDL_PIXELFORMAT_ARGB8888,
# render.SDL_TEXTUREACCESS_STREAMING,
# 10, 10)
# self.assertRaises(SDLError, render.SDL_SetRenderTarget, renderer,
# tex2)
# render.SDL_DestroyTexture(tex2)
render.SDL_DestroyRenderer(renderer)
video.SDL_DestroyWindow(window)
self.assertFalse(failed == rcount, "could not create a renderer")
if skipcount == rcount:
self.skipTest("None of the renderers supports render targets")
dogc()
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:
filename = os.path.join(os.path.dirname(os.path.abspath(__file__)),
"resources", fname % fmt)
fp = open(filename, "rb")
fmtx = fmt.upper().encode("utf-8")
rw = rwops.rw_from_object(fp)
tex = sdlimage.IMG_LoadTextureTyped_RW(rd, rw, 0, fmtx)
fp.close()
self.assertIsInstance(tex.contents, render.SDL_Texture)
render.SDL_DestroyTexture(tex)
render.SDL_DestroyRenderer(rd)
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)
skip = ['svg', 'tga']#, 'webp'] # TGA not supported, others broken
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)
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_LoadTextureTyped_RW(self):
sf = surface.SDL_CreateRGBSurface(0, 10, 10, 32, 0, 0, 0, 0)
rd = render.SDL_CreateSoftwareRenderer(sf)
skip = ['svg'] # SVG broken for LoadTextureTyped_RW
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:
rw = rwops.rw_from_object(fp)
fmtx = fmt.upper().encode("utf-8")
tex = sdlimage.IMG_LoadTextureTyped_RW(rd, rw, 0, fmtx)
assert tex is not None
assert isinstance(tex.contents, render.SDL_Texture)
render.SDL_DestroyTexture(tex)
render.SDL_DestroyRenderer(rd)
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
filename = os.path.join(os.path.dirname(os.path.abspath(__file__)),
"resources", fname % fmt)
fp = open(filename, "rb")
tex = sdlimage.IMG_LoadTexture_RW(rd, rwops.rw_from_object(fp), 0)
fp.close()
self.assertIsInstance(tex.contents, render.SDL_Texture)
render.SDL_DestroyTexture(tex)
render.SDL_DestroyRenderer(rd)
surface.SDL_FreeSurface(sf)
def run_sdl():
sdl2.ext.init()
window = sdl2.ext.Window("SDL Cairo Example",
size=(WIDTH, 300),
flags=sdl2.SDL_WINDOW_ALLOW_HIGHDPI)
window.show()
running = True
renderer = render.SDL_CreateRenderer(window.window, -1, 0)
render.SDL_RenderClear(renderer)
port = rect.SDL_Rect()
render.SDL_RenderGetViewport(renderer, byref(port))
cairo_surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, port.w, port.h)
scale = port.w * 1.0 / WIDTH
texture = render.SDL_CreateTexture(renderer,
sdl2.pixels.SDL_PIXELFORMAT_ARGB32,
render.SDL_TEXTUREACCESS_TARGET, port.w,
port.h)
while running:
draw(cairo_surface, scale)
buf = cairo_surface.get_data().tobytes()
render.SDL_UpdateTexture(texture, port, buf, port.w * 4)
render.SDL_RenderCopy(renderer, texture, port, port)
render.SDL_RenderPresent(renderer)
events = sdl2.ext.get_events()
for event in events:
if event.type == sdl2.SDL_QUIT:
running = False
break
time.sleep(0.2)
render.SDL_DestroyTexture(texture)
def test_SDL_GetSetTextureColorMod(self):
window = video.SDL_CreateWindow(b"Test", 10, 10, 10, 10,
video.SDL_WINDOW_HIDDEN)
self.assertIsInstance(window.contents, video.SDL_Window)
renderer = render.SDL_CreateRenderer(window, -1, self._RENDERFLAGS)
self.assertIsInstance(renderer.contents, render.SDL_Renderer)
tex = render.SDL_CreateTexture(renderer,
pixels.SDL_PIXELFORMAT_ARGB8888,
render.SDL_TEXTUREACCESS_STREAMING, 10,
10)
self.assertIsInstance(tex.contents, render.SDL_Texture)
colors = (
(16, 22, 185),
(32, 64, 128),
(64, 32, 128),
(64, 32, 255),
(255, 32, 64),
(255, 32, 128),
(0, 0, 0),
(255, 255, 255),
(128, 128, 128),
)
for r, g, b in colors:
ret = render.SDL_SetTextureColorMod(tex, r, g, b)
self.assertEqual(ret, 0)
tr, tg, tb = Uint8(), Uint8(), Uint8()
ret = render.SDL_GetTextureColorMod(tex, byref(tr), byref(tg),
byref(tb))
self.assertEqual(ret, 0)
self.assertEqual((tr.value, tg.value, tb.value), (r, g, b))
render.SDL_DestroyTexture(tex)
#self.assertRaises(sdl.SDLError, render.SDL_SetTextureColorMod, tex,
# 10, 20, 30)
#self.assertRaises(sdl.SDLError, render.SDL_GetTextureColorMod, tex)
render.SDL_DestroyRenderer(renderer)
video.SDL_DestroyWindow(window)
dogc()
def test_SDL_QueryTexture(self):
window = video.SDL_CreateWindow(b"Test", 10, 10, 10, 10,
video.SDL_WINDOW_HIDDEN)
self.assertIsInstance(window.contents, video.SDL_Window)
renderer = render.SDL_CreateRenderer(window, -1, self._RENDERFLAGS)
self.assertIsInstance(renderer.contents, render.SDL_Renderer)
formats = (pixels.SDL_PIXELFORMAT_ARGB8888,
pixels.SDL_PIXELFORMAT_RGB555,
pixels.SDL_PIXELFORMAT_RGBA4444,
pixels.SDL_PIXELFORMAT_ARGB2101010,
pixels.SDL_PIXELFORMAT_YUY2
)
access = (render.SDL_TEXTUREACCESS_STATIC,
render.SDL_TEXTUREACCESS_STREAMING,
render.SDL_TEXTUREACCESS_TARGET)
for fmt in formats:
for acc in access:
for w in range(1, 300, 5):
for h in range(1, 300, 5):
tex = render.SDL_CreateTexture(renderer, fmt, acc,
w, h)
self.assertIsInstance(tex.contents, render.SDL_Texture)
qf, qa, qw, qh = Uint32(), c_int(), c_int(), c_int()
ret = render.SDL_QueryTexture(tex, byref(qf),
byref(qa), byref(qw),
byref(qh))
self.assertEqual(ret, 0)
self.assertEqual(qf.value, fmt)
self.assertEqual(qa.value, acc)
self.assertEqual(qw.value, w)
self.assertEqual(qh.value, h)
render.SDL_DestroyTexture(tex)
if _ISPYPY and (w % 50) == 0:
gc.collect()
render.SDL_DestroyRenderer(renderer)
video.SDL_DestroyWindow(window)
dogc()
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)
