badline 0.12.1 → 0.14.0

data/lib/badline/chips/vic/registers.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+module Badline
+  module Chips
+    class VIC
+      # = 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 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
+end

data/lib/badline/chips/vic/sequencer.rb

@@ -0,0 +1,275 @@
+# frozen_string_literal: true
+
+require "badline/chips/vic/border_mask"
+require "badline/chips/vic/color_patches"
+require "badline/chips/vic/graphics_mode"
+require "badline/chips/vic/graphics_shifter"
+require "badline/chips/vic/sequencer_output"
+
+module Badline
+  module Chips
+    class VIC
+      # = VIC-II Sequencer
+      #
+      # Turns fetched graphics data into output pixels.
+      class Sequencer
+        include Output
+
+        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
+end

data/lib/badline/chips/vic/sequencer_output.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Badline
+  module Chips
+    class VIC
+      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
+end

data/lib/badline/chips/vic/sprite/internal_bus.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Badline
+  module Chips
+    class VIC
+      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
+          # The columns of a raster line, and where the region puts the
+          # sprites in it.
+          attr_reader :columns, :timing
+
+          def initialize(bank, timing)
+            @bank = bank
+            @timing = timing
+            @columns = timing.columns
+            @sprite_cycle = timing.sprite_cycle
+            @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 the phi2 halves
+          # of the two cycles from its p-access: Bauer cycles 2n-5 and 2n-4 on
+          # the 6569.
+          def row(index)
+            column = (@sprite_cycle + (2 * index) - 1) % @columns
+            (phi2(column) << 16) | (@ghost << 8) | phi2(column + 1)
+          end
+
+          private
+
+          def phi2(column) = @line[column] == @lines ? @value[column] : 0xff
+        end
+      end
+    end
+  end
+end