badline 0.12.1 → 0.13.0

data/lib/badline/chips/vic/sequencer_output.rb

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

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

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

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

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

data/lib/badline/chips/vic/sprite/shifter.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module Badline
+  module Chips
+    class VIC
+      class Sprite
+        # The X comparator and the 24-bit shift register behind it: where a
+        # line fires the sprite, and the pixels each firing shifts out.
+        module Shifter
+          private
+
+          # The first pixel of every comparator match along the line. Writes to
+          # $d000/$d010 move the compare value mid-line, so a sprite can miss
+          # its match entirely and pick up a later one, a second one, or none.
+          def comparator_hits(log)
+            return compare_x(@registers) unless log
+
+            hits = []
+            log.rewind
+            log.advance(0)
+            from = 0
+            while from < @width
+              upto = [log.next_x, @width].min
+              compare_x(log).each do |start|
+                match = (start - 1) % @width
+                hits << start if match >= from && match < upto
+              end
+              break if upto >= @width
+
+              from = upto
+              log.advance(from)
+            end
+            hits
+          end
+
+          # The pixels the sprite starts at, one past each comparator match.
+          # The 6569's X counter only runs to 503, so the eight coordinates
+          # above it never match and the sprite stays dark — the gap the
+          # spritegap tests find at $1f8.
+          def compare_x(view)
+            msb = view[0x10].anybits?(@bit) ? 0x100 : 0
+            @timing.x_pixels[msb | view[index * 2]]
+          end
+
+          # Pixels from the X match to the next reload.
+          def reload_cut(start) = (start < @reload_x ? @reload_x : @reload_x + @width) - start
+
+          # A run that reaches the next reload is cut there, holding its last
+          # pixel through K+6. Returns the span that is left.
+          def cut_at_reload(cut, span, codes)
+            return span if cut > span || cut >= MAX_SPAN
+
+            RELOAD_HOLD.times { |i| codes[cut + i] = codes[cut - 1] }
+            cut + RELOAD_HOLD
+          end
+
+          # Shift one firing out into `codes`, up to the sprite's end, `cut`
+          # pixels from the reload.
+          def run(log, start, codes, bits, cut)
+            @sr = bits
+            log&.rewind
+            pos = start
+            count = 0
+            boundary = log ? 0 : Float::INFINITY
+            mc = multicolor?
+            expanded = x_expanded?
+            while count < MAX_SPAN
+              if pos >= boundary
+                log.advance(pos)
+                expanded = log[0x1d].anybits?(@bit)
+                mc = logged_multicolor(log, mc, expanded, count)
+                boundary = log.next_x
+              end
+              count.zero? ? prime(mc) : step(mc, expanded, count == cut - 1)
+              break if @latch.zero? && @sr.zero?
+
+              codes[count] = @latch
+              count += 1
+              pos += 1
+            end
+            count
+          end
+
+          # The X match loads the shift register and arms both flip-flops, so
+          # the sprite's first pixel comes straight off the fetched row.
+          def prime(multicolor)
+            @mc_flop = @new_chip && !multicolor
+            @xe_flop = false
+            @latch = (@sr >> 22) & (multicolor ? 3 : 2)
+          end
+
+          # The multicolor bit as the log has it at the pixel. A change after
+          # the first pixel reaches the 8565's flip-flop.
+          def logged_multicolor(log, was, expanded, count)
+            multicolor = log[0x1c].anybits?(@bit)
+            switch_multicolor(multicolor, expanded) if @new_chip && multicolor != was && count.positive?
+            multicolor
+          end
+
+          # On the 8565 a multicolor change works on the flip-flop instead of
+          # the next pixels. It stays as it is unless the change lands between
+          # the two halves of an expanded pixel, where it flips, or is set by a
+          # switch to hi-res.
+          def switch_multicolor(multicolor, expanded)
+            return unless expanded && !@xe_flop
+
+            @mc_flop = multicolor ? !@mc_flop : true
+          end
+
+          # One pixel of the sequencer. An unexpanded sprite shifts every pixel;
+          # an expanded one shifts every other, and the multicolor latch reloads
+          # every other shift, so its pairs stretch with the expansion. Both
+          # flip-flops sit idle while their register bit is clear, which is why
+          # the first pixel after a mid-sprite change repeats the last one.
+          def step(multicolor, expanded, last)
+            shift = true
+            if expanded
+              shift = @xe_flop
+              @xe_flop = !@xe_flop
+            else
+              @xe_flop = false
+            end
+            @mc_flop = false unless multicolor || @new_chip
+            return unless shift
+
+            @sr = (@sr << 1) & 0xffffff
+            load_latch(multicolor, last)
+          end
+
+          # A multicolor pair loaded on the last pixel before the reload keeps
+          # only its high bit, as a hi-res pixel does (spritefetchbug).
+          # On the 8565 a hi-res pixel with the multicolor flip-flop clear
+          # sets it and loads nothing, so the latch repeats its last pixel.
+          def load_latch(multicolor, last)
+            if multicolor
+              @latch = (@sr >> 22) & (last ? 2 : 3) if @mc_flop
+              @mc_flop = !@mc_flop
+            elsif @new_chip && !@mc_flop
+              @mc_flop = true
+            else
+              @latch = (@sr >> 22) & 2
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/badline/chips/vic/sprite/timing.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Badline
+  module Chips
+    class VIC
+      class Sprite
+        # = Timing
+        #
+        # Where a region puts the sprites in the line: the cycles of their
+        # fetches and of the display compare, the pixels those land on, and
+        # the raster pixels the X counter reads each coordinate at. Where the
+        # fetches or the compare run a cycle later than on the 6569, what
+        # hangs off them moves 8 pixels with them.
+        class Timing
+          # The X counter's value where it steps back on a raster of more than
+          # 512 pixels, to run over the eight values below it again.
+          HOLD_AT = 0x188
+
+          attr_reader :columns, :sprite_cycle, :display_off_x, :x_pixels
+
+          def initialize(region)
+            @columns = region.cycles_per_line
+            @sprite_cycle = region.sprite_cycle
+            @shift = region.sprite_cycle - Region::PAL.sprite_cycle
+            @display_off_x = DISPLAY_OFF_X + (8 * (region.sprite_display_cycle - Region::PAL.sprite_display_cycle))
+            @x_pixels = Timing.x_pixels(@columns * 8, region.x_hold)
+          end
+
+          # The column BA falls in for a sprite's own fetch: 55 for sprite 0 on
+          # the 6569, and two later for each sprite after it.
+          def ba_column(index) = 55 + @shift + (2 * index)
+
+          # The raster pixel of a sprite's reload, counted from the start of
+          # the line it is fetched on, so past the end of it for sprites 3-7
+          # on the 6569.
+          def reload_x(index) = RELOAD_X + (8 * @shift) + (RELOAD_STEP * index)
+
+          # The X counter at a raster pixel: X_OFFSET behind it, wrapping at
+          # the end of the line, less the pixels it held for from HOLD_AT on,
+          # where it ran over $180-$187 a second time.
+          def self.xpos(pixel, width, hold)
+            count = (pixel - X_OFFSET) % width
+            count < HOLD_AT ? count : count - hold
+          end
+
+          # The raster pixels at which the X counter reads each coordinate, 512
+          # lists. A sprite starts at one where its X matches. On the 6569 the
+          # coordinates past 503 have none.
+          def self.x_pixels(width, hold)
+            pixels = Array.new(512) { [] }
+            width.times { |pixel| pixels[xpos(pixel, width, hold)] << pixel }
+            pixels.each(&:freeze).freeze
+          end
+        end
+      end
+    end
+  end
+end