ruby_rpg 0.0.4 → 0.1.0

data/lib/engine/component.rb

@@ -1,5 +1,7 @@
 module Engine
   class Component
+    include Serializable
+
     def self.method_added(name)
       @methods ||= Set.new
       return if name == :initialize || name == :destroyed?

data/lib/engine/components/audio_source.rb

@@ -2,10 +2,12 @@
 
 module Engine::Components
   class AudioSource < Engine::Component
-    def initialize(clip, radius: 1000)
-      @clip = clip
-      @radius = radius
-      @source = NativeAudio::AudioSource.new(clip)
+    serialize :clip_path, :radius
+
+    def awake
+      @radius ||= 1000
+      @clip = NativeAudio::Clip.new(@clip_path)
+      @source = NativeAudio::AudioSource.new(@clip)
     end
 
     def play

data/lib/engine/components/direction_light.rb

@@ -2,10 +2,34 @@
 
 module Engine::Components
   class DirectionLight < Engine::Component
-    attr_accessor :colour
+    include Engine::MatrixHelpers
 
-    def initialize(colour: [1.0, 1.0, 1.0])
-      @colour = colour
+    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
@@ -16,8 +40,63 @@ module Engine::Components
       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
+end

data/lib/engine/components/orthographic_camera.rb

@@ -2,13 +2,13 @@
 
 module Engine::Components
   class OrthographicCamera < Engine::Component
+    include Engine::MatrixHelpers
+    attr_reader :near, :far
 
-    def initialize(width:, height:, far:)
-      @width = width
-      @height = height
-      @far = far
-      @near = 0
+    serialize :width, :height, :far
 
+    def awake
+      @near ||= 0
       Engine::Camera.instance = self
     end
 
@@ -19,36 +19,42 @@ module Engine::Components
     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]
+          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 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
+    def inverse_vp_matrix
+      @inverse_vp_matrix ||= matrix.inverse
     end
 
-    private
-
-    def right
-      @right ||= game_object.right / (@width / 2)
+    def position
+      game_object.pos
     end
 
-    def up
-      @up ||= game_object.up / (@height / 2)
+    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 front
-      @front ||= game_object.forward / (@far / 2)
+    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

@@ -2,12 +2,13 @@
 
 module Engine::Components
   class PerspectiveCamera < Engine::Component
-    def initialize(fov:, aspect:, near:, far:)
-      @fov = fov
-      @aspect = aspect
-      @near = near
-      @far = far
+    include Engine::MatrixHelpers
 
+    serialize :fov, :aspect, :near, :far
+
+    attr_reader :near, :far
+
+    def awake
       Engine::Camera.instance = self
     end
 
@@ -33,18 +34,40 @@ module Engine::Components
         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 = @fov * Math::PI / 180
+      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[
-        [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]
-      ]
+        [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)
-      @matrix = nil if game_object.rotation != @rotation || game_object.pos != @pos || game_object.scale != @scale
+      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

data/lib/engine/components/point_light.rb

@@ -2,11 +2,30 @@
 
 module Engine::Components
   class PointLight < Engine::Component
-    attr_accessor :range, :colour
+    include Engine::MatrixHelpers
 
-    def initialize(range: 300, colour: [1.0, 1.0, 1.0])
-      @range = range
-      @colour = colour
+    NR_SHADOW_CASTING_POINT_LIGHTS = 4
+
+    # Cubemap face directions: +X, -X, +Y, -Y, +Z, -Z
+    CUBE_DIRECTIONS = [
+      { dir: Vector[1, 0, 0],  up: Vector[0, -1, 0] },   # +X
+      { dir: Vector[-1, 0, 0], up: Vector[0, -1, 0] },   # -X
+      { dir: Vector[0, 1, 0],  up: Vector[0, 0, 1] },    # +Y
+      { dir: Vector[0, -1, 0], up: Vector[0, 0, -1] },   # -Y
+      { dir: Vector[0, 0, 1],  up: Vector[0, -1, 0] },   # +Z
+      { dir: Vector[0, 0, -1], up: Vector[0, -1, 0] }    # -Z
+    ].freeze
+
+    serialize :range, :colour, :cast_shadows
+
+    attr_accessor :range, :colour, :cast_shadows, :shadow_layer_index
+
+    def awake
+      @range ||= 300
+      @colour ||= [1.0, 1.0, 1.0]
+      @cast_shadows = false if @cast_shadows.nil?
+      @shadow_layer_index = nil
+      @cached_light_space_matrices = nil
     end
 
     def start
@@ -17,8 +36,45 @@ module Engine::Components
       PointLight.point_lights.delete(self)
     end
 
+    def update(delta_time)
+      @cached_light_space_matrices = nil if @cast_shadows
+    end
+
+    def position
+      game_object.local_to_world_coordinate(Vector[0, 0, 0])
+    end
+
+    def shadow_near
+      @range * 0.01
+    end
+
+    def shadow_far
+      @range * 2.0
+    end
+
+    def light_space_matrices
+      @cached_light_space_matrices ||= compute_light_space_matrices
+    end
+
     def self.point_lights
       @point_lights ||= []
     end
+
+    def self.shadow_casting_lights
+      point_lights.select(&:cast_shadows).take(NR_SHADOW_CASTING_POINT_LIGHTS)
+    end
+
+    private
+
+    def compute_light_space_matrices
+      light_pos = position
+      proj = perspective(Math::PI / 2.0, 1.0, shadow_near, shadow_far)
+
+      CUBE_DIRECTIONS.map do |face|
+        target = light_pos + face[:dir]
+        view = look_at(light_pos, target, face[:up])
+        (proj * view).transpose
+      end
+    end
   end
-end
+end

data/lib/engine/components/renderers/font_renderer.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Engine::Components
+  class FontRenderer < FontRendererBase
+    def renderer?
+      true
+    end
+
+    private
+
+    def shader
+      @shader ||= Engine::Shader.text
+    end
+
+    def set_shader_camera_matrix
+      shader.set_mat4("camera", Engine::Camera.instance.matrix)
+    end
+  end
+end

data/lib/engine/components/renderers/font_renderer_base.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Engine::Components
+  class FontRendererBase < Engine::Component
+    serialize :font, :string
+
+    attr_reader :mesh, :texture
+
+    def awake
+      # Original vertex order for ear-clipping, UVs flipped for Y-down camera
+      @mesh = Engine::PolygonMesh.new(
+        [Vector[-0.5, 0.5], Vector[0.5, 0.5], Vector[0.5, -0.5], Vector[-0.5, -0.5]],
+        [[0, 1], [1, 1], [1, 0], [0, 0]]
+      )
+      @texture = @font.texture.texture
+    end
+
+    def start
+      setup_vertex_attribute_buffer
+      setup_vertex_buffer
+      setup_index_buffer
+      Engine::GL.BindVertexArray(0)
+    end
+
+    def update_string(string)
+      @string = string
+      update_vbo_buf
+    end
+
+    def draw
+      shader.use
+      Engine::GL.BindVertexArray(@vao)
+      Engine::GL.BindBuffer(Engine::GL::ELEMENT_ARRAY_BUFFER, @ebo)
+
+      set_shader_per_frame_data
+
+      Engine::GL.DrawElementsInstanced(Engine::GL::TRIANGLES, mesh.index_data.length, Engine::GL::UNSIGNED_INT, 0, @string.length)
+    end
+
+    private
+
+    def shader
+      raise NotImplementedError, "Subclasses must implement #shader"
+    end
+
+    def set_shader_camera_matrix
+      raise NotImplementedError, "Subclasses must implement #set_shader_camera_matrix"
+    end
+
+    def set_shader_per_frame_data
+      set_shader_camera_matrix
+      set_shader_model_matrix
+      set_shader_texture
+    end
+
+    def set_shader_model_matrix
+      shader.set_mat4("model", game_object.model_matrix)
+    end
+
+    def set_shader_texture
+      Engine::Material.bind_texture(0, Engine::GL::TEXTURE_2D, texture)
+      shader.set_int("fontTexture", 0)
+    end
+
+    def setup_index_buffer
+      indices = mesh.index_data
+
+      ebo_buf = ' ' * 4
+      Engine::GL.GenBuffers(1, ebo_buf)
+      @ebo = ebo_buf.unpack('L')[0]
+      Engine::GL.BindBuffer(Engine::GL::ELEMENT_ARRAY_BUFFER, @ebo)
+      Engine::GL.BufferData(
+        Engine::GL::ELEMENT_ARRAY_BUFFER, indices.length * Fiddle::SIZEOF_INT,
+        indices.pack('I*'), Engine::GL::STATIC_DRAW
+      )
+    end
+
+    def setup_vertex_attribute_buffer
+      vao_buf = ' ' * 4
+      Engine::GL.GenVertexArrays(1, vao_buf)
+      @vao = vao_buf.unpack('L')[0]
+      Engine::GL.BindVertexArray(@vao)
+    end
+
+    def setup_vertex_buffer
+      vbo_buf = ' ' * 4
+      Engine::GL.GenBuffers(1, vbo_buf)
+      vbo = vbo_buf.unpack('L')[0]
+      points = mesh.vertex_data
+
+      Engine::GL.BindBuffer(Engine::GL::ARRAY_BUFFER, vbo)
+      Engine::GL.BufferData(
+        Engine::GL::ARRAY_BUFFER, @mesh.vertex_data.length * Fiddle::SIZEOF_FLOAT,
+        points.pack('F*'), Engine::GL::STATIC_DRAW
+      )
+
+      Engine::GL.VertexAttribPointer(0, 3, Engine::GL::FLOAT, Engine::GL::FALSE, 5 * Fiddle::SIZEOF_FLOAT, 0)
+      Engine::GL.VertexAttribPointer(1, 2, Engine::GL::FLOAT, Engine::GL::FALSE, 5 * Fiddle::SIZEOF_FLOAT, 3 * Fiddle::SIZEOF_FLOAT)
+      Engine::GL.EnableVertexAttribArray(0)
+      Engine::GL.EnableVertexAttribArray(1)
+
+      generate_instance_vbo_buf
+    end
+
+    def generate_instance_vbo_buf
+      @instance_vbo = set_instance_vbo_buf
+      update_vbo_buf
+    end
+
+    def set_instance_vbo_buf
+      instance_vbo_buf = ' ' * 4
+      Engine::GL.GenBuffers(1, instance_vbo_buf)
+      instance_vbo_buf.unpack('L')[0]
+    end
+
+    def update_vbo_buf
+      vertex_data = @font.vertex_data(@string)
+      string_length = @string.chars.reject { |c| c == "\n" }.length
+
+      Engine::GL.BindBuffer(Engine::GL::ARRAY_BUFFER, @instance_vbo)
+      vertex_size = Fiddle::SIZEOF_INT + (Fiddle::SIZEOF_FLOAT * 2)
+      Engine::GL.BufferData(
+        Engine::GL::ARRAY_BUFFER, string_length * vertex_size,
+        vertex_data.pack('IFF' * string_length), Engine::GL::STATIC_DRAW
+      )
+      Engine::GL.VertexAttribIPointer(2, 1, Engine::GL::INT, vertex_size, 0)
+      Engine::GL.VertexAttribPointer(3, 2, Engine::GL::FLOAT, Engine::GL::FALSE, vertex_size, Fiddle::SIZEOF_INT)
+      Engine::GL.EnableVertexAttribArray(2)
+      Engine::GL.EnableVertexAttribArray(3)
+      Engine::GL.VertexAttribDivisor(2, 1)
+      Engine::GL.VertexAttribDivisor(3, 1)
+    end
+  end
+end

data/lib/engine/components/renderers/mesh_renderer.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Engine::Components
+  class MeshRenderer < Engine::Component
+    serialize :mesh, :material, :static
+
+    attr_reader :mesh, :material, :static
+
+    def awake
+      @static = false if @static.nil?
+      @last_synced_version = nil
+      @renderer_key = nil
+    end
+
+    def renderer_key
+      @renderer_key ||= [mesh, material].freeze
+    end
+
+    def renderer?
+      true
+    end
+
+    def start
+      Rendering::RenderPipeline.add_instance(self)
+    end
+
+    def sync_transform
+      return if static
+
+      version = game_object.world_transform_version
+      return if @last_synced_version == version
+
+      @last_synced_version = version
+      Rendering::RenderPipeline.update_instance(self)
+    end
+
+    def destroy
+      Rendering::RenderPipeline.remove_instance(self)
+    end
+  end
+end

data/lib/engine/components/renderers/sprite_renderer.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Engine::Components
+  class SpriteRenderer < Engine::Component
+    serialize :material
+
+    attr_reader :material
+
+    def colour=(value)
+      material.set_vec4("spriteColor", colour_to_vec4(value))
+    end
+
+    def colour_to_vec4(value)
+      if value.is_a?(Array)
+        value
+      else
+        [value[:r], value[:g], value[:b], value[:a] || 1.0]
+      end
+    end
+
+    def renderer?
+      true
+    end
+
+    def start
+      @mesh_renderer = MeshRenderer.create(mesh: Engine::Mesh.quad, material: material)
+      @mesh_renderer.set_game_object(game_object)
+      @mesh_renderer.start
+      set_default_frame_coords
+    end
+
+    def sync_transform
+      @mesh_renderer.sync_transform
+    end
+
+    def destroy
+      @mesh_renderer.destroy
+    end
+
+    private
+
+    def set_default_frame_coords
+      material.set_vec4("frameCoords", [0, 0, 1, 1])
+    end
+  end
+end

data/lib/engine/components/spot_light.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Engine::Components
+  class SpotLight < Engine::Component
+    include Engine::MatrixHelpers
+
+    serialize :range, :colour, :inner_angle, :outer_angle, :cast_shadows
+
+    attr_accessor :range, :colour, :inner_angle, :outer_angle, :cast_shadows, :shadow_layer_index
+
+    def awake
+      @range ||= 300
+      @colour ||= [1.0, 1.0, 1.0]
+      @inner_angle ||= 12.5
+      @outer_angle ||= 17.5
+      @cast_shadows = false if @cast_shadows.nil?
+      @shadow_layer_index = nil
+      @cached_light_space_matrix = nil
+    end
+
+    def start
+      SpotLight.spot_lights << self
+    end
+
+    def destroy!
+      SpotLight.spot_lights.delete(self)
+    end
+
+    def inner_cutoff
+      Math.cos(@inner_angle * Math::PI / 180.0)
+    end
+
+    def outer_cutoff
+      Math.cos(@outer_angle * Math::PI / 180.0)
+    end
+
+    def shadow_near
+      @range * 0.01
+    end
+
+    def shadow_far
+      # Factor of 2 needed to match shadow range with spotlight attenuation range
+      @range * 2.0
+    end
+
+    def direction
+      game_object.local_to_world_direction(Vector[0, 0, 1]).normalize
+    end
+
+    def position
+      game_object.local_to_world_coordinate(Vector[0, 0, 0])
+    end
+
+    def light_space_matrix
+      @cached_light_space_matrix ||= compute_light_space_matrix
+    end
+
+    def update(delta_time)
+      # Clear cache each frame so matrix is recomputed if light moves
+      @cached_light_space_matrix = nil
+    end
+
+    def compute_light_space_matrix
+      light_pos = position
+      light_dir = direction
+      target = light_pos + light_dir
+
+      # Choose up vector that's not parallel to light direction
+      # When light points mostly along Y axis, use Z as up instead
+      up = if light_dir[1].abs > 0.9
+        Vector[0, 0, 1]
+      else
+        Vector[0, 1, 0]
+      end
+
+      view_matrix = look_at(light_pos, target, up)
+
+      # Perspective projection based on spotlight cone angle
+      fov = (@outer_angle * 2.0 + 5.0) * Math::PI / 180.0
+      # near/far ratio affects depth precision
+      proj_matrix = perspective(fov, 1.0, shadow_near, shadow_far)
+
+      (proj_matrix * view_matrix).transpose
+    end
+
+    def self.spot_lights
+      @spot_lights ||= []
+    end
+  end
+end