arcanoae 0.1.0

data/lib/arcanoae/gui/controls.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+module Arcanoae
+  module GUI
+    class TextBlock < Control
+      attr_accessor :text, :text_wrapping, :resize_to_fit, :text_horizontal_alignment
+
+      def initialize(name = nil)
+        super
+        @text = ""
+        @text_wrapping = false
+        @resize_to_fit = false
+        @text_horizontal_alignment = HORIZONTAL_ALIGNMENT_LEFT
+      end
+    end
+
+    class Button < Container
+      attr_accessor :text_block, :image, :background, :corner_radius
+      attr_accessor :thickness, :hover_background
+
+      def initialize(name = nil)
+        super
+        @text_block = TextBlock.new
+        @image = nil
+        @background = "gray"
+        @hover_background = "lightgray"
+        @corner_radius = 4
+        @thickness = 1
+        add_control(@text_block)
+      end
+
+      def self.create_simple_button(name, text)
+        button = new(name)
+        button.text_block.text = text
+        button
+      end
+
+      def self.create_image_button(name, text, image_url)
+        button = new(name)
+        button.text_block.text = text
+        button.image = Image.new
+        button.image.source = image_url
+        button.add_control(button.image)
+        button
+      end
+    end
+
+    class Image < Control
+      attr_accessor :source, :stretch, :auto_scale
+
+      STRETCH_NONE = 0
+      STRETCH_FILL = 1
+      STRETCH_UNIFORM = 2
+      STRETCH_EXTEND = 3
+
+      def initialize(name = nil)
+        super
+        @source = nil
+        @stretch = STRETCH_UNIFORM
+        @auto_scale = false
+      end
+    end
+
+    class Slider < Control
+      attr_accessor :minimum, :maximum, :value, :step
+      attr_accessor :bar_color, :thumb_color, :is_vertical
+
+      def initialize(name = nil)
+        super
+        @minimum = 0
+        @maximum = 100
+        @value = 50
+        @step = 1
+        @bar_color = "gray"
+        @thumb_color = "white"
+        @is_vertical = false
+        @on_value_changed_callbacks = []
+      end
+
+      def on_value_changed(&block)
+        @on_value_changed_callbacks << block if block
+        self
+      end
+
+      def value=(new_value)
+        clamped = [[new_value, @minimum].max, @maximum].min
+        return if @value == clamped
+
+        @value = clamped
+        @on_value_changed_callbacks.each { |cb| cb.call(@value) }
+      end
+    end
+
+    class Checkbox < Control
+      attr_accessor :is_checked, :check_size_ratio, :background, :check_color
+
+      def initialize(name = nil)
+        super
+        @is_checked = false
+        @check_size_ratio = 0.8
+        @background = "gray"
+        @check_color = "white"
+        @on_checked_changed_callbacks = []
+      end
+
+      def on_checked_changed(&block)
+        @on_checked_changed_callbacks << block if block
+        self
+      end
+
+      def toggle
+        self.is_checked = !@is_checked
+      end
+
+      def is_checked=(value)
+        return if @is_checked == value
+
+        @is_checked = value
+        @on_checked_changed_callbacks.each { |cb| cb.call(@is_checked) }
+      end
+    end
+
+    class StackPanel < Container
+      attr_accessor :is_vertical, :spacing
+
+      def initialize(name = nil)
+        super
+        @is_vertical = true
+        @spacing = 5
+      end
+    end
+
+    class Grid < Container
+      def initialize(name = nil)
+        super
+        @column_definitions = []
+        @row_definitions = []
+        @cell_info = {}
+      end
+
+      def add_column_definition(width, is_pixel = false)
+        @column_definitions << { width: width, is_pixel: is_pixel }
+        self
+      end
+
+      def add_row_definition(height, is_pixel = false)
+        @row_definitions << { height: height, is_pixel: is_pixel }
+        self
+      end
+
+      def add_control(control, row = 0, column = 0)
+        super(control)
+        @cell_info[control] = { row: row, column: column }
+        self
+      end
+
+      def get_cell_info(control)
+        @cell_info[control]
+      end
+
+      attr_reader :column_definitions, :row_definitions
+    end
+
+    class AdvancedDynamicTexture < Container
+      attr_accessor :ideal_width, :ideal_height, :render_at_ideal_size
+
+      def initialize(name = nil)
+        super
+        @ideal_width = 1024
+        @ideal_height = 1024
+        @render_at_ideal_size = false
+        @is_foreground = true
+      end
+
+      def self.create_full_screen_ui(name, foreground = true, scene = nil)
+        texture = new(name)
+        texture.instance_variable_set(:@is_foreground, foreground)
+        texture.instance_variable_set(:@scene, scene)
+        texture
+      end
+
+      def self.create_for_mesh(mesh, width = 1024, height = 1024)
+        texture = new("MeshUI")
+        texture.ideal_width = width
+        texture.ideal_height = height
+        texture.instance_variable_set(:@mesh, mesh)
+        texture
+      end
+
+      def foreground?
+        @is_foreground
+      end
+    end
+  end
+end

data/lib/arcanoae/input/input_manager.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module Arcanoae
+  module Input
+    class InputManager
+      attr_reader :pointer_x, :pointer_y
+      attr_reader :pointer_delta_x, :pointer_delta_y
+
+      def initialize(scene = nil)
+        @scene = scene
+        @keys_down = {}
+        @keys_pressed = {}
+        @keys_released = {}
+        @mouse_buttons = {}
+        @pointer_x = 0
+        @pointer_y = 0
+        @pointer_delta_x = 0
+        @pointer_delta_y = 0
+        @mouse_wheel = 0
+        @gamepads = []
+        @callbacks = {
+          key_down: [],
+          key_up: [],
+          pointer_down: [],
+          pointer_up: [],
+          pointer_move: []
+        }
+      end
+
+      def key_down?(key_code)
+        @keys_down[key_code] || false
+      end
+
+      def key_pressed?(key_code)
+        @keys_pressed[key_code] || false
+      end
+
+      def key_released?(key_code)
+        @keys_released[key_code] || false
+      end
+
+      def mouse_button_down?(button)
+        @mouse_buttons[button] || false
+      end
+
+      attr_reader :mouse_wheel
+
+      def gamepads
+        @gamepads.dup
+      end
+
+      def gamepad(index)
+        @gamepads[index]
+      end
+
+      def on_key_down(&block)
+        @callbacks[:key_down] << block if block
+        self
+      end
+
+      def on_key_up(&block)
+        @callbacks[:key_up] << block if block
+        self
+      end
+
+      def on_pointer_down(&block)
+        @callbacks[:pointer_down] << block if block
+        self
+      end
+
+      def on_pointer_up(&block)
+        @callbacks[:pointer_up] << block if block
+        self
+      end
+
+      def on_pointer_move(&block)
+        @callbacks[:pointer_move] << block if block
+        self
+      end
+
+      def process_key_down(key_code)
+        was_down = @keys_down[key_code]
+        @keys_down[key_code] = true
+        @keys_pressed[key_code] = !was_down
+        @callbacks[:key_down].each { |cb| cb.call(key_code) }
+      end
+
+      def process_key_up(key_code)
+        @keys_down[key_code] = false
+        @keys_released[key_code] = true
+        @callbacks[:key_up].each { |cb| cb.call(key_code) }
+      end
+
+      def process_pointer_move(x, y)
+        @pointer_delta_x = x - @pointer_x
+        @pointer_delta_y = y - @pointer_y
+        @pointer_x = x
+        @pointer_y = y
+        @callbacks[:pointer_move].each { |cb| cb.call(x, y) }
+      end
+
+      def process_pointer_down(button, x, y)
+        @mouse_buttons[button] = true
+        @callbacks[:pointer_down].each { |cb| cb.call(button, x, y) }
+      end
+
+      def process_pointer_up(button, x, y)
+        @mouse_buttons[button] = false
+        @callbacks[:pointer_up].each { |cb| cb.call(button, x, y) }
+      end
+
+      def process_mouse_wheel(delta)
+        @mouse_wheel = delta
+      end
+
+      def update
+        @keys_pressed.clear
+        @keys_released.clear
+        @mouse_wheel = 0
+        @pointer_delta_x = 0
+        @pointer_delta_y = 0
+      end
+
+      def dispose
+        @callbacks.each_value(&:clear)
+        @keys_down.clear
+        @mouse_buttons.clear
+      end
+    end
+
+    class Gamepad
+      attr_reader :id, :index
+      attr_accessor :connected
+
+      def initialize(id, index)
+        @id = id
+        @index = index
+        @connected = true
+        @buttons = {}
+        @axes = {}
+      end
+
+      def connected?
+        @connected
+      end
+
+      def button_down?(button)
+        @buttons[button] || false
+      end
+
+      def axis(axis_index)
+        @axes[axis_index] || 0.0
+      end
+
+      def update_button(button, pressed)
+        @buttons[button] = pressed
+      end
+
+      def update_axis(axis_index, value)
+        @axes[axis_index] = value
+      end
+
+      def left_stick
+        Math::Vector2.new(axis(0), axis(1))
+      end
+
+      def right_stick
+        Math::Vector2.new(axis(2), axis(3))
+      end
+    end
+  end
+end

data/lib/arcanoae/lights/directional_light.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Arcanoae
+  module Lights
+    class DirectionalLight < Light
+      attr_accessor :direction
+
+      def initialize(name, direction, scene = nil)
+        super(name, scene)
+        @direction = direction.normalize
+      end
+
+      def transfer_to_effect(effect, light_index)
+        {
+          type: :directional,
+          direction: @direction,
+          diffuse: @diffuse,
+          specular: @specular,
+          intensity: @intensity
+        }
+      end
+    end
+  end
+end

data/lib/arcanoae/lights/hemispheric_light.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Arcanoae
+  module Lights
+    class HemisphericLight < Light
+      attr_accessor :direction, :ground_color
+
+      def initialize(name, direction, scene = nil)
+        super(name, scene)
+        @direction = direction.normalize
+        @ground_color = Math::Color3.black
+      end
+
+      def transfer_to_effect(effect, light_index)
+        {
+          type: :hemispheric,
+          direction: @direction,
+          diffuse: @diffuse,
+          ground_color: @ground_color,
+          specular: @specular,
+          intensity: @intensity
+        }
+      end
+    end
+  end
+end

data/lib/arcanoae/lights/light.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Arcanoae
+  module Lights
+    class Light < Scene::TransformNode
+      attr_accessor :diffuse, :specular, :intensity, :range
+
+      def initialize(name, scene = nil)
+        super(name, scene)
+        @diffuse = Math::Color3.white
+        @specular = Math::Color3.white
+        @intensity = 1.0
+        @range = Float::INFINITY
+
+        scene&.add_light(self)
+      end
+
+      def transfer_to_effect(effect, light_index)
+        # Override in subclasses
+      end
+
+      def dispose
+        return if disposed?
+
+        @scene&.remove_light(self)
+        super
+      end
+    end
+  end
+end

data/lib/arcanoae/lights/point_light.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Arcanoae
+  module Lights
+    class PointLight < Light
+      def initialize(name, position, scene = nil)
+        super(name, scene)
+        @position = position.clone
+      end
+
+      def transfer_to_effect(effect, light_index)
+        {
+          type: :point,
+          position: @position,
+          diffuse: @diffuse,
+          specular: @specular,
+          intensity: @intensity,
+          range: @range
+        }
+      end
+    end
+  end
+end

data/lib/arcanoae/lights/shadow_generator.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module Arcanoae
+  module Lights
+    class ShadowGenerator
+      include Arcanoae::Disposable
+
+      attr_reader :light, :shadow_map
+      attr_accessor :map_size, :bias, :darkness
+      attr_accessor :use_percentage_closer_filtering
+      attr_accessor :filter_quality
+      attr_reader :shadow_casters
+
+      DEFAULT_MAP_SIZE = 1024
+      DEFAULT_BIAS = 0.00005
+      DEFAULT_DARKNESS = 0.0
+
+      def initialize(map_size, light)
+        @map_size = map_size || DEFAULT_MAP_SIZE
+        @light = light
+        @bias = DEFAULT_BIAS
+        @darkness = DEFAULT_DARKNESS
+        @use_percentage_closer_filtering = false
+        @filter_quality = :medium
+        @shadow_casters = []
+        @shadow_map = nil
+
+        create_shadow_map
+      end
+
+      def add_shadow_caster(mesh, include_descendants: false)
+        return if @shadow_casters.include?(mesh)
+
+        @shadow_casters << mesh
+
+        if include_descendants && mesh.respond_to?(:get_descendants)
+          mesh.get_descendants.each do |descendant|
+            add_shadow_caster(descendant, include_descendants: false)
+          end
+        end
+      end
+
+      def remove_shadow_caster(mesh, include_descendants: false)
+        @shadow_casters.delete(mesh)
+
+        if include_descendants && mesh.respond_to?(:get_descendants)
+          mesh.get_descendants.each do |descendant|
+            remove_shadow_caster(descendant, include_descendants: false)
+          end
+        end
+      end
+
+      def get_shadow_map
+        @shadow_map
+      end
+
+      def is_ready?
+        @shadow_map&.ready?
+      end
+
+      def prepare_shadow_map
+        return unless @shadow_map
+
+        calculate_light_matrices
+        render_shadow_casters
+      end
+
+      def get_transformation_matrix
+        @transform_matrix ||= Math::Matrix4.identity
+      end
+
+      def recreate_shadow_map
+        dispose_shadow_map
+        create_shadow_map
+      end
+
+      def dispose
+        return if disposed?
+
+        dispose_shadow_map
+        @shadow_casters.clear
+
+        super
+      end
+
+      private
+
+      def create_shadow_map
+        return unless @light&.scene
+
+        @shadow_map = Textures::RenderTargetTexture.new(
+          "#{@light.name}_shadowMap",
+          @map_size,
+          @light.scene,
+          generate_mip_maps: false
+        )
+
+        @transform_matrix = Math::Matrix4.identity
+      end
+
+      def dispose_shadow_map
+        @shadow_map&.dispose
+        @shadow_map = nil
+      end
+
+      def calculate_light_matrices
+        return unless @light
+
+        if @light.is_a?(DirectionalLight)
+          calculate_directional_light_matrices
+        elsif @light.is_a?(PointLight)
+          calculate_point_light_matrices
+        end
+      end
+
+      def calculate_directional_light_matrices
+        direction = @light.direction.normalize
+        up = if direction.y.abs > 0.99
+               Math::Vector3.forward
+             else
+               Math::Vector3.up
+             end
+
+        view_matrix = Math::Matrix4.look_at(
+          Math::Vector3.zero - direction * 50,
+          Math::Vector3.zero,
+          up
+        )
+
+        projection_matrix = Math::Matrix4.orthographic(-50, 50, -50, 50, 0.1, 200)
+
+        @transform_matrix = projection_matrix * view_matrix
+      end
+
+      def calculate_point_light_matrices
+        @transform_matrix = Math::Matrix4.identity
+      end
+
+      def render_shadow_casters
+        @shadow_casters.each do |mesh|
+          next unless mesh.is_visible && mesh.cast_shadows
+
+          render_mesh_to_shadow_map(mesh)
+        end
+      end
+
+      def render_mesh_to_shadow_map(mesh)
+      end
+    end
+  end
+end