badline 0.8.0 → 0.10.0

data/lib/badline/vic20/vic/painter.rb

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+module Badline
+  class Vic20
+    class VIC
+      # Paints the VIC-I's display a line at a time from what the VIC
+      # fetched for it: each character's pattern byte and colour nibble, the
+      # pixel its first character starts at and how many it fetched. Each
+      # line keeps its own, so the next line's fetches, which can start
+      # before this line's last pixels are out, don't overwrite them, and a
+      # fetch that reads what the same line read a frame ago changes
+      # nothing.
+      #
+      # A line is painted when its last pixel is out, unless a colour
+      # register was written while it was going out: then the pixels up to
+      # the write are painted first, with the old colours. Border,
+      # background and auxiliary colour take hold from the pixel the write
+      # lands on, and the reverse bit two pixels later. A line with the
+      # same fetches and colours as the frame before is left alone.
+      #
+      # A character's colour nibble picks its mode. Below 8 it's a hires
+      # character in that colour: a set bit is the character's colour and a
+      # clear one the background, or the other way round with $900F bit 3
+      # clear. From 8 up it's multicolour, two bits to a double-width pixel:
+      # 00 the background, 01 the border, 10 the character's colour (the
+      # nibble's low three bits) and 11 the auxiliary colour, whatever
+      # $900F bit 3 says (MOS 6560/6561 datasheet, "Color operating modes").
+      class Painter
+        # The characters a line holds room for. A line fetches at most 34.
+        SLOTS = 40
+
+        # What the VIC fetched for each line, SLOTS characters a line, and
+        # whether any of it differs from what the line fetched a frame ago.
+        attr_reader :patterns, :colors, :counts, :starts, :stale
+
+        attr_reader :display, :width, :dirty_lines, :render
+
+        # +blanked+ is the number of lines at the top of the frame that are
+        # never painted.
+        def initialize(lines, width, blanked)
+          @width = width
+          @blanked = blanked
+          @display = Array.new(width * lines, 0)
+          @dirty_lines = Array.new(lines, true)
+          @patterns = Array.new(lines * SLOTS, 0)
+          @colors = Array.new(lines * SLOTS, 0)
+          @counts = Array.new(lines, 0)
+          @starts = Array.new(lines, 0)
+          @stale = Array.new(lines, true)
+          @memo_keys = Array.new(lines, -1)
+          @render = true
+        end
+
+        # Clears the display and starts painting +row+, with the colour
+        # registers at zero.
+        def power_on!(row)
+          @border = @background = @aux = 0
+          @reverse = true
+          @row = row
+          @painted = 0
+          @written = false
+          @counts.fill(0)
+          @stale.fill(true)
+          @memo_keys.fill(-1)
+          @display.fill(0)
+          @dirty_lines.fill(true)
+        end
+
+        def clear_dirty_lines!
+          @dirty_lines.fill(false)
+        end
+
+        # The colours, the line being painted and how far, what each line
+        # fetched, and the display, for a snapshot. Whether it renders is
+        # the host's, and a restored display is all changed.
+        def save_state(out)
+          out.int(@border).int(@background).int(@aux).boolean(@reverse)
+          out.int(@row).int(@painted).boolean(@written)
+          out.blob(@display).blob(@patterns).blob(@colors)
+          out.ints(@counts).ints(@starts).booleans(@stale).ints(@memo_keys)
+        end
+
+        def load_state(input)
+          @border = input.int
+          @background = input.int
+          @aux = input.int
+          @reverse = input.boolean?
+          @row = input.int
+          @painted = input.int
+          @written = input.boolean?
+          input.blob_into(@display)
+          input.blob_into(@patterns)
+          input.blob_into(@colors)
+          input.ints_into(@counts)
+          input.ints_into(@starts)
+          input.booleans_into(@stale)
+          input.ints_into(@memo_keys)
+          @dirty_lines.fill(true)
+        end
+
+        # Painting can be turned off, and once it's back on every line is
+        # painted afresh.
+        def render=(value)
+          @memo_keys.fill(-1)
+          @render = value
+        end
+
+        # $900F written while +position+ of the line is going out.
+        def colors_written(position, value)
+          @written = true
+          paint_to(position)
+          @border = value & 0x07
+          @background = value >> 4
+          paint_to(position + 2)
+          @reverse = value.nobits?(0x08)
+        end
+
+        # The auxiliary colour, $900E bits 7-4, written while +position+ of
+        # the line is going out.
+        def aux_written(position, aux)
+          @written = true
+          paint_to(position)
+          @aux = aux
+        end
+
+        # The current line's last pixel is out: paints what's left of it,
+        # then starts +next_row+.
+        def finish_line(next_row)
+          row = @row
+          if @render && row >= @blanked
+            key = memo_key(row)
+            if @written || @stale[row] || key != @memo_keys[row]
+              paint_to(@width)
+              @memo_keys[row] = @written ? -1 : key
+              @dirty_lines[row] = true
+            end
+          end
+          @stale[row] = false
+          @painted = 0
+          @written = false
+          @row = next_row
+        end
+
+        private
+
+        # The colours and the window's place on +row+, packed into one
+        # Integer.
+        def memo_key(row)
+          count = @counts[row]
+          start = count.zero? ? 0 : @starts[row]
+          @border | (@background << 3) | (@aux << 7) | (@reverse ? 0x800 : 0) | (start << 12) | (count << 24)
+        end
+
+        # Paints the current line's pixels from where it got to up to
+        # +stop+.
+        def paint_to(stop)
+          return unless @render && @row >= @blanked
+
+          x = @painted
+          return if x >= stop
+
+          @painted = stop
+          base = @row * @width
+          border_to = @starts[@row]
+          border_to = stop if border_to > stop
+          x = paint_border(base, x, border_to)
+          x = paint_characters(base, x, stop)
+          paint_border(base, x, stop)
+        end
+
+        # Paints the border from +from+ up to +to+, and returns where it
+        # got to.
+        def paint_border(base, from, to)
+          return from if from >= to
+
+          @display.fill(@border, base + from, to - from)
+          to
+        end
+
+        # Paints the characters from +from+ up to +stop+, and returns where it
+        # got to: +stop+, or the end of the line's characters.
+        def paint_characters(base, from, stop)
+          x = from
+          row = @row
+          start = @starts[row]
+          finish = start + (@counts[row] * 8)
+          slot = row * SLOTS
+          while x < stop && x < finish
+            first = x - start
+            cell = first & ~7
+            last = stop - start - cell
+            last = 8 if last > 8
+            paint_character(base + start + cell, slot + (cell >> 3), first & 7, last)
+            x = start + cell + last
+          end
+          x
+        end
+
+        # Paints pixels +first+ up to +last+ of the character in +slot+,
+        # whose first pixel is at +at+.
+        def paint_character(at, slot, first, last)
+          pattern = @patterns[slot]
+          color = @colors[slot]
+          if color < 8
+            paint_hires(at, pattern, color, first, last)
+          else
+            paint_multicolor(at, pattern, color & 0x07, first, last)
+          end
+        end
+
+        def paint_hires(at, pattern, color, first, last)
+          display = @display
+          set = @reverse ? @background : color
+          clear = @reverse ? color : @background
+          i = first
+          while i < last
+            display[at + i] = pattern.anybits?(0x80 >> i) ? set : clear
+            i += 1
+          end
+        end
+
+        def paint_multicolor(at, pattern, color, first, last)
+          display = @display
+          i = first
+          while i < last
+            pair = (pattern >> (6 - (i & 6))) & 0x03
+            display[at + i] =
+              if pair.zero? then @background
+              elsif pair == 1 then @border
+              elsif pair == 2 then color
+              else @aux
+              end
+            i += 1
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Badline
+  class Vic20
+    class VIC
+      # The VIC's state for a snapshot: the registers and what they set, the
+      # raster, the text window and its fetches, and the picture with what
+      # each line fetched. The sound saves its own.
+      module SavedState
+        def save_state(out)
+          out.marker("VIC20 VIC")
+          out.ints(@registers).int(@rasterline).int(@column).int(@next_event)
+          [@origin_x, @origin_y, @columns, @rows, @char_shift, @screen_base, @char_base].each { |value| out.int(value) }
+          out.boolean(@window_open).boolean(@window_done)
+          [@row_start, @matrix, @char_line, @text_rows].each { |value| out.int(value) }
+          [@fetch_from, @fetch_to, @fetched, @slot, @code].each { |value| out.int(value) }
+          @painter.save_state(out)
+        end
+
+        def load_state(input)
+          input.marker("VIC20 VIC")
+          input.ints_into(@registers)
+          @rasterline = input.int
+          @column = input.int
+          @next_event = input.int
+          load_window(input)
+          @fetch_from = input.int
+          @fetch_to = input.int
+          @fetched = input.int
+          @slot = input.int
+          @code = input.int
+          @painter.load_state(input)
+        end
+
+        private
+
+        def load_window(input)
+          @origin_x = input.int
+          @origin_y = input.int
+          @columns = input.int
+          @rows = input.int
+          @char_shift = input.int
+          @screen_base = input.int
+          @char_base = input.int
+          @window_open = input.boolean?
+          @window_done = input.boolean?
+          @row_start = input.int
+          @matrix = input.int
+          @char_line = input.int
+          @text_rows = input.int
+        end
+      end
+    end
+  end
+end

data/lib/badline/vic20/vic/text_window.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Badline
+  class Vic20
+    class VIC
+      # The text window's rows: where it opens and closes, the video matrix
+      # counter and the character line, and the registers that place the
+      # window and its memory.
+      module TextWindow
+        private
+
+        def new_frame
+          @window_open = @window_done = false
+          @row_start = @matrix = @char_line = @text_rows = 0
+        end
+
+        def open_window
+          @window_open = true
+          @char_line = 0
+          @matrix = @row_start
+        end
+
+        # Steps to the next line of the text row, or past the row's last line
+        # to the next row, closing the window after the last.
+        def next_text_line
+          @char_line += 1
+          if @char_line < (1 << @char_shift)
+            @matrix = @row_start
+            return
+          end
+
+          @char_line = 0
+          @row_start = @matrix
+          @text_rows += 1
+          return if @text_rows < @rows
+
+          @window_open = false
+          @window_done = true
+        end
+
+        # $9000 and $9002 move the window's fetches on the line, or only where
+        # they end once they've started.
+        def window_written
+          @origin_x = @registers[0] & 0x7f
+          @columns = @registers[2] & 0x7f
+          bases_written
+          return unless @window_open
+
+          if @column < @fetch_from
+            place_fetches
+          else
+            fetches_end
+          end
+          schedule
+        end
+
+        def rows_written(value)
+          @rows = (value >> 1) & 0x3f
+          @char_shift = value.anybits?(0x01) ? 4 : 3
+        end
+
+        # The video matrix at $9005 bits 7-4 and $9002 bit 7, address bits
+        # 13-9, and the characters at $9005 bits 3-0, bits 13-10.
+        def bases_written
+          @screen_base = ((@registers[5] & 0xf0) << 6) | ((@registers[2] & 0x80) << 2)
+          @char_base = (@registers[5] & 0x0f) << 10
+        end
+      end
+    end
+  end
+end

data/lib/badline/vic20/vic.rb

@@ -0,0 +1,267 @@
+# frozen_string_literal: true
+
+require "badline/vic20/vic/painter"
+require "badline/vic20/vic/text_window"
+require "badline/vic20/vic/saved_state"
+
+module Badline
+  class Vic20
+    # The VIC-I, the 6561 on PAL machines: its sixteen registers, the
+    # raster, the text window's fetches over the V-bus and the picture. The
+    # writes to the sound's registers, $900A-$900E, go on to the Sound
+    # attached as #sound.
+    #
+    # The registers repeat through $9000-$90FF. $9003 bit 7 and $9004 read
+    # the raster line, its bit 0 and bits 8-1. $9006 and $9007 read the
+    # light pen, which nothing triggers yet, and $9008 and $9009 the two
+    # pots, which read $FF with nothing plugged in. The other registers
+    # read back what was written to them.
+    #
+    # The text window opens on the line where the raster's bits 8-1 match
+    # $9001, and closes after the number of text rows in $9003, each 8 lines
+    # of a character, or 16 with $9003 bit 0 set. On each of its lines the
+    # VIC fetches two bytes a character, $9002's count of them: the
+    # character code from the video matrix, with the colour nibble beside it
+    # on the colour bus, then the character's pattern byte for the line.
+    # The first code is fetched four cycles after the column in $9000, so
+    # the window starts 16 cycles into the line with the KERNAL's origin of
+    # 12, and none is fetched past the end of the line. The fetches go to a
+    # 14-bit address, the VIC's own (see Bus#video_fetch), and the byte each
+    # one reads is the V-bus's last byte. Outside the window the 6561E
+    # fetches nothing and the V-bus keeps the CPU's last byte there.
+    #
+    # The video matrix counter steps once a character. It starts each line
+    # of a text row where the row started, and the next row starts where
+    # the last line of the row left it. It starts the frame at zero.
+    #
+    # The picture is 4 pixels a cycle, so 284 a line. A character's 8
+    # pixels come out in the two cycles after its pattern fetch. The
+    # display's lines start 6 cycles after the raster count moves, as
+    # xvic's view of the frame does, so the character fetched 16 cycles
+    # into the line lands 48 pixels in. Lines 0-27 are blanked.
+    class VIC
+      include TextWindow
+      include SavedState
+
+      # What a VIC-I sets for the machine: the clock, the raster's cycles
+      # per line and lines per frame, and how many lines at the top of the
+      # frame it blanks. The 6560 of NTSC machines, with its half lines and
+      # the interlace of $9000 bit 7, would be another.
+      Profile = Data.define(:clock_hz, :cycles_per_line, :lines_per_frame, :blanked_lines)
+
+      # The 6561: 71 cycles by 312 lines, lines 0-27 blanked (Marko
+      # Mäkelä's VIC-I.txt).
+      PAL = Profile.new(clock_hz: 1_108_405, cycles_per_line: 71, lines_per_frame: 312, blanked_lines: 28)
+
+      PIXELS_PER_CYCLE = 4
+
+      # The column whose pixels start a line of the display.
+      FIRST_PIXEL_COLUMN = 6
+
+      # How many cycles after the column in $9000 the first code is fetched.
+      FETCH_DELAY = 4
+
+      # The colours, as RGB, each from its luma and chroma: luma in five
+      # levels from black to white, and chroma at one strength in a phase
+      # that steps by 22.5 degrees from blue's. The levels and phases are
+      # the VIC-I's table on Wikipedia's "MOS Technology VIC" (Y, Pb, Pr),
+      # turned into RGB with the BT.601 matrix and the chroma scaled by 0.2.
+      PALETTE = [
+        0x000000, 0xffffff, 0x82251d, 0x7ddae2, 0xb259bf, 0x4da640, 0x402e9a, 0xbfd165,
+        0xb27240, 0xf2b27f, 0xc2655d, 0xbdffff, 0xf299ff, 0x8de57f, 0x806eda, 0xffffa5
+      ].freeze
+
+      attr_reader :rasterline, :column, :profile
+      attr_accessor :sound
+
+      def initialize(profile = PAL)
+        @profile = profile
+        @cycles_per_line = profile.cycles_per_line
+        @lines_per_frame = profile.lines_per_frame
+        @painter = Painter.new(@lines_per_frame, @cycles_per_line * PIXELS_PER_CYCLE, profile.blanked_lines)
+        @patterns = @painter.patterns
+        @colors = @painter.colors
+        @counts = @painter.counts
+        @starts = @painter.starts
+        @stale = @painter.stale
+        @bus = nil
+        @sound = nil
+        @color_cells = Array.new(0x400, 0)
+        power_on!
+      end
+
+      # The bus the VIC fetches from, the machine's, and the colour RAM
+      # whose cells come in on the colour bus beside each code.
+      def connect(bus)
+        @bus = bus
+        @color_cells = bus.color_ram.cells
+      end
+
+      # The power-on state: the registers cleared and the raster at the top
+      # of the frame. The VIC has no RES pin, so only power reaches it.
+      def power_on!
+        @registers = Array.new(16, 0)
+        @rasterline = 0
+        @column = 0
+        @origin_x = @origin_y = @columns = @rows = 0
+        @char_shift = 3
+        @screen_base = @char_base = 0
+        new_frame
+        @fetch_from = @fetch_to = 0
+        @fetched = @slot = 0
+        @code = 0
+        @painter.power_on!(@lines_per_frame - 1)
+        schedule
+      end
+
+      def cycle!
+        column = @column + 1
+        @column = column
+        return unless column == @next_event
+
+        if column > FIRST_PIXEL_COLUMN && column < @fetch_to && column >= @fetch_from
+          access(column)
+          column += 1
+          @next_event = column < @fetch_to ? column : @cycles_per_line
+        else
+          event(column)
+        end
+      end
+
+      # The sixteen registers as written.
+      def register_file = @registers.dup
+
+      # The display, a palette index a pixel, 284 to a line and every line
+      # of the frame.
+      def display = @painter.display
+
+      def width = @painter.width
+
+      def height = @lines_per_frame
+
+      # Whether each line of the display has changed since the front end
+      # last cleared them.
+      def dirty_lines = @painter.dirty_lines
+
+      def clear_dirty_lines! = @painter.clear_dirty_lines!
+
+      def palette = PALETTE
+
+      # Whether the VIC paints its display. It fetches either way.
+      def render = @painter.render
+
+      def render=(value)
+        @painter.render = value
+      end
+
+      def peek(addr)
+        register = addr & 0x0f
+        case register
+        when 0x03 then ((@rasterline & 0x01) << 7) | (@registers[3] & 0x7f)
+        when 0x04 then @rasterline >> 1
+        when 0x06, 0x07 then 0
+        when 0x08, 0x09 then 0xff
+        else @registers[register]
+        end
+      end
+
+      def poke(addr, value)
+        register = addr & 0x0f
+        @registers[register] = value
+        case register
+        when 0x00, 0x02 then window_written
+        when 0x01 then @origin_y = value
+        when 0x03 then rows_written(value)
+        when 0x05 then bases_written
+        when 0x0a, 0x0b, 0x0c, 0x0d then @sound&.write(register, value)
+        when 0x0e
+          @painter.aux_written(pixel_position, value >> 4)
+          @sound&.write(register, value)
+        when 0x0f then @painter.colors_written(pixel_position, value)
+        end
+      end
+
+      private
+
+      def event(column)
+        if column == @cycles_per_line
+          column = @column = 0
+          start_line
+        end
+        @painter.finish_line(@rasterline) if column == FIRST_PIXEL_COLUMN
+        access(column) if column >= @fetch_from && column < @fetch_to
+        schedule
+      end
+
+      # The next column with something to do: the end of the line, the
+      # start of a display line, or a fetch.
+      def schedule
+        column = @column
+        upcoming = column < FIRST_PIXEL_COLUMN ? FIRST_PIXEL_COLUMN : @cycles_per_line
+        fetch = column < @fetch_from ? @fetch_from : column + 1
+        upcoming = fetch if fetch < @fetch_to && fetch < upcoming
+        @next_event = upcoming
+      end
+
+      def start_line
+        line = @rasterline + 1
+        if line == @lines_per_frame
+          line = 0
+          new_frame
+        end
+        @rasterline = line
+        next_text_line if @window_open
+        open_window if !@window_open && !@window_done && (line >> 1) == @origin_y && @rows.positive?
+        place_fetches
+      end
+
+      def place_fetches
+        line = @rasterline
+        @slot = line * Painter::SLOTS
+        @fetched = @counts[line] = 0
+        @starts[line] = @origin_x * PIXELS_PER_CYCLE
+        unless @window_open
+          @fetch_from = @fetch_to = 0
+          return
+        end
+
+        @fetch_from = @origin_x + FETCH_DELAY
+        fetches_end
+      end
+
+      def fetches_end
+        last = @fetch_from + (2 * @columns)
+        @fetch_to = [last, @cycles_per_line].min
+      end
+
+      def access(column)
+        slot = @slot + @fetched
+        if (column - @fetch_from).even?
+          address = (@screen_base + @matrix) & 0x3fff
+          @code = @bus.video_fetch(address)
+          color = @color_cells[address & 0x3ff]
+          return if @colors[slot] == color
+
+          @colors[slot] = color
+        else
+          pattern = @bus.video_fetch((@char_base + (@code << @char_shift) + @char_line) & 0x3fff)
+          @matrix += 1
+          @fetched += 1
+          @counts[@rasterline] = @fetched
+          return if @patterns[slot] == pattern
+
+          @patterns[slot] = pattern
+        end
+        @stale[@rasterline] = true
+      end
+
+      # The pixel of the display line a register write in this cycle takes
+      # hold from: the second of the cycle's four.
+      def pixel_position
+        column = @column - FIRST_PIXEL_COLUMN
+        column += @cycles_per_line if column.negative?
+        (column * PIXELS_PER_CYCLE) + 1
+      end
+    end
+  end
+end