badline 0.12.0 → 0.13.0

data/lib/badline/vic/registers.rb

@@ -1,195 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class VIC < Cycleable
-    # = VIC-II Registers
-    #
-    # == Sprite positions
-    #
-    #   $D000: Sprite 0 X
-    #   $D001: Sprite 0 Y
-    #   $D002: Sprite 1 X
-    #   $D003: Sprite 1 Y
-    #   $D004: Sprite 2 X
-    #   $D005: Sprite 2 Y
-    #   $D006: Sprite 3 X
-    #   $D007: Sprite 3 Y
-    #   $D008: Sprite 4 X
-    #   $D009: Sprite 4 Y
-    #   $D00A: Sprite 5 X
-    #   $D00B: Sprite 5 Y
-    #   $D00C: Sprite 6 X
-    #   $D00D: Sprite 6 Y
-    #   $D00E: Sprite 7 X
-    #   $D00F: Sprite 7 Y
-    #
-    #   $D010: Most Significant Bits of Sprites 0-7 Horizontal Position
-    #   $D011: Vertical Fine Scrolling and Control Register
-    #   $D012: Rasterline
-    #          - Read: Current rasterline
-    #          - Write: Set rasterline interrupt
-    #
-    # == Light pen
-    #
-    #   $D013: Light Pen Horizontal Position
-    #   $D014: Light Pen Vertical Position
-    #
-    #   $D015: Sprite Enable Register
-    #   $D016: Horizontal Fine Scrolling and Control Register
-    #   $D017: Sprite Vertical Expansion Register
-    #   $D018: VIC-II Chip Memory Control Register
-    #   $D019: VIC Interrupt Flag Register
-    #   $D01A: IRQ Mask Register
-    #   $D01B: Sprite to Foreground Display Priority Register
-    #   $D01C: Sprite Multicolor Registers
-    #   $D01D: Sprite Horizontal Expansion Register
-    #
-    # == Sprite collision detection
-    #
-    #   $D01E: Sprite to Sprite Collision Register
-    #   $D01F: Sprite to Foreground Collision Register
-    #
-    # == Color registers
-    #
-    # All color registers are 4bit, bits 4-7 always read 1.
-    #
-    #   $D020: Border color
-    #   $D021: Background color 0
-    #   $D022: Background color 1
-    #   $D023: Background color 2
-    #   $D024: Background color 3
-    #   $D025: Sprite multicolor 0
-    #   $D026: Sprite multicolor 1
-    #   $D027: Sprite 0 color
-    #   $D028: Sprite 1 color
-    #   $D029: Sprite 2 color
-    #   $D02A: Sprite 3 color
-    #   $D02B: Sprite 4 color
-    #   $D02C: Sprite 5 color
-    #   $D02D: Sprite 6 color
-    #   $D02E: Sprite 7 color
-    #
-    # == VIC-IIe (8566 and 8564)
-    #
-    #   $D02F: Extra keyboard lines K0-K2 in bits 0-2, bits 3-7 read 1
-    #   $D030: FAST (2 MHz) in bit 0 and TEST in bit 1, bits 2-7 read 1
-    #
-    # $D02F-$D03F: Not in use on the 6569 and 8565, always reads 0xff,
-    # and $D031-$D03F on the VIC-IIe
-    # $D040-$D3FF: Repeat $D0000 to $D03F every 64 bytes
-    class Registers
-      include IntegerHelper
-
-      # The raw register bytes, for the per-column reads on the hot path.
-      attr_reader :bytes
-
-      # Every register powers on as zero, as in VICE. A VIC-IIe reads
-      # $D02F and $D030 back as registers.
-      def initialize(iie: false)
-        @bytes = Array.new(2**6, 0)
-        @irq_line = false
-        @iie = iie
-      end
-
-      # True while any enabled latch bit is set in $D019/$D01A. Cached and
-      # re-evaluated on writes, since it's checked every cycle.
-      def irq_line? = @irq_line
-
-      def [](reg) = @bytes[reg]
-
-      def read(reg)
-        case reg
-        when 0x16 then @bytes[reg] | 0xc0 # bits 7-6 unused, read 1
-        when 0x18 then @bytes[reg] | 0x01 # bit 0 unused, reads 1
-        when 0x1a, 0x20..0x2e then @bytes[reg] | 0xf0
-        when 0x1e, 0x1f then read_clear(reg) # collision registers clear on read
-        when 0x2f then @iie ? @bytes[reg] | 0xf8 : 0xff
-        when 0x30 then @iie ? @bytes[reg] | 0xfc : 0xff
-        when 0x31..0x3f then 0xff
-        else @bytes[reg]
-        end
-      end
-
-      def write(reg, value)
-        case reg
-        when 0x19 # write 1 to clear
-          @bytes[reg] &= ~value
-          update_irq_line
-        when 0x1a # only the four latch bits
-          @bytes[reg] = value & 0x0f
-          update_irq_line
-        when 0x1e, 0x1f then nil # the collision registers are read-only
-        else @bytes[reg] = value
-        end
-      end
-
-      # Graphics modes
-      def ecm = @bytes[0x11][6]
-      def bmm = @bytes[0x11][5]
-      def mcm = @bytes[0x16][4]
-      # ECM/BMM from $D011 bits 6-5, MCM from $D016 bit 4.
-      def mode = ((@bytes[0x11] >> 4) & 0b110) | ((@bytes[0x16] >> 4) & 0b001)
-
-      def xscroll = @bytes[0x16] & 0b0111
-      def yscroll = @bytes[0x11] & 0b0111
-
-      def rsel? = @bytes[0x11].anybits?(0x08)
-      def csel? = @bytes[0x16].anybits?(0x08)
-      def display_enabled? = @bytes[0x11].anybits?(0x10)
-
-      def char_base = (@bytes[0x18] & 0b1110) * 0x400
-      def bitmap_base = (@bytes[0x18] & 0b1000) * 0x400
-      def screen_base = (@bytes[0x18] >> 4) * 0x400
-
-      def border = @bytes[0x20] & 0x0f
-      def background(index = 0) = @bytes[0x21 + index] & 0x0f
-
-      # The VIC-IIe's $D02F and $D030 bits. The 6569 and 8565 drive no
-      # extra keyboard lines and run at 1 MHz.
-      def extra_keyboard_lines = @iie ? @bytes[0x2f] & 0x07 : 0x07
-      def fast? = @iie && @bytes[0x30].anybits?(0x01)
-      def test? = @iie && @bytes[0x30].anybits?(0x02)
-
-      # FAST and TEST as bits 0 and 1.
-      def clock_bits = @iie ? @bytes[0x30] & 0x03 : 0
-
-      def raster_target = uint16(@bytes[0x12], (@bytes[0x11] & 0x80) >> 7)
-
-      def latch_irq!(bit)
-        @bytes[0x19] |= bit
-        update_irq_line
-      end
-
-      def latch_raster_irq! = latch_irq!(0x01)
-
-      def save_state(out)
-        out.blob(@bytes).boolean(@irq_line)
-      end
-
-      def load_state(input)
-        input.blob_into(@bytes)
-        @irq_line = input.boolean?
-      end
-
-      def collide!(reg, bits)
-        return false if bits.zero?
-
-        was_zero = @bytes[reg].zero?
-        @bytes[reg] |= bits
-        was_zero
-      end
-
-      # Works the IRQ line out from $D019 and $D01A again, after the bytes
-      # were set directly.
-      def update_irq_line
-        @irq_line = (@bytes[0x19] & @bytes[0x1a]).anybits?(0x0f)
-      end
-
-      private
-
-      def read_clear(reg)
-        @bytes[reg].tap { @bytes[reg] = 0 }
-      end
-    end
-  end
-end

data/lib/badline/vic/sequencer.rb

@@ -1,275 +0,0 @@
-# frozen_string_literal: true
-
-require "badline/vic/border_mask"
-require "badline/vic/color_patches"
-require "badline/vic/graphics_mode"
-require "badline/vic/graphics_shifter"
-require "badline/vic/sequencer_output"
-require "badline/vic/sequencer_state"
-
-module Badline
-  class VIC < Cycleable
-    # = VIC-II Sequencer
-    #
-    # Turns fetched graphics data into output pixels.
-    class Sequencer
-      include Output
-      include SavedState
-
-      BORDER_Y_BOUNDS = [
-        [55, 247].freeze,
-        [51, 251].freeze
-      ].freeze
-
-      MODES = GraphicsMode::MODES
-
-      attr_reader :colors, :fg, :registers, :bank, :cur_colors,
-                  :color_patches
-      # The fg masks are shared frozen patterns assigned by reference, never
-      # mutated in place.
-      attr_accessor :cur_fg
-      # False leaves the line's colours unpainted and keeps only the
-      # foreground mask the sprite collisions read.
-      attr_writer :render
-
-      def initialize(width, registers, bank, model: :mos6569, region: Region::PAL)
-        @width = width
-        window_bounds(region.display_x_bounds)
-        @registers = registers
-        @bank = bank
-        @colors = Array.new(width, 0)
-        @fg = Array.new(width, false)
-        @border_mask = BorderMask.new(width)
-        # Hot-path aliases: the pixel loops write coverage straight into the
-        # mask's arrays.
-        @border = @border_mask.mask
-        @border_groups = @border_mask.groups
-        @cur_colors = Array.new(8, 0)
-        @cur_fg = GraphicsMode::NO_FG
-        @prev_colors = Array.new(8, 0)
-        @prev_fg = GraphicsMode::NO_FG
-        @vertical_border = true
-        @vertical_armed = true
-        @main_border = true
-        @color_patches = ColorPatches.new(self, grey_dots: model == :mos8565)
-        @shifter = GraphicsShifter.new(registers, model:)
-        @xscroll = 0
-        @last_shift = 0
-        @last_mode = 0
-        @settling = false
-        @ring_data = Array.new(4, 0)
-        @ring_char = Array.new(4, 0)
-        @ring_color = Array.new(4, 1)
-        @prev_fresh = false
-        @check = true
-        @render = true
-        new_line(0)
-      end
-
-      # Reset the line buffers at the start of a rasterline.
-      def new_line(line)
-        @line = line
-        @left_vertical_border = nil
-        @first_csel = @registers.csel?
-        @colors.fill(@registers.border)
-        @fg.fill(false)
-        @border_mask.reset
-        @prev_colors.fill(@registers.background)
-        @prev_fg = GraphicsMode::NO_FG
-        @prev_fresh = false
-        @check = true
-        @color_patches.clear
-      end
-
-      # The load point for the next group's byte: XSCROLL as a g-access
-      # column with the border open sees it, a column before the group that
-      # uses it (VICE x64sc `xscroll_pipe`).
-      def latch_xscroll(xscroll = @registers.xscroll)
-        return if xscroll == @xscroll
-
-        @xscroll = xscroll
-        @check = true
-      end
-
-      # A write to a register the painted colours depend on: the byte kept
-      # from the previous group is painted again before its pixels are shown.
-      def colors_changed!
-        @prev_fresh = false
-        @check = true
-      end
-
-      def apply_color_patches
-        @color_patches.apply(@colors, @fg)
-      end
-
-      # The vertical border compares run in every cycle of their line (VICE
-      # x64sc). The top one resets the flip-flop at once when DEN is set. The
-      # bottom one only arms it, and the armed state takes hold at the line's
-      # first cycle and at the left window edge (Bauer §3.9 rules 2-5). The
-      # VIC calls this after each $d011 write.
-      def compare_vertical_border(line)
-        top, bottom = BORDER_Y_BOUNDS[@registers.rsel? ? 1 : 0]
-        @vertical_armed = true if line == bottom
-        @vertical_armed = @vertical_border = false if line == top && @registers.display_enabled?
-      end
-
-      # The line's first cycle, Bauer's cycle 1, which is the last column of
-      # the line before it.
-      def start_vertical_border(line)
-        compare_vertical_border(line)
-        @vertical_border = @vertical_armed
-      end
-
-      # The 40-column left compare, a column before the column that draws its
-      # pixel. The 38-column one runs in the drawing column.
-      def left_compare_vertical_border
-        @left_vertical_border = start_vertical_border(@line) if @registers.csel?
-      end
-
-      def border_at?(pixel_x) = @border_mask.at?(pixel_x)
-
-      # True while the vertical border flip-flop is set and stays set for the
-      # rest of the line: it can only clear mid-line on a top compare line
-      # with DEN set.
-      def vertical_closed?
-        return false unless @vertical_border
-        return true unless @line == 51 || @line == 55
-
-        top, = BORDER_Y_BOUNDS[@registers.rsel? ? 1 : 0]
-        !(@line == top && @registers.display_enabled?)
-      end
-
-      # Snapshot the finished line so apply_border can restore the border
-      # pixels sprites were composited over, keeping mid-line border splits.
-      def snapshot_line = @border_mask.snapshot(@colors)
-
-      # Repaint the border over the composited line, hiding the sprites.
-      def apply_border = @border_mask.restore(@colors)
-
-      # The g-accesses the VIC hands over, as a ring the column's slot
-      # indexes: the byte read, the screen byte and the colour nibble. The
-      # slot before is the byte the previous group loaded.
-      attr_reader :ring_data, :ring_char, :ring_color
-
-      # The border flip-flops: vertical, the vertical one armed to set, and
-      # the main one.
-      def borders = [@vertical_border, @vertical_armed, @main_border]
-
-      def restore_borders(vertical, armed, main)
-        @vertical_border = vertical
-        @vertical_armed = armed
-        @main_border = main
-      end
-
-      # Paints the byte in the slot through the current mode. An idle access
-      # latches 0/0 and one that made no access passes on zero data with the
-      # kept values; under a closed border neither has foreground. A group
-      # where the mode or the load point changes, and the one after it, run
-      # the shift register pixel by pixel.
-      def emit(slot, col, display)
-        mode = @registers.mode
-        return emit_checked(slot, col, display, mode) if @check || mode != @last_mode
-
-        paint_slot(slot, mode, display)
-        output(col, @last_shift)
-        roll
-      end
-
-      private
-
-      # The display window's edges per CSEL state, as the region gives them.
-      # The graphics window always spans the full 40 columns, ignoring CSEL,
-      # and the border flip-flop takes [left compare, right compare] per
-      # CSEL state.
-      def window_bounds(bounds)
-        narrow, wide = bounds
-        @gfx_x_start = wide[0]
-        @gfx_x_end = wide[1] + 1
-        @window_compares = [
-          [narrow[0], narrow[1] + 1].freeze,
-          [@gfx_x_start, @gfx_x_end].freeze
-        ].freeze
-      end
-
-      # After a mode, XSCROLL or colour change: groups paint whole bytes
-      # again once the change has settled, and run pixel by pixel until then.
-      def emit_checked(slot, col, display, mode)
-        shift = @xscroll
-        if mode == @last_mode && shift == @last_shift && !@settling
-          emit_settled(slot, col, display, mode, shift)
-        else
-          emit_pixels(slot, col, mode, shift, !display && border_hidden?)
-          @settling = mode != @last_mode || shift != @last_shift
-          @last_mode = mode
-          @last_shift = shift
-        end
-      end
-
-      def emit_settled(slot, col, display, mode, shift)
-        repaint_previous(mode, (slot - 1) & 3) unless @prev_fresh || shift.zero?
-        paint_slot(slot, mode, display)
-        output(col, shift)
-        roll
-        @prev_fresh = true
-        @check = false
-      end
-
-      def paint_slot(slot, mode, display)
-        if !display && border_hidden?
-          @cur_fg = GraphicsMode::NO_FG
-        else
-          paint(slot, mode)
-        end
-      end
-
-      def repaint_previous(mode, slot)
-        roll
-        paint(slot, mode)
-        roll
-      end
-
-      def paint(slot, mode)
-        if @render
-          MODES[mode].paint(@ring_data[slot], @ring_char[slot], @ring_color[slot], self)
-        else
-          @cur_fg = MODES[mode].fg(@ring_data[slot], @ring_char[slot], @ring_color[slot])
-        end
-      end
-
-      def emit_pixels(slot, col, mode, shift, hidden)
-        prime_shifter((slot - 1) & 3) unless @settling
-        @shifter.draw(hidden ? 0 : @ring_data[slot], @ring_char[slot], @ring_color[slot], shift, mode)
-        @cur_colors[0, 8] = @shifter.colors
-        @cur_fg = @shifter.fg
-        output(col, 0)
-        @prev_fresh = false
-        @check = true
-      end
-
-      # Picks up from a group that painted whole bytes.
-      def prime_shifter(slot)
-        @shifter.prime(@ring_data[slot], @ring_char[slot], @ring_color[slot], @last_shift, @last_mode)
-      end
-
-      # The group is border throughout when the main flip-flop is set and the
-      # vertical one keeps it from clearing.
-      def border_hidden? = @main_border && vertical_closed?
-
-      def pixel_shown?(pixel_x, left_compare, right_compare)
-        @main_border = true if pixel_x == right_compare
-        @main_border = false if pixel_x == left_compare && !left_vertical_border
-        !@main_border
-      end
-
-      def left_vertical_border
-        @left_vertical_border.nil? ? start_vertical_border(@line) : @left_vertical_border
-      end
-
-      def roll
-        @prev_colors, @cur_colors = @cur_colors, @prev_colors
-        @prev_fg, @cur_fg = @cur_fg, @prev_fg
-        nil
-      end
-    end
-  end
-end

data/lib/badline/vic/sequencer_output.rb

@@ -1,116 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class VIC < Cycleable
-    class Sequencer
-      # Writes a column's 8-pixel group into the line buffers, through the
-      # main border flip-flop and XSCROLL.
-      module Output
-        private
-
-        # Write the 8-pixel group for a column into the line buffers. The main
-        # border flip-flop only changes state in the groups containing the
-        # window edge compares, so all other groups take a branch-free bulk
-        # path: fully border or fully window. A group's first pixel, where the
-        # 40-column compares fall, still sees CSEL as the column before had it.
-        def output(col, shift)
-          x_pos = (col + 16) * 8
-          csel = @registers.csel?
-          first = @window_compares[@first_csel ? 1 : 0]
-          @first_csel = csel
-          compares = @window_compares[csel ? 1 : 0]
-          win_lo, right_compare = compares
-
-          if !first.equal?(compares) || boundary_group?(x_pos, win_lo, right_compare)
-            output_boundary(x_pos, first, compares, shift)
-          elsif @main_border
-            output_border(x_pos)
-          else
-            output_window(x_pos, shift)
-          end
-        end
-
-        # True if the group contains a window edge, where the main border
-        # flip-flop can change state.
-        def boundary_group?(x_pos, win_lo, right_compare)
-          lo_delta = win_lo - x_pos
-          hi_delta = right_compare - x_pos
-          (lo_delta >= 0 && lo_delta < 8) || (hi_delta >= 0 && hi_delta < 8)
-        end
-
-        def output_border(x_pos)
-          @colors.fill(@registers.border, x_pos, 8) if @render
-          @border_groups[x_pos >> 3] = BorderMask::FULL
-          @fg.fill(false, x_pos, 8)
-        end
-
-        def output_window(x_pos, shift)
-          in_gfx = x_pos >= @gfx_x_start && x_pos < @gfx_x_end
-          @border_groups[x_pos >> 3] = BorderMask::NONE
-
-          if shift.zero?
-            @colors[x_pos, 8] = @cur_colors if @render
-            if in_gfx
-              @fg[x_pos, 8] = @cur_fg
-            else
-              @fg.fill(false, x_pos, 8)
-            end
-          else
-            output_window_shifted(x_pos, in_gfx, shift)
-          end
-        end
-
-        def output_window_shifted(x_pos, in_gfx, shift)
-          keep = 8 - shift
-
-          if @render
-            copy(@cur_colors, 0, @colors, x_pos + shift, keep)
-            copy(@prev_colors, keep, @colors, x_pos, shift)
-          end
-          output_shifted_fg(x_pos, in_gfx, shift, keep)
-        end
-
-        def output_shifted_fg(x_pos, in_gfx, shift, keep)
-          return @fg.fill(false, x_pos, 8) unless in_gfx
-
-          copy(@cur_fg, 0, @fg, x_pos + shift, keep)
-          copy(@prev_fg, keep, @fg, x_pos, shift)
-        end
-
-        def copy(src, from, dest, to, count)
-          i = 0
-          while i < count
-            dest[to + i] = src[from + i]
-            i += 1
-          end
-        end
-
-        # Slow path for the groups where the border flip-flop can change state.
-        def output_boundary(x_pos, first, compares, shift)
-          border = @registers.border
-          win_lo, right_compare = first
-          @border_groups[x_pos >> 3] = BorderMask::MIXED
-
-          i = 0
-          while i < 8
-            src = i - shift
-            if src >= 0
-              pixel = @cur_colors[src]
-              mask = @cur_fg[src]
-            else
-              pixel = @prev_colors[8 + src]
-              mask = @prev_fg[8 + src]
-            end
-            x = x_pos + i
-            shown = pixel_shown?(x, win_lo, right_compare)
-            @colors[x] = shown ? pixel : border
-            @border[x] = !shown
-            @fg[x] = x >= @gfx_x_start && x < @gfx_x_end ? mask : false
-            win_lo, right_compare = compares if i.zero?
-            i += 1
-          end
-        end
-      end
-    end
-  end
-end

data/lib/badline/vic/sequencer_state.rb

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class VIC < Cycleable
-    class Sequencer
-      # The sequencer's save_state and load_state.
-      module SavedState
-        FG_SHIFTER = -1
-        PAIR_CODES = 256
-
-        # The line buffers, the border flip-flops, the g-access ring and the
-        # pixel pipeline. The foreground masks the groups point at go as
-        # FG_SHIFTER for the shift register's, or their data byte in
-        # GraphicsMode's HIRES_FG, or that plus 256 in its PAIR_FG. The left
-        # vertical border compare goes as -1 before it has run.
-        def save_state(out)
-          out.int(@line).boolean(@first_csel).int(@left_vertical_border.nil? ? -1 : bit(@left_vertical_border))
-          out.blob(@colors).booleans(@fg)
-          @border_mask.save_state(out)
-          out.ints(@cur_colors).int(fg_code(@cur_fg)).ints(@prev_colors).int(fg_code(@prev_fg))
-          out.boolean(@vertical_border).boolean(@vertical_armed).boolean(@main_border)
-          @color_patches.save_state(out)
-          @shifter.save_state(out)
-          out.int(@xscroll).int(@last_shift).int(@last_mode).boolean(@settling).boolean(@prev_fresh).boolean(@check)
-          out.ints(@ring_data).ints(@ring_char).ints(@ring_color)
-        end
-
-        def load_state(input)
-          load_line(input)
-          @border_mask.load_state(input)
-          input.ints_into(@cur_colors)
-          @cur_fg = fg_pattern(input.int)
-          input.ints_into(@prev_colors)
-          @prev_fg = fg_pattern(input.int)
-          @vertical_border = input.boolean?
-          @vertical_armed = input.boolean?
-          @main_border = input.boolean?
-          @color_patches.load_state(input)
-          @shifter.load_state(input)
-          load_pipeline(input)
-        end
-
-        private
-
-        def bit(flag) = flag ? 1 : 0
-
-        def load_line(input)
-          @line = input.int
-          @first_csel = input.boolean?
-          left = input.int
-          @left_vertical_border = left.negative? ? nil : left == 1
-          input.blob_into(@colors)
-          input.booleans_into(@fg)
-        end
-
-        def load_pipeline(input)
-          @xscroll = input.int
-          @last_shift = input.int
-          @last_mode = input.int
-          @settling = input.boolean?
-          @prev_fresh = input.boolean?
-          @check = input.boolean?
-          input.ints_into(@ring_data)
-          input.ints_into(@ring_char)
-          input.ints_into(@ring_color)
-        end
-
-        def fg_code(pattern)
-          return FG_SHIFTER if pattern.equal?(@shifter.fg)
-
-          hires = GraphicsMode::HIRES_FG.index { |fg| fg.equal?(pattern) }
-          return hires if hires
-
-          pair = GraphicsMode::PAIR_FG.index { |fg| fg.equal?(pattern) }
-          raise ArgumentError, "a foreground mask the sequencer doesn't know" unless pair
-
-          PAIR_CODES + pair
-        end
-
-        def fg_pattern(code)
-          return @shifter.fg if code == FG_SHIFTER
-          return GraphicsMode::HIRES_FG.fetch(code) if code < PAIR_CODES
-
-          GraphicsMode::PAIR_FG.fetch(code - PAIR_CODES)
-        end
-      end
-    end
-  end
-end