ruby_rpg 0.0.4 → 0.1.0

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

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative "flex/layout"
+require_relative "flex/stretch_layout"
+require_relative "flex/pack_layout"
+
+module Engine::Components
+  module UI
+    class Flex < Engine::Component
+      serialize :direction, :gap, :justify
+
+      attr_reader :direction, :gap, :justify
+
+      def awake
+        @direction ||= :row
+        @gap ||= 0
+        @justify ||= :stretch
+      end
+
+      def start
+        @ui_rect = game_object.component(UI::Rect)
+        raise "UI::Flex requires a UI::Rect component on the same GameObject" unless @ui_rect
+      end
+
+      def rect_for_child(child_ui_rect)
+        children = child_ui_rects
+        index = children.index(child_ui_rect)
+        return nil unless index
+
+        parent_rect = @ui_rect.computed_rect
+        layout.rect_for_child(child_ui_rect, index, children, parent_rect)
+      end
+
+      private
+
+      def layout
+        @layout ||= create_layout
+      end
+
+      def create_layout
+        if @justify == :stretch
+          FlexLayout::Stretch.new(direction: @direction, gap: @gap)
+        else
+          FlexLayout::Pack.new(direction: @direction, gap: @gap, justify: @justify)
+        end
+      end
+
+      def child_ui_rects
+        @child_ui_rects_cache ||= game_object.children
+          .map { |child| child.component(UI::Rect) }
+          .compact
+      end
+
+      def invalidate_cache
+        @child_ui_rects_cache = nil
+        @layout = nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Engine::Components
+  module UI
+    class FontRenderer < FontRendererBase
+      def ui_renderer?
+        true
+      end
+
+      def start
+        @ui_rect = game_object.component(UI::Rect)
+        raise "UI::FontRenderer requires a UI::Rect component on the same GameObject" unless @ui_rect
+
+        super
+      end
+
+      private
+
+      def shader
+        @shader ||= Engine::Shader.ui_text
+      end
+
+      def set_shader_camera_matrix
+        # Y-down coordinate system: (0,0) at top-left, Y increases downward
+        camera_matrix = Matrix[
+          [2.0 / Engine::Window.framebuffer_width, 0, 0, 0],
+          [0, -2.0 / Engine::Window.framebuffer_height, 0, 0],
+          [0, 0, 1, 0],
+          [-1, 1, 0, 1]
+        ]
+        shader.set_mat4("camera", camera_matrix)
+      end
+
+      def set_shader_model_matrix
+        rect = @ui_rect.computed_rect
+
+        # Scale text to match rect height
+        # The base quad is 1 unit tall, so scale = rect height
+        scale = rect.height
+
+        # Position at left edge of rect, vertically centered
+        # Y-down: position from top, with negative scale to flip
+        x = rect.left + (scale * 0.5)
+        y = rect.top + (scale * 0.5)
+
+        model_matrix = Matrix[
+          [scale, 0, 0, 0],
+          [0, scale, 0, 0],
+          [0, 0, 1, 0],
+          [x, y, 0, 1]
+        ]
+
+        shader.set_mat4("model", model_matrix)
+      end
+    end
+  end
+end

data/lib/engine/components/ui/rect.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Engine::Components
+  module UI
+    class Rect < Engine::Component
+      serialize :left_ratio, :right_ratio, :top_ratio, :bottom_ratio,
+                :left_offset, :right_offset, :top_offset, :bottom_offset,
+                :flex_width, :flex_height, :flex_weight, :flex_align,
+                :z_layer, :mask
+
+      attr_reader :left_ratio, :right_ratio, :top_ratio, :bottom_ratio,
+                  :left_offset, :right_offset, :top_offset, :bottom_offset,
+                  :flex_width, :flex_height, :flex_weight, :flex_align,
+                  :mask
+
+      def self.rects
+        @rects ||= []
+      end
+
+      def self.draw_all
+        rects.each do |rect|
+          Rendering::UI::StencilManager.setup_for_rect(rect)
+          rect.game_object.ui_renderers.each(&:draw)
+        end
+        Rendering::UI::StencilManager.reset
+      end
+
+      def awake
+        @left_ratio    ||= 0.0
+        @right_ratio   ||= 0.0
+        @bottom_ratio  ||= 0.0
+        @top_ratio     ||= 0.0
+        @left_offset   ||= 0
+        @right_offset  ||= 0
+        @bottom_offset ||= 0
+        @top_offset    ||= 0
+        @flex_weight   ||= 1
+        @mask          ||= false
+      end
+
+      def start
+        insert_sorted
+      end
+
+      def destroy
+        Rect.rects.delete(self)
+      end
+
+      def z_layer=(value)
+        @z_layer = value
+        reposition
+      end
+
+      def z_layer
+        return @z_layer if @z_layer
+
+        parent_ui = game_object.parent&.component(UI::Rect)
+        parent_ui ? parent_ui.z_layer + 10 : 0
+      end
+
+      def parent_rect
+        parent_ui = game_object.parent&.component(UI::Rect)
+        parent_ui&.computed_rect || screen_rect
+      end
+
+      def screen_rect
+        # Y-down: top=0, bottom=height
+        Engine::UI::Rect.new(
+          left: 0,
+          right: Engine::Window.framebuffer_width,
+          top: 0,
+          bottom: Engine::Window.framebuffer_height
+        )
+      end
+
+      def computed_rect
+        # Check if parent has a layout component
+        parent_flex = game_object.parent&.component(UI::Flex)
+        return parent_flex.rect_for_child(self) if parent_flex
+
+        pr = parent_rect
+
+        # Y-down: top increases downward from parent top, bottom decreases upward from parent bottom
+        Engine::UI::Rect.new(
+          left:   pr.left   + (pr.width  * @left_ratio)   + @left_offset,
+          right:  pr.right  - (pr.width  * @right_ratio)  - @right_offset,
+          top:    pr.top    + (pr.height * @top_ratio)    + @top_offset,
+          bottom: pr.bottom - (pr.height * @bottom_ratio) - @bottom_offset
+        )
+      end
+
+      def ancestor_masks
+        masks = []
+        current = game_object.parent
+        while current
+          rect_component = current.component(UI::Rect)
+          masks.unshift(rect_component) if rect_component&.mask
+          current = current.parent
+        end
+        masks
+      end
+
+      private
+
+      def insert_sorted
+        z = z_layer
+        index = Rect.rects.bsearch_index { |r| r.z_layer > z } || Rect.rects.length
+        Rect.rects.insert(index, self)
+      end
+
+      def reposition
+        Rect.rects.delete(self)
+        insert_sorted
+      end
+    end
+  end
+end

data/lib/engine/components/ui/sprite_clickbox.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Engine::Components
+  module UI
+    class SpriteClickbox < Engine::Component
+      attr_reader :mouse_inside, :clicked, :mouse_entered, :mouse_exited
+
+      def awake
+        @mouse_inside = false
+        @clicked = false
+        @mouse_entered = false
+        @mouse_exited = false
+      end
+
+      def start
+        @ui_rect = game_object.component(UI::Rect)
+        raise "UI::SpriteClickbox requires a UI::Rect component" unless @ui_rect
+      end
+
+      def update(delta_time)
+        mouse_pos = Engine::Input.mouse_pos
+        return unless mouse_pos
+
+        if point_inside?(mouse_pos)
+          @mouse_entered = !@mouse_inside
+          @mouse_inside = true
+          @clicked = Engine::Input.key_down?(Engine::Input::MOUSE_BUTTON_LEFT)
+        else
+          @mouse_exited = @mouse_inside
+          @mouse_inside = false
+        end
+      end
+
+      private
+
+      def point_inside?(point)
+        rect = @ui_rect.computed_rect
+
+        # Y-down: top < bottom
+        point[0] >= rect.left &&
+          point[0] <= rect.right &&
+          point[1] >= rect.top &&
+          point[1] <= rect.bottom
+      end
+    end
+  end
+end

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

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Engine::Components
+  module UI
+    class SpriteRenderer < Engine::Component
+      serialize :material
+
+      attr_reader :material
+
+      def ui_renderer?
+        true
+      end
+
+      def start
+        @ui_rect = game_object.component(UI::Rect)
+        raise "UI::SpriteRenderer requires a UI::Rect component on the same GameObject" unless @ui_rect
+
+        setup_vertex_attribute_buffer
+        setup_index_buffer
+        setup_vertex_buffer
+        Engine::GL.BindVertexArray(0)
+      end
+
+      def draw
+        rect = @ui_rect.computed_rect
+
+        Engine::GL.BindVertexArray(@vao)
+        Engine::GL.BindBuffer(Engine::GL::ELEMENT_ARRAY_BUFFER, @ebo)
+
+        update_vertex_buffer(rect)
+        set_material_per_frame_data
+
+        Engine::GL.DrawElements(Engine::GL::TRIANGLES, 6, Engine::GL::UNSIGNED_INT, 0)
+      end
+
+      private
+
+      def set_material_per_frame_data
+        set_camera_matrix
+        material.set_mat4("model", Matrix.identity(4))
+        material.update_shader
+      end
+
+      def set_camera_matrix
+        # Y-down coordinate system: (0,0) at top-left, Y increases downward
+        camera_matrix = Matrix[
+          [2.0 / Engine::Window.framebuffer_width, 0, 0, 0],
+          [0, -2.0 / Engine::Window.framebuffer_height, 0, 0],
+          [0, 0, 1, 0],
+          [-1, 1, 0, 1]
+        ]
+        material.set_mat4("camera", camera_matrix)
+      end
+
+      def setup_index_buffer
+        # Counter-clockwise winding for front faces
+        # v0=bottom-left, v1=bottom-right, v2=top-right, v3=top-left
+        indices = [
+          0, 1, 2,
+          0, 2, 3
+        ]
+
+        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, 6 * 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]
+
+        Engine::GL.BindBuffer(Engine::GL::ARRAY_BUFFER, @vbo)
+        Engine::GL.BufferData(
+          Engine::GL::ARRAY_BUFFER, 4 * 5 * Fiddle::SIZEOF_FLOAT,
+          nil, Engine::GL::DYNAMIC_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)
+      end
+
+      def update_vertex_buffer(rect)
+        return if @cached_rect == rect
+        @cached_rect = rect
+
+        # UV V=1 at screen bottom, V=0 at screen top (matches PNG top-to-bottom storage)
+        vertices = [
+          rect.left,  rect.bottom, 0, 0, 1,  # bottom-left
+          rect.right, rect.bottom, 0, 1, 1,  # bottom-right
+          rect.right, rect.top,    0, 1, 0,  # top-right
+          rect.left,  rect.top,    0, 0, 0   # top-left
+        ]
+
+        Engine::GL.BindBuffer(Engine::GL::ARRAY_BUFFER, @vbo)
+        Engine::GL.BufferSubData(
+          Engine::GL::ARRAY_BUFFER, 0, vertices.length * Fiddle::SIZEOF_FLOAT,
+          vertices.pack('F*')
+        )
+      end
+    end
+  end
+end

data/lib/engine/compute_shader.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Engine
+  class ComputeShader
+    def self.new(shader_path)
+      if OS.mac?
+        metal_path = shader_path.sub(/\.(comp|glsl)$/, '.metal')
+        Metal::ComputeShader.new(metal_path)
+      else
+        OpenGL::ComputeShader.new(shader_path)
+      end
+    end
+  end
+end

data/lib/engine/compute_texture.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Engine
+  class ComputeTexture
+    def self.new(width, height)
+      if OS.mac?
+        Metal::ComputeTexture.new(width, height)
+      else
+        OpenGL::ComputeTexture.new(width, height)
+      end
+    end
+  end
+end

data/lib/engine/debugging.rb

@@ -26,16 +26,16 @@ module Engine
 
     def self.debug_opengl_call
       errors = []
-      until GL.GetError == 0; end
+      until Engine::GL.GetError == 0; end
       yield
-      until (error = GL.GetError) == 0
+      until (error = Engine::GL.GetError) == 0
         errors += error.to_s(16)
       end
     end
 
     def self.print_opengl_version
-      puts "OpenGL Version: #{GL.GetString(GL::VERSION)}"
-      puts "GLSL Version: #{GL.GetString(GL::SHADING_LANGUAGE_VERSION)}"
+      puts "OpenGL Version: #{Engine::GL.GetString(Engine::GL::VERSION)}"
+      puts "GLSL Version: #{Engine::GL.GetString(Engine::GL::SHADING_LANGUAGE_VERSION)}"
     end
   end
 end