badline 0.12.1 → 0.14.0

data/lib/badline/vic/sequencer.rb

@@ -1,275 +0,0 @@
-# frozen_string_literal: true
-
-require "badline/vic/border_mask"
-require "badline/vic/color_patches"
-require "badline/vic/graphics_mode"
-require "badline/vic/graphics_shifter"
-require "badline/vic/sequencer_output"
-require "badline/vic/sequencer_state"
-
-module Badline
-  class VIC
-    # = VIC-II Sequencer
-    #
-    # Turns fetched graphics data into output pixels.
-    class Sequencer
-      include Output
-      include SavedState
-
-      BORDER_Y_BOUNDS = [
-        [55, 247].freeze,
-        [51, 251].freeze
-      ].freeze
-
-      MODES = GraphicsMode::MODES
-
-      attr_reader :colors, :fg, :registers, :bank, :cur_colors,
-                  :color_patches
-      # The fg masks are shared frozen patterns assigned by reference, never
-      # mutated in place.
-      attr_accessor :cur_fg
-      # False leaves the line's colours unpainted and keeps only the
-      # foreground mask the sprite collisions read.
-      attr_writer :render
-
-      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)
-        @fg = Array.new(width, false)
-        @border_mask = BorderMask.new(width)
-        # Hot-path aliases: the pixel loops write coverage straight into the
-        # mask's arrays.
-        @border = @border_mask.mask
-        @border_groups = @border_mask.groups
-        @cur_colors = Array.new(8, 0)
-        @cur_fg = GraphicsMode::NO_FG
-        @prev_colors = Array.new(8, 0)
-        @prev_fg = GraphicsMode::NO_FG
-        @vertical_border = true
-        @vertical_armed = true
-        @main_border = true
-        @color_patches = ColorPatches.new(self, grey_dots: model == :mos8565)
-        @shifter = GraphicsShifter.new(registers, model:)
-        @xscroll = 0
-        @last_shift = 0
-        @last_mode = 0
-        @settling = false
-        @ring_data = Array.new(4, 0)
-        @ring_char = Array.new(4, 0)
-        @ring_color = Array.new(4, 1)
-        @prev_fresh = false
-        @check = true
-        @render = true
-        new_line(0)
-      end
-
-      # Reset the line buffers at the start of a rasterline.
-      def new_line(line)
-        @line = line
-        @left_vertical_border = nil
-        @first_csel = @registers.csel?
-        @colors.fill(@registers.border)
-        @fg.fill(false)
-        @border_mask.reset
-        @prev_colors.fill(@registers.background)
-        @prev_fg = GraphicsMode::NO_FG
-        @prev_fresh = false
-        @check = true
-        @color_patches.clear
-      end
-
-      # The load point for the next group's byte: XSCROLL as a g-access
-      # column with the border open sees it, a column before the group that
-      # uses it (VICE x64sc `xscroll_pipe`).
-      def latch_xscroll(xscroll = @registers.xscroll)
-        return if xscroll == @xscroll
-
-        @xscroll = xscroll
-        @check = true
-      end
-
-      # A write to a register the painted colours depend on: the byte kept
-      # from the previous group is painted again before its pixels are shown.
-      def colors_changed!
-        @prev_fresh = false
-        @check = true
-      end
-
-      def apply_color_patches
-        @color_patches.apply(@colors, @fg)
-      end
-
-      # The vertical border compares run in every cycle of their line (VICE
-      # x64sc). The top one resets the flip-flop at once when DEN is set. The
-      # bottom one only arms it, and the armed state takes hold at the line's
-      # first cycle and at the left window edge (Bauer §3.9 rules 2-5). The
-      # VIC calls this after each $d011 write.
-      def compare_vertical_border(line)
-        top, bottom = BORDER_Y_BOUNDS[@registers.rsel? ? 1 : 0]
-        @vertical_armed = true if line == bottom
-        @vertical_armed = @vertical_border = false if line == top && @registers.display_enabled?
-      end
-
-      # The line's first cycle, Bauer's cycle 1, which is the last column of
-      # the line before it.
-      def start_vertical_border(line)
-        compare_vertical_border(line)
-        @vertical_border = @vertical_armed
-      end
-
-      # The 40-column left compare, a column before the column that draws its
-      # pixel. The 38-column one runs in the drawing column.
-      def left_compare_vertical_border
-        @left_vertical_border = start_vertical_border(@line) if @registers.csel?
-      end
-
-      def border_at?(pixel_x) = @border_mask.at?(pixel_x)
-
-      # True while the vertical border flip-flop is set and stays set for the
-      # rest of the line: it can only clear mid-line on a top compare line
-      # with DEN set.
-      def vertical_closed?
-        return false unless @vertical_border
-        return true unless @line == 51 || @line == 55
-
-        top, = BORDER_Y_BOUNDS[@registers.rsel? ? 1 : 0]
-        !(@line == top && @registers.display_enabled?)
-      end
-
-      # Snapshot the finished line so apply_border can restore the border
-      # pixels sprites were composited over, keeping mid-line border splits.
-      def snapshot_line = @border_mask.snapshot(@colors)
-
-      # Repaint the border over the composited line, hiding the sprites.
-      def apply_border = @border_mask.restore(@colors)
-
-      # The g-accesses the VIC hands over, as a ring the column's slot
-      # indexes: the byte read, the screen byte and the colour nibble. The
-      # slot before is the byte the previous group loaded.
-      attr_reader :ring_data, :ring_char, :ring_color
-
-      # The border flip-flops: vertical, the vertical one armed to set, and
-      # the main one.
-      def borders = [@vertical_border, @vertical_armed, @main_border]
-
-      def restore_borders(vertical, armed, main)
-        @vertical_border = vertical
-        @vertical_armed = armed
-        @main_border = main
-      end
-
-      # Paints the byte in the slot through the current mode. An idle access
-      # latches 0/0 and one that made no access passes on zero data with the
-      # kept values; under a closed border neither has foreground. A group
-      # where the mode or the load point changes, and the one after it, run
-      # the shift register pixel by pixel.
-      def emit(slot, col, display)
-        mode = @registers.mode
-        return emit_checked(slot, col, display, mode) if @check || mode != @last_mode
-
-        paint_slot(slot, mode, display)
-        output(col, @last_shift)
-        roll
-      end
-
-      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)
-        shift = @xscroll
-        if mode == @last_mode && shift == @last_shift && !@settling
-          emit_settled(slot, col, display, mode, shift)
-        else
-          emit_pixels(slot, col, mode, shift, !display && border_hidden?)
-          @settling = mode != @last_mode || shift != @last_shift
-          @last_mode = mode
-          @last_shift = shift
-        end
-      end
-
-      def emit_settled(slot, col, display, mode, shift)
-        repaint_previous(mode, (slot - 1) & 3) unless @prev_fresh || shift.zero?
-        paint_slot(slot, mode, display)
-        output(col, shift)
-        roll
-        @prev_fresh = true
-        @check = false
-      end
-
-      def paint_slot(slot, mode, display)
-        if !display && border_hidden?
-          @cur_fg = GraphicsMode::NO_FG
-        else
-          paint(slot, mode)
-        end
-      end
-
-      def repaint_previous(mode, slot)
-        roll
-        paint(slot, mode)
-        roll
-      end
-
-      def paint(slot, mode)
-        if @render
-          MODES[mode].paint(@ring_data[slot], @ring_char[slot], @ring_color[slot], self)
-        else
-          @cur_fg = MODES[mode].fg(@ring_data[slot], @ring_char[slot], @ring_color[slot])
-        end
-      end
-
-      def emit_pixels(slot, col, mode, shift, hidden)
-        prime_shifter((slot - 1) & 3) unless @settling
-        @shifter.draw(hidden ? 0 : @ring_data[slot], @ring_char[slot], @ring_color[slot], shift, mode)
-        @cur_colors[0, 8] = @shifter.colors
-        @cur_fg = @shifter.fg
-        output(col, 0)
-        @prev_fresh = false
-        @check = true
-      end
-
-      # Picks up from a group that painted whole bytes.
-      def prime_shifter(slot)
-        @shifter.prime(@ring_data[slot], @ring_char[slot], @ring_color[slot], @last_shift, @last_mode)
-      end
-
-      # The group is border throughout when the main flip-flop is set and the
-      # vertical one keeps it from clearing.
-      def border_hidden? = @main_border && vertical_closed?
-
-      def pixel_shown?(pixel_x, left_compare, right_compare)
-        @main_border = true if pixel_x == right_compare
-        @main_border = false if pixel_x == left_compare && !left_vertical_border
-        !@main_border
-      end
-
-      def left_vertical_border
-        @left_vertical_border.nil? ? start_vertical_border(@line) : @left_vertical_border
-      end
-
-      def roll
-        @prev_colors, @cur_colors = @cur_colors, @prev_colors
-        @prev_fg, @cur_fg = @cur_fg, @prev_fg
-        nil
-      end
-    end
-  end
-end

data/lib/badline/vic/sequencer_output.rb

@@ -1,116 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class VIC
-    class Sequencer
-      # Writes a column's 8-pixel group into the line buffers, through the
-      # main border flip-flop and XSCROLL.
-      module Output
-        private
-
-        # Write the 8-pixel group for a column into the line buffers. The main
-        # border flip-flop only changes state in the groups containing the
-        # window edge compares, so all other groups take a branch-free bulk
-        # path: fully border or fully window. A group's first pixel, where the
-        # 40-column compares fall, still sees CSEL as the column before had it.
-        def output(col, shift)
-          x_pos = (col + 16) * 8
-          csel = @registers.csel?
-          first = @window_compares[@first_csel ? 1 : 0]
-          @first_csel = csel
-          compares = @window_compares[csel ? 1 : 0]
-          win_lo, right_compare = compares
-
-          if !first.equal?(compares) || boundary_group?(x_pos, win_lo, right_compare)
-            output_boundary(x_pos, first, compares, shift)
-          elsif @main_border
-            output_border(x_pos)
-          else
-            output_window(x_pos, shift)
-          end
-        end
-
-        # True if the group contains a window edge, where the main border
-        # flip-flop can change state.
-        def boundary_group?(x_pos, win_lo, right_compare)
-          lo_delta = win_lo - x_pos
-          hi_delta = right_compare - x_pos
-          (lo_delta >= 0 && lo_delta < 8) || (hi_delta >= 0 && hi_delta < 8)
-        end
-
-        def output_border(x_pos)
-          @colors.fill(@registers.border, x_pos, 8) if @render
-          @border_groups[x_pos >> 3] = BorderMask::FULL
-          @fg.fill(false, x_pos, 8)
-        end
-
-        def output_window(x_pos, shift)
-          in_gfx = x_pos >= @gfx_x_start && x_pos < @gfx_x_end
-          @border_groups[x_pos >> 3] = BorderMask::NONE
-
-          if shift.zero?
-            @colors[x_pos, 8] = @cur_colors if @render
-            if in_gfx
-              @fg[x_pos, 8] = @cur_fg
-            else
-              @fg.fill(false, x_pos, 8)
-            end
-          else
-            output_window_shifted(x_pos, in_gfx, shift)
-          end
-        end
-
-        def output_window_shifted(x_pos, in_gfx, shift)
-          keep = 8 - shift
-
-          if @render
-            copy(@cur_colors, 0, @colors, x_pos + shift, keep)
-            copy(@prev_colors, keep, @colors, x_pos, shift)
-          end
-          output_shifted_fg(x_pos, in_gfx, shift, keep)
-        end
-
-        def output_shifted_fg(x_pos, in_gfx, shift, keep)
-          return @fg.fill(false, x_pos, 8) unless in_gfx
-
-          copy(@cur_fg, 0, @fg, x_pos + shift, keep)
-          copy(@prev_fg, keep, @fg, x_pos, shift)
-        end
-
-        def copy(src, from, dest, to, count)
-          i = 0
-          while i < count
-            dest[to + i] = src[from + i]
-            i += 1
-          end
-        end
-
-        # Slow path for the groups where the border flip-flop can change state.
-        def output_boundary(x_pos, first, compares, shift)
-          border = @registers.border
-          win_lo, right_compare = first
-          @border_groups[x_pos >> 3] = BorderMask::MIXED
-
-          i = 0
-          while i < 8
-            src = i - shift
-            if src >= 0
-              pixel = @cur_colors[src]
-              mask = @cur_fg[src]
-            else
-              pixel = @prev_colors[8 + src]
-              mask = @prev_fg[8 + src]
-            end
-            x = x_pos + i
-            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
-            win_lo, right_compare = compares if i.zero?
-            i += 1
-          end
-        end
-      end
-    end
-  end
-end

data/lib/badline/vic/sequencer_state.rb

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class VIC
-    class Sequencer
-      # The sequencer's save_state and load_state.
-      module SavedState
-        FG_SHIFTER = -1
-        PAIR_CODES = 256
-
-        # The line buffers, the border flip-flops, the g-access ring and the
-        # pixel pipeline. The foreground masks the groups point at go as
-        # FG_SHIFTER for the shift register's, or their data byte in
-        # GraphicsMode's HIRES_FG, or that plus 256 in its PAIR_FG. The left
-        # vertical border compare goes as -1 before it has run.
-        def save_state(out)
-          out.int(@line).boolean(@first_csel).int(@left_vertical_border.nil? ? -1 : bit(@left_vertical_border))
-          out.blob(@colors).booleans(@fg)
-          @border_mask.save_state(out)
-          out.ints(@cur_colors).int(fg_code(@cur_fg)).ints(@prev_colors).int(fg_code(@prev_fg))
-          out.boolean(@vertical_border).boolean(@vertical_armed).boolean(@main_border)
-          @color_patches.save_state(out)
-          @shifter.save_state(out)
-          out.int(@xscroll).int(@last_shift).int(@last_mode).boolean(@settling).boolean(@prev_fresh).boolean(@check)
-          out.ints(@ring_data).ints(@ring_char).ints(@ring_color)
-        end
-
-        def load_state(input)
-          load_line(input)
-          @border_mask.load_state(input)
-          input.ints_into(@cur_colors)
-          @cur_fg = fg_pattern(input.int)
-          input.ints_into(@prev_colors)
-          @prev_fg = fg_pattern(input.int)
-          @vertical_border = input.boolean?
-          @vertical_armed = input.boolean?
-          @main_border = input.boolean?
-          @color_patches.load_state(input)
-          @shifter.load_state(input)
-          load_pipeline(input)
-        end
-
-        private
-
-        def bit(flag) = flag ? 1 : 0
-
-        def load_line(input)
-          @line = input.int
-          @first_csel = input.boolean?
-          left = input.int
-          @left_vertical_border = left.negative? ? nil : left == 1
-          input.blob_into(@colors)
-          input.booleans_into(@fg)
-        end
-
-        def load_pipeline(input)
-          @xscroll = input.int
-          @last_shift = input.int
-          @last_mode = input.int
-          @settling = input.boolean?
-          @prev_fresh = input.boolean?
-          @check = input.boolean?
-          input.ints_into(@ring_data)
-          input.ints_into(@ring_char)
-          input.ints_into(@ring_color)
-        end
-
-        def fg_code(pattern)
-          return FG_SHIFTER if pattern.equal?(@shifter.fg)
-
-          hires = GraphicsMode::HIRES_FG.index { |fg| fg.equal?(pattern) }
-          return hires if hires
-
-          pair = GraphicsMode::PAIR_FG.index { |fg| fg.equal?(pattern) }
-          raise ArgumentError, "a foreground mask the sequencer doesn't know" unless pair
-
-          PAIR_CODES + pair
-        end
-
-        def fg_pattern(code)
-          return @shifter.fg if code == FG_SHIFTER
-          return GraphicsMode::HIRES_FG.fetch(code) if code < PAIR_CODES
-
-          GraphicsMode::PAIR_FG.fetch(code - PAIR_CODES)
-        end
-      end
-    end
-  end
-end

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

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class VIC
-    class Sprite
-      # = InternalBus
-      #
-      # What a sprite's s-accesses read while its DMA is off. The first and
-      # third fall in phi2, where the VIC's internal bus floats to $ff unless
-      # 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, and where the region puts the
-        # sprites in it.
-        attr_reader :columns, :timing
-
-        def initialize(bank, timing)
-          @bank = bank
-          @timing = timing
-          @columns = timing.columns
-          @sprite_cycle = timing.sprite_cycle
-          @lines = 0
-          @ghost = 0xff
-          @value = Array.new(columns, 0xff)
-          @line = Array.new(columns, -1)
-        end
-
-        def save_state(out)
-          out.int(@lines).int(@ghost).ints(@value).ints(@line)
-        end
-
-        def load_state(input)
-          @lines = input.int
-          @ghost = input.int
-          input.ints_into(@value)
-          input.ints_into(@line)
-        end
-
-        # Sprites 3-7 fetch in Bauer cycles 1-10, so the idle byte is taken
-        # as the line starts.
-        def start_line(sprites_enabled)
-          @lines += 1
-          @ghost = @bank.peek(0x3fff) if sprites_enabled
-        end
-
-        # The VIC has advanced to `column`, so the access runs in Bauer cycle
-        # `column + 1`, and column 0 is the first cycle of the line about to
-        # start.
-        def access(column, value)
-          @value[column] = value
-          @line[column] = column.zero? ? @lines + 1 : @lines
-        end
-
-        # The row sprite `index` (3-7) fetched this line, in the phi2 halves
-        # of the two cycles from its p-access: Bauer cycles 2n-5 and 2n-4 on
-        # the 6569.
-        def row(index)
-          column = (@sprite_cycle + (2 * index) - 1) % @columns
-          (phi2(column) << 16) | (@ghost << 8) | phi2(column + 1)
-        end
-
-        private
-
-        def phi2(column) = @line[column] == @lines ? @value[column] : 0xff
-      end
-    end
-  end
-end

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

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class VIC
-    class Sprite
-      # The sprite's save_state and load_state.
-      module SavedState
-        # The shift register, MC, MCBASE, the expansion flip-flop and whether
-        # the sprite shows, for a VICE snapshot.
-        attr_reader :sr, :mc, :mcbase, :exp_ff, :display_on
-
-        # Sets MC, MCBASE, the expansion flip-flop, whether the sprite's DMA
-        # runs and whether it shows, as a VICE snapshot gives them.
-        def restore_counters(counter, base, expanded, dma, shows)
-          @mc = counter
-          @mcbase = base
-          @exp_ff = expanded
-          @dma = dma
-          @display_on = shows
-        end
-
-        def save_state(out)
-          out.boolean(@dma).boolean(@display_on).int(@mcbase).int(@mc).boolean(@exp_ff).optional_int(@crunched_mc)
-          out.int(@bits).boolean(@row_ready).optional_int(@prev_bits).boolean(@first_byte_lost).boolean(@blind)
-          out.int(@show_from).optional_int(@stop_x)
-          out.ints(@codes).int(@leftmost).int(@span).ints(@reload_codes).int(@reload_leftmost).int(@reload_span)
-          out.int(@sr).int(@latch).boolean(@mc_flop).boolean(@xe_flop)
-        end
-
-        def load_state(input)
-          load_counters(input)
-          @show_from = input.int
-          @stop_x = input.optional_int
-          input.ints_into(@codes)
-          @leftmost = input.int
-          @span = input.int
-          input.ints_into(@reload_codes)
-          @reload_leftmost = input.int
-          @reload_span = input.int
-          @sr = input.int
-          @latch = input.int
-          @mc_flop = input.boolean?
-          @xe_flop = input.boolean?
-        end
-
-        private
-
-        def load_counters(input)
-          @dma = input.boolean?
-          @display_on = input.boolean?
-          @mcbase = input.int
-          @mc = input.int
-          @exp_ff = input.boolean?
-          @crunched_mc = input.optional_int
-          @bits = input.int
-          @row_ready = input.boolean?
-          @prev_bits = input.optional_int
-          @first_byte_lost = input.boolean?
-          @blind = input.boolean?
-        end
-      end
-    end
-  end
-end