psx 0.1.0

data/lib/psx/disasm.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+module PSX
+  module Disasm
+    REG_NAMES = %w[
+      zero at v0 v1 a0 a1 a2 a3
+      t0 t1 t2 t3 t4 t5 t6 t7
+      s0 s1 s2 s3 s4 s5 s6 s7
+      t8 t9 k0 k1 gp sp fp ra
+    ].freeze
+
+    COP0_NAMES = {
+      3 => "BPC", 5 => "BDA", 6 => "JUMPDEST", 7 => "DCIC",
+      8 => "BadVAddr", 9 => "BDAM", 11 => "BPCM", 12 => "SR",
+      13 => "CAUSE", 14 => "EPC", 15 => "PRId"
+    }.freeze
+
+    class << self
+      def disassemble(pc, instruction)
+        return format("%08X: %08X  nop", pc, instruction) if instruction == 0
+
+        opcode = (instruction >> 26) & 0x3F
+        text = decode(pc, instruction, opcode)
+        format("%08X: %08X  %s", pc, instruction, text)
+      end
+
+      private
+
+      def decode(pc, instruction, opcode)
+        case opcode
+        when 0x00 then decode_special(instruction)
+        when 0x01 then decode_bcondz(pc, instruction)
+        when 0x02 then decode_j("j", pc, instruction)
+        when 0x03 then decode_j("jal", pc, instruction)
+        when 0x04 then decode_branch("beq", pc, instruction)
+        when 0x05 then decode_branch("bne", pc, instruction)
+        when 0x06 then decode_branch_z("blez", pc, instruction)
+        when 0x07 then decode_branch_z("bgtz", pc, instruction)
+        when 0x08 then decode_imm_arith("addi", instruction)
+        when 0x09 then decode_imm_arith("addiu", instruction)
+        when 0x0A then decode_imm_arith("slti", instruction)
+        when 0x0B then decode_imm_arith("sltiu", instruction)
+        when 0x0C then decode_imm_logic("andi", instruction)
+        when 0x0D then decode_imm_logic("ori", instruction)
+        when 0x0E then decode_imm_logic("xori", instruction)
+        when 0x0F then decode_lui(instruction)
+        when 0x10 then decode_cop0(instruction)
+        when 0x12 then decode_cop2(instruction)
+        when 0x20 then decode_load("lb", instruction)
+        when 0x21 then decode_load("lh", instruction)
+        when 0x22 then decode_load("lwl", instruction)
+        when 0x23 then decode_load("lw", instruction)
+        when 0x24 then decode_load("lbu", instruction)
+        when 0x25 then decode_load("lhu", instruction)
+        when 0x26 then decode_load("lwr", instruction)
+        when 0x28 then decode_store("sb", instruction)
+        when 0x29 then decode_store("sh", instruction)
+        when 0x2A then decode_store("swl", instruction)
+        when 0x2B then decode_store("sw", instruction)
+        when 0x2E then decode_store("swr", instruction)
+        else
+          format("??? (op=%02X)", opcode)
+        end
+      end
+
+      def decode_special(instruction)
+        funct = instruction & 0x3F
+        rs = (instruction >> 21) & 0x1F
+        rt = (instruction >> 16) & 0x1F
+        rd = (instruction >> 11) & 0x1F
+        shamt = (instruction >> 6) & 0x1F
+
+        case funct
+        when 0x00 then format("sll %s, %s, %d", reg(rd), reg(rt), shamt)
+        when 0x02 then format("srl %s, %s, %d", reg(rd), reg(rt), shamt)
+        when 0x03 then format("sra %s, %s, %d", reg(rd), reg(rt), shamt)
+        when 0x04 then format("sllv %s, %s, %s", reg(rd), reg(rt), reg(rs))
+        when 0x06 then format("srlv %s, %s, %s", reg(rd), reg(rt), reg(rs))
+        when 0x07 then format("srav %s, %s, %s", reg(rd), reg(rt), reg(rs))
+        when 0x08 then format("jr %s", reg(rs))
+        when 0x09 then format("jalr %s, %s", reg(rd), reg(rs))
+        when 0x0C then "syscall"
+        when 0x0D then "break"
+        when 0x10 then format("mfhi %s", reg(rd))
+        when 0x11 then format("mthi %s", reg(rs))
+        when 0x12 then format("mflo %s", reg(rd))
+        when 0x13 then format("mtlo %s", reg(rs))
+        when 0x18 then format("mult %s, %s", reg(rs), reg(rt))
+        when 0x19 then format("multu %s, %s", reg(rs), reg(rt))
+        when 0x1A then format("div %s, %s", reg(rs), reg(rt))
+        when 0x1B then format("divu %s, %s", reg(rs), reg(rt))
+        when 0x20 then format("add %s, %s, %s", reg(rd), reg(rs), reg(rt))
+        when 0x21 then format("addu %s, %s, %s", reg(rd), reg(rs), reg(rt))
+        when 0x22 then format("sub %s, %s, %s", reg(rd), reg(rs), reg(rt))
+        when 0x23 then format("subu %s, %s, %s", reg(rd), reg(rs), reg(rt))
+        when 0x24 then format("and %s, %s, %s", reg(rd), reg(rs), reg(rt))
+        when 0x25 then format("or %s, %s, %s", reg(rd), reg(rs), reg(rt))
+        when 0x26 then format("xor %s, %s, %s", reg(rd), reg(rs), reg(rt))
+        when 0x27 then format("nor %s, %s, %s", reg(rd), reg(rs), reg(rt))
+        when 0x2A then format("slt %s, %s, %s", reg(rd), reg(rs), reg(rt))
+        when 0x2B then format("sltu %s, %s, %s", reg(rd), reg(rs), reg(rt))
+        else
+          format("??? (special funct=%02X)", funct)
+        end
+      end
+
+      def decode_bcondz(pc, instruction)
+        rs = (instruction >> 21) & 0x1F
+        rt = (instruction >> 16) & 0x1F
+        imm = instruction & 0xFFFF
+        offset = sign_extend16(imm) << 2
+        target = (pc + 4 + offset) & 0xFFFF_FFFF
+
+        link = (rt & 0x10) != 0
+        bgez = (rt & 0x01) != 0
+
+        name = if bgez
+          link ? "bgezal" : "bgez"
+        else
+          link ? "bltzal" : "bltz"
+        end
+
+        format("%s %s, 0x%08X", name, reg(rs), target)
+      end
+
+      def decode_j(name, pc, instruction)
+        target = instruction & 0x03FF_FFFF
+        addr = ((pc + 4) & 0xF000_0000) | (target << 2)
+        format("%s 0x%08X", name, addr)
+      end
+
+      def decode_branch(name, pc, instruction)
+        rs = (instruction >> 21) & 0x1F
+        rt = (instruction >> 16) & 0x1F
+        imm = instruction & 0xFFFF
+        offset = sign_extend16(imm) << 2
+        target = (pc + 4 + offset) & 0xFFFF_FFFF
+        format("%s %s, %s, 0x%08X", name, reg(rs), reg(rt), target)
+      end
+
+      def decode_branch_z(name, pc, instruction)
+        rs = (instruction >> 21) & 0x1F
+        imm = instruction & 0xFFFF
+        offset = sign_extend16(imm) << 2
+        target = (pc + 4 + offset) & 0xFFFF_FFFF
+        format("%s %s, 0x%08X", name, reg(rs), target)
+      end
+
+      def decode_imm_arith(name, instruction)
+        rs = (instruction >> 21) & 0x1F
+        rt = (instruction >> 16) & 0x1F
+        imm = sign_extend16(instruction & 0xFFFF)
+        format("%s %s, %s, %d", name, reg(rt), reg(rs), imm)
+      end
+
+      def decode_imm_logic(name, instruction)
+        rs = (instruction >> 21) & 0x1F
+        rt = (instruction >> 16) & 0x1F
+        imm = instruction & 0xFFFF
+        format("%s %s, %s, 0x%04X", name, reg(rt), reg(rs), imm)
+      end
+
+      def decode_lui(instruction)
+        rt = (instruction >> 16) & 0x1F
+        imm = instruction & 0xFFFF
+        format("lui %s, 0x%04X", reg(rt), imm)
+      end
+
+      def decode_load(name, instruction)
+        rs = (instruction >> 21) & 0x1F
+        rt = (instruction >> 16) & 0x1F
+        imm = sign_extend16(instruction & 0xFFFF)
+        format("%s %s, %d(%s)", name, reg(rt), imm, reg(rs))
+      end
+
+      def decode_store(name, instruction)
+        rs = (instruction >> 21) & 0x1F
+        rt = (instruction >> 16) & 0x1F
+        imm = sign_extend16(instruction & 0xFFFF)
+        format("%s %s, %d(%s)", name, reg(rt), imm, reg(rs))
+      end
+
+      def decode_cop0(instruction)
+        cop_op = (instruction >> 21) & 0x1F
+        rt = (instruction >> 16) & 0x1F
+        rd = (instruction >> 11) & 0x1F
+
+        case cop_op
+        when 0x00 then format("mfc0 %s, %s", reg(rt), cop0_reg(rd))
+        when 0x04 then format("mtc0 %s, %s", reg(rt), cop0_reg(rd))
+        when 0x10 then "rfe"
+        else
+          format("cop0 (op=%02X)", cop_op)
+        end
+      end
+
+      def decode_cop2(instruction)
+        cop_op = (instruction >> 21) & 0x1F
+        rt = (instruction >> 16) & 0x1F
+        rd = (instruction >> 11) & 0x1F
+
+        case cop_op
+        when 0x00 then format("mfc2 %s, $%d", reg(rt), rd)
+        when 0x02 then format("cfc2 %s, $%d", reg(rt), rd)
+        when 0x04 then format("mtc2 %s, $%d", reg(rt), rd)
+        when 0x06 then format("ctc2 %s, $%d", reg(rt), rd)
+        else
+          cmd = instruction & 0x1FF_FFFF
+          format("cop2 cmd=0x%07X", cmd)
+        end
+      end
+
+      def reg(n)
+        "$#{REG_NAMES[n]}"
+      end
+
+      def cop0_reg(n)
+        COP0_NAMES[n] || "$#{n}"
+      end
+
+      def sign_extend16(val)
+        (val & 0x8000) != 0 ? (val - 0x1_0000) : val
+      end
+    end
+  end
+end

data/lib/psx/display.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+require "sdl2"
+
+module PSX
+  class Display
+    WIDTH = 320
+    HEIGHT = 240
+    SCALE = 2  # 640x480 window
+
+    def initialize(title: "PSX-Ruby")
+      SDL2.init(SDL2::INIT_VIDEO)
+
+      @window = SDL2::Window.create(
+        title,
+        SDL2::Window::POS_CENTERED,
+        SDL2::Window::POS_CENTERED,
+        WIDTH * SCALE,
+        HEIGHT * SCALE,
+        0
+      )
+
+      @renderer = @window.create_renderer(-1, SDL2::Renderer::Flags::ACCELERATED)
+
+      # Input state
+      @quit_requested = false
+      @controller_state = 0xFFFF  # All buttons released (active low)
+
+      # Performance tracking
+      @frame_count = 0
+      @last_fps_time = Time.now
+      @fps = 0
+
+      # Cache texture reference
+      @texture = nil
+
+      # Pre-allocated RGBA buffer (320x240x4 = 307,200 bytes)
+      @rgba_buffer = "\x00".b * (WIDTH * HEIGHT * 4)
+      @rgba_buffer_size = WIDTH * HEIGHT * 4
+
+      # Track if we've seen real content
+      @has_rendered_content = false
+    end
+
+    def update(framebuffer)
+      width = framebuffer[:width]
+      height = framebuffer[:height]
+
+      # GPU now provides pre-packed RGBA string
+      rgba = framebuffer[:rgba]
+
+      # Check if framebuffer has any non-zero content (only until first content seen)
+      if rgba && !@has_rendered_content
+        # Quick check: sample a few bytes instead of iterating all
+        has_content = rgba.getbyte(0) != 0 || rgba.getbyte(rgba.bytesize / 2) != 0
+        @has_rendered_content = true if has_content
+      end
+
+      if rgba && @has_rendered_content
+        @rgba_buffer = rgba
+      else
+        # Use cached loading screen if size matches
+        buffer_size = width * height * 4
+        if @loading_screen_size != buffer_size
+          # Generate loading screen pattern once
+          rgba_arr = []
+          height.times do |y|
+            width.times do |x|
+              if (x % 32 < 2) || (y % 32 < 2)
+                rgba_arr.push(40, 40, 80, 255)  # Grid lines
+              else
+                rgba_arr.push(0, 0, 40, 255)    # Dark blue
+              end
+            end
+          end
+          @loading_screen = rgba_arr.pack("C*")
+          @loading_screen_size = buffer_size
+        end
+        @rgba_buffer = @loading_screen
+      end
+
+      # Create SDL surface from RGBA data
+      surface = SDL2::Surface.from_string(
+        @rgba_buffer,
+        width,
+        height,
+        32,           # depth (bits per pixel)
+        width * 4,    # pitch (bytes per row)
+        0x000000FF,   # R mask
+        0x0000FF00,   # G mask
+        0x00FF0000,   # B mask
+        0xFF000000    # A mask
+      )
+
+      # Create texture from surface
+      @texture&.destroy
+      @texture = @renderer.create_texture_from(surface)
+      surface.destroy
+
+      # Render (stretch to window size)
+      @renderer.copy(@texture, nil, nil)
+      @renderer.present
+
+      # Update FPS counter
+      @frame_count += 1
+      @total_frames = (@total_frames || 0) + 1
+      now = Time.now
+      elapsed = now - @last_fps_time
+      if elapsed >= 1.0
+        @fps = (@frame_count / elapsed).round(1)
+        status = has_content ? "RENDERING" : "Loading..."
+        @window.title = "PSX-Ruby - #{@fps} FPS - Frame #{@total_frames} - #{status}"
+        @frame_count = 0
+        @last_fps_time = now
+      end
+    end
+
+    def poll_events
+      while (event = SDL2::Event.poll)
+        case event
+        when SDL2::Event::Quit
+          @quit_requested = true
+        when SDL2::Event::KeyDown
+          handle_key(event.scancode, true)
+        when SDL2::Event::KeyUp
+          handle_key(event.scancode, false)
+        end
+      end
+    end
+
+    def quit_requested?
+      @quit_requested
+    end
+
+    def controller_state
+      @controller_state
+    end
+
+    def close
+      @texture&.destroy
+      @renderer.destroy
+      @window.destroy
+    end
+
+    private
+
+    # PS1 controller button bits
+    BUTTON_SELECT   = 0
+    BUTTON_L3       = 1
+    BUTTON_R3       = 2
+    BUTTON_START    = 3
+    BUTTON_UP       = 4
+    BUTTON_RIGHT    = 5
+    BUTTON_DOWN     = 6
+    BUTTON_LEFT     = 7
+    BUTTON_L2       = 8
+    BUTTON_R2       = 9
+    BUTTON_L1       = 10
+    BUTTON_R1       = 11
+    BUTTON_TRIANGLE = 12
+    BUTTON_CIRCLE   = 13
+    BUTTON_CROSS    = 14
+    BUTTON_SQUARE   = 15
+
+    # Keyboard to controller mapping
+    KEY_MAP = {
+      SDL2::Key::Scan::UP => BUTTON_UP,
+      SDL2::Key::Scan::DOWN => BUTTON_DOWN,
+      SDL2::Key::Scan::LEFT => BUTTON_LEFT,
+      SDL2::Key::Scan::RIGHT => BUTTON_RIGHT,
+      SDL2::Key::Scan::Z => BUTTON_CROSS,
+      SDL2::Key::Scan::X => BUTTON_CIRCLE,
+      SDL2::Key::Scan::A => BUTTON_SQUARE,
+      SDL2::Key::Scan::S => BUTTON_TRIANGLE,
+      SDL2::Key::Scan::RETURN => BUTTON_START,
+      SDL2::Key::Scan::SPACE => BUTTON_SELECT,
+      SDL2::Key::Scan::Q => BUTTON_L1,
+      SDL2::Key::Scan::W => BUTTON_R1,
+      SDL2::Key::Scan::E => BUTTON_L2,
+      SDL2::Key::Scan::R => BUTTON_R2
+    }.freeze
+
+    def handle_key(scancode, pressed)
+      # Handle quit on Escape
+      if scancode == SDL2::Key::Scan::ESCAPE && pressed
+        @quit_requested = true
+        return
+      end
+
+      button = KEY_MAP[scancode]
+      return unless button
+
+      if pressed
+        @controller_state &= ~(1 << button)  # Active low
+      else
+        @controller_state |= (1 << button)
+      end
+    end
+  end
+end