ruby2d 0.12.1 → 1.0.0

data/lib/ruby2d/window/class_methods.rb

@@ -0,0 +1,218 @@
+# Ruby2D::Window::ClassMethods
+
+module Ruby2D
+  class Window
+    # Class-level accessors that delegate to the DSL window instance
+    module ClassMethods
+      # Get the current window instance
+      def current
+        DSL.window
+      end
+
+      # Get the window title
+      def title
+        DSL.window.title
+      end
+
+      # Get the background color
+      def background
+        DSL.window.background
+      end
+
+      # Get the window width
+      def width
+        DSL.window.width
+      end
+
+      # Get the window height
+      def height
+        DSL.window.height
+      end
+
+      # Get the viewport width
+      def viewport_width
+        DSL.window.viewport_width
+      end
+
+      # Get the viewport height
+      def viewport_height
+        DSL.window.viewport_height
+      end
+
+      # Get the viewport scaling mode
+      def viewport_mode
+        DSL.window.viewport_mode
+      end
+
+      # Get the display width
+      def display_width
+        DSL.window.display_width
+      end
+
+      # Get the display height
+      def display_height
+        DSL.window.display_height
+      end
+
+      # Get the display width in physical pixels
+      def display_pixel_width
+        DSL.window.display_pixel_width
+      end
+
+      # Get the display height in physical pixels
+      def display_pixel_height
+        DSL.window.display_pixel_height
+      end
+
+      # Get whether the window is resizable
+      def resizable
+        DSL.window.resizable
+      end
+
+      # Get whether high DPI mode is enabled
+      def highdpi
+        DSL.window.highdpi
+      end
+
+      # Get the pixel scale
+      def pixel_scale
+        DSL.window.pixel_scale
+      end
+
+      # Get the total number of rendered frames
+      def frames
+        DSL.window.frames
+      end
+
+      # Get the current frames per second
+      def fps
+        DSL.window.fps
+      end
+
+      # Get the most recent frame's delta time, in seconds (clamped to 0.1s).
+      # The same value passed to an `update do |dt|` block; the time source
+      # every animation advances on.
+      def delta_time
+        DSL.window.delta_time
+      end
+
+      # Get the FPS cap
+      def fps_cap
+        DSL.window.fps_cap
+      end
+
+      # Get the mouse x position
+      def mouse_x
+        DSL.window.mouse_x
+      end
+
+      # Get the mouse y position
+      def mouse_y
+        DSL.window.mouse_y
+      end
+
+      # Get the mouse position as [x, y]
+      def mouse_position
+        DSL.window.mouse_position
+      end
+
+      # Get whether diagnostics are enabled
+      def diagnostics
+        DSL.window.diagnostics
+      end
+
+      # Get whether FPS display is enabled
+      def show_fps
+        DSL.window.show_fps
+      end
+
+      # Take a screenshot, saving to `path` (or a timestamped file if omitted)
+      def screenshot(path = nil)
+        DSL.window.screenshot(path)
+      end
+
+      # Get a window attribute by name
+      def get(sym)
+        DSL.window.get(sym)
+      end
+
+      # Set window attributes
+      def set(opts)
+        DSL.window.set(opts)
+      end
+
+      # Register an event handler
+      def on(event = nil, **filters, &proc)
+        DSL.window.on(event, **filters, &proc)
+      end
+
+      # Remove an event handler
+      def off(event_descriptor)
+        DSL.window.off(event_descriptor)
+      end
+
+      # Add an object to the window
+      def add(object)
+        DSL.window.add(object)
+      end
+
+      # Remove an object from the window
+      def remove(object)
+        DSL.window.remove(object)
+      end
+
+      # Register an interactive object
+      def register_interactive(object)
+        DSL.window.register_interactive(object)
+      end
+
+      # Unregister an interactive object
+      def unregister_interactive(object)
+        DSL.window.unregister_interactive(object)
+      end
+
+      # Clear all objects from the window
+      def clear
+        DSL.window.clear
+      end
+
+      # Set the update callback
+      def update(&proc)
+        DSL.window.update(&proc)
+      end
+
+      # Set the render callback
+      def render(&proc)
+        DSL.window.render(&proc)
+      end
+
+      # Show the window
+      def show
+        DSL.window.show
+      end
+
+      # Get the current cursor state
+      def cursor
+        DSL.window.cursor
+      end
+
+      # Set the cursor: `:visible`, `:hidden`, or a system cursor name
+      def cursor=(name)
+        DSL.window.cursor = name
+      end
+
+      # Close the window
+      def close
+        DSL.window.close
+      end
+
+      # Check if the window is ready for rendering
+      def render_ready_check
+        return if shown?
+
+        raise Error,
+              'Attempting to draw before the window is ready. Please put calls to render() inside of a render block.'
+      end
+    end
+  end
+end

data/lib/ruby2d/window/gamepad_events.rb

@@ -0,0 +1,141 @@
+# Ruby2D::Window::GamepadEvents
+
+module Ruby2D
+  class Window
+    # Multi-gamepad input handling. Owns the `gamepads` collection and the
+    # callback the C extension calls for every SDL gamepad event. Holds no
+    # ambient single-pad state — every event carries the `Gamepad` it came
+    # from, and polling lives on each `Gamepad` instance.
+    module GamepadEvents
+      # Default location for the user's gamepad mappings file. Loaded
+      # automatically from `show` if it exists.
+      DEFAULT_GAMEPAD_MAPPINGS_PATH = "#{File.expand_path('~')}/.ruby2d/gamepads.txt".freeze
+
+      # Internal dispatch structs for filter matching. Never exposed to user
+      # code — handlers receive unpacked args (gamepad / button / axis / value),
+      # not the struct.
+      GamepadConnectData = Struct.new(:gamepad) do
+        def gamepad?(other) = gamepad.equal?(other)
+      end
+
+      GamepadButtonData = Struct.new(:gamepad, :button) do
+        def gamepad?(other) = gamepad.equal?(other)
+        def button?(name)   = button == name
+      end
+
+      GamepadAxisData = Struct.new(:gamepad, :axis, :value) do
+        def gamepad?(other) = gamepad.equal?(other)
+        def axis?(name)     = axis == name
+      end
+
+      # Connected gamepads in connect order. Stable: index 0 is the
+      # first-connected pad still present.
+      def gamepads
+        @gamepads
+      end
+
+      # Load gamepad mappings from a file or string. Smart-parses the
+      # argument: if it points at an existing file, loads it via
+      # `SDL_AddGamepadMappingsFromFile`; otherwise treats it as a single
+      # mapping string and forwards to `SDL_AddGamepadMapping`.
+      def add_gamepad_mapping(path_or_string)
+        if File.file?(path_or_string)
+          Ext.window_load_gamepad_mappings_file(self, path_or_string)
+        else
+          Ext.window_add_gamepad_mapping(self, path_or_string)
+        end
+      end
+
+      # Auto-load mappings from the default user file. Called from `show`.
+      def load_default_gamepad_mappings
+        return unless File.exist?(DEFAULT_GAMEPAD_MAPPINGS_PATH)
+
+        Ext.window_load_gamepad_mappings_file(self, DEFAULT_GAMEPAD_MAPPINGS_PATH)
+      end
+
+      # Called from C for every gamepad event. Type is one of:
+      # :connect, :disconnect, :button_down, :button_held, :button_up, :axis.
+      # `data` is the button name (button events), axis name (axis events),
+      # or nil (connect/disconnect). `value` is the dead-zone-applied axis
+      # value, or nil. `name` is the gamepad's display name on connect/
+      # disconnect, otherwise nil.
+      def gamepad_callback(which, type, data, value, name = nil)
+        case type
+        when :connect
+          handle_gamepad_connect(which, name)
+        when :disconnect
+          handle_gamepad_disconnect(which)
+        when :button_down
+          handle_gamepad_button_down(which, data)
+        when :button_held
+          handle_gamepad_button_held(which, data)
+        when :button_up
+          handle_gamepad_button_up(which, data)
+        when :axis
+          handle_gamepad_axis(which, data, value)
+        end
+      end
+
+      def init_gamepad_event_stores
+        @gamepads = []
+        @gamepads_by_id = {}
+      end
+
+      def clear_gamepad_frame_state
+        @gamepads.each(&:_clear_frame_state)
+      end
+
+      private
+
+      def handle_gamepad_connect(id, name)
+        return if @gamepads_by_id.key?(id)
+
+        pad = Gamepad.new(self, id, name)
+        @gamepads << pad
+        @gamepads_by_id[id] = pad
+
+        fire_event_handlers(:gamepad_connect) { GamepadConnectData.new(pad) }
+      end
+
+      def handle_gamepad_disconnect(id)
+        pad = @gamepads_by_id.delete(id)
+        return unless pad
+
+        @gamepads.delete(pad)
+        pad._disconnect
+
+        fire_event_handlers(:gamepad_disconnect) { GamepadConnectData.new(pad) }
+      end
+
+      def handle_gamepad_button_down(id, button)
+        pad = @gamepads_by_id[id] or return
+        pad._apply_button_down(button)
+        fire_event_handlers(:gamepad_button_down) { GamepadButtonData.new(pad, button) }
+      end
+
+      def handle_gamepad_button_held(id, button)
+        pad = @gamepads_by_id[id] or return
+        pad._apply_button_held(button)
+        fire_event_handlers(:gamepad_button_held) { GamepadButtonData.new(pad, button) }
+      end
+
+      def handle_gamepad_button_up(id, button)
+        pad = @gamepads_by_id[id] or return
+        pad._apply_button_up(button)
+        fire_event_handlers(:gamepad_button_up) { GamepadButtonData.new(pad, button) }
+      end
+
+      # Suppress the event when the dead-zoned value didn't change since the
+      # last event for that axis — avoids spamming handlers with motion
+      # entirely inside the dead zone. `_apply_axis` returns the new value
+      # when it changed, or nil otherwise.
+      def handle_gamepad_axis(id, axis, raw_value)
+        pad = @gamepads_by_id[id] or return
+        new_value = pad._apply_axis(axis, raw_value)
+        return if new_value.nil?
+
+        fire_event_handlers(:gamepad_axis) { GamepadAxisData.new(pad, axis, new_value) }
+      end
+    end
+  end
+end

data/lib/ruby2d/window/key_events.rb

@@ -0,0 +1,74 @@
+# Ruby2D::Window::KeyEvents
+
+module Ruby2D
+  class Window
+    # Keyboard input event handling
+    module KeyEvents
+      # Key down event method for class pattern
+      def key_pressed?(key)
+        @keys_down.include? key
+      end
+
+      # Key held event method for class pattern
+      def key_held?(key)
+        @keys_held.include? key
+      end
+
+      # Key up event method for class pattern
+      def key_released?(key)
+        @keys_up.include? key
+      end
+
+      # Key callback method. `key` arrives already normalized (lowercased):
+      # from `dispatch_events` via the cached scancode-name table, or from a
+      # direct caller passing a lowercase key name.
+      def key_callback(type, key)
+        # All key events
+        fire_event_handlers(:key) { KeyEvent.new(type, key) }
+
+        case type
+        # When key is pressed, fired once
+        when :down
+          handle_key_down type, key
+        # When key is being held down, fired every frame
+        when :held
+          handle_key_held type, key
+        # When key released, fired once
+        when :up
+          handle_key_up type, key
+        end
+      end
+
+      private
+
+      def handle_key_down(type, key)
+        close if @close_on_esc && key == 'escape'
+
+        @keys_down << key unless @keys_down.include? key
+
+        fire_event_handlers(:key_down) { KeyEvent.new(type, key) }
+      end
+
+      def handle_key_held(type, key)
+        @keys_held << key unless @keys_held.include? key
+
+        fire_event_handlers(:key_held) { KeyEvent.new(type, key) }
+      end
+
+      def handle_key_up(type, key)
+        @keys_up << key unless @keys_up.include? key
+
+        fire_event_handlers(:key_up) { KeyEvent.new(type, key) }
+      end
+
+      def init_key_event_stores
+        # Event stores for class pattern
+        @keys_down = []
+        @keys_held = []
+        @keys_up   = []
+        # Scancode → frozen lowercased name, filled lazily by `key_name`
+        @key_names = []
+      end
+    end
+  end
+end

data/lib/ruby2d/window/mouse_events.rb

@@ -0,0 +1,171 @@
+# Ruby2D::Window::MouseEvents
+
+module Ruby2D
+  class Window
+    # Mouse input event handling
+    module MouseEvents
+      # Mouse down event method for class pattern
+      def mouse_pressed?(btn)
+        @mouse_buttons_down.include? btn
+      end
+
+      # Mouse up event method for class pattern
+      def mouse_released?(btn)
+        @mouse_buttons_up.include? btn
+      end
+
+      # Mouse held event method for class pattern
+      def mouse_held?(btn)
+        @mouse_buttons_held.include? btn
+      end
+
+      # Current mouse position as a [x, y] pair, for the common case where
+      # both coordinates are needed together.
+      def mouse_position
+        [@mouse_x, @mouse_y]
+      end
+
+      # True while the cursor is over the window. Toggles on :mouse_enter /
+      # :mouse_leave; starts false until SDL reports the first enter event.
+      def mouse_inside?
+        @mouse_inside
+      end
+
+      # Mouse scroll event method for class pattern
+      def mouse_scrolled?
+        @mouse_scroll_event
+      end
+
+      # Get the scroll direction
+      def mouse_scroll_direction
+        @mouse_scroll_direction
+      end
+
+      # Get the scroll delta x
+      def mouse_scroll_delta_x
+        @mouse_scroll_delta_x
+      end
+
+      # Get the scroll delta y
+      def mouse_scroll_delta_y
+        @mouse_scroll_delta_y
+      end
+
+      # Mouse move event method for class pattern
+      def mouse_moved?
+        @mouse_move_event
+      end
+
+      # Get the mouse move delta x
+      def mouse_move_delta_x
+        @mouse_move_delta_x
+      end
+
+      # Get the mouse move delta y
+      def mouse_move_delta_y
+        @mouse_move_delta_y
+      end
+
+      # Mouse callback method, called by the native and web extentions
+      def mouse_callback(type, button, direction, x, y, delta_x, delta_y)
+        # All mouse events
+        fire_event_handlers(:mouse) { MouseEvent.new(type, button, direction, x, y, delta_x, delta_y) }
+
+        case type
+        # When mouse button pressed
+        when :down
+          handle_mouse_down type, button, x, y
+        # When mouse button released
+        when :up
+          handle_mouse_up type, button, x, y
+        # When mouse button is being held down, fired every frame
+        when :held
+          handle_mouse_held type, button, x, y
+        # When mouse scrolling, wheel or trackpad
+        when :scroll
+          handle_mouse_scroll type, direction, delta_x, delta_y
+        # When mouse motion / movement
+        when :move
+          handle_mouse_move type, x, y, delta_x, delta_y
+        # When cursor enters the window
+        when :enter
+          handle_mouse_enter type
+        # When cursor leaves the window
+        when :leave
+          handle_mouse_leave type
+        end
+      end
+
+      private
+
+      def handle_mouse_down(type, button, x, y)
+        @mouse_buttons_down << button unless @mouse_buttons_down.include? button
+
+        fire_event_handlers(:mouse_down) { MouseEvent.new(type, button, nil, x, y, nil, nil) }
+
+        dispatch_object_mouse_down(button, x, y)
+      end
+
+      def handle_mouse_up(type, button, x, y)
+        @mouse_buttons_up << button unless @mouse_buttons_up.include? button
+
+        fire_event_handlers(:mouse_up) { MouseEvent.new(type, button, nil, x, y, nil, nil) }
+
+        dispatch_object_mouse_up(button, x, y)
+      end
+
+      def handle_mouse_held(type, button, x, y)
+        @mouse_buttons_held << button unless @mouse_buttons_held.include? button
+
+        fire_event_handlers(:mouse_held) { MouseEvent.new(type, button, nil, x, y, nil, nil) }
+
+        dispatch_object_mouse_held(button, x, y)
+      end
+
+      def handle_mouse_scroll(type, direction, delta_x, delta_y)
+        @mouse_scroll_event     = true
+        @mouse_scroll_direction = direction
+        @mouse_scroll_delta_x   = delta_x
+        @mouse_scroll_delta_y   = delta_y
+
+        fire_event_handlers(:mouse_scroll) { MouseEvent.new(type, nil, direction, nil, nil, delta_x, delta_y) }
+
+        dispatch_object_mouse_scroll(@mouse_x, @mouse_y, direction, delta_x, delta_y)
+      end
+
+      def handle_mouse_move(type, x, y, delta_x, delta_y)
+        @mouse_move_event   = true
+        @mouse_move_delta_x = delta_x
+        @mouse_move_delta_y = delta_y
+
+        fire_event_handlers(:mouse_move) { MouseEvent.new(type, nil, nil, x, y, delta_x, delta_y) }
+
+        dispatch_object_mouse_move(x, y, delta_x, delta_y)
+      end
+
+      def handle_mouse_enter(type)
+        @mouse_inside = true
+        fire_event_handlers(:mouse_enter) { MouseEvent.new(type, nil, nil, nil, nil, nil, nil) }
+      end
+
+      def handle_mouse_leave(type)
+        @mouse_inside = false
+        fire_event_handlers(:mouse_leave) { MouseEvent.new(type, nil, nil, nil, nil, nil, nil) }
+      end
+
+      def init_mouse_event_stores
+        @mouse_buttons_down = []
+        @mouse_buttons_up   = []
+        @mouse_buttons_held = []
+        @mouse_scroll_event     = false
+        @mouse_scroll_direction = nil
+        @mouse_scroll_delta_x   = 0
+        @mouse_scroll_delta_y   = 0
+        @mouse_move_event   = false
+        @mouse_move_delta_x = 0
+        @mouse_move_delta_y = 0
+        @mouse_inside       = false
+      end
+    end
+  end
+end