ruby_rpg 0.0.5 → 0.1.0

data/lib/engine/autoloader.rb

@@ -1,11 +1,11 @@
-# frozen_string_literal: true
-
-module Engine
-  module AutoLoader
-    def self.load(load_path = nil)
-      base_dir = File.expand_path(load_path || File.dirname($PROGRAM_NAME))
-      Dir[File.join(base_dir, "components", "**/*.rb")].each { |file| require file }
-      Dir[File.join(base_dir, "game_objects", "**/*.rb")].each { |file| require file }
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Engine
+  module AutoLoader
+    def self.load(load_path = nil)
+      base_dir = File.expand_path(load_path || File.dirname($PROGRAM_NAME))
+      Dir[File.join(base_dir, "components", "**/*.rb")].each { |file| require file }
+      Dir[File.join(base_dir, "game_objects", "**/*.rb")].each { |file| require file }
+    end
+  end
+end

data/lib/engine/camera.rb

@@ -1,13 +1,13 @@
-# frozen_string_literal: true
-
-module Engine
-  class Camera
-    def self.instance
-      @instance
-    end
-
-    def self.instance=(new_instance)
-      @instance = new_instance
-    end
-  end
+# frozen_string_literal: true
+
+module Engine
+  class Camera
+    def self.instance
+      @instance
+    end
+
+    def self.instance=(new_instance)
+      @instance = new_instance
+    end
+  end
 end

data/lib/engine/component.rb

@@ -1,63 +1,65 @@
-module Engine
-  class Component
-    def self.method_added(name)
-      @methods ||= Set.new
-      return if name == :initialize || name == :destroyed?
-      @methods.add(name)
-    end
-
-    attr_reader :game_object
-
-    def renderer?
-      false
-    end
-
-    def ui_renderer?
-      false
-    end
-
-    def set_game_object(game_object)
-      @game_object = game_object
-    end
-
-    def start
-    end
-
-    def update(delta_time) end
-
-    def destroyed?
-      @destroyed || false
-    end
-
-    def destroy!
-      Component.destroyed_components << self unless @destroyed
-      destroy unless @destroyed
-      @destroyed = true
-    end
-
-    def _erase!
-      game_object.components.delete(self)
-      class_name = self.class.name.split('::').last
-      self.class.instance_variable_get(:@methods).each do |method|
-        singleton_class.send(:undef_method, method)
-        singleton_class.send(:define_method, method) do |*args, **kwargs|
-          raise "This #{class_name} has been destroyed but you are still trying to access #{method}"
-        end
-      end
-    end
-
-    def self.erase_destroyed_components
-      destroyed_components.each do |object|
-        object._erase!
-      end
-      @destroyed_components = []
-    end
-
-    def destroy
-    end
-
-    def self.destroyed_components
-      @destroyed_components ||= []
-    end
-  end
-end
+module Engine
+  class Component
+    include Serializable
+
+    def self.method_added(name)
+      @methods ||= Set.new
+      return if name == :initialize || name == :destroyed?
+      @methods.add(name)
+    end
+
+    attr_reader :game_object
+
+    def renderer?
+      false
+    end
+
+    def ui_renderer?
+      false
+    end
+
+    def set_game_object(game_object)
+      @game_object = game_object
+    end
+
+    def start
+    end
+
+    def update(delta_time) end
+
+    def destroyed?
+      @destroyed || false
+    end
+
+    def destroy!
+      Component.destroyed_components << self unless @destroyed
+      destroy unless @destroyed
+      @destroyed = true
+    end
+
+    def _erase!
+      game_object.components.delete(self)
+      class_name = self.class.name.split('::').last
+      self.class.instance_variable_get(:@methods).each do |method|
+        singleton_class.send(:undef_method, method)
+        singleton_class.send(:define_method, method) do |*args, **kwargs|
+          raise "This #{class_name} has been destroyed but you are still trying to access #{method}"
+        end
+      end
+    end
+
+    def self.erase_destroyed_components
+      destroyed_components.each do |object|
+        object._erase!
+      end
+      @destroyed_components = []
+    end
+
+    def destroy
+    end
+
+    def self.destroyed_components
+      @destroyed_components ||= []
+    end
+  end
+end

data/lib/engine/components/audio_source.rb

@@ -1,41 +1,43 @@
-# frozen_string_literal: true
-
-module Engine::Components
-  class AudioSource < Engine::Component
-    def initialize(clip, radius: 1000)
-      @clip = clip
-      @radius = radius
-      @source = NativeAudio::AudioSource.new(clip)
-    end
-
-    def play
-      @source.play
-    end
-
-    def stop
-      @source.stop
-    end
-
-    def pause
-      @source.pause
-    end
-
-    def resume
-      @source.resume
-    end
-
-    def volume=(volume)
-      @source.set_volume(volume)
-    end
-
-    def update(delta_time)
-      camera = Engine::Camera.instance
-      local_pos = camera.game_object.world_to_local_coordinate(game_object.pos)
-      angle = Math.atan2(local_pos[0], -local_pos[2]) * 180 / Math::PI
-      angle = (angle + 360) % 360
-      distance = (local_pos.magnitude * 255 / @radius).clamp(0, 255)
-      
-      @source.set_pos(angle, distance)
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Engine::Components
+  class AudioSource < Engine::Component
+    serialize :clip_path, :radius
+
+    def awake
+      @radius ||= 1000
+      @clip = NativeAudio::Clip.new(@clip_path)
+      @source = NativeAudio::AudioSource.new(@clip)
+    end
+
+    def play
+      @source.play
+    end
+
+    def stop
+      @source.stop
+    end
+
+    def pause
+      @source.pause
+    end
+
+    def resume
+      @source.resume
+    end
+
+    def volume=(volume)
+      @source.set_volume(volume)
+    end
+
+    def update(delta_time)
+      camera = Engine::Camera.instance
+      local_pos = camera.game_object.world_to_local_coordinate(game_object.pos)
+      angle = Math.atan2(local_pos[0], -local_pos[2]) * 180 / Math::PI
+      angle = (angle + 360) % 360
+      distance = (local_pos.magnitude * 255 / @radius).clamp(0, 255)
+      
+      @source.set_pos(angle, distance)
+    end
+  end
+end

data/lib/engine/components/direction_light.rb

@@ -1,23 +1,102 @@
-# frozen_string_literal: true
-
-module Engine::Components
-  class DirectionLight < Engine::Component
-    attr_accessor :colour
-
-    def initialize(colour: [1.0, 1.0, 1.0])
-      @colour = colour
-    end
-
-    def start
-      DirectionLight.direction_lights << self
-    end
-
-    def destroy!
-      DirectionLight.direction_lights.delete(self)
-    end
-
-    def self.direction_lights
-      @direction_lights ||= []
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Engine::Components
+  class DirectionLight < Engine::Component
+    include Engine::MatrixHelpers
+
+    serialize :colour, :cast_shadows, :shadow_distance
+
+    attr_reader :colour, :cast_shadows, :shadow_distance
+    attr_accessor :shadow_layer_index
+
+    def awake
+      @colour ||= [1.0, 1.0, 1.0]
+      @cast_shadows = true if @cast_shadows.nil?
+      @shadow_distance ||= 50.0
+      @shadow_layer_index = nil
+      @cached_light_space_matrix = nil
+      @cache_key = nil
+    end
+
+    def colour=(value)
+      @colour = value
+    end
+
+    def cast_shadows=(value)
+      @cast_shadows = value
+      invalidate_cache
+    end
+
+    def shadow_distance=(value)
+      @shadow_distance = value
+      invalidate_cache
+    end
+
+    def start
+      DirectionLight.direction_lights << self
+    end
+
+    def destroy!
+      DirectionLight.direction_lights.delete(self)
+    end
+
+    def direction
+      game_object.forward.normalize
+    end
+
+    def light_space_matrix
+      current_key = compute_cache_key
+      if @cached_light_space_matrix && @cache_key == current_key
+        return @cached_light_space_matrix
+      end
+
+      @cache_key = current_key
+      @cached_light_space_matrix = compute_light_space_matrix
+    end
+
+    def self.direction_lights
+      @direction_lights ||= []
+    end
+
+    private
+
+    def invalidate_cache
+      @cached_light_space_matrix = nil
+      @cache_key = nil
+    end
+
+    def compute_cache_key
+      camera_pos = Engine::Camera.instance&.position || Vector[0, 0, 0]
+      light_dir = direction
+      [camera_pos[0], camera_pos[1], camera_pos[2],
+       light_dir[0], light_dir[1], light_dir[2],
+       @shadow_distance]
+    end
+
+    def compute_light_space_matrix
+      light_dir = direction
+
+      # Center shadow frustum on the main camera's position
+      center = Engine::Camera.instance&.position || Vector[0, 0, 0]
+
+      # Position the light "camera" far back along the light direction from center
+      light_pos = center - light_dir * @shadow_distance
+
+      # Choose up vector that isn't parallel to light direction
+      up = if light_dir[1].abs > 0.9
+        Vector[0, 0, 1]
+      else
+        Vector[0, 1, 0]
+      end
+
+      # Create view matrix looking from light position toward center
+      view_matrix = look_at(light_pos, center, up)
+
+      # Orthographic projection covering the shadow area
+      half_size = @shadow_distance
+      proj_matrix = ortho(-half_size, half_size, -half_size, half_size, 0.1, @shadow_distance * 2)
+
+      (proj_matrix * view_matrix).transpose
+    end
+  end
+end

data/lib/engine/components/orthographic_camera.rb

@@ -1,54 +1,60 @@
-# frozen_string_literal: true
-
-module Engine::Components
-  class OrthographicCamera < Engine::Component
-
-    def initialize(width:, height:, far:)
-      @width = width
-      @height = height
-      @far = far
-      @near = 0
-
-      Engine::Camera.instance = self
-    end
-
-    def destroy
-      Engine::Camera.instance = nil if Engine::Camera.instance == self
-    end
-
-    def matrix
-      @matrix ||=
-        begin
-          camera_pos = game_object.pos - game_object.forward * (@far / 2)
-          Matrix[
-            [right[0], up[0], -front[0], 0],
-            [right[1], up[1], -front[1], 0],
-            [right[2], up[2], -front[2], 0],
-            [-camera_pos.dot(right), -camera_pos.dot(up), camera_pos.dot(front), 1]
-          ]
-        end
-    end
-
-    def update(delta_time)
-      @right = nil if game_object.rotation != @rotation
-      @up = nil if game_object.rotation != @rotation
-      @front = nil if game_object.rotation != @rotation
-      @matrix = nil if game_object.rotation.dup != @rotation
-      @rotation = game_object.rotation.dup
-    end
-
-    private
-
-    def right
-      @right ||= game_object.right / (@width / 2)
-    end
-
-    def up
-      @up ||= game_object.up / (@height / 2)
-    end
-
-    def front
-      @front ||= game_object.forward / (@far / 2)
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Engine::Components
+  class OrthographicCamera < Engine::Component
+    include Engine::MatrixHelpers
+    attr_reader :near, :far
+
+    serialize :width, :height, :far
+
+    def awake
+      @near ||= 0
+      Engine::Camera.instance = self
+    end
+
+    def destroy
+      Engine::Camera.instance = nil if Engine::Camera.instance == self
+    end
+
+    def matrix
+      @matrix ||=
+        begin
+          right = game_object.right
+          up = game_object.up
+          forward = game_object.forward
+
+          view_matrix = Matrix[
+            [right[0], right[1], right[2], -right.dot(game_object.pos)],
+            [up[0], up[1], up[2], -up.dot(game_object.pos)],
+            [forward[0], forward[1], forward[2], -forward.dot(game_object.pos)],
+            [0, 0, 0, 1]
+          ]
+
+          (projection * view_matrix).transpose
+        end
+    end
+
+    def inverse_vp_matrix
+      @inverse_vp_matrix ||= matrix.inverse
+    end
+
+    def position
+      game_object.pos
+    end
+
+    def projection
+      half_w = @width / 2.0
+      half_h = @height / 2.0
+      ortho(-half_w, half_w, -half_h, half_h, @near, @far)
+    end
+
+    def update(delta_time)
+      if game_object.rotation != @rotation || game_object.pos != @pos
+        @matrix = nil
+        @inverse_vp_matrix = nil
+      end
+      @rotation = game_object.rotation.dup
+      @pos = game_object.pos.dup
+    end
+  end
+end

data/lib/engine/components/perspective_camera.rb

@@ -1,53 +1,76 @@
-# frozen_string_literal: true
-
-module Engine::Components
-  class PerspectiveCamera < Engine::Component
-    def initialize(fov:, aspect:, near:, far:)
-      @fov = fov
-      @aspect = aspect
-      @near = near
-      @far = far
-
-      Engine::Camera.instance = self
-    end
-
-    def destroy
-      Engine::Camera.instance = nil if Engine::Camera.instance == self
-    end
-
-    def matrix
-      @matrix ||=
-        begin
-          right = game_object.right
-          up = game_object.up
-          forward = game_object.forward
-
-          transformation_matrix = Matrix[
-            [right[0], right[1], right[2], -right.dot(game_object.pos)],
-            [up[0], up[1], up[2], -up.dot(game_object.pos)],
-            [forward[0], forward[1], forward[2], -forward.dot(game_object.pos)],
-            [0, 0, 0, 1]
-          ]
-
-          (projection * transformation_matrix).transpose
-        end
-    end
-
-    def projection
-      fov = @fov * Math::PI / 180
-      Matrix[
-        [1 / (Math.tan(fov / 2) * @aspect), 0, 0, 0],
-        [0, 1 / Math.tan(fov / 2), 0, 0],
-        [0, 0, (@far + @near) / (@near - @far), 2 * @far * @near / (@near - @far)],
-        [0, 0, -1, 0]
-      ]
-    end
-
-    def update(delta_time)
-      @matrix = nil if game_object.rotation != @rotation || game_object.pos != @pos || game_object.scale != @scale
-      @rotation = game_object.rotation.dup
-      @pos = game_object.pos.dup
-      @scale = game_object.scale.dup
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Engine::Components
+  class PerspectiveCamera < Engine::Component
+    include Engine::MatrixHelpers
+
+    serialize :fov, :aspect, :near, :far
+
+    attr_reader :near, :far
+
+    def awake
+      Engine::Camera.instance = self
+    end
+
+    def destroy
+      Engine::Camera.instance = nil if Engine::Camera.instance == self
+    end
+
+    def matrix
+      @matrix ||=
+        begin
+          right = game_object.right
+          up = game_object.up
+          forward = game_object.forward
+
+          transformation_matrix = Matrix[
+            [right[0], right[1], right[2], -right.dot(game_object.pos)],
+            [up[0], up[1], up[2], -up.dot(game_object.pos)],
+            [forward[0], forward[1], forward[2], -forward.dot(game_object.pos)],
+            [0, 0, 0, 1]
+          ]
+
+          (projection * transformation_matrix).transpose
+        end
+    end
+
+    def inverse_vp_matrix
+      # matrix is already transposed for OpenGL column-major format
+      # inverse of A^T is (A^-1)^T, so matrix.inverse gives us the inverse in column-major
+      @inverse_vp_matrix ||= matrix.inverse
+    end
+
+    def position
+      game_object.pos
+    end
+
+    def projection
+      fov_radians = @fov * Math::PI / 180.0
+      perspective(fov_radians, @aspect, @near, @far)
+    end
+
+    def view_matrix
+      right = game_object.right
+      up = game_object.up
+      forward = game_object.forward
+      pos = game_object.pos
+
+      Matrix[
+        [right[0], right[1], right[2], -right.dot(pos)],
+        [up[0], up[1], up[2], -up.dot(pos)],
+        [forward[0], forward[1], forward[2], -forward.dot(pos)],
+        [0, 0, 0, 1]
+      ].transpose
+    end
+
+    def update(delta_time)
+      if game_object.rotation != @rotation || game_object.pos != @pos || game_object.scale != @scale
+        @matrix = nil
+        @inverse_vp_matrix = nil
+      end
+      @rotation = game_object.rotation.dup
+      @pos = game_object.pos.dup
+      @scale = game_object.scale.dup
+    end
+  end
+end