ruby_rpg 0.0.5 → 0.1.0

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

@@ -1,93 +1,14 @@
-module Engine
-  class ComputeShader
-    def initialize(compute_shader)
-      @uniform_locations = {}
-      @compute_shader = compile_shader(compute_shader)
-      @program = GL.CreateProgram
-      GL.AttachShader(@program, @compute_shader)
-      GL.LinkProgram(@program)
-
-      linked_buf = ' ' * 4
-      GL.GetProgramiv(@program, GL::LINK_STATUS, linked_buf)
-      linked = linked_buf.unpack('L')[0]
-      if linked == 0
-        compile_log = ' ' * 1024
-        GL.GetProgramInfoLog(@program, 1023, nil, compile_log)
-        compute_log = ' ' * 1024
-        GL.GetShaderInfoLog(@compute_shader, 1023, nil, compute_log)
-        puts "Shader program failed to link"
-        puts compile_log.strip
-        puts compute_log.strip
-      end
-      @uniform_cache = {}
-      @uniform_locations = {}
-    end
-
-    def compile_shader(shader)
-      handle = GL.CreateShader(GL::COMPUTE_SHADER)
-      path = File.expand_path(File.join(GAME_DIR, shader))
-      s_srcs = [File.read(path)].pack('p')
-      s_lens = [File.size(path)].pack('I')
-      GL.ShaderSource(handle, 1, s_srcs, s_lens)
-      GL.CompileShader(handle)
-      handle
-    end
-
-    def dispatch(x, y, z, floats: {}, textures: [], ints: {}, vec3s: {}, vec4s: {}, mat4s: {})
-      textures.each_with_index { |texture, slot| set_texture(slot, texture) }
-
-      GL.UseProgram(@program)
-
-      floats.each { |name, value| set_float(name, value) }
-      ints.each { |name, value| set_int(name, value) }
-      vec3s.each { |name, value| set_vec3(name, value) }
-      vec4s.each { |name, value| set_vec4(name, value) }
-      mat4s.each { |name, value| set_mat4(name, value) }
-
-      GL.DispatchCompute(x, y, z)
-      GL.MemoryBarrier(GL::SHADER_IMAGE_ACCESS_BARRIER_BIT)
-    end
-
-    private
-
-    def set_float(name, float)
-      GL.Uniform1f(uniform_location(name), float)
-    end
-
-    def set_texture(slot, texture)
-      #puts "set #{slot}, to #{texture}"
-      GL.ActiveTexture(Object.const_get("GL::TEXTURE#{slot}"))
-      if texture
-        GL.BindImageTexture(slot, texture, 0, GL::FALSE, 0, GL::READ_WRITE, GL::RGBA32F)
-      else
-        GL.BindImageTexture(slot, 0, 0, GL::FALSE, 0, GL::READ_WRITE, GL::RGBA32F)
-      end
-    end
-
-    def set_vec3(name, vec)
-      GL.Uniform3f(uniform_location(name), vector[0], vector[1], vector[2])
-    end
-
-    def set_vec4(name, vec)
-      GL.Uniform4f(uniform_location(name), vec[0], vec[1], vec[2], vec[3])
-    end
-
-    def set_mat4(name, mat)
-      mat_array = [
-        mat[0, 0], mat[0, 1], mat[0, 2], mat[0, 3],
-        mat[1, 0], mat[1, 1], mat[1, 2], mat[1, 3],
-        mat[2, 0], mat[2, 1], mat[2, 2], mat[2, 3],
-        mat[3, 0], mat[3, 1], mat[3, 2], mat[3, 3]
-      ]
-      GL.UniformMatrix4fv(uniform_location(name), 1, GL::FALSE, mat_array.pack('F*'))
-    end
-
-    def set_int(name, int)
-      GL.Uniform1i(uniform_location(name), int)
-    end
-
-    def uniform_location(name)
-      @uniform_locations[name] ||= GL.GetUniformLocation(@program, name)
-    end
-  end
-end
+# 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/cursor.rb

@@ -1,43 +1,43 @@
-# frozen_string_literal: true
-
-module Engine
-  class Cursor
-    class << self
-
-      def supported_modes
-        {
-          :enable   => GLFW::CURSOR_NORMAL,
-          :disable  => GLFW::CURSOR_DISABLED,
-          :hide     => GLFW::CURSOR_HIDDEN
-        }
-      end
-
-      def enable
-        set_input_mode(:enable)
-      end
-
-      def disable
-        set_input_mode(:disable)
-      end
-
-      def hide
-        set_input_mode(:hide)
-      end
-
-      # Expects a symbol present in supported_modes, e.g. ':hide'
-      def set_input_mode(mode)
-        GLFW.SetInputMode(Window.window, GLFW::CURSOR, supported_modes[mode])
-      end
-
-      # Returns a symbol from the supported_modes, e.g. ':hide'
-      def get_input_mode
-        supported_modes.key(GLFW.GetInputMode(Window.window, GLFW::CURSOR))
-      end
-
-      # Expects a symbol present in supported_modes, e.g. ':hide'
-      def restore_input_mode(original_mode)
-        set_input_mode(original_mode)
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Engine
+  class Cursor
+    class << self
+
+      def supported_modes
+        {
+          :enable   => GLFW::CURSOR_NORMAL,
+          :disable  => GLFW::CURSOR_DISABLED,
+          :hide     => GLFW::CURSOR_HIDDEN
+        }
+      end
+
+      def enable
+        set_input_mode(:enable)
+      end
+
+      def disable
+        set_input_mode(:disable)
+      end
+
+      def hide
+        set_input_mode(:hide)
+      end
+
+      # Expects a symbol present in supported_modes, e.g. ':hide'
+      def set_input_mode(mode)
+        GLFW.SetInputMode(Window.window, GLFW::CURSOR, supported_modes[mode])
+      end
+
+      # Returns a symbol from the supported_modes, e.g. ':hide'
+      def get_input_mode
+        supported_modes.key(GLFW.GetInputMode(Window.window, GLFW::CURSOR))
+      end
+
+      # Expects a symbol present in supported_modes, e.g. ':hide'
+      def restore_input_mode(original_mode)
+        set_input_mode(original_mode)
+      end
+    end
+  end
+end

data/lib/engine/debugging.rb

@@ -1,41 +1,41 @@
-# frozen_string_literal: true
-
-module Engine
-  module Debugging
-
-    # Hit a breakpoint within the context of where the breakpoint is defined, assuming a block is passed
-    # with a `binding.pry` (or an alternative debugger), otherwise hit a breakpoint within this method.
-    def self.breakpoint(&block)
-      orig_fullscreen = Window.full_screen?
-      if orig_fullscreen
-        Window.set_to_windowed
-        GLFW.PollEvents # Required to trigger the switch from fullscreen to windowed within this breakpoint
-      end
-
-      orig_cursor_mode = Cursor.get_input_mode
-      Cursor.enable
-
-      block_given? ? yield : binding.pry
-      Cursor.restore_input_mode(orig_cursor_mode)
-      Window.set_to_full_screen if orig_fullscreen
-      Window.focus_window
-
-      # Reset the time, otherwise delta_time will be off for the next frame, and teleporting occurs
-      @time = Time.now
-    end
-
-    def self.debug_opengl_call
-      errors = []
-      until GL.GetError == 0; end
-      yield
-      until (error = 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)}"
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Engine
+  module Debugging
+
+    # Hit a breakpoint within the context of where the breakpoint is defined, assuming a block is passed
+    # with a `binding.pry` (or an alternative debugger), otherwise hit a breakpoint within this method.
+    def self.breakpoint(&block)
+      orig_fullscreen = Window.full_screen?
+      if orig_fullscreen
+        Window.set_to_windowed
+        GLFW.PollEvents # Required to trigger the switch from fullscreen to windowed within this breakpoint
+      end
+
+      orig_cursor_mode = Cursor.get_input_mode
+      Cursor.enable
+
+      block_given? ? yield : binding.pry
+      Cursor.restore_input_mode(orig_cursor_mode)
+      Window.set_to_full_screen if orig_fullscreen
+      Window.focus_window
+
+      # Reset the time, otherwise delta_time will be off for the next frame, and teleporting occurs
+      @time = Time.now
+    end
+
+    def self.debug_opengl_call
+      errors = []
+      until Engine::GL.GetError == 0; end
+      yield
+      until (error = Engine::GL.GetError) == 0
+        errors += error.to_s(16)
+      end
+    end
+
+    def self.print_opengl_version
+      puts "OpenGL Version: #{Engine::GL.GetString(Engine::GL::VERSION)}"
+      puts "GLSL Version: #{Engine::GL.GetString(Engine::GL::SHADING_LANGUAGE_VERSION)}"
+    end
+  end
+end