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()