badline 0.1.0 → 0.2.1

data/lib/badline/vic/graphics_mode.rb

@@ -15,6 +15,11 @@ module Badline
         Array.new(8) { |i| (data >> (6 - (i & ~1))).allbits?(0b10) }.freeze
       end.freeze
 
+      # The same patterns as masks, all bits set for a foreground pixel.
+      HIRES_MASK = Array.new(256) do |data|
+        Array.new(8) { |i| data.anybits?(1 << (7 - i)) ? -1 : 0 }.freeze
+      end.freeze
+
       NO_FG = HIRES_FG[0]
 
       module Hires
@@ -23,117 +28,137 @@ module Badline
           colors = seq.cur_colors
           return colors.fill(background) if data.zero?
 
-          i = 0
-          while i < 8
-            colors[i] = data.anybits?(1 << (7 - i)) ? color : background
-            i += 1
-          end
+          mask = HIRES_MASK[data]
+          flip = color ^ background
+          colors[0] = background ^ (flip & mask[0])
+          colors[1] = background ^ (flip & mask[1])
+          colors[2] = background ^ (flip & mask[2])
+          colors[3] = background ^ (flip & mask[3])
+          colors[4] = background ^ (flip & mask[4])
+          colors[5] = background ^ (flip & mask[5])
+          colors[6] = background ^ (flip & mask[6])
+          colors[7] = background ^ (flip & mask[7])
         end
       end
 
-      # Decodes 2-bit pixel pairs into double-wide pixels. The colour for each
-      # pair is supplied by the block.
+      # Decodes 2-bit pixel pairs into double-wide pixels, each pair indexing
+      # the four colours in the mode's palette.
       module Multicolor
         def paint_pairs(data, seq)
           seq.cur_fg = PAIR_FG[data]
           colors = seq.cur_colors
-          i = 0
-          while i < 8
-            colors[i] = yield((data >> (6 - (i & ~1))) & 0b11)
-            i += 1
-          end
+          palette = @palette
+          colors[0] = colors[1] = palette[data >> 6]
+          colors[2] = colors[3] = palette[(data >> 4) & 0b11]
+          colors[4] = colors[5] = palette[(data >> 2) & 0b11]
+          colors[6] = colors[7] = palette[data & 0b11]
         end
       end
 
+      # Each mode paints the byte a g-access read with the screen byte and
+      # colour nibble it latched. The VIC reads the byte itself, in the
+      # g-access column. #fg gives the foreground mask #paint would leave,
+      # without the colours.
       class Text
         include Hires
 
-        def decode(screencode, color, _cell, row, seq)
-          registers = seq.registers
-          data = seq.bank.peek(registers.char_base + (screencode * 8) + row)
-          paint_hires(data, color, registers.background, seq)
+        def paint(data, _screencode, color, seq)
+          paint_hires(data, color, seq.registers.background, seq)
         end
+
+        def fg(data, _screencode, _color) = HIRES_FG[data]
       end
 
       class MulticolorText
         include Hires
         include Multicolor
 
-        def decode(screencode, color, _cell, row, seq)
+        def initialize
+          @palette = Array.new(4, 0)
+        end
+
+        def paint(data, _screencode, color, seq)
           registers = seq.registers
-          data = seq.bank.peek(registers.char_base + (screencode * 8) + row)
           if color.anybits?(0x08)
-            paint_pairs(data, seq) do |pair|
-              multicolor_pixel(pair, color, registers)
-            end
+            palette = @palette
+            palette[0] = registers.background(0)
+            palette[1] = registers.background(1)
+            palette[2] = registers.background(2)
+            palette[3] = color & 0x07
+            paint_pairs(data, seq)
           else
             paint_hires(data, color & 0x07, registers.background, seq)
           end
         end
 
-        private
-
-        def multicolor_pixel(pair, color, registers)
-          case pair
-          when 0b00 then registers.background(0)
-          when 0b01 then registers.background(1)
-          when 0b10 then registers.background(2)
-          else color & 0x07
-          end
-        end
+        def fg(data, _screencode, color) = color.anybits?(0x08) ? PAIR_FG[data] : HIRES_FG[data]
       end
 
       class ExtendedBackgroundText
         include Hires
 
-        def decode(screencode, color, _cell, row, seq)
-          registers = seq.registers
-          background = registers.background((screencode >> 6) & 0b11)
-          data = seq.bank.peek(registers.char_base + ((screencode & 0x3f) * 8) + row)
+        def paint(data, screencode, color, seq)
+          background = seq.registers.background((screencode >> 6) & 0b11)
           paint_hires(data, color, background, seq)
         end
+
+        def fg(data, _screencode, _color) = HIRES_FG[data]
       end
 
       class Bitmap
         include Hires
 
-        def decode(screencode, _color, cell, row, seq)
-          data = seq.bank.peek(seq.registers.bitmap_base + (cell * 8) + row)
+        def paint(data, screencode, _color, seq)
           foreground = (screencode >> 4) & 0x0f
           background = screencode & 0x0f
           paint_hires(data, foreground, background, seq)
         end
+
+        def fg(data, _screencode, _color) = HIRES_FG[data]
       end
 
       class MulticolorBitmap
         include Multicolor
 
-        def decode(screencode, color, cell, row, seq)
-          registers = seq.registers
-          data = seq.bank.peek(registers.bitmap_base + (cell * 8) + row)
-          paint_pairs(data, seq) do |pair|
-            multicolor_pixel(pair, screencode, color, registers)
-          end
+        def initialize
+          @palette = Array.new(4, 0)
         end
 
-        private
-
-        def multicolor_pixel(pair, screencode, color, registers)
-          case pair
-          when 0b00 then registers.background(0)
-          when 0b01 then (screencode >> 4) & 0x0f
-          when 0b10 then screencode & 0x0f
-          else color & 0x0f
-          end
+        def paint(data, screencode, color, seq)
+          palette = @palette
+          palette[0] = seq.registers.background(0)
+          palette[1] = (screencode >> 4) & 0x0f
+          palette[2] = screencode & 0x0f
+          palette[3] = color & 0x0f
+          paint_pairs(data, seq)
         end
+
+        def fg(data, _screencode, _color) = PAIR_FG[data]
       end
 
       class Null
-        def decode(_screencode, _color, _cell, _row, seq)
+        def paint(_data, _screencode, _color, seq)
           seq.cur_fg = NO_FG
           seq.cur_colors.fill(0)
         end
+
+        def fg(_data, _screencode, _color) = NO_FG
       end
+
+      NULL_MODE = Null.new
+
+      # Indexed by ECM/BMM/MCM; the three invalid combinations decode to
+      # black.
+      MODES = [
+        Text.new,                   # 000 standard text
+        MulticolorText.new,         # 001 multicolour text
+        Bitmap.new,                 # 010 standard bitmap
+        MulticolorBitmap.new,       # 011 multicolour bitmap
+        ExtendedBackgroundText.new, # 100 ECM text
+        NULL_MODE,                  # 101 invalid
+        NULL_MODE,                  # 110 invalid
+        NULL_MODE                   # 111 invalid
+      ].freeze
     end
   end
 end

data/lib/badline/vic/graphics_shifter.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module Badline
+  class VIC < Cycleable
+    # The graphics shift register, pixel by pixel, for the groups where a
+    # mode or XSCROLL change lands (VICE x64sc `draw_graphics`). The
+    # sequencer paints whole bytes everywhere else, which comes to the same
+    # thing while nothing changes.
+    #
+    # 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
+    # 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.
+    class GraphicsShifter
+      ECM_BMM = 0b110
+      ECM_MCM = 0b101
+      BMM = 0b010
+
+      # The group #draw painted, and which of its pixels are foreground.
+      attr_reader :colors, :fg
+
+      def initialize(registers)
+        @registers = registers
+        @colors = Array.new(8, 0)
+        @fg = Array.new(8, false)
+        @gbuf = 0
+        @vbuf = 0
+        @cbuf = 0
+        @flop = 0
+        @pixel = 0
+        @mode_lookup = 0
+        @mode_read = 0
+        @late_mcm = false
+        @late_read = false
+      end
+
+      # Rebuilds the state at the end of a group that painted whole bytes:
+      # the byte loaded at pixel shift under an unchanging mode.
+      def prime(data, screencode, color, shift, mode)
+        @mode_lookup = mode
+        @mode_read = mode & 1
+        @late_read = false
+        load(data, screencode, color)
+        (8 - shift).times { read_pixel }
+      end
+
+      # Draws one group, loading the byte at pixel shift.
+      def draw(data, screencode, color, shift, mode)
+        i = 0
+        while i < 8
+          step_mode(i, mode)
+          load(data, screencode, color) if i == shift
+          pixel = read_pixel
+          @colors[i] = lookup(pixel)
+          @fg[i] = pixel >= 2
+          i += 1
+        end
+      end
+
+      private
+
+      def step_mode(pixel, mode)
+        case pixel
+        when 0 then end_late_read
+        when 4 then step_lookup(mode)
+        when 5 then @mode_lookup &= ~1 if @late_mcm
+        when 6 then @mode_lookup &= mode | 1
+        when 7 then step_read
+        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)
+      end
+
+      def step_read
+        return @late_read = true if @late_mcm
+
+        mcm = @mode_lookup & 1
+        @flop = 0 if mcm == 1 && @mode_read.zero?
+        @mode_read = mcm
+      end
+
+      def end_late_read
+        return unless @late_read
+
+        @mode_read = 0
+        @late_read = false
+      end
+
+      def load(data, screencode, color)
+        @gbuf = data
+        @vbuf = screencode
+        @cbuf = color & 0x0f
+        @flop = 1
+      end
+
+      def read_pixel
+        multicolor = multicolor?
+        if @mode_read == 1 && multicolor
+          @pixel = @gbuf >> 6 if @flop == 1
+        elsif @gbuf.anybits?(0x80)
+          @pixel = multicolor && @mode_read.zero? ? 2 : 3
+        else
+          @pixel = 0
+        end
+        @gbuf = (@gbuf << 1) & 0xff
+        @flop ^= 1
+        @pixel
+      end
+
+      def multicolor? = @mode_lookup.anybits?(BMM) || @cbuf.anybits?(0x08)
+
+      def lookup(pixel)
+        case @mode_lookup
+        when 0 then pixel < 2 ? @registers.background : @cbuf
+        when 1 then pixel == 3 ? @cbuf & 0x07 : @registers.background(pixel)
+        when 2 then pixel < 2 ? @vbuf & 0x0f : @vbuf >> 4
+        when 3 then multicolor_bitmap(pixel)
+        when 4 then pixel < 2 ? @registers.background(@vbuf >> 6) : @cbuf
+        else 0
+        end
+      end
+
+      def multicolor_bitmap(pixel)
+        case pixel
+        when 0 then @registers.background
+        when 1 then @vbuf >> 4
+        when 2 then @vbuf & 0x0f
+        else @cbuf
+        end
+      end
+    end
+  end
+end

data/lib/badline/vic/register_log.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Badline
+  class VIC < Cycleable
+    # Mid-line writes to the sprite registers, keyed by the pixel at which
+    # they become visible. Compositing replays the line through the log, so
+    # each pixel is drawn with the register values that were in effect when
+    # the VIC reached it.
+    class RegisterLog
+      def initialize(registers)
+        @registers = registers
+        @entries = []
+        @seed = []
+        @values = Array.new(2**6, 0)
+        @cursor = 0
+        @next_x = 0
+      end
+
+      # The pixel at which the next logged write takes effect.
+      attr_reader :next_x
+
+      def empty? = @entries.empty?
+      def length = @entries.length
+
+      def clear
+        return if @entries.empty?
+
+        @entries.clear
+        @seed.clear
+      end
+
+      def log(pixel_x, reg, old, value)
+        @seed[reg] = old if @seed[reg].nil?
+        @entries << [pixel_x, reg, value]
+      end
+
+      def prepare
+        @entries.sort_by! { |entry| entry[0] }
+      end
+
+      # Restart the cursor before the line's first pixel, with every logged
+      # register back at the value it held when the line started.
+      def rewind
+        @values.length.times { |reg| @values[reg] = @registers[reg] }
+        @seed.each_with_index { |value, reg| @values[reg] = value unless value.nil? }
+        @cursor = 0
+        @next_x = @entries.empty? ? Float::INFINITY : @entries[0][0]
+      end
+
+      def [](reg) = @values[reg]
+
+      # Apply every write visible at or before pixel_x.
+      def advance(pixel_x)
+        while @cursor < @entries.length && @entries[@cursor][0] <= pixel_x
+          entry = @entries[@cursor]
+          @values[entry[1]] = entry[2]
+          @cursor += 1
+        end
+        @next_x = @cursor < @entries.length ? @entries[@cursor][0] : Float::INFINITY
+      end
+    end
+  end
+end

data/lib/badline/vic/registers.rb

@@ -74,6 +74,9 @@ module Badline
     class Registers
       include IntegerHelper
 
+      # The raw register bytes, for the per-column reads on the hot path.
+      attr_reader :bytes
+
       def initialize
         @bytes = Array.new(2**6, 0)
         @irq_line = false