def test_SDL_GL_CreateDeleteContext(self):
if video.SDL_GetCurrentVideoDriver() == b"dummy":
pytest.skip("dummy video driver does not support GL loading")
# self.assertRaises((AttributeError, TypeError),
# video.SDL_GL_CreateContext, None)
# self.assertRaises((AttributeError, TypeError),
# video.SDL_GL_CreateContext, "Test")
# self.assertRaises((AttributeError, TypeError),
# video.SDL_GL_CreateContext, 1234)
window = video.SDL_CreateWindow(b"No OpenGL", 10, 10, 10, 10,
video.SDL_WINDOW_BORDERLESS)
#self.assertRaises(sdl.SDLError, video.SDL_GL_CreateContext, window)
video.SDL_DestroyWindow(window)
assert video.SDL_GL_LoadLibrary(None) == 0, SDL_GetError()
window = video.SDL_CreateWindow(b"OpenGL", 10, 10, 10, 10,
video.SDL_WINDOW_OPENGL)
ctx = video.SDL_GL_CreateContext(window)
video.SDL_GL_DeleteContext(ctx)
video.SDL_DestroyWindow(window)
window = video.SDL_CreateWindow(b"OpenGL", 10, 10, 10, 10,
video.SDL_WINDOW_OPENGL)
ctx = video.SDL_GL_CreateContext(window)
video.SDL_DestroyWindow(window)
video.SDL_GL_DeleteContext(ctx)
video.SDL_GL_UnloadLibrary()
def test_SDL_GetWindowsBordersSize(self):
if video.SDL_GetCurrentVideoDriver() == b"dummy":
pytest.skip(
"dummy video driver does not support the window border size")
window = video.SDL_CreateWindow(b"Borders", 10, 10, 10, 10, 0)
l, r, t, b = c_int(), c_int(), c_int(), c_int()
ret = video.SDL_GetWindowBordersSize(window, byref(t), byref(l),
byref(b), byref(r))
if sys.platform in ("cygwin", "darwin"):
assert ret == -1
assert t.value == 0
assert l.value == 0
assert b.value == 0
assert r.value == 0
else:
assert ret == 0
assert t.value != 0
assert l.value != 0
assert b.value != 0
assert r.value != 0
video.SDL_DestroyWindow(window)
window = video.SDL_CreateWindow(b"No Borders", 10, 10, 10, 10,
video.SDL_WINDOW_BORDERLESS)
ret = video.SDL_GetWindowBordersSize(window, byref(t), byref(l),
byref(b), byref(r))
if sys.platform not in ("cygwin", "darwin"):
assert ret == 0
assert t.value == 0
assert l.value == 0
assert b.value == 0
assert r.value == 0
video.SDL_DestroyWindow(window)
def test_SDL_GetWindowsBordersSize(self):
if video.SDL_GetCurrentVideoDriver() == b"dummy":
self.skipTest(
"dummy video driver does not support the window border size")
window = video.SDL_CreateWindow(b"Borders", 10, 10, 10, 10, 0)
l, r, t, b = c_int(), c_int(), c_int(), c_int()
ret = video.SDL_GetWindowBordersSize(window, byref(t), byref(l),
byref(b), byref(r))
if sys.platform in ("win32", "cygwin", "darwin"):
self.assertEqual(ret, -1)
self.assertEqual(t.value, 0)
self.assertEqual(l.value, 0)
self.assertEqual(b.value, 0)
self.assertEqual(r.value, 0)
else:
self.assertEqual(ret, 0)
self.assertNotEqual(t.value, 0)
self.assertNotEqual(l.value, 0)
self.assertNotEqual(b.value, 0)
self.assertNotEqual(r.value, 0)
video.SDL_DestroyWindow(window)
window = video.SDL_CreateWindow(b"No Borders", 10, 10, 10, 10,
video.SDL_WINDOW_BORDERLESS)
ret = video.SDL_GetWindowBordersSize(window, byref(t), byref(l),
byref(b), byref(r))
if sys.platform not in ("win32", "cygwin", "darwin"):
self.assertEqual(ret, 0)
self.assertEqual(t.value, 0)
self.assertEqual(l.value, 0)
self.assertEqual(b.value, 0)
self.assertEqual(r.value, 0)
video.SDL_DestroyWindow(window)
def test_SDL_GetRendererInfo(self):
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)
assert isinstance(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
assert isinstance(renderer.contents, render.SDL_Renderer)
info = render.SDL_RendererInfo()
ret = render.SDL_GetRendererInfo(renderer, byref(info))
assert ret == 0
render.SDL_DestroyRenderer(renderer)
#self.assertRaises(sdl.SDLError, render.SDL_GetRendererInfo,
# renderer)
video.SDL_DestroyWindow(window)
assert not (failed == rcount), "could not create a renderer"
with pytest.raises((AttributeError, TypeError)):
render.SDL_GetRendererInfo(None)
with pytest.raises((AttributeError, TypeError)):
render.SDL_GetRendererInfo("Test")
dogc()
def test_SDL_GetRenderer(self):
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)
assert isinstance(window.contents, video.SDL_Window)
renderer = render.SDL_GetRenderer(window)
assert not renderer
renderer = render.SDL_CreateRenderer(window, i, self._RENDERFLAGS)
if not (renderer and renderer.contents):
failed += 1
video.SDL_DestroyWindow(window)
continue
ren = render.SDL_GetRenderer(window)
assert isinstance(ren.contents, render.SDL_Renderer)
render.SDL_DestroyRenderer(renderer)
assert not render.SDL_GetRenderer(window)
video.SDL_DestroyWindow(window)
assert not render.SDL_GetRenderer(window)
#self.assertRaises((AttributeError, TypeError),
# render.SDL_GetRenderer, None)
#self.assertRaises((AttributeError, TypeError),
# render.SDL_GetRenderer, "Test")
assert not (failed == rcount), "could not create a renderer"
dogc()
def test_SDL_GetSetRenderDrawBlendMode(self):
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)
modes = (
blendmode.SDL_BLENDMODE_NONE,
blendmode.SDL_BLENDMODE_ADD,
blendmode.SDL_BLENDMODE_BLEND,
blendmode.SDL_BLENDMODE_MOD,
)
for mode in modes:
ret = render.SDL_SetRenderDrawBlendMode(renderer, mode)
bmode = blendmode.SDL_BlendMode()
ret = render.SDL_GetRenderDrawBlendMode(renderer, byref(bmode))
self.assertEqual(ret, 0)
self.assertEqual(bmode.value, mode)
render.SDL_DestroyRenderer(renderer)
#self.assertRaises(sdl.SDLError, render.SDL_SetRenderDrawBlendMode,
# renderer, video.SDL_BLENDMODE_ADD)
#self.assertRaises(sdl.SDLError, render.SDL_GetRenderDrawBlendMode,
# renderer)
video.SDL_DestroyWindow(window)
self.assertFalse(failed == rcount, "could not create a renderer")
dogc()
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_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_GL_GetSetSwapInterval(self):
if video.SDL_GetCurrentVideoDriver() == b"dummy":
pytest.skip("dummy video driver does not support GL loading")
#self.assertRaises(ValueError, video.SDL_GL_SetSwapInterval, None)
#self.assertRaises(ValueError, video.SDL_GL_SetSwapInterval, "Test")
#self.assertRaises(ValueError, video.SDL_GL_SetSwapInterval, 1234)
# No current OpenGL context yet.
# Might crash on certain platforms, since the internal state of
# SDL2 does not support calling GL functions without having a
# GL library loaded.
# self.assertRaises(sdl.SDLError, video.SDL_GL_SetSwapInterval, 1)
# self.assertRaises(sdl.SDLError, video.SDL_GL_SetSwapInterval, 0)
assert video.SDL_GL_LoadLibrary(None) == 0, SDL_GetError()
window = video.SDL_CreateWindow(b"OpenGL", 10, 10, 10, 10,
video.SDL_WINDOW_OPENGL)
ctx = video.SDL_GL_CreateContext(window)
video.SDL_GL_MakeCurrent(window, ctx)
ret = video.SDL_GL_SetSwapInterval(0)
if ret == 0:
assert video.SDL_GL_GetSwapInterval() == 0
ret = video.SDL_GL_SetSwapInterval(1)
if ret == 0:
assert video.SDL_GL_GetSwapInterval() == 1
video.SDL_GL_DeleteContext(ctx)
video.SDL_DestroyWindow(window)
video.SDL_GL_UnloadLibrary()
def test_SDL_GetRendererInfo(self):
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)
info = render.SDL_RendererInfo()
ret = render.SDL_GetRendererInfo(renderer, byref(info))
self.assertEqual(ret, 0)
render.SDL_DestroyRenderer(renderer)
#self.assertRaises(sdl.SDLError, render.SDL_GetRendererInfo,
# renderer)
video.SDL_DestroyWindow(window)
self.assertFalse(failed == rcount, "could not create a renderer")
self.assertRaises((AttributeError, TypeError),
render.SDL_GetRendererInfo, None)
self.assertRaises((AttributeError, TypeError),
render.SDL_GetRendererInfo, "Test")
dogc()
def test_SDL_DestroyWindow(self):
flags = (video.SDL_WINDOW_BORDERLESS,
video.SDL_WINDOW_BORDERLESS | video.SDL_WINDOW_HIDDEN)
for flag in flags:
window = video.SDL_CreateWindow(b"Test", 10, 10, 10, 10, flag)
# TODO: how to check for this in a meaningful way?
video.SDL_DestroyWindow(window)
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_SDL_UpdateWindowSurface(self):
flags = (video.SDL_WINDOW_BORDERLESS,
video.SDL_WINDOW_BORDERLESS | video.SDL_WINDOW_HIDDEN,
video.SDL_WINDOW_RESIZABLE | video.SDL_WINDOW_MINIMIZED)
for flag in flags:
window = video.SDL_CreateWindow(b"Test", 200, 200, 200, 200, flag)
video.SDL_UpdateWindowSurface(window)
video.SDL_DestroyWindow(window)
def test_SDL_GetWindowFlags(self):
flags = (video.SDL_WINDOW_BORDERLESS,
video.SDL_WINDOW_BORDERLESS | video.SDL_WINDOW_HIDDEN,
video.SDL_WINDOW_RESIZABLE)
for flag in flags:
window = video.SDL_CreateWindow(b"Test", 10, 10, 10, 10, flag)
wflags = video.SDL_GetWindowFlags(window)
assert (wflags & flag) == flag
def test_SDL_GetWindowID(self):
flags = (video.SDL_WINDOW_BORDERLESS,
video.SDL_WINDOW_BORDERLESS | video.SDL_WINDOW_HIDDEN)
for flag in flags:
window = video.SDL_CreateWindow(b"Test", 10, 10, 10, 10, flag)
assert video.SDL_GetWindowID(window) >= 0
video.SDL_DestroyWindow(window)
def test_SDL_GetWindowPixelFormat(self):
flags = (video.SDL_WINDOW_BORDERLESS,
video.SDL_WINDOW_BORDERLESS | video.SDL_WINDOW_HIDDEN)
for flag in flags:
window = video.SDL_CreateWindow(b"Test", 10, 10, 10, 10, flag)
fmt = video.SDL_GetWindowPixelFormat(window)
assert type(fmt) in (int, long)
video.SDL_DestroyWindow(window)
def test_SDL_GetWindowDisplayMode(self):
flags = (video.SDL_WINDOW_BORDERLESS,
video.SDL_WINDOW_BORDERLESS | video.SDL_WINDOW_HIDDEN)
for flag in flags:
window = video.SDL_CreateWindow(b"Test", 10, 10, 10, 10, flag)
dmode = video.SDL_DisplayMode()
ret = video.SDL_GetWindowDisplayMode(window, byref(dmode))
assert ret == 0
video.SDL_DestroyWindow(window)
def test_SDL_GetWindowSurface(self):
flags = (video.SDL_WINDOW_BORDERLESS,
video.SDL_WINDOW_BORDERLESS | video.SDL_WINDOW_HIDDEN,
video.SDL_WINDOW_RESIZABLE | video.SDL_WINDOW_MINIMIZED)
for flag in flags:
window = video.SDL_CreateWindow(b"Test", 200, 200, 200, 200, flag)
sf = video.SDL_GetWindowSurface(window)
assert isinstance(sf.contents, surface.SDL_Surface)
video.SDL_DestroyWindow(window)
def test_SDL_GL_GetSetAttribute(self):
if video.SDL_GetCurrentVideoDriver() == b"dummy":
pytest.skip("dummy video driver does not support GL loading")
# self.assertRaises(sdl.SDLError, video.SDL_GL_GetAttribute,
# video.SDL_GL_DEPTH_SIZE)
# self.assertRaises(sdl.SDLError, video.SDL_GL_SetAttribute,
# 1455, 24)
assert video.SDL_GL_LoadLibrary(None) == 0, SDL_GetError()
window = video.SDL_CreateWindow(b"OpenGL", 10, 10, 10, 10,
video.SDL_WINDOW_OPENGL)
ctx = video.SDL_GL_CreateContext(window)
depth = c_int()
video.SDL_GL_GetAttribute(video.SDL_GL_DEPTH_SIZE, byref(depth))
video.SDL_GL_DeleteContext(ctx)
video.SDL_DestroyWindow(window)
newdepth = 24
if depth == 8:
newdepth = 16
elif depth == 16:
newdepth = 24
elif depth == 24:
newdepth = 16
video.SDL_GL_SetAttribute(video.SDL_GL_DEPTH_SIZE, newdepth)
window = video.SDL_CreateWindow(b"OpenGL", 10, 10, 10, 10,
video.SDL_WINDOW_OPENGL)
ctx = video.SDL_GL_CreateContext(window)
val = c_int()
video.SDL_GL_GetAttribute(video.SDL_GL_DEPTH_SIZE, byref(val))
assert depth != val
assert val.value >= newdepth
# self.assertEqual(val.value, newdepth)
video.SDL_GL_DeleteContext(ctx)
video.SDL_DestroyWindow(window)
video.SDL_GL_UnloadLibrary()
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_GetKeyboardFocus(self):
# window = keyboard.SDL_GetKeyboardFocus()
# TODO: x
# self.assertEqual(window, None)
rwin = video.SDL_CreateWindow(b"test", 10, 10, 10, 10, 0)
window = keyboard.SDL_GetKeyboardFocus()
if window:
assert video.SDL_GetWindowID(window) == video.SDL_GetWindowID(rwin)
video.SDL_DestroyWindow(rwin)
window = keyboard.SDL_GetKeyboardFocus()
def test_SDL_GetSetWindowGrab(self):
flags = (video.SDL_WINDOW_BORDERLESS,
video.SDL_WINDOW_BORDERLESS | video.SDL_WINDOW_HIDDEN,
video.SDL_WINDOW_RESIZABLE | video.SDL_WINDOW_MINIMIZED)
for flag in flags:
window = video.SDL_CreateWindow(b"Test", 200, 200, 200, 200, flag)
assert video.SDL_GetWindowGrab(window) == SDL_FALSE
video.SDL_SetWindowGrab(window, SDL_TRUE)
assert video.SDL_GetWindowGrab(window) == SDL_TRUE
video.SDL_SetWindowGrab(window, SDL_FALSE)
assert video.SDL_GetWindowGrab(window) == SDL_FALSE
def test_SDL_CreateTextureFromSurface(self):
sf = surface.SDL_CreateRGBSurface(0, 100, 100, 32, 0xFF000000,
0x00FF0000, 0x0000FF00, 0x000000FF)
self.assertIsInstance(sf.contents, surface.SDL_Surface)
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_CreateTextureFromSurface(renderer, sf)
self.assertIsInstance(tex.contents, render.SDL_Texture)
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_SDL_RenderGetSetViewport(self):
rects = (
rect.SDL_Rect(0, 0, 0, 0),
rect.SDL_Rect(0, 0, 10, 10),
rect.SDL_Rect(3, 3, 5, 5),
rect.SDL_Rect(-5, -5, 10, 10),
rect.SDL_Rect(10, 10, 10, 10),
rect.SDL_Rect(0, 0, -10, -10),
rect.SDL_Rect(-10, 0, 10, 10),
rect.SDL_Rect(0, -10, 10, 10),
rect.SDL_Rect(-10, -10, 10, 10),
)
failcount = 0
port = rect.SDL_Rect()
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 | video.SDL_WINDOW_BORDERLESS)
assert isinstance(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
assert isinstance(renderer.contents, render.SDL_Renderer)
ret = render.SDL_RenderSetViewport(renderer, None)
assert ret == 0
render.SDL_RenderGetViewport(renderer, byref(port))
assert port == rect.SDL_Rect(0, 0, 10, 10)
for r in rects:
if r.w == r.h == 0:
# http://bugzilla.libsdl.org/show_bug.cgi?id=1622
# OpenGL renderers cause a exception here.
continue
ret = render.SDL_RenderSetViewport(renderer, r)
assert ret == 0
render.SDL_RenderGetViewport(renderer, byref(port))
if port != r:
failcount += 1
render.SDL_DestroyRenderer(renderer)
video.SDL_DestroyWindow(window)
assert not (failed == rcount), "could not create a renderer"
errmsg = ("For some reason, even with correct values, this seems to "
"fail on creating the second renderer of the window, if any")
if failcount > 0:
pytest.skip(errmsg)
dogc()
def test_SDL_SetWindowResizable(self):
if video.SDL_GetCurrentVideoDriver() == b"dummy":
pytest.skip("dummy video driver does not support resizable flags")
window = video.SDL_CreateWindow(b"Resizable", 10, 10, 10, 10,
video.SDL_WINDOW_RESIZABLE)
flags = video.SDL_GetWindowFlags(window)
assert flags & video.SDL_WINDOW_RESIZABLE == video.SDL_WINDOW_RESIZABLE
video.SDL_SetWindowResizable(window, SDL_FALSE)
flags = video.SDL_GetWindowFlags(window)
assert flags & video.SDL_WINDOW_RESIZABLE != video.SDL_WINDOW_RESIZABLE
video.SDL_SetWindowResizable(window, SDL_TRUE)
flags = video.SDL_GetWindowFlags(window)
assert flags & video.SDL_WINDOW_RESIZABLE == video.SDL_WINDOW_RESIZABLE
video.SDL_DestroyWindow(window)
def test_SDL_CreateWindow(self):
# Borderless to ensure that the size check works
flags = (video.SDL_WINDOW_BORDERLESS,
video.SDL_WINDOW_BORDERLESS | video.SDL_WINDOW_HIDDEN)
for flag in flags:
window = video.SDL_CreateWindow(b"Test", 10, 11, 12, 13, flag)
assert isinstance(window.contents, video.SDL_Window)
px, py = c_int(), c_int()
video.SDL_GetWindowPosition(window, byref(px), byref(py))
assert (px.value, py.value) == (10, 11)
video.SDL_GetWindowSize(window, byref(px), byref(py))
assert (px.value, py.value) == (12, 13)
assert video.SDL_GetWindowFlags(window) & flag == flag
assert video.SDL_GetWindowTitle(window) == b"Test"
video.SDL_DestroyWindow(window)
def test_SDL_GetSetWindowPosition(self):
window = video.SDL_CreateWindow(b"Test", 10, 10, 10, 10, 0)
px, py = c_int(), c_int()
video.SDL_GetWindowPosition(window, byref(px), byref(py))
assert (px.value, py.value) == (10, 10)
video.SDL_SetWindowPosition(window, 0, 0)
video.SDL_GetWindowPosition(window, byref(px), byref(py))
assert (px.value, py.value) == (0, 0)
video.SDL_SetWindowPosition(window, 600, 900)
video.SDL_GetWindowPosition(window, byref(px), byref(py))
assert (px.value, py.value) == (600, 900)
video.SDL_SetWindowPosition(window, -200, -10)
video.SDL_GetWindowPosition(window, byref(px), byref(py))
assert (px.value, py.value) == (-200, -10)
video.SDL_DestroyWindow(window)
def test_SDL_SetWindowFullscreen(self):
# TODO: HIDDEN avoids flickering, but is this really a sufficient test?
flags = (video.SDL_WINDOW_BORDERLESS | video.SDL_WINDOW_HIDDEN,
video.SDL_WINDOW_BORDERLESS | video.SDL_WINDOW_HIDDEN,
video.SDL_WINDOW_RESIZABLE | video.SDL_WINDOW_MINIMIZED
| video.SDL_WINDOW_HIDDEN)
is_fullscreen = video.SDL_WINDOW_FULLSCREEN
for flag in flags:
window = video.SDL_CreateWindow(b"Test", 0, 0, 1024, 768, flag)
video.SDL_SetWindowFullscreen(window, True)
flags = video.SDL_GetWindowFlags(window)
assert flags & is_fullscreen == is_fullscreen
video.SDL_SetWindowFullscreen(window, False)
flags = video.SDL_GetWindowFlags(window)
assert flags & is_fullscreen != is_fullscreen
video.SDL_DestroyWindow(window)
def test_SDL_GL_SwapWindow(self):
if video.SDL_GetCurrentVideoDriver() == b"dummy":
pytest.skip("dummy video driver does not support GL loading")
assert video.SDL_GL_LoadLibrary(None) == 0, SDL_GetError()
window = video.SDL_CreateWindow(b"OpenGL", 10, 10, 10, 10,
video.SDL_WINDOW_OPENGL)
ctx = video.SDL_GL_CreateContext(window)
video.SDL_GL_MakeCurrent(window, ctx)
video.SDL_GL_SwapWindow(window)
video.SDL_GL_SwapWindow(window)
video.SDL_GL_SwapWindow(window)
video.SDL_GL_SwapWindow(window)
video.SDL_GL_DeleteContext(ctx)
video.SDL_DestroyWindow(window)
video.SDL_GL_UnloadLibrary()
