ruby_rpg 0.0.4 → 0.1.0

data/lib/engine/input.rb

@@ -2,6 +2,113 @@
 
 module Engine
   class Input
+    # Key action constants
+    RELEASE = 0
+    PRESS = 1
+    REPEAT = 2
+
+    # Keyboard keys
+    KEY_SPACE = 32
+    KEY_APOSTROPHE = 39
+    KEY_COMMA = 44
+    KEY_MINUS = 45
+    KEY_PERIOD = 46
+    KEY_SLASH = 47
+    KEY_0 = 48
+    KEY_1 = 49
+    KEY_2 = 50
+    KEY_3 = 51
+    KEY_4 = 52
+    KEY_5 = 53
+    KEY_6 = 54
+    KEY_7 = 55
+    KEY_8 = 56
+    KEY_9 = 57
+    KEY_SEMICOLON = 59
+    KEY_EQUAL = 61
+    KEY_A = 65
+    KEY_B = 66
+    KEY_C = 67
+    KEY_D = 68
+    KEY_E = 69
+    KEY_F = 70
+    KEY_G = 71
+    KEY_H = 72
+    KEY_I = 73
+    KEY_J = 74
+    KEY_K = 75
+    KEY_L = 76
+    KEY_M = 77
+    KEY_N = 78
+    KEY_O = 79
+    KEY_P = 80
+    KEY_Q = 81
+    KEY_R = 82
+    KEY_S = 83
+    KEY_T = 84
+    KEY_U = 85
+    KEY_V = 86
+    KEY_W = 87
+    KEY_X = 88
+    KEY_Y = 89
+    KEY_Z = 90
+    KEY_LEFT_BRACKET = 91
+    KEY_BACKSLASH = 92
+    KEY_RIGHT_BRACKET = 93
+    KEY_GRAVE_ACCENT = 96
+    KEY_ESCAPE = 256
+    KEY_ENTER = 257
+    KEY_TAB = 258
+    KEY_BACKSPACE = 259
+    KEY_INSERT = 260
+    KEY_DELETE = 261
+    KEY_RIGHT = 262
+    KEY_LEFT = 263
+    KEY_DOWN = 264
+    KEY_UP = 265
+    KEY_PAGE_UP = 266
+    KEY_PAGE_DOWN = 267
+    KEY_HOME = 268
+    KEY_END = 269
+    KEY_CAPS_LOCK = 280
+    KEY_SCROLL_LOCK = 281
+    KEY_NUM_LOCK = 282
+    KEY_PRINT_SCREEN = 283
+    KEY_PAUSE = 284
+    KEY_F1 = 290
+    KEY_F2 = 291
+    KEY_F3 = 292
+    KEY_F4 = 293
+    KEY_F5 = 294
+    KEY_F6 = 295
+    KEY_F7 = 296
+    KEY_F8 = 297
+    KEY_F9 = 298
+    KEY_F10 = 299
+    KEY_F11 = 300
+    KEY_F12 = 301
+    KEY_LEFT_SHIFT = 340
+    KEY_LEFT_CONTROL = 341
+    KEY_LEFT_ALT = 342
+    KEY_LEFT_SUPER = 343
+    KEY_RIGHT_SHIFT = 344
+    KEY_RIGHT_CONTROL = 345
+    KEY_RIGHT_ALT = 346
+    KEY_RIGHT_SUPER = 347
+
+    # Mouse buttons
+    MOUSE_BUTTON_1 = 0
+    MOUSE_BUTTON_2 = 1
+    MOUSE_BUTTON_3 = 2
+    MOUSE_BUTTON_4 = 3
+    MOUSE_BUTTON_5 = 4
+    MOUSE_BUTTON_6 = 5
+    MOUSE_BUTTON_7 = 6
+    MOUSE_BUTTON_8 = 7
+    MOUSE_BUTTON_LEFT = MOUSE_BUTTON_1
+    MOUSE_BUTTON_RIGHT = MOUSE_BUTTON_2
+    MOUSE_BUTTON_MIDDLE = MOUSE_BUTTON_3
+
     def self.init
       @key_callback = GLFW::create_callback(:GLFWkeyfun) do |window, key, scancode, action, mods|
         Input.key_callback(key, action)
@@ -44,16 +151,16 @@ module Engine
 
     def self._on_key_down(key)
       keys[key] = :down
-      if key == GLFW::KEY_ESCAPE
+      if key == KEY_ESCAPE
         Engine.close
       end
 
-      if key == GLFW::KEY_BACKSPACE
+      if key == KEY_BACKSPACE
         Engine::Debugging.breakpoint { binding.pry }
         # Engine.breakpoint { debugger }
       end
 
-      if key == GLFW::KEY_F
+      if key == KEY_F
         Engine::Window.toggle_full_screen
       end
     end
@@ -63,9 +170,9 @@ module Engine
     end
 
     def self.key_callback(key, action)
-      if action == GLFW::PRESS
+      if action == PRESS
         _on_key_down(key)
-      elsif action == GLFW::RELEASE
+      elsif action == RELEASE
         _on_key_up(key)
       end
     end
@@ -73,13 +180,14 @@ module Engine
     def self.mouse_callback(x, y)
       @mouse_pos_updated = true
       @old_mouse_pos = @mouse_pos
+      # Y-down coordinate system: use GLFW y directly
       @mouse_pos = Vector[x, y]
     end
 
     def self.mouse_button_callback(button, action)
-      if action == GLFW::PRESS
+      if action == PRESS
         keys[button] = :down
-      elsif action == GLFW::RELEASE
+      elsif action == RELEASE
         keys[button] = :up
       end
     end

data/lib/engine/material.rb

@@ -2,16 +2,52 @@
 
 module Engine
   class Material
+    include Serializable
+
+    serialize :shader, :floats, :ints, :vec2s, :vec3s, :vec4s, :mat4s, :textures
+
+    # Cache texture slot constants to avoid const_get every frame
+    TEXTURE_SLOTS = Array.new(32) { |i| Object.const_get("Engine::GL::TEXTURE#{i}") }
+
+    def self.bind_texture(slot, target, texture_id)
+      Engine::GL.ActiveTexture(TEXTURE_SLOTS[slot])
+      Engine::GL.BindTexture(target, texture_id)
+    end
+
     attr_reader :shader
 
-    def initialize(shader)
-      @shader = shader
+    def self.default_white_texture
+      @default_white_texture ||= create_1x1_texture(255, 255, 255, 255)
+    end
+
+    def self.default_normal_texture
+      @default_normal_texture ||= create_1x1_texture(128, 128, 255, 255)
+    end
+
+    def self.default_black_texture
+      @default_black_texture ||= create_1x1_texture(0, 0, 0, 255)
+    end
+
+    def self.create_1x1_texture(r, g, b, a)
+      tex = ' ' * 4
+      Engine::GL.GenTextures(1, tex)
+      texture_id = tex.unpack('L')[0]
+      Engine::GL.BindTexture(Engine::GL::TEXTURE_2D, texture_id)
+      pixel = [r, g, b, a].pack('C*')
+      Engine::GL.TexImage2D(Engine::GL::TEXTURE_2D, 0, Engine::GL::RGBA, 1, 1, 0, Engine::GL::RGBA, Engine::GL::UNSIGNED_BYTE, pixel)
+      Engine::GL.TexParameteri(Engine::GL::TEXTURE_2D, Engine::GL::TEXTURE_MIN_FILTER, Engine::GL::NEAREST)
+      Engine::GL.TexParameteri(Engine::GL::TEXTURE_2D, Engine::GL::TEXTURE_MAG_FILTER, Engine::GL::NEAREST)
+      texture_id
     end
 
     def set_mat4(name, value)
       mat4s[name] = value
     end
 
+    def set_vec2(name, value)
+      vec2s[name] = value
+    end
+
     def set_vec3(name, value)
       vec3s[name] = value
     end
@@ -24,8 +60,30 @@ module Engine
       floats[name] = value
     end
 
-    def set_texture(name, value)
-      textures[name] = value
+    def set_int(name, value)
+      ints[name] = value
+    end
+
+    def set_texture(name, texture)
+      textures[name] = texture
+    end
+
+    # TODO: Runtime textures are not serializable. We need to revisit this
+    # to make render targets serializable or find another approach.
+    def set_runtime_texture(name, gl_id)
+      runtime_textures[name] = gl_id
+    end
+
+    def set_cubemap(name, value)
+      cubemaps[name] = value
+    end
+
+    def set_texture_array(name, value)
+      texture_arrays[name] = value
+    end
+
+    def set_cubemap_array(name, value)
+      cubemap_arrays[name] = value
     end
 
     def update_shader
@@ -34,6 +92,9 @@ module Engine
       mat4s.each do |name, value|
         shader.set_mat4(name, value)
       end
+      vec2s.each do |name, value|
+        shader.set_vec2(name, value)
+      end
       vec3s.each do |name, value|
         shader.set_vec3(name, value)
       end
@@ -43,23 +104,77 @@ module Engine
       floats.each do |name, value|
         shader.set_float(name, value)
       end
-      textures.each.with_index do |(name, value), slot|
-        GL.ActiveTexture(Object.const_get("GL::TEXTURE#{slot}"))
-        if value
-          GL.BindTexture(GL::TEXTURE_2D, value)
-        else
-          GL.BindTexture(GL::TEXTURE_2D, 0)
-        end
+      ints.each do |name, value|
+        shader.set_int(name, value)
+      end
+      # Start with shader's expected textures (defaulting to nil for fallbacks)
+      expected = shader.expected_textures.each_with_object({}) { |name, h| h[name] = nil }
+      all_textures = expected.merge(textures).merge(runtime_textures)
+      all_textures.each.with_index do |(name, value), slot|
+        texture_id = if value.is_a?(Texture)
+                       value.texture
+                     elsif value
+                       value
+                     else
+                       fallback_texture_for(name)
+                     end
+        Material.bind_texture(slot, Engine::GL::TEXTURE_2D, texture_id)
+        shader.set_int(name, slot)
+      end
+
+      # Cubemaps start after regular textures
+      cubemap_start_slot = all_textures.size
+      cubemaps.each.with_index do |(name, value), i|
+        slot = cubemap_start_slot + i
+        texture_id = value || fallback_cubemap_for(name)
+        Material.bind_texture(slot, Engine::GL::TEXTURE_CUBE_MAP, texture_id)
+        shader.set_int(name, slot)
+      end
+
+      # Texture arrays start after cubemaps
+      texture_array_start_slot = cubemap_start_slot + cubemaps.size
+      texture_arrays.each.with_index do |(name, value), i|
+        slot = texture_array_start_slot + i
+        Material.bind_texture(slot, Engine::GL::TEXTURE_2D_ARRAY, value || 0)
+        shader.set_int(name, slot)
+      end
+
+      # Cubemap arrays start after texture arrays
+      cubemap_array_start_slot = texture_array_start_slot + texture_arrays.size
+      cubemap_arrays.each.with_index do |(name, value), i|
+        slot = cubemap_array_start_slot + i
+        Material.bind_texture(slot, Engine::GL::TEXTURE_CUBE_MAP_ARRAY, value || 0)
         shader.set_int(name, slot)
       end
     end
 
     private
 
+    def fallback_texture_for(name)
+      case shader.texture_fallback(name)
+      when :normal then self.class.default_normal_texture
+      when :black then self.class.default_black_texture
+      else self.class.default_white_texture
+      end
+    end
+
+    def fallback_cubemap_for(name)
+      case shader.cubemap_fallback(name)
+      when :skybox
+        Rendering::RenderPipeline.skybox_cubemap&.texture || 0
+      else
+        0
+      end
+    end
+
     def mat4s
       @mat4s ||= {}
     end
 
+    def vec2s
+      @vec2s ||= {}
+    end
+
     def vec3s
       @vec3s ||= {}
     end
@@ -72,8 +187,28 @@ module Engine
       @floats ||= {}
     end
 
+    def ints
+      @ints ||= {}
+    end
+
     def textures
       @textures ||= {}
     end
+
+    def runtime_textures
+      @runtime_textures ||= {}
+    end
+
+    def cubemaps
+      @cubemaps ||= {}
+    end
+
+    def texture_arrays
+      @texture_arrays ||= {}
+    end
+
+    def cubemap_arrays
+      @cubemap_arrays ||= {}
+    end
   end
 end

data/lib/engine/matrix_helpers.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Engine
+  module MatrixHelpers
+    def look_at(eye, center, up)
+      f = (center - eye).normalize
+      s = f.cross(up).normalize
+      u = s.cross(f)
+
+      Matrix[
+        [s[0], s[1], s[2], -s.dot(eye)],
+        [u[0], u[1], u[2], -u.dot(eye)],
+        [-f[0], -f[1], -f[2], f.dot(eye)],
+        [0, 0, 0, 1]
+      ]
+    end
+
+    def perspective(fov, aspect, near, far)
+      tan_half_fov = Math.tan(fov / 2.0)
+
+      Matrix[
+        [1.0 / (aspect * tan_half_fov), 0, 0, 0],
+        [0, 1.0 / tan_half_fov, 0, 0],
+        [0, 0, -(far + near) / (far - near), -(2.0 * far * near) / (far - near)],
+        [0, 0, -1, 0]
+      ]
+    end
+
+    def ortho(left, right, bottom, top, near, far)
+      Matrix[
+        [2.0 / (right - left), 0, 0, -(right + left) / (right - left)],
+        [0, 2.0 / (top - bottom), 0, -(top + bottom) / (top - bottom)],
+        [0, 0, -2.0 / (far - near), -(far + near) / (far - near)],
+        [0, 0, 0, 1]
+      ]
+    end
+  end
+end

data/lib/engine/mesh.rb

@@ -2,42 +2,67 @@
 
 module Engine
   class Mesh
-    attr_reader :vertex_data, :index_data
-    private_class_method :new
+    include Serializable
 
-    def initialize(mesh_file)
-      @vertex_data = Mesh.open_vertex(mesh_file)
-      @index_data = Mesh.open_index(mesh_file)
+    attr_reader :mesh_file, :source
+
+    def self.from_serializable_data(data)
+      self.for(data[:mesh_file], source: (data[:source] || :game).to_sym)
+    end
+
+    def serializable_data
+      { mesh_file: @mesh_file, source: @source }
+    end
+
+    def vertex_data
+      @vertex_data ||= Mesh.load_vertex(base_path)
+    end
+
+    def index_data
+      @index_data ||= Mesh.load_index(base_path)
     end
 
-    def self.for(mesh_file)
-      mesh_cache[mesh_file]
+    def self.for(mesh_file, source: :game)
+      cache_key = [mesh_file, source]
+      mesh_cache[cache_key] ||= create(mesh_file: mesh_file, source: source)
     end
 
     def self.mesh_cache
-      @mesh_cache ||= Hash.new do |hash, key|
-        hash[key] = new(key)
-      end
+      @mesh_cache ||= {}
     end
 
-    def self.open_vertex(mesh_file)
-      vertex_cache[File.join(GAME_DIR, "_imported", mesh_file + ".vertex_data")]
+    def self.load_vertex(base_path)
+      vertex_cache[base_path + ".vertex_data"]
     end
 
     def self.vertex_cache
-      @index_data_cache ||= Hash.new do |hash, key|
+      @vertex_cache ||= Hash.new do |hash, key|
         hash[key] = File.readlines(key).reject{|l| l == ""}.map(&:to_f)
       end
     end
 
-    def self.open_index(mesh_file)
-      index_cache[File.join(GAME_DIR, "_imported", mesh_file + ".index_data")]
+    def self.load_index(base_path)
+      index_cache[base_path + ".index_data"]
     end
 
     def self.index_cache
-      @index_data_cache ||= Hash.new do |hash, key|
+      @index_cache ||= Hash.new do |hash, key|
         hash[key] = File.readlines(key).reject{|l| l == ""}.map(&:to_i)
       end
     end
+
+    def self.quad
+      @quad ||= QuadMesh.new
+    end
+
+    private
+
+    def base_path
+      @base_path ||= if @source == :engine
+        File.join(ENGINE_DIR, "assets", "_imported", @mesh_file)
+      else
+        File.join(GAME_DIR, "_imported", @mesh_file)
+      end
+    end
   end
 end

data/lib/engine/metal/compute_shader.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require_relative 'device'
+
+module Engine
+  module Metal
+    class ComputeShader
+      include Fiddle
+
+      def initialize(shader_path)
+        @device = Device.instance
+        @uniform_buffer_data = {}
+
+        path = File.expand_path(File.join(GAME_DIR, shader_path))
+        source = File.read(path)
+
+        @library = @device.new_library_with_source(source)
+        @pipeline = @device.new_compute_pipeline(@library, 'computeMain')
+
+        # Get thread execution width for optimal dispatch
+        @thread_width = ObjC.msg(@pipeline, 'threadExecutionWidth').to_i
+        @thread_height = ObjC.msg(@pipeline, 'maxTotalThreadsPerThreadgroup').to_i / @thread_width
+      end
+
+      def dispatch(width, height, depth, textures: [], floats: {}, ints: {})
+        command_buffer = @device.new_command_buffer
+        encoder = ObjC.msg(command_buffer, 'computeCommandEncoder')
+
+        # Set the pipeline state
+        ObjC.msg(encoder, 'setComputePipelineState:', @pipeline)
+
+        # Set textures (extract metal_texture from ComputeTexture objects)
+        textures.each_with_index do |texture, index|
+          next if texture.nil?
+          metal_tex = texture.respond_to?(:metal_texture) ? texture.metal_texture : texture
+          ObjC.msg(encoder, 'setTexture:atIndex:', metal_tex, index)
+        end
+
+        # Create uniform buffer with floats and ints
+        if floats.any? || ints.any?
+          uniform_data = create_uniform_buffer(floats, ints)
+          uniform_buffer = create_metal_buffer(uniform_data)
+          ObjC.msg(encoder, 'setBuffer:offset:atIndex:', uniform_buffer, 0, 0)
+        end
+
+        # Calculate thread groups
+        # Use dispatchThreads for simpler dispatch (Metal 2.0+)
+        threads = create_mtl_size_ptr(width, height, depth)
+        threads_per_group = create_mtl_size_ptr(@thread_width, @thread_height, 1)
+
+        # Use objc_msgSend_stret variant for struct-passing methods
+        dispatch_threads(encoder, threads, threads_per_group)
+
+        ObjC.msg(encoder, 'endEncoding')
+        ObjC.msg(command_buffer, 'commit')
+        ObjC.msg(command_buffer, 'waitUntilCompleted')
+
+        # Sync textures to make results available for OpenGL rendering
+        textures.each { |tex| tex.sync if tex.respond_to?(:sync) }
+      end
+
+      private
+
+      def create_uniform_buffer(floats, ints)
+        # Pack uniforms into a byte buffer
+        # Layout: all floats first, then ints (aligned to 4 bytes)
+        data = []
+        floats.each_value { |v| data.concat([v].pack('f').bytes) }
+        ints.each_value { |v| data.concat([v].pack('i').bytes) }
+        data.pack('C*')
+      end
+
+      def create_metal_buffer(data)
+        data_ptr = Pointer[data]
+        ObjC.msg(
+          @device.device,
+          'newBufferWithBytes:length:options:',
+          data_ptr,
+          data.bytesize,
+          0 # MTLResourceStorageModeShared
+        )
+      end
+
+      def create_mtl_size_ptr(width, height, depth)
+        # MTLSize is a struct { width, height, depth } - 3 NSUInteger (64-bit each)
+        data = [width, height, depth].pack('Q3')
+        ptr = Pointer.malloc(24)
+        ptr[0, 24] = data
+        ptr
+      end
+
+      def dispatch_threads(encoder, threads, threads_per_group)
+        # dispatchThreads:threadsPerThreadgroup: passes MTLSize structs
+        # On ARM64, structs > 16 bytes are passed by pointer in x8
+        # We need to use objc_msgSend directly with proper calling convention
+
+        sel = ObjC.sel('dispatchThreads:threadsPerThreadgroup:')
+
+        # Build a function that takes the struct values directly
+        # ARM64 ABI: first 8 args in x0-x7, structs by value if <= 16 bytes, else by pointer
+        # MTLSize is 24 bytes, so passed by pointer
+
+        func = Fiddle::Function.new(
+          ObjC::OBJC_MSGSEND_ADDR,
+          [
+            Fiddle::TYPE_VOIDP,  # self (encoder)
+            Fiddle::TYPE_VOIDP,  # _cmd (selector)
+            Fiddle::TYPE_VOIDP,  # threads (pointer to MTLSize)
+            Fiddle::TYPE_VOIDP   # threadsPerThreadgroup (pointer to MTLSize)
+          ],
+          Fiddle::TYPE_VOID
+        )
+
+        func.call(encoder, sel, threads, threads_per_group)
+      end
+    end
+  end
+end