ruby_rpg 0.0.4 → 0.1.0

data/lib/engine/engine.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 GAME_DIR = File.expand_path(File.dirname($PROGRAM_NAME))
+ENGINE_DIR = File.expand_path(File.dirname(__FILE__))
 
 module Engine
   def self.start(&first_frame_block)
@@ -24,14 +25,14 @@ module Engine
     GLFW.MakeContextCurrent(Window.window)
 
     Input.init
-    GL.load_lib
+    Rendering::GpuTimer.enable if ENV['GPU_PROFILE']
 
     set_opengl_blend_mode
     @engine_started = true
-    GL.ClearColor(0.0, 0.0, 0.0, 1.0)
+    Engine::GL.ClearColor(0.0, 0.0, 0.0, 1.0)
 
-    GL.Enable(GL::CULL_FACE)
-    GL.CullFace(GL::BACK)
+    Engine::GL.Enable(Engine::GL::CULL_FACE)
+    Engine::GL.CullFace(Engine::GL::BACK)
 
     GLFW.SwapInterval(0)
   end
@@ -42,7 +43,7 @@ module Engine
     @time = Time.now
     @fps = 0
     Window.get_framebuffer_size
-    GL.Clear(GL::COLOR_BUFFER_BIT | GL::DEPTH_BUFFER_BIT)
+    Engine::GL.Clear(Engine::GL::COLOR_BUFFER_BIT | Engine::GL::DEPTH_BUFFER_BIT)
 
     until GLFW.WindowShouldClose(Window.window) == GLFW::TRUE || @game_stopped
       if first_frame_block
@@ -59,13 +60,8 @@ module Engine
       GameObject.update_all(delta_time)
 
       @swap_buffers_promise.wait! if @swap_buffers_promise
-      GL.Clear(GL::COLOR_BUFFER_BIT | GL::DEPTH_BUFFER_BIT)
-      GL.Enable(GL::DEPTH_TEST)
-      GL.DepthFunc(GL::LESS)
 
       Rendering::RenderPipeline.draw unless @game_stopped
-      GL.Disable(GL::DEPTH_TEST)
-      GameObject.render_ui(delta_time)
 
       if Screenshoter.scheduled_screenshot
         Screenshoter.take_screenshot
@@ -125,7 +121,7 @@ module Engine
   end
 
   def self.set_opengl_blend_mode
-    GL.Enable(GL::BLEND)
-    GL.BlendFunc(GL::SRC_ALPHA, GL::ONE_MINUS_SRC_ALPHA)
+    Engine::GL.Enable(Engine::GL::BLEND)
+    Engine::GL.BlendFunc(Engine::GL::SRC_ALPHA, Engine::GL::ONE_MINUS_SRC_ALPHA)
   end
 end

data/lib/engine/font.rb

@@ -4,19 +4,36 @@ require "json"
 
 module Engine
   class Font
+    include Serializable
+
+    attr_reader :font_file_path, :source
+
     TEXTURE_SIZE = 1024
     GLYPH_COUNT = 16
     CELL_SIZE = TEXTURE_SIZE / GLYPH_COUNT
 
-    def initialize(font_file_path)
-      @font_file_path = font_file_path
+    def self.for(font_file_path, source: :game)
+      cache_key = [font_file_path, source]
+      font_cache[cache_key] ||= create(font_file_path: font_file_path, source: source)
+    end
+
+    def self.font_cache
+      @font_cache ||= {}
+    end
+
+    def self.from_serializable_data(data)
+      self.for(data[:font_file_path], source: (data[:source] || :game).to_sym)
+    end
+
+    def serializable_data
+      { font_file_path: @font_file_path, source: @source }
     end
 
     def texture
       @texture ||=
         begin
           path = File.join("_imported", @font_file_path.gsub(".ttf", ".png"))
-          Engine::Texture.for(path)
+          Engine::Texture.for(path, source: @source)
         end
     end
 
@@ -35,7 +52,7 @@ module Engine
       scale_factor = 1 / (1024.0 * 2)
       horizontal_offset = 0.0
       vertical_offset = 0.0
-      font_path = File.expand_path(File.join(GAME_DIR, "_imported", @font_file_path.gsub(".ttf", ".json")))
+      font_path = resolve_font_json_path
       font_metrics = JSON.parse File.read(font_path)
       string.chars.each do |char|
         if char == "\n"
@@ -49,6 +66,14 @@ module Engine
       offsets
     end
 
+    def resolve_font_json_path
+      if @source == :engine
+        File.expand_path(File.join(ENGINE_DIR, "assets", "_imported", @font_file_path.gsub(".ttf", ".json")))
+      else
+        File.expand_path(File.join(GAME_DIR, "_imported", @font_file_path.gsub(".ttf", ".json")))
+      end
+    end
+
     private
 
     def character(index)

data/lib/engine/game_object.rb

@@ -2,37 +2,64 @@ require "matrix"
 
 module Engine
   class GameObject
+    include Serializable
+
+    serialize :name, :pos, :rotation, :scale, :components, :renderers, :ui_renderers, :parent
+
     def self.method_added(name)
       @methods ||= Set.new
       return if name == :initialize || name == :destroyed?
       @methods.add(name)
     end
 
-    attr_accessor :name, :pos, :scale, :components, :renderers, :ui_renderers, :created_at, :parent
+    attr_accessor :name, :components, :renderers, :ui_renderers, :created_at
+    attr_reader :pos, :scale, :parent, :local_version, :rotation
+
+    def awake
+      # Set defaults
+      @name ||= "Game Object"
+      @pos ||= Vector[0, 0, 0]
+      @rotation ||= Vector[0, 0, 0]
+      @scale ||= Vector[1, 1, 1]
+      @local_version ||= 0
+      @cached_world_version ||= nil
+      @created_at ||= Time.now
+
+      # Normalize rotation (handle Numeric/Quaternion/Vector)
+      @rotation = normalize_rotation(@rotation)
+      @rotation_quaternion = Quaternion.from_euler(@rotation)
+
+      # Normalize pos to ensure 3 components
+      @pos = Vector[@pos[0], @pos[1], @pos[2] || 0]
+
+      # Split components by type (handles both .create with mixed array and deserialization with separate arrays)
+      all_components = (@components || []) + (@renderers || []) + (@ui_renderers || [])
+      @components = all_components.select { |c| !c.renderer? && !c.ui_renderer? }
+      @renderers = all_components.select { |c| c.renderer? }
+      @ui_renderers = all_components.select { |c| c.ui_renderer? }
 
-    def initialize(name = "Game Object", pos: Vector[0, 0, 0], rotation: 0, scale: Vector[1, 1, 1], components: [], parent: nil)
       GameObject.object_spawned(self)
-      @pos = Vector[pos[0], pos[1], pos[2] || 0]
+      @parent&.add_child(self)
+
+      all_components.each { |component| component.set_game_object(self) }
+      all_components.each(&:start)
+      GameObject.register_renderers(self)
+    end
+
+    private
+
+    def normalize_rotation(rotation)
       if rotation.is_a?(Numeric)
-        self.rotation = Quaternion.from_euler(Vector[0, 0, rotation])
+        Vector[0, 0, rotation]
       elsif rotation.is_a?(Quaternion)
-        self.rotation = rotation
+        rotation.to_euler
       else
-        self.rotation = Quaternion.from_euler(rotation)
+        rotation
       end
-      @scale = scale
-      @name = name
-      @components = components.select { |component| !component.renderer? && !component.ui_renderer? }
-      @renderers = components.select { |component| component.renderer? }
-      @ui_renderers = components.select { |component| component.ui_renderer? }
-      @created_at = Time.now
-      @parent = parent
-      parent.add_child(self) if parent
-
-      components.each { |component| component.set_game_object(self) }
-      components.each(&:start)
     end
 
+    public
+
     def to_s
       @name
     end
@@ -41,6 +68,19 @@ module Engine
       @children ||= Set.new
     end
 
+    def component(klass)
+      components_of_type(klass).first
+    end
+
+    def components_of_type(klass)
+      @components_cache ||= {}
+      @components_cache[klass] ||= all_components.select { |c| c.is_a?(klass) }
+    end
+
+    def all_components
+      @all_components ||= @components + @renderers + @ui_renderers
+    end
+
     def add_child(child)
       child.parent = self
       children << child
@@ -49,9 +89,20 @@ module Engine
     def parent=(parent)
       @parent.children.delete(self) if @parent
       @parent = parent
+      @local_version += 1
       parent.children << self if parent
     end
 
+    def pos=(value)
+      @pos = value
+      @local_version += 1
+    end
+
+    def scale=(value)
+      @scale = value
+      @local_version += 1
+    end
+
     def rotation
       @rotation_quaternion
     end
@@ -60,6 +111,7 @@ module Engine
       raise "Rotation must be a Quaternion" unless value.is_a?(Quaternion)
 
       @rotation_quaternion = value
+      @local_version += 1
     end
 
     def euler_angles
@@ -72,6 +124,7 @@ module Engine
 
     def x=(value)
       @pos = Vector[value, y, z]
+      @local_version += 1
     end
 
     def y
@@ -80,6 +133,7 @@ module Engine
 
     def y=(value)
       @pos = Vector[x, value, z]
+      @local_version += 1
     end
 
     def z
@@ -88,6 +142,7 @@ module Engine
 
     def z=(value)
       @pos = Vector[x, y, value]
+      @local_version += 1
     end
 
     def local_to_world_coordinate(local)
@@ -103,7 +158,7 @@ module Engine
     end
 
     def local_to_world_direction(local)
-      local_to_world_coordinate(local) - pos
+      local_to_world_coordinate(local) - local_to_world_coordinate(Vector[0, 0, 0])
     end
 
     def rotate_around(axis, angle)
@@ -112,33 +167,43 @@ module Engine
       self.rotation = rotation_quaternion * rotation
     end
 
+    def world_transform_version
+      @local_version + (@parent&.world_transform_version || 0)
+    end
+
     def model_matrix
-      cache_key = [@pos.dup, rotation.dup, @scale.dup, @parent&.model_matrix&.to_a]
-      @model_matrix = nil if @model_matrix_cache_key != cache_key
-      @model_matrix_cache_key = cache_key
-      @model_matrix ||=
-        begin
-          rot = euler_angles * Math::PI / 180
-
-          cos_x = Math.cos(rot[0])
-          cos_y = Math.cos(rot[1])
-          cos_z = Math.cos(rot[2])
-
-          sin_x = Math.sin(rot[0])
-          sin_y = Math.sin(rot[1])
-          sin_z = Math.sin(rot[2])
-
-          Matrix[
-            [scale[0] * (cos_y * cos_z), scale[0] * (-cos_y * sin_z), scale[0] * sin_y, 0],
-            [scale[1] * (cos_x * sin_z + sin_x * sin_y * cos_z), scale[1] * (cos_x * cos_z - sin_x * sin_y * sin_z), scale[1] * -sin_x * cos_y, 0],
-            [scale[2] * (sin_x * sin_z - cos_x * sin_y * cos_z), scale[2] * (sin_x * cos_z + cos_x * sin_y * sin_z), scale[2] * cos_x * cos_y, 0],
-            [x, y, z, 1]
-          ]
-        end
+      current_version = world_transform_version
+      return @cached_world_matrix if @cached_world_version == current_version
+
+      @cached_world_version = current_version
+      @cached_world_matrix = compute_world_matrix
+    end
+
+    private def compute_local_matrix
+      rot = euler_angles * Math::PI / 180
+
+      cos_x = Math.cos(rot[0])
+      cos_y = Math.cos(rot[1])
+      cos_z = Math.cos(rot[2])
+
+      sin_x = Math.sin(rot[0])
+      sin_y = Math.sin(rot[1])
+      sin_z = Math.sin(rot[2])
+
+      Matrix[
+        [scale[0] * (cos_y * cos_z), scale[0] * (-cos_y * sin_z), scale[0] * sin_y, 0],
+        [scale[1] * (cos_x * sin_z + sin_x * sin_y * cos_z), scale[1] * (cos_x * cos_z - sin_x * sin_y * sin_z), scale[1] * -sin_x * cos_y, 0],
+        [scale[2] * (sin_x * sin_z - cos_x * sin_y * cos_z), scale[2] * (sin_x * cos_z + cos_x * sin_y * sin_z), scale[2] * cos_x * cos_y, 0],
+        [x, y, z, 1]
+      ]
+    end
+
+    private def compute_world_matrix
+      local = compute_local_matrix
       if parent
-        @model_matrix * parent.model_matrix
+        local * parent.model_matrix
       else
-        @model_matrix
+        local
       end
     end
 
@@ -153,6 +218,7 @@ module Engine
       ui_renderers.each(&:destroy!)
       renderers.each(&:destroy!)
 
+      GameObject.unregister_renderers(self)
       GameObject.destroyed_objects << self unless @destroyed
       @destroyed = true
     end
@@ -208,15 +274,21 @@ module Engine
     end
 
     def self.mesh_renderers
-      GameObject.objects.flat_map do |object|
-        object.renderers
-      end
+      @cached_mesh_renderers ||= []
     end
 
-    def self.render_ui(delta_time)
-      GameObject.objects.each do |object|
-        object.ui_renderers.each { |renderer| renderer.update(delta_time) }
-      end
+    def self.ui_renderers
+      @cached_ui_renderers ||= []
+    end
+
+    def self.register_renderers(game_object)
+      game_object.renderers.each { |r| mesh_renderers << r }
+      game_object.ui_renderers.each { |r| ui_renderers << r }
+    end
+
+    def self.unregister_renderers(game_object)
+      game_object.renderers.each { |r| mesh_renderers.delete(r) }
+      game_object.ui_renderers.each { |r| ui_renderers.delete(r) }
     end
 
     def self.object_spawned(object)