badline 0.12.1 → 0.13.0

data/lib/badline/vic/display_state.rb

@@ -1,185 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class VIC
-    # = VIC-II display state
-    #
-    # The bad line condition, the video counters it drives, and the DMA it
-    # starts. A condition that arrives mid-line opens the row late, which is
-    # what makes the screen scroll sideways or lose a column of cells.
-    class DisplayState
-      FIRST_LINE = 0x30 # 48: bad lines and the DEN-at-$30 latch begin here
-      LAST_LINE  = 0xf7 # 247
-      COLUMNS_PER_ROW = 40
-
-      # AEC follows BA three cycles later; the c-accesses before it read
-      # the bus the CPU still drives.
-      BA_DELAY = 3
-
-      # Columns run two ahead of Bauer's cycle numbers: column 10 is his
-      # cycle 12. BA falls on a match in columns 10-52, the c-accesses run
-      # in 13-52 and the g-accesses in 14-53. VC and VMLI reload in column
-      # 12 and the row counter steps in column 56.
-      DMA_FIRST = 10
-      DMA_LAST = 52
-      FETCH_FIRST = 13
-      GRAPHICS_FIRST = 14
-      GRAPHICS_LAST = 53
-      LOAD_COLUMN = 12
-      RC_COLUMN = 56
-
-      GRAPHICS_COLUMNS = Array.new(65) { |column| column.between?(GRAPHICS_FIRST, GRAPHICS_LAST) }.freeze
-
-      attr_reader :vc_base, :vc, :vmli, :rc, :bad_lines_enabled
-
-      # The wrap column is the last column of a rasterline, 62 on the 6569,
-      # which already compares against the line about to start, the same
-      # wrap the raster IRQ latch uses.
-      def initialize(registers, wrap_column = 62)
-        @registers = registers
-        @wrap_column = wrap_column
-        @vc_base = 0
-        @vc = 0
-        @vmli = 0
-        @rc = 0
-        @display = false
-        @bad_lines_enabled = false
-        @matched = false
-        @ba = nil
-        new_line(0)
-      end
-
-      def display? = @display
-
-      # Sets VCBASE, VC, RC and VMLI, in that order, and the display and
-      # bad-line flags, as a VICE snapshot gives them.
-      def restore_counters(counters, display, bad_lines_enabled)
-        @vc_base, @vc, @rc, @vmli = counters
-        @display = display
-        @bad_lines_enabled = bad_lines_enabled
-      end
-
-      def idle? = !@display
-      def bad_line? = !@ba.nil?
-
-      # The bad line condition as the last column compared it.
-      def bad_line_condition? = @matched
-
-      # True once AEC has followed BA down and the VIC owns the bus.
-      def bus_taken?(column) = @ba ? column >= @ba + BA_DELAY : false
-
-      # The CPU kept the bus through the cycle before +column+, so on a bad
-      # line AEC falls BA_DELAY cycles after it at the earliest.
-      def keep_bus(column)
-        @ba &&= column
-      end
-
-      def fetching?(column)
-        @matched && column >= FETCH_FIRST && column <= DMA_LAST
-      end
-
-      def save_state(out)
-        out.int(@vc_base).int(@vc).int(@vmli).int(@rc).boolean(@display).boolean(@bad_lines_enabled)
-        out.boolean(@matched).optional_int(@ba).int(@line_bits).boolean(@den_line).boolean(@in_window)
-      end
-
-      def load_state(input)
-        @vc_base = input.int
-        @vc = input.int
-        @vmli = input.int
-        @rc = input.int
-        @display = input.boolean?
-        @bad_lines_enabled = input.boolean?
-        @matched = input.boolean?
-        @ba = input.optional_int
-        @line_bits = input.int
-        @den_line = input.boolean?
-        @in_window = input.boolean?
-      end
-
-      def new_frame
-        @vc_base = 0
-        @bad_lines_enabled = false
-      end
-
-      def new_line(line)
-        @ba = nil
-        raster_step(line)
-      end
-
-      # The raster counter moved on to +line+, at the line's start or, under
-      # the VIC-IIe's TEST bit, within it.
-      def raster_step(line)
-        @line_bits = line & 0b111
-        @den_line = line == FIRST_LINE
-        @in_window = line.between?(FIRST_LINE, LAST_LINE)
-      end
-
-      # Returns true when this compare opened display state.
-      def cycle(rasterline, column)
-        match = column == @wrap_column ? wrap_match(rasterline + 1) : line_match
-        @matched = match
-        opened = false
-        if match
-          opened = !@display
-          @display = true
-          @ba = column if @ba.nil? && column >= DMA_FIRST && column <= DMA_LAST
-        end
-        load_counters(match) if column == LOAD_COLUMN
-        check_row_counter(match) if column == RC_COLUMN
-        opened
-      end
-
-      # A g-access in display state consumes one buffer cell and one video
-      # matrix address. A row that opens mid-line makes fewer of them, and
-      # the shortfall carries into VCBASE.
-      def graphics_column?(column) = GRAPHICS_COLUMNS[column]
-
-      def graphics_access(column)
-        return unless graphics_column?(column)
-
-        @vc = (@vc + 1) & 0x3ff
-        @vmli += 1
-      end
-
-      private
-
-      def line_match
-        latch_den if @den_line
-        @bad_lines_enabled && @in_window && @line_bits == @registers.yscroll
-      end
-
-      # The wrap column compares against the line about to start. The DEN
-      # latch is level-sensitive across the counter's increment, so this one
-      # column sees both the line ending and the line starting.
-      def wrap_match(line)
-        latch_den if @den_line || line == FIRST_LINE
-        return false unless line.between?(FIRST_LINE, LAST_LINE)
-
-        @bad_lines_enabled && (line & 0b111) == @registers.yscroll
-      end
-
-      def latch_den
-        @bad_lines_enabled = true if @registers.display_enabled?
-      end
-
-      def load_counters(match)
-        @vc = @vc_base
-        @vmli = 0
-        @rc = 0 if match
-      end
-
-      # A condition still standing when the row counter wraps puts the logic
-      # straight back into display state, so a forced row rolls into the
-      # next one instead of leaving the line idle (Bauer 3.7.2 step 5).
-      def check_row_counter(match)
-        if @rc == 7
-          @display = false
-          @vc_base = @vc
-        end
-        @display ||= match
-        @rc = (@rc + 1) & 0b111 if @display
-      end
-    end
-  end
-end

data/lib/badline/vic/graphics_mode.rb

@@ -1,164 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class VIC
-    module GraphicsMode
-      # Foreground masks depend only on the data byte, so each byte maps to a
-      # precomputed frozen pattern shared by reference instead of being
-      # written out pixel by pixel.
-      HIRES_FG = Array.new(256) do |data|
-        Array.new(8) { |i| data.anybits?(1 << (7 - i)) }.freeze
-      end.freeze
-
-      # The high bit of each 2-bit pair (10/11) is foreground.
-      PAIR_FG = Array.new(256) do |data|
-        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
-        def paint_hires(data, color, background, seq)
-          seq.cur_fg = HIRES_FG[data]
-          colors = seq.cur_colors
-          return colors.fill(background) if data.zero?
-
-          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, 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
-          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 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 initialize
-          @palette = Array.new(4, 0)
-        end
-
-        def paint(data, _screencode, color, seq)
-          registers = seq.registers
-          if color.anybits?(0x08)
-            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
-
-        def fg(data, _screencode, color) = color.anybits?(0x08) ? PAIR_FG[data] : HIRES_FG[data]
-      end
-
-      class ExtendedBackgroundText
-        include Hires
-
-        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 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 initialize
-          @palette = Array.new(4, 0)
-        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 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

@@ -1,207 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class VIC
-    # 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), 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, 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
-        @vbuf = 0
-        @cbuf = 0
-        @flop = 0
-        @pixel = 0
-        @mode_lookup = 0
-        @mode_read = 0
-        @late_mcm = false
-        @late_read = false
-      end
-
-      def save_state(out)
-        out.int(@next_ecm_bmm).int(@black_below).ints(@colors).booleans(@fg)
-        out.int(@gbuf).int(@vbuf).int(@cbuf).int(@flop).int(@pixel)
-        out.int(@mode_lookup).int(@mode_read).boolean(@late_mcm).boolean(@late_read)
-      end
-
-      def load_state(input)
-        @next_ecm_bmm = input.int
-        @black_below = input.int
-        input.ints_into(@colors)
-        input.booleans_into(@fg)
-        load_buffers(input)
-        @mode_lookup = input.int
-        @mode_read = input.int
-        @late_mcm = input.boolean?
-        @late_read = input.boolean?
-      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
-        @next_ecm_bmm = mode & ECM_BMM
-        @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] = 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 load_buffers(input)
-        @gbuf = input.int
-        @vbuf = input.int
-        @cbuf = input.int
-        @flop = input.int
-        @pixel = input.int
-      end
-
-      def step_mode(pixel, mode)
-        case pixel
-        when 0 then start_group
-        when 4 then step_lookup(mode)
-        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 = @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
-        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

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class VIC
-    # 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
-
-      # The entries as pixel, register and value in turn, the seed with -1
-      # for a register the line hasn't logged, and a next pixel past the
-      # last entry as -1.
-      def save_state(out)
-        out.ints(@entries.flatten)
-        out.ints(@seed.map { |value| value.nil? ? -1 : value })
-        out.ints(@values).int(@cursor).int(@next_x.infinite? ? -1 : @next_x)
-      end
-
-      def load_state(input)
-        @entries.replace(input.ints.each_slice(3).to_a)
-        @seed.replace(input.ints.map { |value| value.negative? ? nil : value })
-        input.ints_into(@values)
-        @cursor = input.int
-        next_x = input.int
-        @next_x = next_x.negative? ? Float::INFINITY : next_x
-      end
-
-      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