badline 0.12.1 → 0.14.0

data/lib/badline/vic/border_mask.rb

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class VIC
-    # Border coverage per 8-pixel group, tracked as the sequencer outputs
-    # a line.
-    #
-    # The border is repainted over composited sprites from a snapshot of
-    # the finished line, which keeps mid-line border color splits intact.
-    class BorderMask
-      FULL  = 0
-      NONE  = 1
-      MIXED = 2
-
-      # The group table and per-pixel mask are exposed so the sequencer's
-      # pixel loops can write them without a method call per column.
-      attr_reader :groups, :mask
-
-      def initialize(width)
-        @width = width
-        @groups = Array.new(width / 8, FULL)
-        @mask = Array.new(width, true)
-        @snapshot = Array.new(width, 0)
-      end
-
-      def reset
-        @groups.fill(FULL)
-      end
-
-      def save_state(out)
-        out.ints(@groups).booleans(@mask).blob(@snapshot)
-      end
-
-      def load_state(input)
-        input.ints_into(@groups)
-        input.booleans_into(@mask)
-        input.blob_into(@snapshot)
-      end
-
-      def at?(pixel_x)
-        case @groups[pixel_x >> 3]
-        when FULL then true
-        when MIXED then @mask[pixel_x]
-        else false
-        end
-      end
-
-      def snapshot(colors)
-        @snapshot[0, @width] = colors
-      end
-
-      def restore(colors)
-        group = 0
-        while group < @groups.length
-          case @groups[group]
-          when FULL then group = restore_full(colors, group)
-          when MIXED then restore_mixed(colors, group * 8)
-          end
-          group += 1
-        end
-      end
-
-      private
-
-      # Copies a run of full-border groups in one splice and returns its
-      # last group.
-      def restore_full(colors, first)
-        last = first
-        last += 1 while @groups[last + 1] == FULL
-        x_pos = first * 8
-        length = (last - first + 1) * 8
-        colors[x_pos, length] = @snapshot[x_pos, length]
-        last
-      end
-
-      def restore_mixed(colors, x_pos)
-        i = 0
-        while i < 8
-          x = x_pos + i
-          colors[x] = @snapshot[x] if @mask[x]
-          i += 1
-        end
-      end
-    end
-  end
-end

data/lib/badline/vic/collisions.rb

@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class VIC
-    # = Sprite collisions
-    #
-    # The $D01E/$D01F latches and the per-pixel sprite coverage that feeds
-    # them. Collisions latch as the beam passes each covered pixel, so a
-    # read mid-line sees the pixels drawn before the reading cycle and none
-    # of the ones after it.
-    class Collisions
-      # $D019 latch bits raised by the collision registers.
-      SPRITE_COLLISION_IRQ = 0x04 # IMMC, mirrors $D01E
-      DATA_COLLISION_IRQ   = 0x02 # IMBC, mirrors $D01F
-
-      # A read holds the register's reset asserted past the cycle that
-      # issued it, so the pixels drawn under it never reach the register.
-      # The read still reports only the pixels drawn before its own cycle,
-      # which is why the two numbers do not cancel out.
-      CLEAR_OVERRUN = 12
-
-      # The pixel the last fold reached, so the sprites know whether a read
-      # has anything left to latch.
-      attr_reader :folded
-
-      # One bitmask per pixel of the line, written straight by the sprite
-      # merge and read back here and by the composite.
-      attr_reader :hits
-
-      def initialize(registers, width)
-        @registers = registers
-        @width = width
-        @hits = Array.new(width, 0)
-        @folded = 0
-        @cleared_sprite = 0
-        @cleared_data = 0
-      end
-
-      def save_state(out)
-        out.blob(@hits).int(@folded).int(@cleared_sprite).int(@cleared_data)
-      end
-
-      def load_state(input)
-        input.blob_into(@hits)
-        @folded = input.int
-        @cleared_sprite = input.int
-        @cleared_data = input.int
-      end
-
-      def start_line
-        @folded = 0
-        @cleared_sprite = carry(@cleared_sprite)
-        @cleared_data = carry(@cleared_data)
-      end
-
-      # Latch every covered pixel between the last fold and the beam. The
-      # sprites' touched span bounds the scan; the coverage is zero outside
-      # it either way.
-      def fold(mask, upto, low, high)
-        from = [@folded, low].max
-        @folded = upto
-        scan(mask, from, [upto, high].min)
-      end
-
-      # A read resets its register for the pixels that follow the reading
-      # cycle as well as for everything before it.
-      def clear(reg, beam_x)
-        if reg == 0x1e
-          @cleared_sprite = beam_x + CLEAR_OVERRUN
-        else
-          @cleared_data = beam_x + CLEAR_OVERRUN
-        end
-      end
-
-      private
-
-      # Two or more sprites on a pixel collide with each other; any sprite
-      # over a foreground pixel collides with the graphics. Pixels still
-      # under a read's reset are dropped rather than latched.
-      def scan(mask, from, upto)
-        sprite_clash = 0
-        data_clash = 0
-        pos = from
-        while pos < upto
-          bits = @hits[pos]
-          unless bits.zero?
-            sprite_clash |= bits if pos >= @cleared_sprite && bits.anybits?(bits - 1)
-            data_clash |= bits if pos >= @cleared_data && mask[pos]
-          end
-          pos += 1
-        end
-        latch(sprite_clash, data_clash)
-      end
-
-      def latch(sprite_clash, data_clash)
-        latch_one(0x1e, sprite_clash, SPRITE_COLLISION_IRQ)
-        latch_one(0x1f, data_clash, DATA_COLLISION_IRQ)
-      end
-
-      # The IRQ is raised on the edge out of an empty register, so a
-      # collision folded on top of an unread one raises nothing.
-      def latch_one(reg, clash, irq)
-        return if clash.zero?
-        return unless @registers.collide!(reg, clash)
-
-        @registers.latch_irq!(irq)
-      end
-
-      # A reset still asserted at the line wrap carries into the new line.
-      def carry(cleared)
-        cleared > @width ? cleared - @width : 0
-      end
-    end
-  end
-end

data/lib/badline/vic/color_patches.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class VIC
-    # A mid-line color register write becomes visible one pixel into the
-    # column emitted the cycle after the write. That emit paints the whole
-    # column with the new color, so the boundary pixel is patched back to
-    # the old one before the line is finished. On the 8565 the boundary
-    # pixel shows light grey instead, the grey dot, whatever the old and new
-    # colors are.
-    class ColorPatches
-      def initialize(sequencer, grey_dots: false)
-        @sequencer = sequencer
-        @grey_dots = grey_dots
-        @patches = []
-      end
-
-      def clear = @patches.clear
-
-      # Each patch as its four numbers: the boundary pixel, the register,
-      # the old colour and the new.
-      def save_state(out)
-        out.int(@patches.length)
-        @patches.each { |patch| out.ints(patch) }
-      end
-
-      def load_state(input)
-        @patches.replace(Array.new(input.int) { input.ints })
-      end
-
-      def log(reg, old, value, boundary_x)
-        @patches << [boundary_x, reg, @grey_dots ? GREY_DOT : old & 0x0f, value & 0x0f]
-      end
-
-      def apply(colors, fg_mask)
-        @patches.each do |(x, reg, old, value)|
-          border = @sequencer.border_at?(x)
-          if reg == 0x20
-            colors[x] = old if border
-          elsif !border && !fg_mask[x] && colors[x] == value
-            colors[x] = old
-          end
-        end
-      end
-    end
-  end
-end

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