badline 0.12.1 → 0.14.0

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

data/lib/badline/vic/registers.rb

@@ -1,195 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  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