badline 0.1.0 → 0.2.1

data/lib/badline/vic/sequencer.rb

@@ -1,6 +1,10 @@
 # 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"
 
 module Badline
   class VIC < Cycleable
@@ -8,6 +12,8 @@ module Badline
     #
     # Turns fetched graphics data into output pixels.
     class Sequencer
+      include Output
+
       DISPLAY_X_BOUNDS = [
         [135, 438].freeze,
         [128, 447].freeze
@@ -28,28 +34,16 @@ module Badline
         [51, 251].freeze
       ].freeze
 
-      # Border coverage per 8-pixel group, tracked so apply_border can skip
-      # window groups and bulk-fill full border groups.
-      BORDER_FULL  = 0
-      BORDER_NONE  = 1
-      BORDER_MIXED = 2
-
-      NULL_MODE = GraphicsMode::Null.new
-      MODES = [
-        GraphicsMode::Text.new,                   # 000 standard text
-        GraphicsMode::MulticolorText.new,         # 001 multicolour text
-        GraphicsMode::Bitmap.new,                 # 010 standard bitmap
-        GraphicsMode::MulticolorBitmap.new,       # 011 multicolour bitmap
-        GraphicsMode::ExtendedBackgroundText.new, # 100 ECM text
-        NULL_MODE,                                # 101 invalid
-        NULL_MODE,                                # 110 invalid
-        NULL_MODE                                 # 111 invalid
-      ].freeze
+      MODES = GraphicsMode::MODES
 
-      attr_reader :colors, :fg, :border, :registers, :bank, :cur_colors
+      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)
         @width = width
@@ -57,180 +51,212 @@ module Badline
         @bank = bank
         @colors = Array.new(width, 0)
         @fg = Array.new(width, false)
-        @border = Array.new(width, true)
-        @border_groups = Array.new(width / 8, BORDER_FULL)
+        @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)
+        @shifter = GraphicsShifter.new(registers)
+        @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 and re-evaluate the
-      # vertical border flip-flop.
+      # Reset the line buffers at the start of a rasterline.
       def new_line(line)
-        update_vertical_border(line)
+        @line = line
+        @left_vertical_border = nil
+        @first_csel = @registers.csel?
         @colors.fill(@registers.border)
         @fg.fill(false)
-        @border_groups.fill(BORDER_FULL)
+        @border_mask.reset
         @prev_colors.fill(@registers.background)
         @prev_fg = GraphicsMode::NO_FG
+        @prev_fresh = false
+        @check = true
+        @color_patches.clear
       end
 
-      # Repaint the border over the composited line, hiding the sprites.
-      def apply_border
-        color = @registers.border
-        group = 0
-        while group < @border_groups.length
-          case @border_groups[group]
-          when BORDER_FULL then @colors.fill(color, group * 8, 8)
-          when BORDER_MIXED then paint_mixed_border(color, group * 8)
-          end
-          group += 1
-        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
 
-      def emit(screencode, color, col, cell, row)
-        MODES[@registers.mode].decode(screencode, color, cell, row, self)
-        output(col)
-        roll
+      # 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 emit_idle(col)
-        @cur_colors.fill(@registers.background)
-        @cur_fg = GraphicsMode::NO_FG
-        output(col)
-        roll
+      def apply_color_patches
+        @color_patches.apply(@colors, @fg)
       end
 
-      private
+      # 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
 
-      # 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.
-      def output(col)
-        x_pos = (col + 16) * 8
-        win_lo, right_compare = WINDOW_COMPARES[@registers.csel? ? 1 : 0]
-
-        if boundary_group?(x_pos, win_lo, right_compare)
-          output_boundary(col, x_pos, win_lo, right_compare)
-        elsif @main_border || @vertical_border
-          output_border(x_pos)
-        else
-          output_window(col, x_pos)
-        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
 
-      # 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)
+      # 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 output_border(x_pos)
-        @colors.fill(@registers.border, x_pos, 8)
-        @border_groups[x_pos >> 3] = BORDER_FULL
-        @fg.fill(false, x_pos, 8)
+      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
 
-      def output_window(col, x_pos)
-        in_gfx = x_pos >= GFX_X_START && x_pos < GFX_X_END
-        @border_groups[x_pos >> 3] = BORDER_NONE
+      # 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
+
+      # 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
 
-        if @registers.xscroll.zero?
-          @colors[x_pos, 8] = @cur_colors
-          if in_gfx
-            @fg[x_pos, 8] = @cur_fg
-          else
-            @fg.fill(false, x_pos, 8)
-          end
+        paint_slot(slot, mode, display)
+        output(col, @last_shift)
+        roll
+      end
+
+      private
+
+      # 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
-          output_window_shifted(col, x_pos, in_gfx)
+          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 output_window_shifted(col, x_pos, in_gfx)
-        shift = @registers.xscroll
-        keep = 8 - shift
+      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
 
-        @colors[x_pos + shift, keep] = @cur_colors[0, keep]
-        if col.positive? # the left column only exists from column 1 on
-          @colors[x_pos, shift] = @prev_colors[keep, shift]
+      def paint_slot(slot, mode, display)
+        if !display && border_hidden?
+          @cur_fg = GraphicsMode::NO_FG
         else
-          @colors.fill(@registers.background, x_pos, shift)
+          paint(slot, mode)
         end
-        output_shifted_fg(col, x_pos, in_gfx, shift, keep)
       end
 
-      def output_shifted_fg(col, x_pos, in_gfx, shift, keep)
-        return @fg.fill(false, x_pos, 8) unless in_gfx
+      def repaint_previous(mode, slot)
+        roll
+        paint(slot, mode)
+        roll
+      end
 
-        @fg[x_pos + shift, keep] = @cur_fg[0, keep]
-        if col.positive?
-          @fg[x_pos, shift] = @prev_fg[keep, shift]
+      def paint(slot, mode)
+        if @render
+          MODES[mode].paint(@ring_data[slot], @ring_char[slot], @ring_color[slot], self)
         else
-          @fg.fill(false, x_pos, shift)
+          @cur_fg = MODES[mode].fg(@ring_data[slot], @ring_char[slot], @ring_color[slot])
         end
       end
 
-      # Slow path for the groups where the border flip-flop can change state.
-      def output_boundary(col, x_pos, win_lo, right_compare)
-        shift = @registers.xscroll
-        bg = @registers.background
-        bleed = col.positive?
-        border = @registers.border
-        @border_groups[x_pos >> 3] = BORDER_MIXED
-
-        i = 0
-        while i < 8
-          src = i - shift
-          if src >= 0
-            pixel = @cur_colors[src]
-            mask = @cur_fg[src]
-          elsif bleed
-            pixel = @prev_colors[8 + src]
-            mask = @prev_fg[8 + src]
-          else
-            pixel = bg
-            mask = false
-          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
-          i += 1
-        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
 
-      def paint_mixed_border(color, x_pos)
-        i = 0
-        while i < 8
-          @colors[x_pos + i] = color if @border[x_pos + i]
-          i += 1
-        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 && !@vertical_border
-        !(@main_border || @vertical_border)
+        @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
-      end
-
-      def update_vertical_border(line)
-        top, bottom = BORDER_Y_BOUNDS[@registers.rsel? ? 1 : 0]
-        @vertical_border = true if line == bottom
-        @vertical_border = false if line == top && @registers.display_enabled?
+        nil
       end
     end
   end

data/lib/badline/vic/sequencer_output.rb

@@ -0,0 +1,116 @@
+# 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/sprite/internal_bus.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Badline
+  class VIC < Cycleable
+    class Sprite
+      # = InternalBus
+      #
+      # What a sprite's s-accesses read while its DMA is off. The first and
+      # third fall in phi2, where the VIC's internal bus floats to $ff unless
+      # the CPU reads or writes a VIC register in that cycle, and the middle
+      # one is the idle fetch at $3fff (sbsprf24's readme).
+      class InternalBus
+        def initialize(bank, columns)
+          @bank = bank
+          @lines = 0
+          @ghost = 0xff
+          @value = Array.new(columns, 0xff)
+          @line = Array.new(columns, -1)
+        end
+
+        # Sprites 3-7 fetch in Bauer cycles 1-10, so the idle byte is taken
+        # as the line starts.
+        def start_line(sprites_enabled)
+          @lines += 1
+          @ghost = @bank.peek(0x3fff) if sprites_enabled
+        end
+
+        # The VIC has advanced to `column`, so the access runs in Bauer cycle
+        # `column + 1`, and column 0 is the first cycle of the line about to
+        # start.
+        def access(column, value)
+          @value[column] = value
+          @line[column] = column.zero? ? @lines + 1 : @lines
+        end
+
+        # The row sprite `index` (3-7) fetched this line, in Bauer cycles
+        # 2n-5 and 2n-4.
+        def row(index)
+          column = (2 * index) - 6
+          (phi2(column) << 16) | (@ghost << 8) | phi2(column + 1)
+        end
+
+        private
+
+        def phi2(column) = @line[column] == @lines ? @value[column] : 0xff
+      end
+    end
+  end
+end

data/lib/badline/vic/sprite/shifter.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Badline
+  class VIC < Cycleable
+    class Sprite
+      # The X comparator and the 24-bit shift register behind it: where a
+      # line fires the sprite, and the pixels each firing shifts out.
+      module Shifter
+        EMPTY = [].freeze
+
+        private
+
+        # The first pixel of every comparator match along the line. Writes to
+        # $d000/$d010 move the compare value mid-line, so a sprite can miss
+        # its match entirely and pick up a later one, a second one, or none.
+        def comparator_hits(log)
+          unless log
+            match = compare_x(@registers)
+            return match ? [(match + 1) % @width] : EMPTY
+          end
+
+          hits = []
+          log.rewind
+          log.advance(0)
+          from = 0
+          while from < @width
+            upto = [log.next_x, @width].min
+            match = compare_x(log)
+            hits << ((match + 1) % @width) if match && match >= from && match < upto
+            break if upto >= @width
+
+            from = upto
+            log.advance(from)
+          end
+          hits
+        end
+
+        # The VIC's X counter only runs to 503, so the eight coordinates above
+        # it never match and the sprite stays dark — the gap the spritegap
+        # tests find at $1f8.
+        def compare_x(view)
+          msb = view[0x10].anybits?(@bit) ? 0x100 : 0
+          xpos = msb | view[index * 2]
+          return if xpos >= @width
+
+          (xpos + COMPARE_OFFSET) % @width
+        end
+
+        # Pixels from the X match to the next reload.
+        def reload_cut(start) = (start < @reload_x ? @reload_x : @reload_x + @width) - start
+
+        # A run that reaches the next reload is cut there, holding its last
+        # pixel through K+6. Returns the span that is left.
+        def cut_at_reload(cut, span, codes)
+          return span if cut > span || cut >= MAX_SPAN
+
+          RELOAD_HOLD.times { |i| codes[cut + i] = codes[cut - 1] }
+          cut + RELOAD_HOLD
+        end
+
+        # Shift one firing out into `codes`, up to the sprite's end, `cut`
+        # pixels from the reload.
+        def run(log, start, codes, bits, cut)
+          @sr = bits
+          log&.rewind
+          pos = start
+          count = 0
+          boundary = log ? 0 : Float::INFINITY
+          mc = multicolor?
+          expanded = x_expanded?
+          while count < MAX_SPAN
+            if pos >= boundary
+              log.advance(pos)
+              mc = log[0x1c].anybits?(@bit)
+              expanded = log[0x1d].anybits?(@bit)
+              boundary = log.next_x
+            end
+            count.zero? ? prime(mc) : step(mc, expanded, count == cut - 1)
+            break if @latch.zero? && @sr.zero?
+
+            codes[count] = @latch
+            count += 1
+            pos += 1
+          end
+          count
+        end
+
+        # The X match loads the shift register and arms both flip-flops, so
+        # the sprite's first pixel comes straight off the fetched row.
+        def prime(multicolor)
+          @mc_flop = false
+          @xe_flop = false
+          @latch = (@sr >> 22) & (multicolor ? 3 : 2)
+        end
+
+        # One pixel of the sequencer. An unexpanded sprite shifts every pixel;
+        # an expanded one shifts every other, and the multicolor latch reloads
+        # every other shift, so its pairs stretch with the expansion. Both
+        # flip-flops sit idle while their register bit is clear, which is why
+        # the first pixel after a mid-sprite change repeats the last one.
+        def step(multicolor, expanded, last)
+          shift = true
+          if expanded
+            shift = @xe_flop
+            @xe_flop = !@xe_flop
+          else
+            @xe_flop = false
+          end
+          @mc_flop = false unless multicolor
+          return unless shift
+
+          @sr = (@sr << 1) & 0xffffff
+          load_latch(multicolor, last)
+        end
+
+        # A multicolor pair loaded on the last pixel before the reload keeps
+        # only its high bit, as a hi-res pixel does (spritefetchbug).
+        def load_latch(multicolor, last)
+          if multicolor
+            @latch = (@sr >> 22) & (last ? 2 : 3) if @mc_flop
+            @mc_flop = !@mc_flop
+          else
+            @latch = (@sr >> 22) & 2
+          end
+        end
+      end
+    end
+  end
+end