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 setup_colors(self):
texture = sdl2.SDL_CreateTexture(self.renderer.sdlrenderer,
sdl2.SDL_PIXELFORMAT_BGRA32,
sdl2.SDL_TEXTUREACCESS_STREAMING,
self.img_size[1], self.img_size[0])
pixel = np.zeros(self.img_size + (4, ), dtype=np.uint8)
return texture, pixel, 4
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 renderImage(image, blocks, ren):
# create all the blocks
ren_blocks = []
for block in blocks:
ren_block = sdl2.SDL_CreateTexture(ren.sdlrenderer,
sdl2.SDL_PIXELFORMAT_ABGR8888,
sdl2.SDL_TEXTUREACCESS_STATIC, 8, 8)
pixels = bytearray()
for p in range(64):
if block[p] == 1:
pixels.append(0xff)
pixels.append(0xff)
pixels.append(0xff)
pixels.append(0xff)
else:
pixels.append(0)
pixels.append(0)
pixels.append(0)
pixels.append(0)
pointer = (ctypes.c_char * len(pixels)).from_buffer(pixels)
sdl2.SDL_UpdateTexture(ren_block, None, pointer, 8 * 4)
ren_blocks.append(ren_block)
# draw the image from the blocks
for y in range(12):
for x in range(16):
texture = ren_blocks[image[y * 16 + x]]
# texture=ren_blocks[0]
sdl2.SDL_RenderCopy(ren.sdlrenderer, texture,
sdl2.SDL_Rect(0, 0, 8, 8),
sdl2.SDL_Rect(128 + x * 8, y * 8, 8, 8))
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 renderImage(image, ren):
# create all the blocks
frame = sdl2.SDL_CreateTexture(ren.sdlrenderer,
sdl2.SDL_PIXELFORMAT_ABGR8888,
sdl2.SDL_TEXTUREACCESS_STATIC, 64, 48)
pixels = bytearray()
col = image[0] # first value is whether black or not
for val in image[2:]:
for count in range(val + 1):
if col:
pixels.append(0xff)
pixels.append(0xff)
pixels.append(0xff)
pixels.append(0xff)
else:
pixels.append(0)
pixels.append(0)
pixels.append(0)
pixels.append(0)
col = not col
pointer = (ctypes.c_char * len(pixels)).from_buffer(pixels)
sdl2.SDL_UpdateTexture(frame, None, pointer, 64 * 4)
# draw the frame
sdl2.SDL_RenderCopy(ren.sdlrenderer, frame, sdl2.SDL_Rect(0, 0, 64, 48),
sdl2.SDL_Rect(128, 0, 128, 96))
sdl2.SDL_DestroyTexture(frame)
def render_object_from_color(cls, renderer: sdl2.SDL_Renderer,
color: Color) -> RenderObject:
texture = sdl2.SDL_CreateTexture(renderer,
sdl2.SDL_PIXELFORMAT_RGBA8888,
sdl2.SDL_TEXTUREACCESS_TARGET, 1, 1)
sdl2.SDL_SetRenderTarget(renderer, texture)
sdl2.SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b,
color.a)
sdl2.SDL_RenderClear(renderer)
sdl2.SDL_SetRenderTarget(renderer, None)
return RenderObject(texture)
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__(self, entities, timer):
self.entities = entities
self.timer = timer
self.window = sdle.Window("Game", size=(self.WINDOW_X, self.WINDOW_Y))
self.renderer = sdle.Renderer(self.window,
flags=sdl.SDL_RENDERER_ACCELERATED)
self.texture = sdl.SDL_CreateTexture(self.renderer.renderer,
sdl.SDL_PIXELFORMAT_ARGB8888,
sdl.SDL_TEXTUREACCESS_STREAMING,
self.WINDOW_X, self.WINDOW_Y)
self.window.show()
def _save_pict(self, num):
pict = self.picts.get(num)
if not pict:
pict = sdl2.SDL_CreateTexture(self.renderer,
sdl2.SDL_PIXELFORMAT_RGBA8888,
sdl2.SDL_TEXTUREACCESS_TARGET, 128,
64)
self.picts[num] = pict
# render current texture to pict
sdl2.SDL_SetRenderTarget(self.renderer, pict)
sdl2.SDL_RenderCopy(self.renderer, self.texture_graph, None, None)
sdl2.SDL_SetRenderTarget(self.renderer, None)
def _initialize_sdl2(self):
sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO)
self.window = sdl2.SDL_CreateWindow(
b'CASINT: CASIO Basic Interpreter', sdl2.SDL_WINDOWPOS_CENTERED,
sdl2.SDL_WINDOWPOS_CENTERED, 512, 256,
sdl2.SDL_WINDOW_SHOWN | sdl2.SDL_WINDOW_RESIZABLE)
self.renderer = sdl2.SDL_CreateRenderer(self.window, -1,
sdl2.SDL_RENDERER_ACCELERATED)
sdl2.SDL_RenderSetLogicalSize(self.renderer, 128, 64)
self.texture_graph = sdl2.SDL_CreateTexture(
self.renderer, sdl2.SDL_PIXELFORMAT_RGBA8888,
sdl2.SDL_TEXTUREACCESS_TARGET, 128, 64)
self.texture_text = sdl2.SDL_CreateTexture(
self.renderer, sdl2.SDL_PIXELFORMAT_RGBA8888,
sdl2.SDL_TEXTUREACCESS_TARGET, 128, 64)
# for scrolling the text screen
self.texture_scroll = sdl2.SDL_CreateTexture(
self.renderer, sdl2.SDL_PIXELFORMAT_RGBA8888,
sdl2.SDL_TEXTUREACCESS_TARGET, 128, 64)
# init with a clear screen
self._render_begin(self.texture_graph)
self._clear_screen()
self._render_end()
self._render_begin(self.texture_text)
self._clear_screen()
self._render_end()
self.font_graph, self.font_graph_inverted = self._load_texture(
'img/font_graph.bmp')
self.font_text, self.font_text_inverted = self._load_texture(
'img/font_text.bmp')
def setup(self, fmt):
if fmt.codec == VideoCodec.H264:
pixel_fmt = sdl2.SDL_PIXELFORMAT_YV12
elif fmt.codec == VideoCodec.YUV:
raise TypeError("YUV format not implemented")
elif fmt.codec == VideoCodec.RGB:
raise TypeError("RGB format not implemented")
else:
raise TypeError("Unknown video codec: %d" % fmt.codec)
self._decoder = FrameDecoder.video(fmt.codec)
self._texture = sdl2.SDL_CreateTexture(
self._renderer.sdlrenderer, pixel_fmt,
sdl2.SDL_TEXTUREACCESS_STREAMING, fmt.width, fmt.height)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.NCOLS = 60
self.NROWS = 36
self.shift_down = False
self.start_address = 0x0000
self.bg_color = [0xFF, 0xFF, 0xFF]
self.fg_color = [0x00, 0x00, 0x00]
self._text_buffer_raw = array("B", [0x20] * (self.NROWS * self.NCOLS))
if cythonmode:
self.text_buffer = memoryview(self._text_buffer_raw).cast(
"B", shape=(self.NROWS, self.NCOLS))
else:
view = memoryview(self._text_buffer_raw)
self.text_buffer = [
view[i:i + self.NCOLS]
for i in range(0, self.NROWS * self.NCOLS, self.NCOLS)
]
# self.text_buffer = [bytearray([0x20]*self.NCOLS) for _ in range(self.NROWS)]
self.write_border()
self.write_addresses()
font_path = os.path.join(os.path.dirname(os.path.realpath(__file__)),
"font.txt")
with open(font_path) as font_file:
font_lines = font_file.readlines()
font_blob = "".join(
line.strip()
for line in font_lines[font_lines.index("BASE64DATA:\n") + 1:])
font_bytes = zlib.decompress(b64decode(font_blob.encode()))
self.fbuf, self.fbuf0, self.fbuf_p = make_buffer(8, 16 * 256)
for y, b in enumerate(font_bytes):
for x in range(8):
self.fbuf0[y][x] = 0xFFFFFFFF if ((0x80 >> x)
& b) else 0x00000000
self.font_texture = sdl2.SDL_CreateTexture(
self._sdlrenderer, sdl2.SDL_PIXELFORMAT_RGBA32,
sdl2.SDL_TEXTUREACCESS_STATIC, 8, 16 * 256)
self._prepare_font_texture()
# Persistent to make Cython happy...
self.src = sdl2.SDL_Rect(0, 0, 8, 16)
self.dst = sdl2.SDL_Rect(0, 0, 8, 16)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.NCOLS = 60
self.NROWS = 36
self.shift_down = False
self.start_address = 0x0000
self.bg_color = [0xFF, 0xFF, 0xFF]
self.fg_color = [0x00, 0x00, 0x00]
self._text_buffer_raw = array("B", [0x20] * (self.NROWS * self.NCOLS))
if cythonmode:
self.text_buffer = memoryview(self._text_buffer_raw).cast(
"B", shape=(self.NROWS, self.NCOLS))
else:
view = memoryview(self._text_buffer_raw)
self.text_buffer = [
view[i:i + self.NCOLS]
for i in range(0, self.NROWS * self.NCOLS, self.NCOLS)
]
# self.text_buffer = [bytearray([0x20]*self.NCOLS) for _ in range(self.NROWS)]
self.write_border()
self.write_addresses()
font_path = os.path.join("font", "ter-16b-ibm437.txt.gz")
with gzip.open(font_path) as font_file:
font_bytes = b"".join(
bytes.fromhex(x.strip().decode())
for x in font_file.readlines())
self.fbuf, self.fbuf0, self.fbuf_p = make_buffer(8, 16 * 256)
for y, b in enumerate(font_bytes):
for x in range(8):
self.fbuf0[y][x] = 0xFFFFFFFF if ((0x80 >> x)
& b) else 0x00000000
self.font_texture = sdl2.SDL_CreateTexture(
self._sdlrenderer, sdl2.SDL_PIXELFORMAT_RGBA32,
sdl2.SDL_TEXTUREACCESS_STATIC, 8, 16 * 256)
self._prepare_font_texture()
# Persistent to make Cython happy...
self.src = sdl2.SDL_Rect(0, 0, 8, 16)
self.dst = sdl2.SDL_Rect(0, 0, 8, 16)
def __init__(self, pyboy, mb, pyboy_argv, *, scale, title, width, height, pos_x, pos_y):
super().__init__(pyboy, mb, pyboy_argv)
self.scale = scale
self.width, self.height = width, height
self.base_title = title
self.hover_x = -1
self.hover_y = -1
self._window = sdl2.SDL_CreateWindow(
self.base_title.encode("utf8"), pos_x, pos_y, width * scale, height * scale, sdl2.SDL_WINDOW_RESIZABLE
)
self.window_id = sdl2.SDL_GetWindowID(self._window)
self.buf, self.buf0, self.buf_p = make_buffer(width, height)
self._sdlrenderer = sdl2.SDL_CreateRenderer(self._window, -1, sdl2.SDL_RENDERER_ACCELERATED)
self._sdltexturebuffer = sdl2.SDL_CreateTexture(
self._sdlrenderer, sdl2.SDL_PIXELFORMAT_RGBA8888, sdl2.SDL_TEXTUREACCESS_STATIC, width, height
)
def __init__(self, pyboy, mb, pyboy_argv):
super().__init__(pyboy, mb, pyboy_argv)
if not self.enabled():
return
sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO)
self._ftime = 0.0
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_RGBA8888, sdl2.SDL_TEXTUREACCESS_STATIC, COLS, ROWS
)
sdl2.SDL_ShowWindow(self._window)
def run_raw():
global renderer, bg_texture, maze, vmp, walls_texture
sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO)
window = sdl2.SDL_CreateWindow(b"Eye of the Beholder 2",
sdl2.SDL_WINDOWPOS_CENTERED, sdl2.SDL_WINDOWPOS_CENTERED,
800, 600, sdl2.SDL_WINDOW_SHOWN | sdl2.SDL_WINDOW_RESIZABLE)
renderer = sdl2.SDL_CreateRenderer(window, -1,
sdl2.SDL_RENDERER_ACCELERATED + sdl2.SDL_RENDERER_TARGETTEXTURE + sdl2.SDL_RENDERER_PRESENTVSYNC)
sdl2.SDL_SetRenderDrawBlendMode(renderer, sdl2.SDL_BLENDMODE_BLEND)
render_target = sdl2.SDL_CreateTexture(renderer, sdl2.SDL_PIXELFORMAT_RGB888, sdl2.SDL_TEXTUREACCESS_TARGET,
VP_WIDTH_PIXELS,
VP_HEIGHT_PIXELS)
sdl2.SDL_SetTextureBlendMode(render_target, sdl2.SDL_BLENDMODE_BLEND)
sdl2.sdlimage.IMG_Init(sdl2.sdlimage.IMG_INIT_PNG)
maze = load_maze('build/level1.maz')
vmp = load_vmp('build/dung.vmp.json')
bg_texture = get_vmp_bg_texture()
walls_texture = get_vmp_wall_texture()
party_position = (5, 28)
party_direction = Direction.North
running = True
event = sdl2.SDL_Event()
while running:
while sdl2.SDL_PollEvent(byref(event)) != 0:
if event.type == sdl2.SDL_QUIT:
running = False
break
elif event.type == sdl2.SDL_KEYDOWN:
if event.key.keysym.sym == KEY_W:
party_position = party_direction.update_pos(party_position)
elif event.key.keysym.sym == KEY_S:
party_position = party_direction.opposite().update_pos(party_position)
elif event.key.keysym.sym == KEY_A:
party_position = party_direction.previous_dir().update_pos(party_position)
elif event.key.keysym.sym == KEY_D:
party_position = party_direction.next_dir().update_pos(party_position)
elif event.key.keysym.sym == KEY_Q:
party_direction = party_direction.previous_dir()
elif event.key.keysym.sym == KEY_E:
party_direction = party_direction.next_dir()
print(f'position: {party_position[0]}, {party_position[1]}, direction: {party_direction.symbol}')
sdl2.SDL_SetRenderTarget(renderer, render_target)
sdl2.SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255)
sdl2.SDL_RenderClear(renderer)
draw_bg()
draw_walls(party_position, party_direction)
sdl2.SDL_SetRenderTarget(renderer, None)
sdl2.SDL_RenderCopy(renderer, render_target, None, None)
sdl2.SDL_RenderPresent(renderer)
sdl2.SDL_DestroyWindow(window)
sdl2.SDL_Quit()
return 0
# select clear color
sdl2.SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255)
# clear screen
sdl2.SDL_RenderClear(renderer)
sdl2.SDL_RenderPresent(renderer)
# mode 1
if rendererYuv == True and streamInfo['pixelFormat'] == 'yuv420p':
print('mode 1: fast yuv rendering...')
useYuv = True
# texture will change frequently so use streaming access
yuvTexture = sdl2.SDL_CreateTexture(
renderer, sdl2.SDL_PIXELFORMAT_YV12,
sdl2.SDL_TEXTUREACCESS_STREAMING, size[0], size[1])
else:
print('mode 2: basic rgb rendering (slow)...')
# mode 2
m.addScaler(vstream, *size)
else:
print('mode 3: software rendering (very slow)...')
# mode 3
m.addScaler(vstream, *size)
width, height = 640, 320
if sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) < 0:
raise sdl2.SDL_GetError()
window = sdl2.SDL_CreateWindow(b'pychip8', sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED, width, height,
sdl2.SDL_WINDOW_SHOWN)
if not window:
raise sdl2.SDL_GetError()
renderer = sdl2.SDL_CreateRenderer(window, -1, sdl2.SDL_RENDERER_ACCELERATED)
if not renderer:
raise sdl2.SDL_GetError()
#sdl2.SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255)
texture = sdl2.SDL_CreateTexture(renderer, sdl2.SDL_PIXELFORMAT_ARGB8888,
sdl2.SDL_TEXTUREACCESS_STREAMING, 64, 32)
if not texture:
raise sdl2.ext.SDLError()
sdl2.SDL_RenderClear(renderer)
sdl2.SDL_RenderPresent(renderer)
buf = np.zeros(64 * 32, dtype=np.uint32)
#buf[:] = 0xFFFF0000
#sdl2.SDL_UpdateTexture(
# texture,
# None,
# buf.ctypes.data_as(ctypes.c_void_p),
# ctypes.c_int(4*64)
#)
c_p = ctypes.POINTER(ctypes.c_void_p)
c_i = ctypes.POINTER(ctypes.c_int)
def __init__(self,
perhiperal_type=Input.Type.JOYSTICK,
verbosity=0,
silent=False):
self.atari = jigo2600.Atari2600()
self.speed = 1
self.max_fps = 60.
self.aspect = 1.8
self.paused = False
self.done = False
self.verbosity = verbosity
self.cart_db = None
self.cart_sha1 = None
self.cart_meta = None
self.peripheral_type = Input.Type.JOYSTICK
self.switches_interface = SwitchesInterface()
self.joysticks_interface = JoystickInterface()
self.paddles_interface = PaddleInterface()
self.input_stream = InputStream()
self.has_sdl_audio = False
self.has_sdl_gamecontroller = False
self.has_sdl_joystick = False
# Load the cartridge database.
try:
data = pkgutil.get_data('jigo2600',
'cartridges.json').decode("utf8")
self.cart_db = json.loads(data)
del data
except FileNotFoundError:
if self.verbosity > 0:
print(f'Warning: could not open the cartridge metadata file')
# Setup the graphics.
frame = self.atari.get_current_frame()
if sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) != 0:
print(sdl2.SDL_GetError())
sys.exit(-1)
self.screen = sdl2.SDL_CreateWindow(
b"Atari2600", sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED, int(frame.width * self.aspect * 2),
int(frame.height * 2),
sdl2.SDL_WINDOW_SHOWN | sdl2.SDL_WINDOW_RESIZABLE)
if not self.screen:
print(sdl2.SDL_GetError())
sys.exit(-1)
self.renderer = sdl2.SDL_CreateRenderer(self.screen, -1,
sdl2.SDL_RENDERER_PRESENTVSYNC)
self.texture = sdl2.SDL_CreateTexture(self.renderer,
sdl2.SDL_PIXELFORMAT_BGRA32,
sdl2.SDL_TEXTUREACCESS_STREAMING,
frame.width, frame.height)
# Setup the audio.
self.has_sdl_audio = not silent and (sdl2.SDL_InitSubSystem(
sdl2.SDL_INIT_AUDIO) == 0)
if self.has_sdl_audio:
self.audio_spec = sdl2.SDL_AudioSpec(
44100, sdl2.AUDIO_U8, 1, 1024,
sdl2.SDL_AudioCallback(self.play_audio))
self.audio_dev = sdl2.SDL_OpenAudioDevice(None, 0, self.audio_spec,
self.audio_spec, 0)
self.audio_buffer_rate = self.audio_spec.freq / self.audio_spec.samples
assert self.audio_spec.channels == 1
# Setup the joysticks.
self.has_sdl_joystick = (sdl2.SDL_InitSubSystem(
sdl2.SDL_INIT_JOYSTICK) == 0)
if self.has_sdl_joystick:
sdl2.SDL_SetHint(sdl2.SDL_HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS,
b"1")
sdl2.SDL_JoystickEventState(sdl2.SDL_ENABLE)
# Setup the game controllers.
self.has_sdl_gamecontroller = (sdl2.SDL_InitSubSystem(
sdl2.SDL_INIT_GAMECONTROLLER) == 0)
if self.has_sdl_gamecontroller:
sdl2.SDL_GameControllerEventState(sdl2.SDL_ENABLE)
data = pkgutil.get_data("jigo2600", "gamecontrollerdb.txt")
rw = sdl2.SDL_RWFromConstMem(data, len(data))
n = sdl2.SDL_GameControllerAddMappingsFromRW(rw, False)
if self.verbosity > 0:
if n == -1:
print(
f"Warning: could not load the controller database file"
)
else:
print(f"Loaded {n} game controller mappings")
