badline 0.2.1 → 0.4.0

data/lib/badline/vic/graphics_shifter.rb

@@ -9,22 +9,34 @@ module Badline
     #
     # The byte a group draws loads at pixel XSCROLL. ECM and BMM take hold at
     # pixel 4 as they rise and at pixel 6 as they fall (the 6569's colour
-    # latency). MCM takes hold at pixel 4 for the colour lookup but only at
+    # latency), except that BMM falls at pixel 5 out of any mode but hi-res
+    # bitmap. MCM takes hold at pixel 4 for the colour lookup but only at
     # pixel 7 for how the register is read, where a rising MCM also resets
     # the multicolour flip-flop. An MCM that falls out of the invalid
     # ECM+MCM mode is a pixel later on both counts: the lookup changes at
     # pixel 5 and the read at the next group's pixel 0. The mode bits are
     # the sequencer's: ECM 4, BMM 2, MCM 1.
+    #
+    # The 8565 has no colour latency: ECM and BMM take hold, rising or
+    # falling, at the next group's pixel 0, and an MCM that falls out of
+    # ECM+MCM does so on time. Where that pixel 0 takes the group out of an
+    # invalid mode, it is still black into hi-res text, and so is a
+    # background pixel into multicolour bitmap.
     class GraphicsShifter
+      ECM = 0b100
       ECM_BMM = 0b110
+      MULTICOLOR_BITMAP = 0b011
       ECM_MCM = 0b101
       BMM = 0b010
 
       # The group #draw painted, and which of its pixels are foreground.
       attr_reader :colors, :fg
 
-      def initialize(registers)
+      def initialize(registers, model: :mos6569)
         @registers = registers
+        @latency = model != :mos8565
+        @next_ecm_bmm = 0
+        @black_below = 0
         @colors = Array.new(8, 0)
         @fg = Array.new(8, false)
         @gbuf = 0
@@ -42,6 +54,7 @@ module Badline
       # the byte loaded at pixel shift under an unchanging mode.
       def prime(data, screencode, color, shift, mode)
         @mode_lookup = mode
+        @next_ecm_bmm = mode & ECM_BMM
         @mode_read = mode & 1
         @late_read = false
         load(data, screencode, color)
@@ -55,27 +68,55 @@ module Badline
           step_mode(i, mode)
           load(data, screencode, color) if i == shift
           pixel = read_pixel
-          @colors[i] = lookup(pixel)
+          @colors[i] = pixel < @black_below ? 0 : lookup(pixel)
+          @black_below = 0
           @fg[i] = pixel >= 2
           i += 1
         end
+        @next_ecm_bmm = mode & ECM_BMM
       end
 
       private
 
       def step_mode(pixel, mode)
         case pixel
-        when 0 then end_late_read
+        when 0 then start_group
         when 4 then step_lookup(mode)
-        when 5 then @mode_lookup &= ~1 if @late_mcm
-        when 6 then @mode_lookup &= mode | 1
+        when 5 then step_early_fall(mode)
+        when 6 then @mode_lookup &= mode | 1 if @latency
         when 7 then step_read
         end
       end
 
+      def start_group
+        end_late_read
+        return if @latency
+
+        invalid = @mode_lookup > ECM
+        @mode_lookup = (@mode_lookup & ~ECM_BMM) | @next_ecm_bmm
+        @black_below = black_pixels_out_of_invalid if invalid
+      end
+
+      # The pixel values below which pixel 0 stays black as the group leaves
+      # an invalid mode: all four into hi-res text, the background ones into
+      # multicolour bitmap.
+      def black_pixels_out_of_invalid
+        case @mode_lookup
+        when 0 then 4
+        when MULTICOLOR_BITMAP then 2
+        else 0
+        end
+      end
+
       def step_lookup(mode)
-        @late_mcm = @mode_lookup.allbits?(ECM_MCM) && mode.nobits?(1)
-        @mode_lookup = (@mode_lookup & ~1) | (mode & 1) | (@late_mcm ? 1 : 0) | (mode & ECM_BMM)
+        @late_mcm = @latency && @mode_lookup.allbits?(ECM_MCM) && mode.nobits?(1)
+        rising = @latency ? mode & ECM_BMM : 0
+        @mode_lookup = (@mode_lookup & ~1) | (mode & 1) | (@late_mcm ? 1 : 0) | rising
+      end
+
+      def step_early_fall(mode)
+        @mode_lookup &= ~1 if @late_mcm
+        @mode_lookup &= mode | ~BMM if @latency && @mode_lookup != BMM
       end
 
       def step_read

data/lib/badline/vic/registers.rb

@@ -53,21 +53,21 @@ module Badline
     #
     # All color registers are 4bit, bits 4-7 always read 1.
     #
-    #   $D020: Border color        - Default: 14, light blue
-    #   $D021: Background color 0  - Default: 6,  blue
-    #   $D022: Background color 1  - Default: 1,  white
-    #   $D023: Background color 2  - Default: 2,  red
-    #   $D024: Background color 3  - Default: 3,  cyan
-    #   $D025: Sprite multicolor 0 - Default: 4,  purple
-    #   $D026: Sprite multicolor 1 - Default: 0,  black
-    #   $D027: Sprite 0 color      - Default: 1,  white
-    #   $D028: Sprite 1 color      - Default: 2,  red
-    #   $D029: Sprite 2 color      - Default: 3,  cyan
-    #   $D02A: Sprite 3 color      - Default: 4,  purple
-    #   $D02B: Sprite 4 color      - Default: 5,  green
-    #   $D02C: Sprite 5 color      - Default: 6,  blue
-    #   $D02D: Sprite 6 color      - Default: 7,  yellow
-    #   $D02E: Sprite 7 color      - Default: 12, medium gray
+    #   $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
     #
     # $D02F-$D03F: Not in use, always reads 0xff
     # $D040-$D3FF: Repeat $D0000 to $D03F every 64 bytes
@@ -77,10 +77,10 @@ module Badline
       # 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.
       def initialize
         @bytes = Array.new(2**6, 0)
         @irq_line = false
-        write_defaults
       end
 
       # True while any enabled latch bit is set in $D019/$D01A. Cached and
@@ -91,6 +91,8 @@ module Badline
 
       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..0x3f then 0xff
@@ -106,6 +108,7 @@ module Badline
         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
@@ -157,17 +160,6 @@ module Badline
       def read_clear(reg)
         @bytes[reg].tap { @bytes[reg] = 0 }
       end
-
-      def write_defaults
-        write_each(0x20, [14, 6, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 6, 7, 12])
-        write_each(0x11, [0x1b, 0]) # $D011: DEN=1, RSEL=1, YSCROLL=3
-        write_each(0x16, [0xc8])    # $D016: Text mode, XSCROLL=0
-        write_each(0x19, [0, 0])    # IRQ flags
-      end
-
-      def write_each(addr, values)
-        values.each_with_index { |v, i| @bytes[addr + i] = v }
-      end
     end
   end
 end

data/lib/badline/vic/sequencer.rb

@@ -14,21 +14,6 @@ module Badline
     class Sequencer
       include Output
 
-      DISPLAY_X_BOUNDS = [
-        [135, 438].freeze,
-        [128, 447].freeze
-      ].freeze
-
-      # The graphics window always spans the full 40 columns, ignoring CSEL.
-      GFX_X_START = DISPLAY_X_BOUNDS[1][0]
-      GFX_X_END = DISPLAY_X_BOUNDS[1][1] + 1
-
-      # [left compare, right compare] for the border flip-flop per CSEL state.
-      WINDOW_COMPARES = [
-        [DISPLAY_X_BOUNDS[0][0], DISPLAY_X_BOUNDS[0][1] + 1].freeze,
-        [GFX_X_START, GFX_X_END].freeze
-      ].freeze
-
       BORDER_Y_BOUNDS = [
         [55, 247].freeze,
         [51, 251].freeze
@@ -45,8 +30,9 @@ module Badline
       # foreground mask the sprite collisions read.
       attr_writer :render
 
-      def initialize(width, registers, bank)
+      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)
@@ -63,8 +49,8 @@ module Badline
         @vertical_border = true
         @vertical_armed = true
         @main_border = true
-        @color_patches = ColorPatches.new(self)
-        @shifter = GraphicsShifter.new(registers)
+        @color_patches = ColorPatches.new(self, grey_dots: model == :mos8565)
+        @shifter = GraphicsShifter.new(registers, model:)
         @xscroll = 0
         @last_shift = 0
         @last_mode = 0
@@ -179,6 +165,20 @@ module Badline
 
       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)

data/lib/badline/vic/sequencer_output.rb

@@ -16,9 +16,9 @@ module Badline
         def output(col, shift)
           x_pos = (col + 16) * 8
           csel = @registers.csel?
-          first = WINDOW_COMPARES[@first_csel ? 1 : 0]
+          first = @window_compares[@first_csel ? 1 : 0]
           @first_csel = csel
-          compares = WINDOW_COMPARES[csel ? 1 : 0]
+          compares = @window_compares[csel ? 1 : 0]
           win_lo, right_compare = compares
 
           if !first.equal?(compares) || boundary_group?(x_pos, win_lo, right_compare)
@@ -45,7 +45,7 @@ module Badline
         end
 
         def output_window(x_pos, shift)
-          in_gfx = x_pos >= GFX_X_START && x_pos < GFX_X_END
+          in_gfx = x_pos >= @gfx_x_start && x_pos < @gfx_x_end
           @border_groups[x_pos >> 3] = BorderMask::NONE
 
           if shift.zero?
@@ -105,7 +105,7 @@ module Badline
             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
+            @fg[x] = x >= @gfx_x_start && x < @gfx_x_end ? mask : false
             win_lo, right_compare = compares if i.zero?
             i += 1
           end

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

@@ -10,8 +10,12 @@ module Badline
       # 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.
+        attr_reader :columns
+
         def initialize(bank, columns)
           @bank = bank
+          @columns = columns
           @lines = 0
           @ghost = 0xff
           @value = Array.new(columns, 0xff)

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

@@ -71,8 +71,8 @@ module Badline
           while count < MAX_SPAN
             if pos >= boundary
               log.advance(pos)
-              mc = log[0x1c].anybits?(@bit)
               expanded = log[0x1d].anybits?(@bit)
+              mc = logged_multicolor(log, mc, expanded, count)
               boundary = log.next_x
             end
             count.zero? ? prime(mc) : step(mc, expanded, count == cut - 1)
@@ -88,11 +88,29 @@ module Badline
         # 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
+          @mc_flop = @new_chip && !multicolor
           @xe_flop = false
           @latch = (@sr >> 22) & (multicolor ? 3 : 2)
         end
 
+        # The multicolor bit as the log has it at the pixel. A change after
+        # the first pixel reaches the 8565's flip-flop.
+        def logged_multicolor(log, was, expanded, count)
+          multicolor = log[0x1c].anybits?(@bit)
+          switch_multicolor(multicolor, expanded) if @new_chip && multicolor != was && count.positive?
+          multicolor
+        end
+
+        # On the 8565 a multicolor change works on the flip-flop instead of
+        # the next pixels. It stays as it is unless the change lands between
+        # the two halves of an expanded pixel, where it flips, or is set by a
+        # switch to hi-res.
+        def switch_multicolor(multicolor, expanded)
+          return unless expanded && !@xe_flop
+
+          @mc_flop = multicolor ? !@mc_flop : true
+        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
@@ -106,7 +124,7 @@ module Badline
           else
             @xe_flop = false
           end
-          @mc_flop = false unless multicolor
+          @mc_flop = false unless multicolor || @new_chip
           return unless shift
 
           @sr = (@sr << 1) & 0xffffff
@@ -115,10 +133,14 @@ module Badline
 
         # A multicolor pair loaded on the last pixel before the reload keeps
         # only its high bit, as a hi-res pixel does (spritefetchbug).
+        # On the 8565 a hi-res pixel with the multicolor flip-flop clear
+        # sets it and loads nothing, so the latch repeats its last pixel.
         def load_latch(multicolor, last)
           if multicolor
             @latch = (@sr >> 22) & (last ? 2 : 3) if @mc_flop
             @mc_flop = !@mc_flop
+          elsif @new_chip && !@mc_flop
+            @mc_flop = true
           else
             @latch = (@sr >> 22) & 2
           end

data/lib/badline/vic/sprite.rb

@@ -56,12 +56,13 @@ module Badline
       attr_reader :index, :leftmost, :span, :codes,
                   :reload_leftmost, :reload_span, :reload_codes
 
-      def initialize(index, registers, bank, width, bus = InternalBus.new(bank, width / 8))
+      def initialize(index, registers, bank, bus, model: :mos6569)
         @index = index
+        @new_chip = model == :mos8565
         @registers = registers
         @bank = bank
         @bus = bus
-        @width = width
+        @width = bus.columns * 8
         @bit = 1 << index
         @dma = false
         @display_on = false
@@ -77,8 +78,8 @@ module Badline
         @reload_codes = Array.new(MAX_SPAN + RELOAD_HOLD, 0)
         @reload_leftmost = 0
         @reload_span = 0
-        @reload_x = (RELOAD_X + (RELOAD_STEP * index)) % width
-        @reload_next_line = RELOAD_X + (RELOAD_STEP * index) < width
+        @reload_x = (RELOAD_X + (RELOAD_STEP * index)) % @width
+        @reload_next_line = RELOAD_X + (RELOAD_STEP * index) < @width
         @sr = 0
         @latch = 0
         @mc_flop = false

data/lib/badline/vic/sprites.rb

@@ -27,12 +27,17 @@ module Badline
         [0x25, 0x26, *0x27..0x2e].each { |reg| delays[reg] = COLOR_DELAY }
       end.freeze
 
-      def initialize(registers, bank, width)
+      # The 8565's sprite sequencers take a multicolor change a pixel
+      # sooner than the 6569's.
+      WRITE_DELAY_8565 = WRITE_DELAY.dup.tap { |delays| delays[0x1c] = SEQUENCER_DELAY - 1 }.freeze
+
+      def initialize(registers, bank, width, model: :mos6569)
         @registers = registers
+        @write_delay = model == :mos8565 ? WRITE_DELAY_8565 : WRITE_DELAY
         @bank = bank
         @width = width
         @bus = Sprite::InternalBus.new(bank, width / 8)
-        @sprites = Array.new(8) { |i| Sprite.new(i, registers, bank, width, @bus) }
+        @sprites = Array.new(8) { |i| Sprite.new(i, registers, bank, @bus, model:) }
         @collisions = Collisions.new(registers, width)
         @hits = @collisions.hits
         @win_color = Array.new(width, 0)
@@ -123,7 +128,7 @@ module Badline
       # Record a mid-line write at the pixel where it becomes visible.
       def log_change(reg, old, value, beam_x)
         clear_y_expansion(old & ~value, beam_x) if reg == 0x17
-        delay = WRITE_DELAY[reg]
+        delay = @write_delay[reg]
         return unless delay && active?
 
         @log.log(beam_x + delay, reg, old, value)