Exemplo n.º 1
0
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()
Exemplo n.º 2
0
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
Exemplo n.º 3
0
def main():
    sdl2.sdl2_load(ctypes.util.find_library('SDL2')) # '/usr/local/lib/libSDL2.dylib'
    sdl2.SDL_Init(sdl2.SDL_INIT_EVERYTHING)

    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

        count += 1
        if count >= 100:
            done = True
        sdl2.SDL_Delay(fpsdelay)

    sdl2.SDL_Quit()
Exemplo n.º 4
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
Exemplo n.º 5
0
    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
Exemplo n.º 6
0
def loop(window, renderer, inputfoo, renderfoo, choke_ms = 100):
    while True:
        loopstart = sdl2.SDL_GetTicks()
        while True:
            event = sdl2.SDL_Event()
            rv = sdl2.SDL_PollEvent(ctypes.byref(event))
            if rv == 0:
                break
            elif event.type == sdl2.SDL_QUIT:
                return
            elif event.type == sdl2.SDL_KEYUP:
                if event.key.keysym.sym == sdl2.SDLK_ESCAPE:
                    if inputfoo():
                        return
            elif event.type == sdl2.SDL_WINDOWEVENT:
                if event.window.event == sdl2.SDL_WINDOWEVENT_RESIZED:
                    sz = Size2(event.window.data1, event.window.data2)
                    sdl2.SDL_GetWindowSize(window, ctypes.byref(w_w), ctypes.byref(w_h))
                elif sdl2.SDL_WINDOWEVENT_CLOSE:
                    inputfoo()
                else:
                    continue
                    print(event.window.event)
            elif event.type == sdl2.SDL_MOUSEBUTTONDOWN:
                inputfoo()
        elapsed = sdl2.SDL_GetTicks() - loopstart
        if choke_ms > elapsed:
            sdl2.SDL_Delay(choke_ms - elapsed)
        renderfoo(window, renderer)
Exemplo n.º 7
0
 def event_loop(self):
     assert not self.event_loop_is_running
     self._next_axes_tick = 0
     self._axes_throttle_delay_timer_set = False
     self._get_axis_pos = sdl2.SDL_GameControllerGetAxis if self.device_is_game_controller else sdl2.SDL_JoystickGetAxis
     self.event_loop_is_running = True
     try:
         assert SDL_INITED
         assert self.device
         self.init_handlers()
         self._last_axes_positions = {
             axis_idx: None
             for axis_idx in self._axis_movement_handlers.keys()
         }
         try:
             while not self.quit_event_posted:
                 event = sdl2.SDL_Event()
                 # If there is no event for an entire second, we iterate, giving CPython an opportunity to
                 # raise KeyboardInterrupt.
                 if sdl2.SDL_WaitEventTimeout(ctypes.byref(event), 1000):
                     self._event_handlers.get(
                         event.type, self._on_unhandled_event)(event)
         except KeyboardInterrupt:
             pass
     finally:
         self.event_loop_is_running = False
         self._halt_stage(only_axes_with_nonzero_last_command_velocity=True)
Exemplo n.º 8
0
    def run(self, screen, draw_func, update_func, fps=DEFAULT_FPS):
        self._screen = screen
        self._running = True
        self._fps = fps
        self._frame_time_ms = 1000 / fps
        event = sdl2.SDL_Event()

        time_accumulator_ms = 0
        old_time = sdl2.SDL_GetPerformanceCounter()
        timer_resolution = sdl2.SDL_GetPerformanceFrequency() / 1000  # ms

        while self._running:
            while sdl2.SDL_PollEvent(ctypes.byref(event)) != 0:
                if event.type == sdl2.SDL_QUIT:
                    self._running = False

            # Adjust the loop speed based on the time passed
            current_time = sdl2.SDL_GetPerformanceCounter()
            delta_time_ms = (current_time - old_time) / timer_resolution

            time_accumulator_ms += delta_time_ms
            while time_accumulator_ms > self._frame_time_ms:
                update_func(delta_time_ms)
                time_accumulator_ms -= self._frame_time_ms
            old_time = current_time

            # Update the screen
            screen.begin_update()
            draw_func(screen)
            screen.end_update()

        self.stop()
Exemplo n.º 9
0
 def exit_event_loop(self):
     '''The exit_event_loop method is thread safe and is safe to call even if the event loop is not running.
     Calling exit_event_loop pushes a quit request onto the SDL event queue, causing self.event_loop() to
     exit gracefully (IE, return) if it is running.'''
     event = sdl2.SDL_Event()
     event.type = sdl2.SDL_QUIT
     sdl2.SDL_PushEvent(ctypes.byref(event))
Exemplo n.º 10
0
 def refresh(self):
     event = sdl2.SDL_Event()
     self.update_data(self.lidar.get_image())
     while sdl2.SDL_PollEvent(ctypes.byref(event)) != 0:
         if event.type == sdl2.SDL_QUIT:
             self.running = False
             break
         elif event.type == sdl2.SDL_KEYDOWN:
             if event.key.keysym.sym == sdl2.SDLK_ESCAPE:
                 self.running = False 
             elif event.key.keysym.sym == sdl2.SDLK_1:
                 self.mode = RAW
             elif event.key.keysym.sym == sdl2.SDLK_2:
                 self.mode = POLAR
             elif event.key.keysym.sym == sdl2.SDLK_3:
                 self.mode = EUCLID_3D
             elif event.key.keysym.sym == sdl2.SDLK_4:
                 self.mode = PRETTY_POLAR
             elif event.key.keysym.sym == sdl2.SDLK_5:
                 self.mode = PRETTY_3D
                     
     if self.mode == RAW:
         self.draw_raw()
     elif self.mode == POLAR:
         self.draw_polar()
     elif self.mode == EUCLID_3D:
         self.draw_3D()
     elif self.mode == PRETTY_POLAR:
         self.draw_pretty_polar()
     elif self.mode == PRETTY_3D:
         self.draw_pretty_3D()
     
     self.window.refresh()
Exemplo n.º 11
0
 def event_handler(data, event_ptr):
     if self.running:
         # SDL2 seems to re-use SDL_Event structures, so we need to make a copy.
         event = sdl2.SDL_Event()
         ctypes.pointer(event)[0] = event_ptr.contents
         self.dispatch(event)
     return 0
Exemplo n.º 12
0
    def run(self) -> None:
        e = sdl2.SDL_Event()
        while not self.context.quit:
            while sdl2.SDL_PollEvent(ctypes.byref(e)) != 0:
                if e.type == sdl2.SDL_QUIT:
                    self.context.quit = True
                self.world.handle_event(e)

            self.world.handle_keyboard(sdl2.SDL_GetKeyboardState(None))

            self.world.clean()

            self.world.process_physics()

            self.world.detect_collisions()

            self.world.animate()

            sdl2.SDL_SetRenderDrawColor(self.context.renderer, 0xff, 0xff,
                                        0xff, 0xff)
            sdl2.SDL_RenderClear(self.context.renderer)

            self.world.render(self.world.frame.center,
                              self.world.camera.global_position(),
                              self.world.camera.frame.size)
            self.ui.render(self.ui.frame.center, Vector2D(),
                           self.world.camera.originalSize)

            sdl2.SDL_RenderPresent(self.context.renderer)

        self.exit()
Exemplo n.º 13
0
    def _mainLoop(self):
        # Main loop
        running = True
        event = sdl2.SDL_Event()
        logging.info('SDL2 Main Loop: Executing.')
        #sdl2.SDL_ShowWindow(self.vulkan_window)

        while running:
            # Poll sdl2 window for currently pending events.
            while sdl2.SDL_PollEvent(ctypes.byref(event)) != 0:        
            
               if event.type == sdl2.SDL_QUIT:
                   logging.info('Leaving SDL2 Main Loop: sdl2.SDL_QUIT.')
                   running = False
                   break

               if event.type == sdl2.SDL_WINDOWEVENT:
                   if event.window.event == sdl2.SDL_WINDOWEVENT_SIZE_CHANGED:
                       newWidth, newHeight = self.vulkan_window.getWindowSize()
                       self.vulkan_base._recreateSwapChain()
                       break

            # Renderer: Present Vulkan images onto sdl2 window.
            self.vulkan_base._drawFrame() 


        vkDeviceWaitIdle( self.vulkan_base.logical_device )
        logging.info('Checked all outstanding queue operations for all'
                    ' queues in Logical Device have ceased.')
        return 0
Exemplo n.º 14
0
    def __init__(self, window):
        self._event_dispatcher = EventDispatcher(self, window)
        self._running = False

        rotate_event = sdl2.SDL_Event()
        rotate_event.type = EventDispatcher.ROTATE_EVENT
        self._window = window
        self._rotate_event_pointer = ctypes.byref(rotate_event)
Exemplo n.º 15
0
def click(button='right', loc=(0, 0), release=False):
    etype = sdl2.SDL_MOUSEBUTTONUP if release else sdl2.SDL_MOUSEBUTTONDOWN
    e = sdl2.SDL_Event()
    e.type = etype
    e.button.type = etype
    e.button.x, e.button.y = loc
    e.button.button = _mousebutton_flag(button)
    return e
Exemplo n.º 16
0
def keyup(key, mod=None):
    keycode, modval = _keysym_attrs(key, mod)
    e = sdl2.SDL_Event()
    e.type = sdl2.SDL_KEYUP
    e.key.type = sdl2.SDL_KEYUP
    e.key.keysym.sym = keycode
    e.key.keysym.mod = modval
    return e
Exemplo n.º 17
0
Arquivo: 3dwf.py Projeto: mfkiwl/pysdr
 def thread_target():
     try:
         input_thread(readfunc, ringbuf, nbins, overlap, wf)
     except Exception as e:
         err_queue.put(e)
         event = sdl2.SDL_Event()
         event.type = sdl2.SDL_QUIT
         sdl2.SDL_PushEvent(event)
Exemplo n.º 18
0
def run(small=False):
    """SDL2 back end."""
    target_board = board.Board(192, 32)

    # initialise renderer
    if small:
        target_renderer = renderer.SdlRendererActualSize()
    else:
        target_renderer = renderer.SdlRendererLarge()

    target_renderer.initialise((192, 32))

    board_lock = threading.RLock()
    end_event = threading.Event()

    # initialise board animator
    animator_thread = animator.BoardAnimator(
        board=target_board,
        renderer=target_renderer,
        time_step_in_s=0.05,
        board_lock=board_lock,
        end_event=end_event,
    )

    # initialise board updater (also initialises board with 3 rows)
    target_board_updater = (
        board_updater.BoardUpdater_192_32_3_Rows_From_ProtocolBuffers(
            target_board=target_board, board_lock=board_lock))

    # initialise gRPC server
    server = grpc.server(futures.ThreadPoolExecutor(max_workers=3))
    departure_pb2_grpc.add_BoardManagerServicer_to_server(
        BoardManagerServicer(target_board_updater), server)
    server.add_insecure_port("[::]:50051")

    # start gRPC server and board animator
    animator_thread.start()
    server.start()

    running = True
    event = sdl2.SDL_Event()

    try:
        while running:
            if (sdl2.SDL_PollEvent(ctypes.byref(event)) != 0
                    and event.type == sdl2.SDL_QUIT):
                logger.info("received SDL QUIT event")
                running = False
                break
            end_event.wait(0.5)
    except KeyboardInterrupt:
        logger.info("received keyboard interrupt")

    end_event.set()
    server.stop(0)
    animator_thread.join()

    target_renderer.terminate()
Exemplo n.º 19
0
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()
Exemplo n.º 20
0
 def run(self):
     event = sdl2.SDL_Event()
     while self.running:
         while sdl2.SDL_PollEvent(ctypes.byref(event)) != 0:
             self.onEvent(event)
         # sdl2.SDL_Delay(10)  # uncomment this if you want to save CPU resources
         self.onLoop()
     self.onCleanup()
     sdl2.SDL_Quit()
Exemplo n.º 21
0
 def main_loop(self, draw_frame):
     running = True
     event = sdl2.SDL_Event()
     while running:
         while sdl2.SDL_PollEvent(ctypes.byref(event)):
             if event.type == sdl2.SDL_QUIT:
                 running = False
         draw_frame()
         sdl2.SDL_Delay(160)
Exemplo n.º 22
0
 def emit(self, code: int = 0, data: typing.Any = None) -> sdl2.SDL_Event:
     event = sdl2.SDL_Event()
     sdl2.SDL_memset(ctypes.byref(event), 0, ctypes.sizeof(sdl2.SDL_Event))
     event.type = self.type
     event.user.code = code
     event.user.data1 = ctypes.cast(ctypes.pointer(ctypes.py_object(data)),
                                    ctypes.c_void_p)
     if sdl2.SDL_PushEvent(event) != 1:
         raise sdl2.ext.SDLError()
     return event
Exemplo n.º 23
0
 def pump(self, world):
     # TODO: optimize eventloop to use more efficient functions like PeepEvents?
     event = sdl2.SDL_Event()
     while sdl2.SDL_PollEvent(event):
         for event_handler in event_handlers.get(event.type, ()):
             event_handler(event, world)
             if not self.keepRunning:
                 break
         if not self.keepRunning:
             break
Exemplo n.º 24
0
 def run(self):
     event = sdl2.SDL_Event()
     running = True
     while running:
         while sdl2.SDL_PollEvent(ctypes.byref(event)) != 0:
             if event.type == sdl2.SDL_QUIT:
                 running = False
             elif (event.type == sdl2.SDL_KEYDOWN
                   and event.key.keysym.sym == sdl2.SDLK_ESCAPE):
                 running = False
         self.render()
Exemplo n.º 25
0
def stop_event_wait():
    """Post an event to break out of the event loop wait."""
    try:
        user_event = sdl2.SDL_Event()
        user_event.type = sdl2.SDL_USEREVENT
        user_event.user.code = 2
        user_event.user.data1 = None
        user_event.user.data2 = None
        sdl2.SDL_PushEvent(ctypes.byref(user_event))
    except:
        pass
Exemplo n.º 26
0
def main():
    init()
    joy = sdl2.SDL_JoystickOpen(0)
    print('Name: {}'.format(sdl2.SDL_JoystickName(joy)))
    print('Axes: {}'.format(sdl2.SDL_JoystickNumAxes(joy)))

    state = ControllerState()
    evt = sdl2.SDL_Event()
    running = True
    conn = SerialConnection(
        sys.argv[1] if len(sys.argv) >= 2 else '/dev/ttyACM0')

    # set to mode 1 so it will not attack
    conn.call(MD49_MODE, (0x00, 0x34, 0x01))

    while running:
        while sdl2.SDL_PollEvent(ctypes.byref(evt)) != 0:
            if evt.type == sdl2.SDL_QUIT:
                running = False
                break
            elif evt.type == sdl2.SDL_JOYAXISMOTION:
                jaxis = evt.jaxis
                # print(state, jaxis.axis, jaxis.value)
                state.axis_state[jaxis.axis] = jaxis.value
                handle_axis_motion(conn, state, jaxis.axis, jaxis.value)
            elif evt.type == sdl2.SDL_JOYBUTTONUP:
                button = evt.jbutton
                if button.button == 0:
                    # A: toggle independent
                    state.ind = not state.ind
                    print('Independent: {}'.format(state.ind))
                elif button.button == 8:
                    # B: log encoders
                    print(conn.md49_get_encoders())
                    log_encoders(conn)
                elif button.button == 3:
                    # Y: reset encoders
                    conn.call(MD49_MODE, (
                        0x00,
                        0x35,
                    ))
                elif button.button == 4:
                    # left shoulder: reverse
                    state.r_rev = not state.r_rev
                    print('Right reverse: {}'.format(state.r_rev))
                elif button.button == 5:
                    # right shoulder: reverse
                    state.l_rev = not state.l_rev
                    print('Left reverse: {}'.format(state.l_rev))
                else:
                    print('Button', button.button)
        time.sleep(0.01)
    sdl2.SDL_Quit()
Exemplo n.º 27
0
def poll_events():
    ''' 1) checks for window quit events '''

    event = sdl2.SDL_Event()
    if sdl2.SDL_PollEvent(ctypes.byref(event)):
        # check for escape key press
        if (event.type == sdl2.SDL_KEYDOWN
                and event.key.keysym.sym == sdl2.SDLK_ESCAPE):
            return False
        # check for other forms of quit
        if (event.type == sdl2.SDL_QUIT):
            return False
    return True
Exemplo n.º 28
0
def pushPesEvent(eventType, data1="", data2=""):
    global EVENT_TYPE
    if EVENT_TYPE == None:
        logging.error("pushPesEvent: PES Event Type has not been registered!")
        return False
    pesEvent = sdl2.SDL_Event()
    pesEvent.type = EVENT_TYPE
    pesEvent.user.code = eventType
    pesEvent.user.data1 = cast(c_char_p(data1), c_void_p)
    pesEvent.user.data2 = cast(c_char_p(data2), c_void_p)
    logging.debug("pushPesEvent: pushing event (%d, %s, %s)" %
                  (eventType, data1, data2))
    sdl2.SDL_PushEvent(pesEvent)
    return True
Exemplo n.º 29
0
    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()
Exemplo n.º 30
0
def run(args):
    sdl2.ext.init()
    window = sdl2.ext.Window(
        "Live scan",
        (800, 600),
        flags=(sdl2.SDL_WINDOW_SHOWN | sdl2.SDL_WINDOW_RESIZABLE),
    )

    scanner_event_type = sdl2.SDL_RegisterEvents(1)
    if scanner_event_type == -1:
        raise RuntimeError()
    scanner_event = sdl2.SDL_Event()
    scanner_event.type = scanner_event_type

    factory = sdl2.ext.SpriteFactory(sdl2.ext.SOFTWARE)
    scanner = Scanner(args, scanner_event, factory)
    scanner.start()

    renderer = sdl2.ext.Renderer(window, logical_size=scanner.sprite.size)

    window.size = renderer.logical_size[0] * 20, renderer.logical_size[1] * 20

    running = True
    tex = None
    while running:
        for event in sdl2.ext.get_events():
            if event.type == sdl2.SDL_QUIT:
                running = False
                break
            if event.type == scanner_event_type:
                tex = sdl2.SDL_CreateTextureFromSurface(
                    renderer.sdlrenderer, scanner.sprite.surface).contents
                renderer.copy(tex)
                renderer.present()
            if event.type == sdl2.SDL_WINDOWEVENT:
                win_ev = event.window
                if win_ev.event == sdl2.SDL_WINDOWEVENT_SIZE_CHANGED:
                    renderer.clear()
                    if tex is not None:
                        renderer.copy(tex)
                    renderer.present()
            if event.type == sdl2.SDL_KEYDOWN:
                if event.key.keysym.sym == sdl2.SDLK_s:
                    im = contrast_enhance(
                        surface_to_pil(scanner.completed_part.surface),
                        args.contrast)
                    im.save(args.image_out)
            window.refresh()
    scanner.join()