badline 0.2.1 → 0.4.0

data/lib/badline/gui/application.rb

@@ -3,12 +3,12 @@
 module Badline
   module GUI
     class Application
-      PAL_CLOCK_HZ = 985_248
       TITLE = "Badline"
-      TOGGLE_SYM = SDL2::Key::TAB
-      REVERSE_MOD = SDL2::Key::Mod::SHIFT
+      TOGGLE_SYM = SDL::KEY_TAB
+      MUTE_SYM = SDL::KEY_F10
+      REVERSE_MOD = SDL::KMOD_SHIFT
 
-      SHARED_KEYS = %i[up left cursor_h cursor_v space w a s d lshift].freeze
+      SHARED_KEYS = %i[cursor_up cursor_left cursor_h cursor_v space w a s d lshift].freeze
 
       # Tab steps through the input modes and shift-Tab back; the title bar
       # names the live one. The pot devices appear once per control port, since
@@ -28,24 +28,24 @@ module Badline
       }.freeze
       MOUSE_BUTTONS = { 1 => :left, 3 => :right }.freeze
 
-      def initialize(media_path: nil, autostart: true, song: nil, sid_model: nil, debug: false)
-        @computer = Computer.new(debug:, sid_model: sid_model || Media.sid_model(media_path))
-        puts Media.attach(@computer, media_path, autostart:, song:) if media_path
+      # The media options (autostart:, song:, disk:) go to Media.attach.
+      def initialize(media_path: nil, sid_model: nil, sound: false, **media)
+        @computer = Computer.new(sid_model: sid_model || Media.sid_model(media_path))
+        puts Media.attach(@computer, media_path, **media) if media_path
 
         @mode = :keyboard
         @pot_device = nil
         @panes = [ScreenPane.new(@computer)]
+        @stream = open_stream if sound
+        @paced = ENV["NOVSYNC"].nil?
         @window = Window.new(
           title: TITLE,
           width: canvas_width, height: canvas_height,
-          vsync: ENV["NOVSYNC"].nil?
+          vsync: @paced && !@stream
         )
         @gamepads = Gamepads.new(@computer)
         @gamepads.names.each { |name| puts "Gamepad: #{name}" }
-
-        rate = @window.refresh_rate
-        @cycles_per_frame = PAL_CLOCK_HZ / rate
-        puts "Display #{rate} Hz -> #{@cycles_per_frame} cycles/frame"
+        fit_frame
       end
 
       def run
@@ -54,29 +54,33 @@ module Badline
           handle_events
           @gamepads.poll
           @cycles_per_frame.times { @computer.cycle! }
+          @stream&.feed
           @window.draw(@panes)
+          @stream.pace(@frame_seconds) if @stream && @paced
         end
       ensure
+        @stream&.close
         @gamepads.close
+        @window.close
         puts @computer.cpu.inspect
       end
 
       private
 
       def handle_events
-        while (event = SDL2::Event.poll)
+        while (event = SDL.poll_event)
           case event
-          when SDL2::Event::Quit
+          when SDL::Quit
             @running = false
-          when SDL2::Event::KeyDown
+          when SDL::KeyDown
             handle_key_down(event)
-          when SDL2::Event::KeyUp
+          when SDL::KeyUp
             handle_key_up(event)
-          when SDL2::Event::MouseMotion
+          when SDL::MouseMotion
             @pot_device&.move(event.xrel, event.yrel)
-          when SDL2::Event::MouseButton
+          when SDL::MouseButton
             handle_mouse_button(event)
-          when SDL2::Event::ControllerDevice
+          when SDL::ControllerDevice
             @gamepads.rescan
           end
         end
@@ -84,17 +88,27 @@ module Badline
 
       def handle_key_down(event)
         return cycle_mode(event.mod.anybits?(REVERSE_MOD) ? -1 : 1) if event.sym == TOGGLE_SYM
+        return toggle_mute if event.sym == MUTE_SYM
 
         port, dir = JoyMap.parse(event) if @mode == :joystick
         if port
           joystick(port).press(dir)
         else
-          @computer.keyboard.press(KeyMap.parse(event))
+          press_key(KeyMap.parse(event), event.repeat)
         end
       end
 
+      # RESTORE isn't in the key matrix, so it goes to the machine instead,
+      # once per press as the real key's one-shot fires.
+      def press_key(key, repeat)
+        return @computer.press_restore if key == :restore && !repeat
+        return if key == :restore
+
+        @computer.keyboard.press(key)
+      end
+
       def handle_key_up(event)
-        return if event.sym == TOGGLE_SYM
+        return if [TOGGLE_SYM, MUTE_SYM].include?(event.sym)
 
         port, dir = JoyMap.parse(event) if @mode == :joystick
         if port
@@ -108,9 +122,10 @@ module Badline
         button = MOUSE_BUTTONS[event.button]
         return unless button && @pot_device
 
-        case event
-        when SDL2::Event::MouseButtonDown then @pot_device.press(button)
-        when SDL2::Event::MouseButtonUp then @pot_device.release(button)
+        if event.pressed
+          @pot_device.press(button)
+        else
+          @pot_device.release(button)
         end
       end
 
@@ -123,7 +138,36 @@ module Badline
         @mode = modes[(modes.index(@mode) + step) % modes.size]
         release_inputs
         attach_pot_device
-        @window.title = [TITLE, MODES[@mode] && "[#{MODES[@mode]}]"].compact.join(" ")
+        update_title
+      end
+
+      def toggle_mute
+        return unless @stream
+
+        @stream.toggle_mute
+        update_title
+      end
+
+      def update_title
+        tags = [MODES[@mode], @stream&.muted? && "MUTED"].select(&:itself)
+        @window.title = [TITLE, *tags.map { |tag| "[#{tag}]" }].join(" ")
+      end
+
+      def open_stream
+        sink = Audio::SDLSink.new(rate: Audio::Renderer::DEFAULT_RATE)
+        puts "Sound at #{sink.rate} Hz, F10 mutes"
+        Audio::Stream.new(sink, @computer.sid,
+                          on_underrun: -> { puts "Running below real time, so the sound will stutter." })
+      rescue Audio::SDLSink::Error => e
+        warn "badline: no sound, can't open the audio device: #{e.message}"
+      end
+
+      def fit_frame
+        rate = @window.refresh_rate
+        clock_hz = @computer.region.clock_hz
+        @cycles_per_frame = clock_hz / rate
+        @frame_seconds = @cycles_per_frame.fdiv(clock_hz)
+        puts "Display #{rate} Hz -> #{@cycles_per_frame} cycles/frame"
       end
 
       def attach_pot_device
@@ -132,7 +176,7 @@ module Badline
         ports = @computer.control_ports
         ports.device1 = port == 1 ? @pot_device : nil
         ports.device2 = port == 2 ? @pot_device : nil
-        SDL2::Mouse.relative_mode = !@pot_device.nil?
+        SDL::SetRelativeMouseMode.call(@pot_device ? 1 : 0)
       end
 
       def release_inputs

data/lib/badline/gui/gamepads.rb

@@ -9,8 +9,8 @@ module Badline
     # face and shoulder button fires.
     #
     # SDL announces arrivals by device index but reports button presses by
-    # instance id, and the binding gives no way to line the two up, so this
-    # class polls the controllers every frame. It only releases directions it
+    # instance id, so rather than line the two up, this class polls the
+    # controllers every frame. It only releases directions it
     # pressed itself, so the keyboard mapping keeps working with a pad
     # connected.
     class Gamepads
@@ -18,39 +18,39 @@ module Badline
       PORTS = [2, 1].freeze
 
       BUTTONS = {
-        up: [SDL2::GameController::Button::DPAD_UP],
-        down: [SDL2::GameController::Button::DPAD_DOWN],
-        left: [SDL2::GameController::Button::DPAD_LEFT],
-        right: [SDL2::GameController::Button::DPAD_RIGHT],
-        fire: [SDL2::GameController::Button::A, SDL2::GameController::Button::B,
-               SDL2::GameController::Button::X, SDL2::GameController::Button::Y,
-               SDL2::GameController::Button::LEFTSHOULDER,
-               SDL2::GameController::Button::RIGHTSHOULDER]
+        up: [SDL::CONTROLLER_BUTTON_DPAD_UP],
+        down: [SDL::CONTROLLER_BUTTON_DPAD_DOWN],
+        left: [SDL::CONTROLLER_BUTTON_DPAD_LEFT],
+        right: [SDL::CONTROLLER_BUTTON_DPAD_RIGHT],
+        fire: [SDL::CONTROLLER_BUTTON_A, SDL::CONTROLLER_BUTTON_B,
+               SDL::CONTROLLER_BUTTON_X, SDL::CONTROLLER_BUTTON_Y,
+               SDL::CONTROLLER_BUTTON_LEFTSHOULDER, SDL::CONTROLLER_BUTTON_RIGHTSHOULDER]
       }.freeze
 
       AXES = {
-        up: [SDL2::GameController::Axis::LEFTY, -1],
-        down: [SDL2::GameController::Axis::LEFTY, 1],
-        left: [SDL2::GameController::Axis::LEFTX, -1],
-        right: [SDL2::GameController::Axis::LEFTX, 1]
+        up: [SDL::CONTROLLER_AXIS_LEFTY, -1],
+        down: [SDL::CONTROLLER_AXIS_LEFTY, 1],
+        left: [SDL::CONTROLLER_AXIS_LEFTX, -1],
+        right: [SDL::CONTROLLER_AXIS_LEFTX, 1]
       }.freeze
 
       def initialize(computer)
-        SDL2.init(SDL2::INIT_GAMECONTROLLER)
+        SDL.check(SDL::InitSubSystem.call(SDL::INIT_GAMECONTROLLER))
         @computer = computer
         @controllers = []
         @pressed = Array.new(PORTS.size) { [] }
         rescan
       end
 
-      def names = @controllers.map(&:name)
+      def names = @controllers.map { |controller| SDL::GameControllerName.call(controller) }
 
       def rescan
         close
-        @controllers = (0...SDL2::Joystick.num_connected_joysticks)
-                       .select { |index| SDL2::Joystick.game_controller?(index) }
+        @controllers = (0...SDL::NumJoysticks.call)
+                       .select { |index| SDL::IsGameController.call(index) == 1 }
                        .first(PORTS.size)
-                       .map { |index| SDL2::GameController.open(index) }
+                       .map { |index| SDL::GameControllerOpen.call(index) }
+                       .reject(&:null?)
       end
 
       def poll
@@ -58,7 +58,7 @@ module Badline
       end
 
       def close
-        @controllers.each { |controller| controller.destroy unless controller.destroy? }
+        @controllers.each { |controller| SDL::GameControllerClose.call(controller) }
         @controllers = []
         @pressed.size.times { |index| release(index) }
       end
@@ -78,7 +78,7 @@ module Badline
       end
 
       def active?(controller, direction)
-        BUTTONS.fetch(direction).any? { |button| controller.button_pressed?(button) } ||
+        BUTTONS.fetch(direction).any? { |button| SDL::GameControllerGetButton.call(controller, button) == 1 } ||
           tilted?(controller, direction)
       end
 
@@ -86,7 +86,7 @@ module Badline
         axis, sign = AXES[direction]
         return false unless axis
 
-        controller.axis(axis) * sign > DEADZONE
+        SDL::GameControllerGetAxis.call(controller, axis) * sign > DEADZONE
       end
 
       def joystick(index)

data/lib/badline/gui/joy_map.rb

@@ -13,7 +13,7 @@ module Badline
       }.freeze
 
       def self.parse(event)
-        name = SDL2::Key.name_of(event.sym)
+        name = SDL.key_name(event.sym)
 
         PORTS.each do |port, map|
           direction = map[name]

data/lib/badline/gui/key_map.rb

@@ -11,6 +11,11 @@ module Badline
         "Return" => :return,
         "Right" => :cursor_h,
         "Down" => :cursor_v,
+        "Left" => :cursor_left,
+        "Up" => :cursor_up,
+        "`" => :left,
+        "]" => :up,
+        "PageUp" => :restore,
         "Space" => :space,
         "Left Ctrl" => :control,
         "Left Alt" => :cbm,
@@ -26,7 +31,7 @@ module Badline
       }.freeze
 
       def self.parse(event)
-        name = SDL2::Key.name_of(event.sym)
+        name = SDL.key_name(event.sym)
         MAP[name] || name.downcase.to_sym
       end
     end

data/lib/badline/gui/pane.rb

@@ -10,7 +10,7 @@ module Badline
         @height = height
         @left = left
         @top = top
-        @rect = SDL2::Rect.new(left, top, width, height)
+        @rect = [left, top, width, height].pack("l4")
       end
 
       def render(_renderer)
@@ -19,16 +19,17 @@ module Badline
 
       private
 
+      # The pixels are little-endian RGBA dwords, red in the low byte.
       def blit(renderer, pixels)
-        surface = SDL2::Surface.from_string(
+        surface = SDL::CreateRGBSurfaceFrom.call(
           pixels, width, height, 32, width * 4,
           0x0000_00ff, 0x0000_ff00, 0x00ff_0000, 0xff00_0000
         )
-        texture = renderer.create_texture_from(surface)
-        renderer.copy(texture, nil, @rect)
+        texture = SDL::CreateTextureFromSurface.call(renderer, surface)
+        SDL::RenderCopy.call(renderer, texture, nil, @rect)
       ensure
-        texture&.destroy
-        surface&.destroy
+        SDL::DestroyTexture.call(texture) if texture
+        SDL::FreeSurface.call(surface) if surface
       end
     end
   end

data/lib/badline/gui/screen_pane.rb

@@ -2,19 +2,15 @@
 
 module Badline
   module GUI
+    # The part of the VIC's raster the machine's region crops out.
     class ScreenPane < Pane
-      WIDTH = 384
-      HEIGHT = 272
-      COL_OFFSET = 96
-      ROW_OFFSET = 20
-
-      ROW_BYTES = WIDTH * 4
-
       def initialize(computer, left: 0, top: 0, palette: Palette.new)
-        super(width: WIDTH, height: HEIGHT, left:, top:)
+        @col_offset, @row_offset, crop_width, crop_height = computer.region.crop
+        super(width: crop_width, height: crop_height, left:, top:)
         @computer = computer
+        @row_bytes = width * 4
         @palette = palette.dwords
-        @buffer = ("\x00" * (HEIGHT * ROW_BYTES)).b
+        @buffer = ("\x00" * (height * @row_bytes)).b
       end
 
       def render(renderer)
@@ -30,10 +26,10 @@ module Badline
         vic_width = vic.width
         dirty = vic.dirty_lines
 
-        HEIGHT.times do |row|
-          next unless dirty[row + ROW_OFFSET]
+        height.times do |row|
+          next unless dirty[row + @row_offset]
 
-          @buffer[row * ROW_BYTES, ROW_BYTES] =
+          @buffer[row * @row_bytes, @row_bytes] =
             pack_row(display, vic_width, row)
         end
         vic.clear_dirty_lines!
@@ -41,7 +37,7 @@ module Badline
       end
 
       def pack_row(display, vic_width, row)
-        line = display[((row + ROW_OFFSET) * vic_width) + COL_OFFSET, WIDTH]
+        line = display[((row + @row_offset) * vic_width) + @col_offset, width]
         line.map! { |c| @palette[c] }
         line.pack("V*")
       end

data/lib/badline/gui/window.rb

@@ -5,41 +5,56 @@ module Badline
     class Window
       DEFAULT_REFRESH_RATE = 60
 
+      # SDL_DisplayMode: Uint32 format; int w, h, refresh_rate; then a pointer.
+      DISPLAY_MODE_SIZE = 24
+
       attr_reader :renderer
 
       def initialize(title:, width:, height:, scale: 2, vsync: true)
-        SDL2.init(SDL2::INIT_VIDEO | SDL2::INIT_EVENTS)
-        SDL2::Hints["SDL_RENDER_SCALE_QUALITY"] = "0" # nearest-neighbour
-
-        @window = SDL2::Window.create(
-          title,
-          SDL2::Window::POS_CENTERED, SDL2::Window::POS_CENTERED,
-          width * scale, height * scale,
-          SDL2::Window::Flags::RESIZABLE
-        )
-
-        flags = SDL2::Renderer::Flags::ACCELERATED
-        flags |= SDL2::Renderer::Flags::PRESENTVSYNC if vsync
-        @renderer = @window.create_renderer(-1, flags)
-        @renderer.logical_size = [width, height]
+        SDL.check(SDL::InitSubSystem.call(SDL::INIT_VIDEO | SDL::INIT_EVENTS))
+        SDL::SetHint.call("SDL_RENDER_SCALE_QUALITY", "0") # nearest-neighbour
+        SDL::SetHint.call("SDL_MOUSE_RELATIVE_SCALING", "0") # host pixels, whatever the window size
+
+        @window = SDL.check_pointer(SDL::CreateWindow.call(
+                                      title,
+                                      SDL::WINDOWPOS_CENTERED, SDL::WINDOWPOS_CENTERED,
+                                      width * scale, height * scale,
+                                      SDL::WINDOW_RESIZABLE
+                                    ))
+
+        flags = SDL::RENDERER_ACCELERATED
+        flags |= SDL::RENDERER_PRESENTVSYNC if vsync
+        @renderer = SDL.check_pointer(SDL::CreateRenderer.call(@window, -1, flags))
+        SDL.check(SDL::RenderSetLogicalSize.call(@renderer, width, height))
       end
 
       def title=(title)
-        @window.title = title
+        SDL::SetWindowTitle.call(@window, title)
       end
 
       def refresh_rate
-        rate = SDL2::Display.displays.first.current_mode.refresh_rate
+        mode = "\0".b * DISPLAY_MODE_SIZE
+        SDL.check(SDL::GetCurrentDisplayMode.call(0, mode))
+        rate = mode.unpack1("l", offset: 12)
         rate.positive? ? rate : DEFAULT_REFRESH_RATE
-      rescue StandardError
+      rescue SDL::Error
         DEFAULT_REFRESH_RATE
       end
 
       def draw(panes)
-        @renderer.draw_color = [0, 0, 0]
-        @renderer.clear
+        SDL::SetRenderDrawColor.call(@renderer, 0, 0, 0, 255)
+        SDL::RenderClear.call(@renderer)
         panes.each { |pane| pane.render(@renderer) }
-        @renderer.present
+        SDL::RenderPresent.call(@renderer)
+      end
+
+      def close
+        return unless @window
+
+        SDL::DestroyRenderer.call(@renderer)
+        SDL::DestroyWindow.call(@window)
+        SDL::QuitSubSystem.call(SDL::INIT_VIDEO | SDL::INIT_EVENTS)
+        @window = nil
       end
     end
   end

data/lib/badline/gui.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "sdl2"
+require "badline/sdl"
 
 require "badline/gui/palette"
 require "badline/gui/key_map"

data/lib/badline/input/mouse1351.rb

@@ -10,16 +10,23 @@ module Badline
     # wrap, so a single reading says nothing on its own, and the driver has to
     # sample before the mouse travels 32 counts.
     #
-    # #move takes host deltas with y counting down the screen; the counter
-    # counts the other way. The left button sits on the joystick fire line, the
+    # #move takes host pixel deltas with y counting down the screen; the counter
+    # counts the other way. Two host pixels make one count, as in VICE, and the
+    # counters keep the odd half count so slow movement adds up. Motion waits
+    # until the pot register is read, and at most 31 counts of it reach the
+    # counter per read, so a fast flick can't wrap the counter into the
+    # opposite direction. The left button sits on the joystick fire line, the
     # right button on the up line.
     class Mouse1351
       BUTTONS = { left: :fire, right: :up }.freeze
+      MAX_TRAVEL = 62
 
       def initialize
         @lines = Joystick.new
         @x = 0
         @y = 0
+        @pending_x = 0
+        @pending_y = 0
       end
 
       def press(button) = @lines.press(BUTTONS[button])
@@ -29,13 +36,21 @@ module Badline
       def port_bits = @lines.port_bits
 
       def move(delta_x, delta_y)
-        @x = (@x + delta_x) & 0x3f
-        @y = (@y - delta_y) & 0x3f
+        @pending_x = (@pending_x + delta_x).clamp(-MAX_TRAVEL, MAX_TRAVEL)
+        @pending_y = (@pending_y - delta_y).clamp(-MAX_TRAVEL, MAX_TRAVEL)
       end
 
-      def pot_x = @x << 1
+      def pot_x
+        @x = (@x + @pending_x) & 0x7f
+        @pending_x = 0
+        @x & 0x7e
+      end
 
-      def pot_y = @y << 1
+      def pot_y
+        @y = (@y + @pending_y) & 0x7f
+        @pending_y = 0
+        @y & 0x7e
+      end
     end
   end
 end

data/lib/badline/input/paddles.rb

@@ -8,17 +8,18 @@ module Badline
     # on POTY with its button on the right line. Positions are the 0-255 counts
     # SID reads back, and the knobs stop at either end.
     #
+    # #move takes host pixel deltas, two to a count, and the knobs keep the odd
+    # half count so slow turns add up.
+    #
     # Buttons are named after the host mouse buttons, as on the 1351: the left
     # one fires paddle A, the right one paddle B.
     class Paddles
       BUTTONS = { left: :left, right: :right }.freeze
 
-      attr_reader :pot_x, :pot_y
-
       def initialize
         @lines = Joystick.new
-        @pot_x = 0x80
-        @pot_y = 0x80
+        @half_x = 0x100
+        @half_y = 0x100
       end
 
       def press(button) = @lines.press(BUTTONS[button])
@@ -28,9 +29,13 @@ module Badline
       def port_bits = @lines.port_bits
 
       def move(turn_a, turn_b)
-        @pot_x = (@pot_x + turn_a).clamp(0, 0xff)
-        @pot_y = (@pot_y + turn_b).clamp(0, 0xff)
+        @half_x = (@half_x + turn_a).clamp(0, 0x1ff)
+        @half_y = (@half_y + turn_b).clamp(0, 0x1ff)
       end
+
+      def pot_x = @half_x >> 1
+
+      def pot_y = @half_y >> 1
     end
   end
 end