GBRb 0.1.0

data/lib/gbrb/gb.rb

@@ -0,0 +1,125 @@
+require_relative 'mmu'
+require_relative 'cpu/z80'
+require_relative 'graphics/gpu'
+require_relative 'cartridge'
+
+require 'thread'
+
+module GBRb
+  class GB
+    def initialize cartridge_path='', debug=false
+      @debug = debug
+
+      @gpu_send = Queue.new
+      @gpu_receive = Queue.new
+
+      @mmu = GBRb::MMU.new read_bios, create_cartridge(cartridge_path), @gpu_send
+      @cpu = GBRb::CPU::Z80.new @mmu
+      @gpu = GBRb::Graphics::GPU.new @mmu, @gpu_send, @gpu_receive
+    end
+
+    def power_on
+      @power = :on
+      @gpu.power_on
+      @mode = @debug ? :break : :default
+      @breakpoint = nil
+
+      puts "   pc   |   sp   |   a    |   b    |   c    |   d    |   e    |   h    |   l    |   f    | CB | OP Code |" unless @mode == :default
+
+      loop do
+        if @mode == :break
+          new_mode = nil
+          until new_mode
+            new_mode = debug_input
+          end
+          @mode = new_mode
+        end
+
+        pc = @cpu.r.pc.read
+        op_code = @mmu.read_byte(pc).to_i
+        prefix = @cpu.instance_eval '@cb_prefix'
+
+        begin
+          @gpu_send.push [:cpu, @cpu.step]
+        rescue GBRb::CPU::InstructionNotImplemented => e
+          display_status prefix, op_code
+          @gpu.power_off
+          exit
+        end
+
+        @gpu_receive.pop
+        if @debug
+          display_status prefix, op_code
+          if @step
+            @step -= 1
+            if @step == 0
+              @breakpoint = @cpu.r.pc.read
+              @step = nil
+            end
+          end
+          if @cpu.r.pc.read == @breakpoint
+            @breakpoint = nil
+            @mode = :break
+          end
+        end
+      end
+    end
+
+    private
+    def debug_help
+      "Available modes: (b)reakpoint (h)elp (q)uit (s)tep (t)iles"
+    end
+
+    def debug_input
+      input = STDIN.gets
+      case input.chars.first
+      when 'b'
+        @breakpoint = input[1..-1].to_i 16
+        :debug
+      when 'h'
+        STDERR.puts debug_help
+      when 'm'
+        range = input[1..-1].split.map{|el| el.to_i 16}.map{|el| el/0x10*0x10}
+        if range.length == 2
+          STDERR.puts @mmu.dump(range.first, range.last)
+        else
+          STDERR.puts @mmu.dump
+        end
+      when 'q'
+        @gpu.power_off
+        exit
+      when 's'
+        @step = input[1..-1].to_i
+        @step = 1 if @step == 0
+        :debug
+      when 't'
+        @gpu.dump_tiles
+        nil
+      else
+        @step = 1
+        :debug
+      end
+    end
+
+    def display_status prefix, opcode
+      @cpu.r.each {|register| STDOUT.write ("0x"+register.read.to_s(16)).center(8) + "|" }
+      STDOUT.write "#{prefix ? '  ✓ ' : '    ' }|#{opcode.to_s(16).center(9)}|"
+      STDOUT.write "\n"
+    end
+
+    def read_bios
+      File.read(File.expand_path('../bios', __FILE__)).split.map{ |el| el.to_i(16) }
+    end
+
+    def create_cartridge path
+      puts path
+      f = File.open(path, 'r')
+      c = Cartridge.new f
+      f.close
+      c
+    rescue Errno::ENOENT
+      raise InvalidCartridge, path
+    end
+  end
+end
+

data/lib/gbrb/graphics.rb

@@ -0,0 +1,14 @@
+module GBRb
+  module Graphics
+    WIDTH=160
+    HEIGHT=144
+
+    NUMBER_OF_COLORS = 4
+    MAX_COLOR = NUMBER_OF_COLORS - 1
+
+    SOCKET_PATH= '/tmp/gbrb.sock'
+
+    class WrongPixelCount < StandardError; end
+  end
+end
+

data/lib/gbrb/graphics/gpu.rb

@@ -0,0 +1,196 @@
+require_relative '../graphics'
+require_relative 'mode_clock'
+require_relative 'screen_client'
+
+require 'thread'
+
+module GBRb::Graphics
+  class GPU
+    include ModeClock
+
+    CONTROL_REGISTER = 0xff40
+    SCROLL_Y_ADDRESS = 0xff42
+    SCROLL_X_ADDRESS = 0xff43
+    LINE_ADDRESS     = 0xff44
+    PALETTE_REGISTER = 0xff47
+    TILE_MAP_0       = 0x9800
+    TILE_MAP_1       = 0x9c00
+    TILE_SET_START   = 0x8000
+
+    def initialize memory, incoming, outgoing
+      @memory = memory
+      @incoming = incoming
+      @outgoing = outgoing
+      reset
+    end
+
+    def reset
+      super
+      create_frame_buffer
+      create_tiles
+    end
+
+    def create_tiles
+      @tiles = []
+      0x0200.times do
+        a = []
+        8.times do
+          a << Array.new(8) {0}
+        end
+        @tiles << a
+      end
+    end
+
+    def update_tile address
+      tile = ((address & 0x1ffe) >> 4) & 0x1ff
+      y    = ((address & 0x1ffe) >> 1) & 0x07
+      8.times do |x|
+        x_mask = 1 << (7-x)
+        @tiles[tile][y][x] = ((@memory.read_byte(address) & x_mask) == x_mask ? 1 : 0) + ((@memory.read_byte(address+1) & x_mask) == x_mask ? 2 : 0)
+      end
+    end
+
+    def create_frame_buffer
+      @frame_buffer = Array.new(HEIGHT) { Array.new(WIDTH) {0} }
+    end
+
+    def power_on
+      trap(:CHLD) { exit }
+      @screen_pid = fork { start_screen }
+
+      Thread.abort_on_exception = true
+      Thread.new do
+        loop do
+          message = @incoming.pop
+          case message.first
+          when :cpu
+            self.update! message.last.to_i if display_on?
+            @outgoing.push :nothing
+          when :mmu
+            self.update_tile message.last.to_i
+          end
+        end
+      end
+    end
+
+    def power_off
+      Process.kill :HUP, @screen_pid
+      Process.wait @screen_pid
+    end
+
+    def render_scan_line
+      screen_y_adjusted = line + scroll_y
+      initial_tilemap_offset = current_tile_map_address + ((screen_y_adjusted & 0xff)/8) * 32
+      initial_line_offset = (scroll_x >> 3) %32
+      initial_tile_x = scroll_x & 7
+      initial_tile_y = screen_y_adjusted & 7
+      draw_scan_line initial_tilemap_offset, initial_line_offset, initial_tile_x, initial_tile_y
+    end
+
+    def draw_scan_line tilemap_offset, horizontal_offset, tile_x, tile_y
+      tile_index = calculate_tile_number tilemap_offset, horizontal_offset
+
+      row = []
+      WIDTH.times do
+        palette_index = @tiles[tile_index][tile_y][tile_x]
+        color = palette[palette_index]
+        row << color
+        tile_x += 1
+        if tile_x == 0x08
+          tile_x = 0x00
+          horizontal_offset = (horizontal_offset + 1) % 32
+          tile_index = calculate_tile_number tilemap_offset, horizontal_offset
+        end
+      end
+      @frame_buffer[line] = row
+    end
+
+    def calculate_tile_number tilemap_offset, line_offset
+      id = @memory.read_byte(tilemap_offset + line_offset)
+      id += 256 if background_tile_set == 0x10 and id < 128
+      id
+    end
+
+    def palette
+      value = @memory.read_byte PALETTE_REGISTER
+      colors = []
+      4.times do |i|
+        mask = 0b11 << 2*i
+        colors << (((value & mask) >> 2*i) ^ 0b11)
+      end
+      colors
+    end
+
+    def dump_tiles
+      puts @tiles.inspect
+    end
+
+    def draw_frame_buffer
+      screen.write @frame_buffer if display_on?
+    end
+
+    def line
+      @memory.read_byte LINE_ADDRESS
+    end
+
+    def line= value
+      @memory.write_byte LINE_ADDRESS, value
+    end
+
+    def scroll_y
+      @memory.read_byte SCROLL_Y_ADDRESS
+    end
+
+    def scroll_x
+      @memory.read_byte SCROLL_X_ADDRESS
+    end
+
+    def control_register
+      @memory.read_byte CONTROL_REGISTER
+    end
+
+    def background_on?
+      control_register & 0x01 == 0x01
+    end
+
+    def sprites_on?
+      control_register & 0x02 == 0x02
+    end
+
+    def sprite_size
+      control_register & 0x04 == 0x04 ? [8,16] : [8, 8]
+    end
+
+    def background_tile_map
+      control_register & 0x08
+    end
+
+    def current_tile_map_address
+      background_tile_map == 0x08 ? TILE_MAP_1 : TILE_MAP_0
+    end
+
+    def background_tile_set
+      control_register & 0x10 == 0x10
+    end
+
+    def window_on?
+      control_register & 0x20 == 0x20
+    end
+
+    def window_tile_map
+      control_register & 0x40 == 0x40
+    end
+
+    def display_on?
+      control_register & 0x80 == 0x80
+    end
+
+    def screen
+      @screen ||= GBRb::Graphics::ScreenClient.new
+    end
+
+    def start_screen
+      exec 'bin/display'
+    end
+  end
+end

data/lib/gbrb/graphics/mode_clock.rb

@@ -0,0 +1,51 @@
+require_relative '../graphics'
+
+module GBRb::Graphics
+  module ModeClock
+    attr_reader :mode
+
+    def reset
+      @clock = 0
+      @mode = 2
+      self.line = 0
+    end
+
+    def update! time_increment
+      @clock += time_increment
+
+      case mode
+      when 2
+        if @clock >= 80
+          @clock = 0
+          @mode = 3
+        end
+      when 3
+        if @clock >= 172
+          @clock = 0
+          @mode = 0
+          render_scan_line
+        end
+      when 0
+        if @clock >= 204
+          @clock = 0
+          self.line = line.to_i + 1
+          if line == 144
+            @mode = 1
+            draw_frame_buffer
+          else
+            @mode = 2
+          end
+        end
+      when 1
+        if @clock >= 456
+          self.line = line +  1
+          @clock = 0
+         if line > 153
+           self.line = 0
+           @mode = 2
+         end
+        end
+      end
+    end
+  end
+end

data/lib/gbrb/graphics/screen_client.rb

@@ -0,0 +1,31 @@
+require_relative '../graphics'
+
+require 'socket'
+
+module GBRb::Graphics
+  class ScreenClient
+    def initialize
+      trap(:PIPE) { exit }
+      @connection = UNIXSocket.new SOCKET_PATH
+    rescue Errno::ECONNREFUSED
+      sleep 0.1
+      retry
+    end
+
+    def write data
+      @connection.write format data
+    end
+
+    def format data
+      raise WrongPixelCount unless data.length == HEIGHT and data.first.length == WIDTH
+
+      d = "P6 #{WIDTH} #{HEIGHT} #{MAX_COLOR} "
+      data.each do |row|
+        row.each do |pixel|
+          d << pixel.chr * 3
+        end
+      end
+      d << "\n"
+    end
+  end
+end

data/lib/gbrb/graphics/screen_server.rb

@@ -0,0 +1,90 @@
+require_relative '../graphics'
+
+require 'socket'
+
+module GBRb::Graphics
+  class ScreenServer
+    def initialize
+      @consumer, @producer = IO.pipe
+      create_server
+    end
+
+    def create_server
+      File.unlink SOCKET_PATH if File.exist? SOCKET_PATH
+      @server = UNIXServer.new SOCKET_PATH
+    end
+
+    def incoming_handler
+      @consumer.close
+      trap(:PIPE) { exit }
+      trap(:CHLD) { exit }
+      trap(:HUP)  { kill_window }
+      Socket.accept_loop(@server) do |connection|
+        loop do
+          request = connection.gets
+          @producer.write request if request
+        end
+      end
+    end
+
+    def tk_process
+      @producer.close
+
+      require 'tk'
+      require 'thread'
+
+      Thread.abort_on_exception = true
+
+      Window.new @consumer
+    end
+
+    def kill_window
+      Process.kill :HUP, @window_pid
+      Process.wait @window_pid
+    end
+
+    def power_on
+      @window_pid = fork { tk_process }
+      incoming_handler
+    end
+
+    private
+    class Window
+      def initialize incoming
+        tkroot = TkRoot.new do
+        title "GBRb"
+          resizable false, false
+        end
+
+        display = Display.new tkroot
+
+        Thread.new do
+          loop do
+            data = incoming.gets
+            begin
+              display.update_pixels data if data
+            rescue RuntimeError => e
+              next
+            end
+          end
+        end
+
+        tkroot.mainloop
+      end
+    end
+
+    class Display
+      def initialize root
+        @root = root
+        @display = TkPhotoImage.new
+        @label = TkLabel.new @root, image: @display
+        @label.pack
+      end
+
+      def update_pixels formatted_data
+        @label.configure(image: (TkPhotoImage.new data: formatted_data))
+      end
+    end
+  end
+end
+