ruby_rpg 0.0.5 → 0.1.0

data/lib/engine/components/point_light.rb

@@ -1,24 +1,80 @@
-# frozen_string_literal: true
-
-module Engine::Components
-  class PointLight < Engine::Component
-    attr_accessor :range, :colour
-
-    def initialize(range: 300, colour: [1.0, 1.0, 1.0])
-      @range = range
-      @colour = colour
-    end
-
-    def start
-      PointLight.point_lights << self
-    end
-
-    def destroy!
-      PointLight.point_lights.delete(self)
-    end
-
-    def self.point_lights
-      @point_lights ||= []
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Engine::Components
+  class PointLight < Engine::Component
+    include Engine::MatrixHelpers
+
+    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
+      PointLight.point_lights << self
+    end
+
+    def destroy!
+      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

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

data/lib/engine/components/sprite_animator.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Engine::Components
+  class SpriteAnimator < Engine::Component
+    serialize :material, :frame_coords, :frame_rate, :loop
+
+    attr_reader :frame_rate, :loop
+
+    def awake
+      @frame_rate ||= 1
+      @loop = true if @loop.nil?
+    end
+
+    def start
+      @start_time = Time.now
+      update_frame
+    end
+
+    def update(delta_time)
+      update_frame
+    end
+
+    private
+
+    def update_frame
+      current_frame_index = ((Time.now - @start_time) * @frame_rate).to_i
+      current_frame_index = if @loop
+                              current_frame_index % @frame_coords.length
+                            else
+                              [@frame_coords.length - 1, current_frame_index].min
+                            end
+
+      frame = @frame_coords[current_frame_index]
+      @material.set_vec4("frameCoords", [
+        frame[:tl][0],
+        frame[:tl][1],
+        frame[:width],
+        frame[:height]
+      ])
+    end
+  end
+end

data/lib/engine/components/ui/flex/layout.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Engine::Components
+  module UI
+    module FlexLayout
+      class Base
+        def initialize(direction:, gap:)
+          @direction = direction
+          @gap = gap
+        end
+
+        def rect_for_child(child_ui_rect, index, children, parent_rect)
+          raise NotImplementedError
+        end
+
+        private
+
+        attr_reader :direction, :gap
+
+        def row?
+          @direction == :row
+        end
+
+        def main_axis_size(rect)
+          row? ? rect.width : rect.height
+        end
+
+        def total_gap(children)
+          @gap * (children.length - 1)
+        end
+
+        def build_rect(parent_rect, main_start:, main_size:, child_ui_rect: nil)
+          # Y-down coordinate system: both row and column increment main_start
+          if row?
+            # Cross-axis is vertical; use flex_height if specified, else stretch
+            cross_size = child_ui_rect&.flex_height
+            top, bottom = calculate_cross_axis_position(
+              parent_rect.top, parent_rect.bottom, cross_size, child_ui_rect&.flex_align
+            )
+
+            Engine::UI::Rect.new(
+              left: main_start,
+              right: main_start + main_size,
+              top: top,
+              bottom: bottom
+            )
+          else
+            # Cross-axis is horizontal; use flex_width if specified, else stretch
+            cross_size = child_ui_rect&.flex_width
+            left, right = calculate_cross_axis_position(
+              parent_rect.left, parent_rect.right, cross_size, child_ui_rect&.flex_align
+            )
+
+            Engine::UI::Rect.new(
+              left: left,
+              right: right,
+              top: main_start,
+              bottom: main_start + main_size
+            )
+          end
+        end
+
+        def calculate_cross_axis_position(cross_start, cross_end, cross_size, align)
+          # If no cross_size specified, stretch to fill
+          return [cross_start, cross_end] unless cross_size
+
+          align ||= :start
+          available = cross_end - cross_start
+
+          case align
+          when :start
+            [cross_start, cross_start + cross_size]
+          when :center
+            offset = (available - cross_size) / 2.0
+            [cross_start + offset, cross_start + offset + cross_size]
+          when :end
+            [cross_end - cross_size, cross_end]
+          else
+            [cross_start, cross_start + cross_size]
+          end
+        end
+
+        def main_axis_start(parent_rect)
+          row? ? parent_rect.left : parent_rect.top
+        end
+
+        def available_space(parent_rect, children)
+          size = row? ? parent_rect.width : parent_rect.height
+          size - total_gap(children)
+        end
+      end
+    end
+  end
+end

data/lib/engine/components/ui/flex/pack_layout.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Engine::Components
+  module UI
+    module FlexLayout
+      class Pack < Base
+        def initialize(direction:, gap:, justify:)
+          super(direction: direction, gap: gap)
+          @justify = justify
+        end
+
+        def rect_for_child(child_ui_rect, index, children, parent_rect)
+          sizes = children.map { |c| child_main_size(c) }
+          total_content = sizes.sum + total_gap(children)
+
+          available = row? ? parent_rect.width : parent_rect.height
+          start_offset = calculate_start_offset(available, total_content, children.length)
+
+          # Y-down: both row and column increment main_start
+          main_start = main_axis_start(parent_rect)
+          main_start += start_offset
+
+          children.each_with_index do |_, i|
+            break if i == index
+            main_start += sizes[i] + gap
+          end
+
+          build_rect(parent_rect, main_start: main_start, main_size: sizes[index], child_ui_rect: child_ui_rect)
+        end
+
+        private
+
+        def child_main_size(child_ui_rect)
+          size = row? ? child_ui_rect.flex_width : child_ui_rect.flex_height
+          unless size
+            property = row? ? "flex_width" : "flex_height"
+            raise "UI::Rect requires #{property} when parent Flex has justify: :#{@justify}"
+          end
+          size
+        end
+
+        def calculate_start_offset(available_space, total_content, child_count)
+          remaining = available_space - total_content
+
+          case @justify
+          when :start
+            0
+          when :end
+            remaining
+          when :center
+            remaining / 2.0
+          when :space_between
+            0
+          when :space_around
+            remaining / (child_count * 2.0)
+          when :space_evenly
+            remaining / (child_count + 1.0)
+          else
+            0
+          end
+        end
+      end
+    end
+  end
+end

data/lib/engine/components/ui/flex/stretch_layout.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Engine::Components
+  module UI
+    module FlexLayout
+      class Stretch < Base
+        def rect_for_child(child_ui_rect, index, children, parent_rect)
+          sizes = calculate_sizes(children, parent_rect)
+
+          # Y-down: both row and column increment main_start
+          main_start = main_axis_start(parent_rect)
+          children.each_with_index do |_, i|
+            break if i == index
+            main_start += sizes[i] + gap
+          end
+
+          build_rect(parent_rect, main_start: main_start, main_size: sizes[index], child_ui_rect: child_ui_rect)
+        end
+
+        private
+
+        def calculate_sizes(children, parent_rect)
+          available = available_space(parent_rect, children)
+
+          fixed_total = 0
+          total_weight = 0
+
+          children.each do |child|
+            fixed_size = row? ? child.flex_width : child.flex_height
+            if fixed_size
+              fixed_total += fixed_size
+            else
+              total_weight += child.flex_weight || 1
+            end
+          end
+
+          remaining = available - fixed_total
+          per_weight = total_weight > 0 ? remaining / total_weight.to_f : 0
+
+          children.map do |child|
+            fixed_size = row? ? child.flex_width : child.flex_height
+            if fixed_size
+              fixed_size
+            else
+              (child.flex_weight || 1) * per_weight
+            end
+          end
+        end
+      end
+    end
+  end
+end