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]
