badline 0.12.1 → 0.13.0

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

@@ -0,0 +1,197 @@
+# 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 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
+end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Badline
+  module Chips
+    class VIC
+      # The VIC's state for a snapshot.
+      module SavedState
+        # Everything the VIC holds between cycles: the beam, the fetch and
+        # g-access pipeline, the light pen and raster latches, the finished
+        # lines, on the VIC-IIe the display line and the TEST bit's wrap, the
+        # registers and the display, sequencer and sprite logic.
+        # Whether it renders is the host's, and every line comes back dirty so
+        # a front end repaints.
+        def save_state(out)
+          out.marker("VIC")
+          out.int(@column).int(@rasterline)
+          out.int(@g_tick).ints(@g_kind).int(@g_kept_char).int(@g_kept_color).boolean(@g_display)
+          out.int(@fetch_d011).boolean(@lp_triggered).boolean(@lp_low).boolean(@raster_match)
+          out.int(@vic_bank.lines)
+          out.blob(@character_buffer).blob(@color_buffer).booleans(@sprite_ba)
+          @lines.each { |line| out.blob(line) }
+          out.int(@output_line).boolean(@test_wrap) if @iie
+          @registers.save_state(out)
+          @display_state.save_state(out)
+          @sequencer.save_state(out)
+          @sprites.save_state(out)
+        end
+
+        def load_state(input)
+          input.marker("VIC")
+          load_beam(input)
+          load_buffers(input)
+          load_lines(input)
+          load_test_state(input) if @iie
+          @registers.load_state(input)
+          @display_state.load_state(input)
+          @sequencer.load_state(input)
+          @sprites.load_state(input)
+        end
+
+        private
+
+        def load_beam(input)
+          @column = input.int
+          @rasterline = @output_line = input.int
+          @g_tick = input.int
+          input.ints_into(@g_kind)
+          @g_kept_char = input.int
+          @g_kept_color = input.int
+          @g_display = input.boolean?
+          @fetch_d011 = input.int
+          @lp_triggered = input.boolean?
+          @lp_low = input.boolean?
+          @raster_match = input.boolean?
+          @vic_bank.lines = input.int
+        end
+
+        def load_buffers(input)
+          input.blob_into(@character_buffer)
+          input.blob_into(@color_buffer)
+          input.booleans_into(@sprite_ba)
+        end
+
+        # The VIC-IIe's display line and TEST wrap, which only its TEST bit
+        # moves off the raster line.
+        def load_test_state(input)
+          @output_line = input.int
+          @test_wrap = input.boolean?
+        end
+
+        # The display is the finished lines one after another.
+        def load_lines(input)
+          @lines.each_with_index do |line, number|
+            input.blob_into(line)
+            @display[number * @width, @width] = line
+          end
+          @dirty_lines.fill(true)
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,277 @@
+# 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"
+require "badline/chips/vic/sequencer/saved_state"
+
+module Badline
+  module Chips
+    class VIC
+      # = 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
+end