ruby_rpg 0.0.5 → 0.1.0

data/lib/engine/importers/obj_importer.rb

@@ -1,33 +1,33 @@
-# frozen_string_literal: true
-
-module Engine
-  class ObjImporter
-    attr_reader :source, :destination_vertex, :destination_index
-
-    def initialize(source, destination_vertex, destination_index)
-      @source = source
-      @destination_vertex = destination_vertex
-      @destination_index = destination_index
-    end
-
-    def import
-      obj_file = Engine::ObjFile.new(source)
-
-      vertex_data = obj_file.vertex_data
-
-      FileUtils.mkdir_p(File.dirname(destination_vertex)) unless File.exist?(destination_vertex)
-      File.delete(destination_vertex) if File.exist?(destination_vertex)
-      File.open(destination_vertex, "w") do |file|
-        vertex_data.each { |d| file.puts d }
-      end
-
-      index_data = obj_file.index_data
-
-      FileUtils.mkdir_p(File.dirname(destination_index)) unless File.exist?(destination_index)
-      File.delete(destination_index) if File.exist?(destination_index)
-      File.open(destination_index, "w") do |file|
-        index_data.each { |i| file.puts i }
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Engine
+  class ObjImporter
+    attr_reader :source, :destination_vertex, :destination_index
+
+    def initialize(source, destination_vertex, destination_index)
+      @source = source
+      @destination_vertex = destination_vertex
+      @destination_index = destination_index
+    end
+
+    def import
+      obj_file = Engine::ObjFile.new(source)
+
+      vertex_data = obj_file.vertex_data
+
+      FileUtils.mkdir_p(File.dirname(destination_vertex)) unless File.exist?(destination_vertex)
+      File.delete(destination_vertex) if File.exist?(destination_vertex)
+      File.open(destination_vertex, "w") do |file|
+        vertex_data.each { |d| file.puts d }
+      end
+
+      index_data = obj_file.index_data
+
+      FileUtils.mkdir_p(File.dirname(destination_index)) unless File.exist?(destination_index)
+      File.delete(destination_index) if File.exist?(destination_index)
+      File.open(destination_index, "w") do |file|
+        index_data.each { |i| file.puts i }
+      end
+    end
+  end
+end

data/lib/engine/input.rb

@@ -1,105 +1,212 @@
-# frozen_string_literal: true
-
-module Engine
-  class Input
-    def self.init
-      @key_callback = GLFW::create_callback(:GLFWkeyfun) do |window, key, scancode, action, mods|
-        Input.key_callback(key, action)
-      end
-      GLFW.SetKeyCallback(Window.window, @key_callback)
-
-      @cursor_pos_callback = GLFW::create_callback(:GLFWcursorposfun) do |window, x, y|
-        Input.mouse_callback(x, y)
-      end
-      GLFW.SetCursorPosCallback(Window.window, @cursor_pos_callback)
-
-      @mouse_button_callback = GLFW::create_callback(:GLFWmousebuttonfun) do |window, button, action, mods|
-        Input.mouse_button_callback(button, action)
-      end
-      GLFW.SetMouseButtonCallback(Window.window, @mouse_button_callback)
-    end
-
-    def self.key?(key)
-      keys[key] == :down || keys[key] == :held
-    end
-
-    def self.key_down?(key)
-      keys[key] == :down
-    end
-
-    def self.key_up?(key)
-      keys[key] == :up
-    end
-
-    def self.mouse_pos
-      @mouse_pos
-    end
-
-    def self.mouse_delta
-      return Vector[0, 0] if @old_mouse_pos.nil?
-      return Vector[0, 0] unless @mouse_pos_updated
-
-      @mouse_pos - @old_mouse_pos
-    end
-
-    def self._on_key_down(key)
-      keys[key] = :down
-      if key == GLFW::KEY_ESCAPE
-        Engine.close
-      end
-
-      if key == GLFW::KEY_BACKSPACE
-        Engine::Debugging.breakpoint { binding.pry }
-        # Engine.breakpoint { debugger }
-      end
-
-      if key == GLFW::KEY_F
-        Engine::Window.toggle_full_screen
-      end
-    end
-
-    def self._on_key_up(key)
-      keys[key] = :up
-    end
-
-    def self.key_callback(key, action)
-      if action == GLFW::PRESS
-        _on_key_down(key)
-      elsif action == GLFW::RELEASE
-        _on_key_up(key)
-      end
-    end
-
-    def self.mouse_callback(x, y)
-      @mouse_pos_updated = true
-      @old_mouse_pos = @mouse_pos
-      screen_height = Window.height
-      @mouse_pos = Vector[x, screen_height - y]
-    end
-
-    def self.mouse_button_callback(button, action)
-      if action == GLFW::PRESS
-        keys[button] = :down
-      elsif action == GLFW::RELEASE
-        keys[button] = :up
-      end
-    end
-
-    def self.update_key_states
-      @mouse_pos_updated = false
-      keys.each do |key, state|
-        if state == :down
-          keys[key] = :held
-        elsif state == :up
-          keys.delete(key)
-        end
-      end
-    end
-
-    private
-
-    def self.keys
-      @keys ||= {}
-    end
-  end
-end
+# frozen_string_literal: true
+
+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)
+      end
+      GLFW.SetKeyCallback(Window.window, @key_callback)
+
+      @cursor_pos_callback = GLFW::create_callback(:GLFWcursorposfun) do |window, x, y|
+        Input.mouse_callback(x, y)
+      end
+      GLFW.SetCursorPosCallback(Window.window, @cursor_pos_callback)
+
+      @mouse_button_callback = GLFW::create_callback(:GLFWmousebuttonfun) do |window, button, action, mods|
+        Input.mouse_button_callback(button, action)
+      end
+      GLFW.SetMouseButtonCallback(Window.window, @mouse_button_callback)
+    end
+
+    def self.key?(key)
+      keys[key] == :down || keys[key] == :held
+    end
+
+    def self.key_down?(key)
+      keys[key] == :down
+    end
+
+    def self.key_up?(key)
+      keys[key] == :up
+    end
+
+    def self.mouse_pos
+      @mouse_pos
+    end
+
+    def self.mouse_delta
+      return Vector[0, 0] if @old_mouse_pos.nil?
+      return Vector[0, 0] unless @mouse_pos_updated
+
+      @mouse_pos - @old_mouse_pos
+    end
+
+    def self._on_key_down(key)
+      keys[key] = :down
+      if key == KEY_ESCAPE
+        Engine.close
+      end
+
+      if key == KEY_BACKSPACE
+        Engine::Debugging.breakpoint { binding.pry }
+        # Engine.breakpoint { debugger }
+      end
+
+      if key == KEY_F
+        Engine::Window.toggle_full_screen
+      end
+    end
+
+    def self._on_key_up(key)
+      keys[key] = :up
+    end
+
+    def self.key_callback(key, action)
+      if action == PRESS
+        _on_key_down(key)
+      elsif action == RELEASE
+        _on_key_up(key)
+      end
+    end
+
+    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 == PRESS
+        keys[button] = :down
+      elsif action == RELEASE
+        keys[button] = :up
+      end
+    end
+
+    def self.update_key_states
+      @mouse_pos_updated = false
+      keys.each do |key, state|
+        if state == :down
+          keys[key] = :held
+        elsif state == :up
+          keys.delete(key)
+        end
+      end
+    end
+
+    private
+
+    def self.keys
+      @keys ||= {}
+    end
+  end
+end

data/lib/engine/material.rb

@@ -1,79 +1,214 @@
-# frozen_string_literal: true
-
-module Engine
-  class Material
-    attr_reader :shader
-
-    def initialize(shader)
-      @shader = shader
-    end
-
-    def set_mat4(name, value)
-      mat4s[name] = value
-    end
-
-    def set_vec3(name, value)
-      vec3s[name] = value
-    end
-
-    def set_vec4(name, value)
-      vec4s[name] = value
-    end
-
-    def set_float(name, value)
-      floats[name] = value
-    end
-
-    def set_texture(name, value)
-      textures[name] = value
-    end
-
-    def update_shader
-      shader.use
-
-      mat4s.each do |name, value|
-        shader.set_mat4(name, value)
-      end
-      vec3s.each do |name, value|
-        shader.set_vec3(name, value)
-      end
-      vec4s.each do |name, value|
-        shader.set_vec4(name, value)
-      end
-      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
-        shader.set_int(name, slot)
-      end
-    end
-
-    private
-
-    def mat4s
-      @mat4s ||= {}
-    end
-
-    def vec3s
-      @vec3s ||= {}
-    end
-
-    def vec4s
-      @vec4s ||= {}
-    end
-
-    def floats
-      @floats ||= {}
-    end
-
-    def textures
-      @textures ||= {}
-    end
-  end
-end
+# frozen_string_literal: true
+
+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 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
+
+    def set_vec4(name, value)
+      vec4s[name] = value
+    end
+
+    def set_float(name, value)
+      floats[name] = value
+    end
+
+    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
+      shader.use
+
+      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
+      vec4s.each do |name, value|
+        shader.set_vec4(name, value)
+      end
+      floats.each do |name, value|
+        shader.set_float(name, value)
+      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
+
+    def vec4s
+      @vec4s ||= {}
+    end
+
+    def floats
+      @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