def __init__(self, shader_programs=None, version=(3, 3)): if sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) != 0: print(sdl2.SDL_GetError()) return -1 self.window = sdl2.SDL_CreateWindow(b"SDL2 OpenGL Context", sdl2.SDL_WINDOWPOS_UNDEFINED, sdl2.SDL_WINDOWPOS_UNDEFINED, self.viewport[2], self.viewport[3], sdl2.SDL_WINDOW_OPENGL) if not self.window: print(sdl2.SDL_GetError()) return -1 # Force OpenGL 3.3 'core' context. # Must set *before* creating GL context! video.SDL_GL_SetAttribute(video.SDL_GL_CONTEXT_MAJOR_VERSION, version[0]) video.SDL_GL_SetAttribute(video.SDL_GL_CONTEXT_MINOR_VERSION, version[1]) video.SDL_GL_SetAttribute(video.SDL_GL_CONTEXT_PROFILE_MASK, video.SDL_GL_CONTEXT_PROFILE_CORE) self.context = sdl2.SDL_GL_CreateContext(self.window) self.update()
def main(): sdl2.sdl2_load( ctypes.util.find_library('SDL2')) # '/usr/local/lib/libSDL2.dylib' sdl2.SDL_Init(sdl2.SDL_INIT_EVERYTHING) WINDOW_W = 320 WINDOW_H = 240 window = sdl2.SDL_CreateWindow(b"1st SDL Window via Python-SDL2", 0, 0, WINDOW_W, WINDOW_H, 0) fpsdelay = 100 count = 0 event = sdl2.SDL_Event() done = False while not done: while sdl2.SDL_PollEvent(ctypes.byref(event)) != 0: # 'type' and 'timestamp' are common members for all SDL Event structs. event_type = event.common.type event_timestamp = event.common.timestamp print("Event : type=0x%s, timestamp=%s" % (event_type, event_timestamp)) if event_type == sdl2.SDL_KEYDOWN: if event.key.keysym.sym == sdl2.SDLK_ESCAPE: print("\tSPACE key pressed.") count += 1 if count >= 100: done = True sdl2.SDL_Delay(fpsdelay) sdl2.SDL_Quit()
def run(): sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) window = sdl2.SDL_CreateWindow(b"Hello World", sdl2.SDL_WINDOWPOS_CENTERED, sdl2.SDL_WINDOWPOS_CENTERED, 592, 460, sdl2.SDL_WINDOW_SHOWN) fname = os.path.join(os.path.dirname(os.path.abspath(__file__)), "resources", "hello.bmp") image = sdl2.SDL_LoadBMP(fname.encode("utf-8")) windowsurface = sdl2.SDL_GetWindowSurface(window) sdl2.SDL_BlitSurface(image, None, windowsurface, None) sdl2.SDL_UpdateWindowSurface(window) sdl2.SDL_FreeSurface(image) running = True event = sdl2.SDL_Event() while running: while sdl2.SDL_PollEvent(ctypes.byref(event)) != 0: if event.type == sdl2.SDL_QUIT: running = False break sdl2.SDL_Delay(10) sdl2.SDL_DestroyWindow(window) sdl2.SDL_Quit() return 0
def main(): window_size = (DEFAULT_WINDOW_WIDTH, DEFAULT_WINDOW_HEIGHT) sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) window = sdl2.SDL_CreateWindow( b"Lab 1 - Cardioid", sdl2.SDL_WINDOWPOS_CENTERED, sdl2.SDL_WINDOWPOS_CENTERED, window_size[0], window_size[1], sdl2.SDL_WINDOW_SHOWN | sdl2.SDL_WINDOW_RESIZABLE) # CREATE !!! renderer = sdl2.SDL_CreateRenderer(window, -1, sdl2.SDL_RENDERER_ACCELERATED) running = True event = sdl2.SDL_Event() while running: while sdl2.SDL_PollEvent(ctypes.byref(event)) != 0: if event.type == sdl2.SDL_QUIT: running = False break elif event.type == sdl2.SDL_WINDOWEVENT: if event.window.event == sdl2.SDL_WINDOWEVENT_SIZE_CHANGED: new_width = event.window.data1 new_height = event.window.data2 print("Window {} resized to {}x{}".format( event.window.windowID, new_width, new_height)) window_size = (new_width, new_height) draw(renderer, window_size) sdl2.SDL_DestroyWindow(window) sdl2.SDL_Quit() return 0
def __init__(self, Δx=1.0, Δy=1.0, m=10, n=10): self.Δx = Δx self.Δy = Δy self.m = m self.n = n self.width = Δx * m self.height = Δy * n if sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) != 0: print(sdl2.SDL_GetError()) return sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_MAJOR_VERSION, 3) sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_MINOR_VERSION, 3) sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_PROFILE_MASK, sdl2.SDL_GL_CONTEXT_PROFILE_CORE) self.window = sdl2.SDL_CreateWindow( b"Example 1", sdl2.SDL_WINDOWPOS_UNDEFINED, sdl2.SDL_WINDOWPOS_UNDEFINED, 640, 480, sdl2.SDL_WINDOW_OPENGL | sdl2.SDL_WINDOW_ALWAYS_ON_TOP) sdl2.SDL_SetWindowInputFocus(self.window) self.context = sdl2.SDL_GL_CreateContext(self.window) self.setupGL() self.prepGrid() self.prepBuffers() sdl2.SDL_RaiseWindow(self.window)
def __init__( self, width: int, height: int, fft_bins: int # Number of bins in a FFT spectrum. ): # The object creates interacts with Window Manager of the OS. # And displays the rendered pixel data in Window. # Width and Height are dynamic (must overflow the Display size). self.window = sdl2.SDL_CreateWindow(b'', sdl2.SDL_WINDOWPOS_CENTERED, sdl2.SDL_WINDOWPOS_CENTERED, width, height, sdl2.SDL_RENDERER_ACCELERATED) # Renderer draws rasterizes the data to pixels to be # displayed on the screen. (Doesn't support Float precision). self.renderer = sdl2.SDL_CreateRenderer(self.window, 0, sdl2.SDL_RENDERER_ACCELERATED) # Stores severeal information about events get emitted # in SDL2. Mainly required to detect "Window Close". self.event = sdl2.SDL_Event() # Create several SDL_Point objects which store the coordinates # of the path. self.data_points = pointer((sdl2.SDL_Point * fft_bins)()) self.bar_width = width / fft_bins self.viewport = {'width': width, 'height': height} self.fft_bins = fft_bins
def __init__(self, lcd, w, h, scale, title, pos=(sdl2.SDL_WINDOWPOS_CENTERED, sdl2.SDL_WINDOWPOS_CENTERED)): self.lcd = lcd self.width = w self.height = h self.mouse_hover_x = -1 self.mouse_hover_y = -1 self.mouse_x = -1 self.mouse_y = -1 self.scale = scale self.window = sdl2.SDL_CreateWindow(title, pos[0], pos[1], w * scale, h * scale, sdl2.SDL_WINDOW_RESIZABLE) self.buf, self.buf0, self.buf_p = make_buffer(w, h) self.sdlrenderer = sdl2.SDL_CreateRenderer( self.window, -1, sdl2.SDL_RENDERER_ACCELERATED) self.sdl_texture_buffer = sdl2.SDL_CreateTexture( self.sdlrenderer, sdl2.SDL_PIXELFORMAT_RGBA32, sdl2.SDL_TEXTUREACCESS_STATIC, w, h) sdl2.SDL_ShowWindow(self.window)
def init(self, hide_window): self._ticks = sdl2.SDL_GetTicks() # Should be less... https://wiki.libsdl.org/SDL_Init sdl2.SDL_Init(sdl2.SDL_INIT_EVERYTHING) self._window = sdl2.SDL_CreateWindow(b"PyBoy", sdl2.SDL_WINDOWPOS_CENTERED, sdl2.SDL_WINDOWPOS_CENTERED, self._scaledresolution[0], self._scaledresolution[1], sdl2.SDL_WINDOW_RESIZABLE) self._sdlrenderer = sdl2.SDL_CreateRenderer( self._window, -1, sdl2.SDL_RENDERER_ACCELERATED) self._sdltexturebuffer = sdl2.SDL_CreateTexture( self._sdlrenderer, sdl2.SDL_PIXELFORMAT_RGBA32, sdl2.SDL_TEXTUREACCESS_STATIC, COLS, ROWS) self.blank_screen() if hide_window: sdl2.SDL_HideWindow(self._window) else: sdl2.SDL_ShowWindow(self._window)
def __init__(self, width, height, title): self.width, self.height = width, height self.title = title if sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) != 0: print(sdl2.SDL_GetError()) exit(-1) self.window = sdl2.SDL_CreateWindow( str.encode(self.title), sdl2.SDL_WINDOWPOS_CENTERED, sdl2.SDL_WINDOWPOS_CENTERED, self.width, self.height, sdl2.SDL_WINDOW_OPENGL | sdl2.SDL_WINDOW_SHOWN) if not self.window: print(sdl2.SDL_GetError()) exit(-1) # Force OpenGL 4.3 'core' context. This is needed for compute shader support. SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4) SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3) SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE) SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8) SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8) SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8) SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8) SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, 32) SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24) SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1) self._context = sdl2.SDL_GL_CreateContext(self.window)
def __init__(self, display_scale: int = 10): self._display_scale = display_scale self._width = self._display_scale * Display._original_width self._height = self._display_scale * Display._original_height self._pixels = np.zeros(Display._original_width * Display._original_height, dtype=np.uint32) if sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) < 0: raise sdl2.ext.SDLError() self._window = sdl2.SDL_CreateWindow(b'pychip8', sdl2.SDL_WINDOWPOS_UNDEFINED, sdl2.SDL_WINDOWPOS_UNDEFINED, self._width, self._height, sdl2.SDL_WINDOW_SHOWN) if not self._window: raise sdl2.ext.SDLError() self._renderer = sdl2.SDL_CreateRenderer(self._window, -1, sdl2.SDL_RENDERER_ACCELERATED) if not self._renderer: raise sdl2.ext.SDLError() self._texture = sdl2.SDL_CreateTexture( self._renderer, sdl2.SDL_PIXELFORMAT_ARGB8888, sdl2.SDL_TEXTUREACCESS_STREAMING, Display._original_width, Display._original_height) if not self._texture: raise sdl2.ext.SDLError() sdl2.SDL_RenderClear(self._renderer) sdl2.SDL_RenderPresent(self._renderer)
def initialize(self): if os.name == "nt": ctypes.windll.shcore.SetProcessDpiAwareness(1) sdl2.SDL_Init(sdl2.SDL_INIT_EVERYTHING) IMG_Init(IMG_INIT_PNG) # Ugly hack to determine resolution scaling factor as early as possible. win = sdl2.SDL_CreateWindow( "ResolutionTest".encode("utf-8"), sdl2.SDL_WINDOWPOS_UNDEFINED, sdl2.SDL_WINDOWPOS_UNDEFINED, 100, 100, sdl2.SDL_WINDOW_HIDDEN | sdl2.SDL_WINDOW_ALLOW_HIGHDPI, ) rend = sdl2.SDL_CreateRenderer(win, -1, sdl2.SDL_RENDERER_ACCELERATED) win_w = ctypes.c_int() rend_w = ctypes.c_int() sdl2.SDL_GetWindowSize(win, ctypes.byref(win_w), None) sdl2.SDL_GetRendererOutputSize(rend, ctypes.byref(rend_w), None) # Windows HiDPI is silly like this. You get back different window sizes than you put in. self.win_scale = win_w.value / 100.0 Environment.scale.default = rend_w.value / 100.0 sdl2.SDL_DestroyRenderer(rend) sdl2.SDL_DestroyWindow(win) # Initialize our font cache and calculate DPI scaling. Font.initialize()
def _create_handles(window_title, window_position, window_size, window_flags, renderer_info): """Create the SDL2 handles.""" window_flags = sdl2.SDL_WINDOW_SHOWN | window_flags if renderer_info.api == GraphicsAPI.OPENGL: window_flags |= sdl2.SDL_WINDOW_OPENGL window = sdl2.SDL_CreateWindow( window_title.encode(), window_position.x, window_position.y, window_size.x, window_size.y, window_flags) if not window: raise RuntimeError(sdl2.SDL_GetError().decode()) context = sdl2.SDL_GL_CreateContext(window) if not context: raise RuntimeError(sdl2.SDL_GetError().decode()) # Try to disable the vertical synchronization. It applies to the active # context and thus needs to be called after `SDL_GL_CreateContext`. sdl2.SDL_GL_SetSwapInterval(0) return _Handles( window=window, renderer=_GLHandles(context=context))
def main(): sdl2.sdl2_load(ctypes.util.find_library('SDL2'), # '/usr/local/lib/libSDL2.dylib' ttf_libpath = ctypes.util.find_library('SDL2_ttf'), img_libpath = ctypes.util.find_library('SDL2_image') ) sdl2.SDL_Init(sdl2.SDL_INIT_EVERYTHING) WINDOW_W = 640 WINDOW_H = 360 window = sdl2.SDL_CreateWindow(b"Minimal SDL_Image Test via python-sdl2", 0, 0, WINDOW_W, WINDOW_H, sdl2.SDL_WINDOW_OPENGL) renderer = sdl2.SDL_CreateRenderer(window, -1, 0) sdl2.IMG_Init(sdl2.IMG_INIT_JPG|sdl2.IMG_INIT_PNG|sdl2.IMG_INIT_TIF|sdl2.IMG_INIT_WEBP) rwops_ptr = sdl2.SDL_RWFromFile(bytes(sys.argv[1], 'utf-8'), b"rb") print("PNG?: %s" % ('true' if sdl2.IMG_isPNG(rwops_ptr) else 'false')) texture = sdl2.IMG_LoadTexture_RW(renderer, rwops_ptr, 1) wh = 300 pos = sdl2.SDL_Rect() pos.x = int((WINDOW_W - wh) / 2) pos.y = int((WINDOW_H - wh) / 2) pos.w = wh pos.h = wh sdl2.SDL_RenderCopy(renderer, texture, None, ctypes.byref(pos)) sdl2.SDL_RenderPresent(renderer) fpsdelay = 100 count = 0 event = sdl2.SDL_Event() done = False while not done: while sdl2.SDL_PollEvent(ctypes.byref(event)) != 0: # 'type' and 'timestamp' are common members for all SDL Event structs. event_type = event.common.type event_timestamp = event.common.timestamp # print("Event : type=0x%s, timestamp=%s" % (event_type, event_timestamp) ) if event_type == sdl2.SDL_KEYDOWN: if event.key.keysym.sym == sdl2.SDLK_ESCAPE: done = True sdl2.SDL_SetRenderDrawColor(renderer, 0xA0, 0xA0, 0xA0, 0xFF) sdl2.SDL_RenderClear(renderer) sdl2.SDL_RenderCopy(renderer, texture, None, ctypes.byref(pos)) sdl2.SDL_RenderPresent(renderer) sdl2.SDL_Delay(fpsdelay) sdl2.IMG_Quit() sdl2.SDL_DestroyRenderer(renderer) sdl2.SDL_DestroyWindow(window) sdl2.SDL_Quit()
def __init__(self, width, height): self.width = width self.height = height # init SDL sdl2.SDL_Init(sdl2.SDL_INIT_EVERYTHING) sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_DOUBLEBUFFER, 1) self.window = sdl2.SDL_CreateWindow( b"SPARK(&pyspk) Fireworks Demo", sdl2.SDL_WINDOWPOS_UNDEFINED, sdl2.SDL_WINDOWPOS_UNDEFINED, width, height, sdl2.SDL_WINDOW_SHOWN | sdl2.SDL_WINDOW_OPENGL) sdl2.SDL_CaptureMouse(True) # init OpenGL self.context = sdl2.SDL_GL_CreateContext(self.window) sdl2.SDL_GL_SetSwapInterval(0) gl.glClearColor(0.0, 0.0, 0.0, 1.0) surface = sdl2.SDL_GetWindowSurface(self.window) gl.glViewport(0, 0, surface.contents.w, surface.contents.h) # load Textures texture = loadTexture(b'res/flare.bmp', gl.GL_ALPHA, gl.GL_REPEAT) # init FTGL if not notext: font = FTGL.TextureFont('res/font.ttf') font.FaceSize(24) self.font = font # init SPARK(pyspk) # random seed initialization spk.setRandomSeed(int(time.time())) # step configuration spk.System.setClampStep(True, 0.1) # clamp the step to 100 ms spk.System.useAdaptiveStep(0.001, 0.01) # use an adaptive step from 1ms to 10ms (1000fps to 100fps) # the base system self.basesystem = BaseSystem(self.height, texture) print('SPARK FACTORY AFTER INIT :') spk.Factory.getInstance().traceAll() # init Variables self.running = True self.paused = False self.deltaTime = 0 self.step = 0 self.text = 2 self.renderValue = 0 self.angleY = 0.0 self.camPosZ = 5.0 self.spacePressed = -1.0 self.systems = [] self.nbParticles = '' self.fps = '' self.frames = [sdl2.SDL_GetTicks()-1] self.lasttime = self.frames[-1]
def __init__(self): """ Initializes sdl2, sets up key and mouse events and creates a ``moderngl.Context`` using the context sdl2 createad. Using the sdl2 window requires sdl binaries and PySDL2. """ super().__init__() self.window_closing = False self.tmp_size_x = c_int() self.tmp_size_y = c_int() print("Using sdl2 library version:", self.get_library_version()) if sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) != 0: raise ValueError("Failed to initialize sdl2") sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_MAJOR_VERSION, self.gl_version.major) sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_MINOR_VERSION, self.gl_version.minor) sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_PROFILE_MASK, sdl2.SDL_GL_CONTEXT_PROFILE_CORE) sdl2.video.SDL_GL_SetAttribute( sdl2.SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG, 1) sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_DOUBLEBUFFER, 1) sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_DEPTH_SIZE, 24) sdl2.SDL_ShowCursor( sdl2.SDL_ENABLE if self.cursor else sdl2.SDL_DISABLE) if self.samples > 1: sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_MULTISAMPLEBUFFERS, 1) sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_MULTISAMPLESAMPLES, self.samples) flags = sdl2.SDL_WINDOW_OPENGL if self.fullscreen: flags |= sdl2.SDL_WINDOW_FULLSCREEN_DESKTOP else: if self.resizable: flags |= sdl2.SDL_WINDOW_RESIZABLE self.window = sdl2.SDL_CreateWindow(self.title.encode(), sdl2.SDL_WINDOWPOS_UNDEFINED, sdl2.SDL_WINDOWPOS_UNDEFINED, self.width, self.height, flags) if not self.window: raise ValueError("Failed to create window:", sdl2.SDL_GetError()) self.context = sdl2.SDL_GL_CreateContext(self.window) sdl2.video.SDL_GL_SetSwapInterval(1 if self.vsync else 0) self.ctx = moderngl.create_context(require=self.gl_version.code) context.WINDOW = self self.fbo = self.ctx.screen self.set_default_viewport()
def __init__(self, **kwargs): super().__init__(**kwargs) if sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) != 0: raise ValueError("Failed to initialize sdl2") # Configure OpenGL context sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_MAJOR_VERSION, self.gl_version[0]) sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_MINOR_VERSION, self.gl_version[1]) sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_PROFILE_MASK, sdl2.SDL_GL_CONTEXT_PROFILE_CORE) sdl2.video.SDL_GL_SetAttribute( sdl2.SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG, 1) sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_DOUBLEBUFFER, 1) sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_DEPTH_SIZE, 24) # Display/hide mouse cursor sdl2.SDL_ShowCursor( sdl2.SDL_ENABLE if self.cursor else sdl2.SDL_DISABLE) # Configure multisampling if self.samples > 1: sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_MULTISAMPLEBUFFERS, 1) sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_MULTISAMPLESAMPLES, self.samples) # Built the window flags flags = sdl2.SDL_WINDOW_OPENGL if self.fullscreen: # Use primary desktop screen resolution flags |= sdl2.SDL_WINDOW_FULLSCREEN_DESKTOP else: if self.resizable: flags |= sdl2.SDL_WINDOW_RESIZABLE # Create the window self.window = sdl2.SDL_CreateWindow( self.title.encode(), sdl2.SDL_WINDOWPOS_UNDEFINED, sdl2.SDL_WINDOWPOS_UNDEFINED, self.width, self.height, flags, ) if not self.window: raise ValueError("Failed to create window:", sdl2.SDL_GetError()) self.context = sdl2.SDL_GL_CreateContext(self.window) sdl2.video.SDL_GL_SetSwapInterval(1 if self.vsync else 0) self.ctx = moderngl.create_context(require=self.gl_version_code) self.set_default_viewport() self.print_context_info()
def __init__(self): window = sdl2.SDL_CreateWindow( bytes("haxima2", "utf-8"), sdl2.SDL_WINDOWPOS_UNDEFINED, sdl2.SDL_WINDOWPOS_UNDEFINED, 640 * 2, 480 * 2, sdl2.SDL_WINDOW_SHOWN | sdl2.SDL_WINDOW_OPENGL, ) self._renderer = sdl2.SDL_CreateRenderer(window, -1, 0)
def __init__(self, title, width=DEFAULT_WIDTH, height=DEFAULT_HEIGHT): sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO | sdl2.SDL_INIT_TIMER) self.sdl_window = sdl2.SDL_CreateWindow(title, sdl2.SDL_WINDOWPOS_CENTERED, sdl2.SDL_WINDOWPOS_CENTERED, width, height, sdl2.SDL_WINDOW_RESIZABLE) self._right_mouse_pressed = False self._left_mouse_pressed = False self._renderer = Renderer(self) self.resize()
def init_sdl2(game, window_name): global cell_size sdl2.ext.init() wsize = cell_size * game.size window = sdl2.SDL_CreateWindow(bytes(window_name, 'utf-8'), sdl2.SDL_WINDOWPOS_UNDEFINED, sdl2.SDL_WINDOWPOS_UNDEFINED, wsize, wsize, sdl2.SDL_WINDOW_SHOWN) renderer = sdl2.SDL_CreateRenderer(window, -1, sdl2.SDL_RENDERER_ACCELERATED) return window, renderer
def setupWindow(self, width, height): self.window = sdl2.SDL_CreateWindow( "%s: %s" % (config.sdl_window_caption, self.clientName), sdl2.SDL_WINDOWPOS_CENTERED, sdl2.SDL_WINDOWPOS_CENTERED, width, height, sdl2.SDL_WINDOW_SHOWN) self.renderer = sdl2.SDL_CreateRenderer( self.window, -1, sdl2.SDL_RENDERER_ACCELERATED) self.texture = sdl2.SDL_CreateTexture( self.renderer, sdl2.SDL_PIXELFORMAT_YV12, sdl2.SDL_TEXTUREACCESS_STREAMING, width, height)
def init_rendering(): global window, render_context # initialize window sdl2.SDL_Init(sdl2.SDL_INIT_EVERYTHING) window = sdl2.SDL_CreateWindow("Peer 2 Paint".encode('utf-8'), sdl2.SDL_WINDOWPOS_CENTERED, sdl2.SDL_WINDOWPOS_CENTERED, window_x, window_y, 0) render_context = RenderContext(window)
def initialise(self, size): # pylint: disable=arguments-differ sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) self.window = sdl2.SDL_CreateWindow( b"Departure board", sdl2.SDL_WINDOWPOS_CENTERED, sdl2.SDL_WINDOWPOS_CENTERED, *size, sdl2.SDL_WINDOW_SHOWN ) self.renderer = sdl2.SDL_CreateRenderer( self.window, -1, sdl2.SDL_RENDERER_ACCELERATED )
def __init__( self, width=256, height=256, title=None, visible=True, aspect=None, decoration=True, fullscreen=False, config=None, context=None, color=(0,0,0,1)): """ """ window.Window.__init__(self, width=width, height=height, title=title, visible=visible, aspect=aspect, decoration=decoration, fullscreen=fullscreen, config=config, context=context, color=color) if config is None: config = configuration.Configuration() set_configuration(config) flags = sdl2.SDL_WINDOW_SHOWN # flags |= sdl2.SDL_WINDOW_ALLOW_HIGHDPI flags |= sdl2.SDL_WINDOW_RESIZABLE flags |= sdl2.SDL_WINDOW_OPENGL if visible: flags |= sdl2.SDL_WINDOW_SHOWN else: flags |= SDL_WINDOW_HIDDEN if not decoration: flags |= sdl2.SDL_WINDOW_BORDERLESS self._native_window = sdl2.SDL_CreateWindow(self._title, sdl2.SDL_WINDOWPOS_UNDEFINED, sdl2.SDL_WINDOWPOS_UNDEFINED, width, height, flags) self._native_context = sdl2.SDL_GL_CreateContext(self._native_window) self._native_id = sdl2.SDL_GetWindowID(self._native_window) sdl2.SDL_GL_SetSwapInterval(0) # OSX: check framebuffer size / window size. On retina display, they # can be different so we try to correct window size such as having # the framebuffer size of the right size # w,h = ctypes.c_int(),ctypes.c_int() # sdl2.SDL_GL_GetDrawableSize(self._native_window, w, h) # w,h = w.value(), h.value() # if w != width or h!= height: # width = width/2 # height= height/2 # sdl2.SDL_SetWindowSize(self._native_window, int(width), int(height)) self._height = height self._width = width __windows__[self._native_id] = self
def __init__(self, **kwargs): super().__init__(**kwargs) if sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) != 0: raise ValueError("Failed to initialize sdl2") sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_MAJOR_VERSION, self.gl_version[0]) sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_MINOR_VERSION, self.gl_version[1]) sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_CONTEXT_PROFILE_MASK, sdl2.SDL_GL_CONTEXT_PROFILE_CORE) sdl2.video.SDL_GL_SetAttribute( sdl2.SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG, 1) sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_DOUBLEBUFFER, 1) sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_DEPTH_SIZE, 24) sdl2.SDL_ShowCursor( sdl2.SDL_ENABLE if self.cursor else sdl2.SDL_DISABLE) if self.samples > 1: sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_MULTISAMPLEBUFFERS, 1) sdl2.video.SDL_GL_SetAttribute(sdl2.SDL_GL_MULTISAMPLESAMPLES, self.samples) flags = sdl2.SDL_WINDOW_OPENGL if self.fullscreen: flags |= sdl2.SDL_WINDOW_FULLSCREEN_DESKTOP else: if self.resizable: flags |= sdl2.SDL_WINDOW_RESIZABLE self._window = sdl2.SDL_CreateWindow( self.title.encode(), sdl2.SDL_WINDOWPOS_UNDEFINED, sdl2.SDL_WINDOWPOS_UNDEFINED, self.width, self.height, flags, ) if not self._window: raise ValueError("Failed to create window:", sdl2.SDL_GetError()) self._context = sdl2.SDL_GL_CreateContext(self._window) sdl2.video.SDL_GL_SetSwapInterval(1 if self.vsync else 0) if self._create_mgl_context: self.init_mgl_context() self.set_default_viewport()
def _do_create_window(self, width, height): """Create a new SDL window """ flags = sdl2.SDL_WINDOW_RESIZABLE | sdl2.SDL_WINDOW_SHOWN if self.fullscreen: flags |= sdl2.SDL_WINDOW_FULLSCREEN_DESKTOP | sdl2.SDL_WINDOW_BORDERLESS sdl2.SDL_DestroyWindow(self.display) self.display = sdl2.SDL_CreateWindow(self.caption, sdl2.SDL_WINDOWPOS_CENTERED, sdl2.SDL_WINDOWPOS_CENTERED, width, height, flags) self._set_icon() self.display_surface = sdl2.SDL_GetWindowSurface(self.display) self.screen_changed = True self.window_width, self.window_height = width, height
def _create(self): '''Create SDL2 Window''' if sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) != 0: logging.error('SDL2 library with video flag fail to initialise') exit() logging.info('SDL2 library with video flag initialised.') self.window = sdl2.SDL_CreateWindow(self.title.encode('ascii'), self.x, self.y, self.w, self.h, self.flag) if not self.window: logging.error('Fail to create SDL2 window.') exit() logging.info('Created SDL2 Window: {}.'.format(self.title))
def InitializeSDL(self): # SDL sub systems sdl2.SDL_Init(sdl2.SDL_INIT_EVERYTHING) # Video sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) # Window self.window = sdl2.SDL_CreateWindow("shoot 0.0.1",\ sdl2.SDL_WINDOWPOS_UNDEFINED,\ sdl2.SDL_WINDOWPOS_UNDEFINED, 640,\ 480,\ sdl2.SDL_WINDOW_SHOWN) # renderer self.sdl_renderer = sdl2.SDL_CreateRenderer(self.window, -1,\ sdl2.SDL_RENDERER_ACCELERATED) sdl2.SDL_SetRenderDrawColor(self.sdl_renderer, 255, 255, 255, 0) # Sound (from tutorial: http://lazyfoo.net/SDL_tutorials/lesson11/index.php ) # Initialize sdl mixer # Mix_OpenAudio args # First arg (22050) is sound frequency (recommended according to multiple tutorials, # but look into this) # Second arg is sound format # Third arg is number of channels we plan to use (e.g., 2 for stereo sound) # Fourth arg is the sample size (should be 4096) # Audio #sdl2.SDL_Init(sdl2.SDL_INIT_AUDIO) # If using SDL sound; shouldn't do this sdl2.sdlmixer.Mix_Init(sdl2.sdlmixer.MIX_INIT_MOD) # Insert the file formats you wish to allow here, e.g. OGG sdl2.sdlmixer.Mix_OpenAudio(22050, sdl2.sdlmixer.MIX_DEFAULT_FORMAT, 2, 4096) # TTF sdl2.sdlttf.TTF_Init() # Joystick sdl2.SDL_Init(sdl2.SDL_INIT_JOYSTICK) self.joystick = sdl2.SDL_JoystickOpen(0) # Event self.input = sdl2.SDL_Event()
def openwindow(size=(480, 320), title='minicom', icon=None, resizable = True): if resizable: flags = sdl2.video.SDL_WINDOW_OPENGL | sdl2.video.SDL_WINDOW_RESIZABLE else: flags = sdl2.video.SDL_WINDOW_OPENGL window = sdl2.SDL_CreateWindow(title.encode('utf-8'), sdl2.video.SDL_WINDOWPOS_UNDEFINED, sdl2.video.SDL_WINDOWPOS_UNDEFINED, size[0], size[1], flags) if icon: sdl2.video.SDL_SetWindowIcon(window, icon) renderer = sdl2.render.SDL_CreateRenderer(window, -1, sdl2.render.SDL_RENDERER_ACCELERATED) vp = sdl2.rect.SDL_Rect(0, 0, size[0], size[1]) sdl2.render.SDL_RenderSetViewport(renderer, ctypes.byref(vp)) return (window, renderer)
def init(size=(480, 320), title='zhban test', icon=None, resizable=True): if resizable: flags = sdl2.video.SDL_WINDOW_OPENGL | sdl2.video.SDL_WINDOW_RESIZABLE else: flags = sdl2.video.SDL_WINDOW_OPENGL window = sdl2.SDL_CreateWindow(title.encode('utf-8'), sdl2.video.SDL_WINDOWPOS_UNDEFINED, sdl2.video.SDL_WINDOWPOS_UNDEFINED, size[0], size[1], flags) if icon: sdl2.video.SDL_SetWindowIcon(window, icon) renderer = sdl2.render.SDL_CreateRenderer( window, -1, sdl2.render.SDL_RENDERER_ACCELERATED) return (window, renderer)
def init(self): import sdl2 import sdl2.sdlgfx as gfx self._window = sdl2.SDL_CreateWindow(b"FGAme App", sld2.SDL_WINDOWPOS_CENTERED, sld2.SDL_WINDOWPOS_CENTERED, width, height, sld2.SDL_WINDOW_SHOWN) self._renderer = sdl2.SDL_CreateRenderer(self._window, -1, sld2.SDL_RENDERER_ACCELERATED | sld2.SDL_RENDERER_PRESENTVSYNC) self._screen_rect = sdl2.SDL_Rect(x=0, y=0, w=width, h=height) R, G, B = self.background self._bg_color = (R << 24) + (G << 16) + (B << 8) + 255 self.sdl2 = sdl2 self.gfx = gfx self._LP_short = aapolygonRGBA.argtypes[1]