arcanoae 0.1.0

data/lib/arcanoae/audio/sound.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module Arcanoae
+  module Audio
+    class Sound
+      include Arcanoae::Disposable
+
+      attr_accessor :name, :loop, :volume, :playback_rate
+      attr_accessor :spatial_sound
+      attr_reader :url, :scene, :attached_mesh
+
+      def initialize(name, url, scene, options = {})
+        @name = name
+        @url = url
+        @scene = scene
+
+        @loop = options.fetch(:loop, false)
+        @volume = options.fetch(:volume, 1.0)
+        @playback_rate = options.fetch(:playback_rate, 1.0)
+        @spatial_sound = options.fetch(:spatial_sound, false)
+        @autoplay = options.fetch(:autoplay, false)
+
+        @is_playing = false
+        @is_paused = false
+        @is_ready = false
+        @attached_mesh = nil
+        @position = Math::Vector3.zero
+
+        @on_ready_callbacks = []
+        @on_ended_callbacks = []
+
+        load_sound(url) if url
+
+        scene.audio_engine&.add_sound(self)
+      end
+
+      def play(time = 0, offset = 0)
+        return unless @is_ready
+
+        @is_playing = true
+        @is_paused = false
+      end
+
+      def pause
+        return unless @is_playing
+
+        @is_paused = true
+        @is_playing = false
+      end
+
+      def stop
+        @is_playing = false
+        @is_paused = false
+      end
+
+      def resume
+        return unless @is_paused
+
+        @is_paused = false
+        @is_playing = true
+      end
+
+      def playing?
+        @is_playing && !@is_paused
+      end
+
+      def paused?
+        @is_paused
+      end
+
+      def ready?
+        @is_ready
+      end
+
+      def set_position(position)
+        @position = position
+      end
+
+      def get_position
+        @position
+      end
+
+      def attach_to_mesh(mesh)
+        @attached_mesh = mesh
+        @spatial_sound = true
+      end
+
+      def detach_from_mesh
+        @attached_mesh = nil
+      end
+
+      def update(delta_time)
+        if @attached_mesh && @spatial_sound
+          @position = @attached_mesh.absolute_position
+        end
+      end
+
+      def update_volume
+      end
+
+      def on_ready(&block)
+        @on_ready_callbacks << block
+        block.call if @is_ready
+      end
+
+      def on_ended(&block)
+        @on_ended_callbacks << block
+      end
+
+      def dispose
+        return if disposed?
+
+        stop
+        @scene.audio_engine&.remove_sound(self)
+        @on_ready_callbacks.clear
+        @on_ended_callbacks.clear
+
+        super
+      end
+
+      private
+
+      def load_sound(url)
+        return unless File.exist?(url)
+
+        @is_ready = true
+        @on_ready_callbacks.each(&:call)
+
+        play if @autoplay
+
+        Arcanoae::Logger.debug("Sound loaded: #{url}")
+      end
+    end
+  end
+end

data/lib/arcanoae/audio/sound_track.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Arcanoae
+  module Audio
+    class SoundTrack
+      include Arcanoae::Disposable
+
+      attr_accessor :name, :volume
+      attr_reader :sounds
+
+      def initialize(name, scene, options = {})
+        @name = name
+        @scene = scene
+        @volume = options.fetch(:volume, 1.0)
+        @sounds = []
+      end
+
+      def add_sound(sound)
+        @sounds << sound unless @sounds.include?(sound)
+      end
+
+      def remove_sound(sound)
+        @sounds.delete(sound)
+      end
+
+      def play
+        @sounds.each(&:play)
+      end
+
+      def pause
+        @sounds.each(&:pause)
+      end
+
+      def stop
+        @sounds.each(&:stop)
+      end
+
+      def set_volume(volume)
+        @volume = Arcanoae::Math.clamp(volume, 0.0, 1.0)
+        @sounds.each(&:update_volume)
+      end
+
+      def dispose
+        return if disposed?
+
+        @sounds.each(&:dispose)
+        @sounds.clear
+
+        super
+      end
+    end
+  end
+end

data/lib/arcanoae/backends/glfw_bindings.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require 'ffi'
+
+module Arcanoae
+  module Backends
+    module GLFW
+      extend FFI::Library
+
+      case RbConfig::CONFIG['host_os']
+      when /darwin/
+        ffi_lib '/opt/homebrew/lib/libglfw.dylib'
+      when /linux/
+        ffi_lib 'libglfw.so.3'
+      when /mingw|mswin/
+        ffi_lib 'glfw3.dll'
+      else
+        ffi_lib 'glfw'
+      end
+
+      TRUE = 1
+      FALSE = 0
+
+      RELEASE = 0
+      PRESS = 1
+      REPEAT = 2
+
+      CONTEXT_VERSION_MAJOR = 0x00022002
+      CONTEXT_VERSION_MINOR = 0x00022003
+      OPENGL_PROFILE = 0x00022008
+      OPENGL_FORWARD_COMPAT = 0x00022006
+      OPENGL_CORE_PROFILE = 0x00032001
+      SAMPLES = 0x0002100D
+
+      KEY_ESCAPE = 256
+      KEY_SPACE = 32
+      KEY_0 = 48
+      KEY_1 = 49
+      KEY_2 = 50
+      KEY_3 = 51
+      KEY_4 = 52
+      KEY_5 = 53
+      KEY_6 = 54
+      KEY_7 = 55
+      KEY_8 = 56
+      KEY_9 = 57
+      KEY_W = 87
+      KEY_A = 65
+      KEY_S = 83
+      KEY_D = 68
+      KEY_UP = 265
+      KEY_DOWN = 264
+      KEY_LEFT = 263
+      KEY_RIGHT = 262
+
+      attach_function :glfwInit, [], :int
+      attach_function :glfwTerminate, [], :void
+      attach_function :glfwWindowHint, [:int, :int], :void
+      attach_function :glfwCreateWindow, [:int, :int, :string, :pointer, :pointer], :pointer
+      attach_function :glfwDestroyWindow, [:pointer], :void
+      attach_function :glfwMakeContextCurrent, [:pointer], :void
+      attach_function :glfwSwapBuffers, [:pointer], :void
+      attach_function :glfwSwapInterval, [:int], :void
+      attach_function :glfwPollEvents, [], :void
+      attach_function :glfwWindowShouldClose, [:pointer], :int
+      attach_function :glfwSetWindowShouldClose, [:pointer, :int], :void
+      attach_function :glfwGetTime, [], :double
+      attach_function :glfwGetFramebufferSize, [:pointer, :pointer, :pointer], :void
+      attach_function :glfwGetKey, [:pointer, :int], :int
+      attach_function :glfwGetMouseButton, [:pointer, :int], :int
+      attach_function :glfwGetCursorPos, [:pointer, :pointer, :pointer], :void
+      attach_function :glfwSetInputMode, [:pointer, :int, :int], :void
+
+      callback :key_callback, [:pointer, :int, :int, :int, :int], :void
+      callback :cursor_pos_callback, [:pointer, :double, :double], :void
+      callback :mouse_button_callback, [:pointer, :int, :int, :int], :void
+      callback :framebuffer_size_callback, [:pointer, :int, :int], :void
+
+      attach_function :glfwSetKeyCallback, [:pointer, :key_callback], :pointer
+      attach_function :glfwSetCursorPosCallback, [:pointer, :cursor_pos_callback], :pointer
+      attach_function :glfwSetMouseButtonCallback, [:pointer, :mouse_button_callback], :pointer
+      attach_function :glfwSetFramebufferSizeCallback, [:pointer, :framebuffer_size_callback], :pointer
+
+      def self.get_framebuffer_size(window)
+        width_ptr = FFI::MemoryPointer.new(:int)
+        height_ptr = FFI::MemoryPointer.new(:int)
+        glfwGetFramebufferSize(window, width_ptr, height_ptr)
+        [width_ptr.read_int, height_ptr.read_int]
+      end
+
+      def self.get_cursor_pos(window)
+        x_ptr = FFI::MemoryPointer.new(:double)
+        y_ptr = FFI::MemoryPointer.new(:double)
+        glfwGetCursorPos(window, x_ptr, y_ptr)
+        [x_ptr.read_double, y_ptr.read_double]
+      end
+    end
+  end
+end

data/lib/arcanoae/backends/opengl_bindings.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+require 'ffi'
+
+module Arcanoae
+  module Backends
+    module GL
+      extend FFI::Library
+
+      case RbConfig::CONFIG['host_os']
+      when /darwin/
+        ffi_lib '/System/Library/Frameworks/OpenGL.framework/OpenGL'
+      when /linux/
+        ffi_lib 'libGL.so.1'
+      when /mingw|mswin/
+        ffi_lib 'opengl32.dll'
+      else
+        ffi_lib 'GL'
+      end
+
+      GL_FALSE = 0
+      GL_TRUE = 1
+
+      GL_DEPTH_BUFFER_BIT = 0x00000100
+      GL_COLOR_BUFFER_BIT = 0x00004000
+
+      GL_POINTS = 0x0000
+      GL_LINES = 0x0001
+      GL_TRIANGLES = 0x0004
+
+      GL_DEPTH_TEST = 0x0B71
+      GL_CULL_FACE = 0x0B44
+      GL_BLEND = 0x0BE2
+      GL_MULTISAMPLE = 0x809D
+
+      GL_FRONT = 0x0404
+      GL_BACK = 0x0405
+
+      GL_SRC_ALPHA = 0x0302
+      GL_ONE_MINUS_SRC_ALPHA = 0x0303
+
+      GL_FLOAT = 0x1406
+      GL_UNSIGNED_INT = 0x1405
+
+      GL_ARRAY_BUFFER = 0x8892
+      GL_ELEMENT_ARRAY_BUFFER = 0x8893
+      GL_STATIC_DRAW = 0x88E4
+      GL_DYNAMIC_DRAW = 0x88E8
+
+      GL_FRAGMENT_SHADER = 0x8B30
+      GL_VERTEX_SHADER = 0x8B31
+      GL_COMPILE_STATUS = 0x8B81
+      GL_LINK_STATUS = 0x8B82
+      GL_INFO_LOG_LENGTH = 0x8B84
+
+      attach_function :glEnable, [:uint], :void
+      attach_function :glDisable, [:uint], :void
+      attach_function :glClear, [:uint], :void
+      attach_function :glClearColor, [:float, :float, :float, :float], :void
+      attach_function :glViewport, [:int, :int, :int, :int], :void
+      attach_function :glCullFace, [:uint], :void
+      attach_function :glBlendFunc, [:uint, :uint], :void
+
+      attach_function :glGenBuffers, [:int, :pointer], :void
+      attach_function :glDeleteBuffers, [:int, :pointer], :void
+      attach_function :glBindBuffer, [:uint, :uint], :void
+      attach_function :glBufferData, [:uint, :long, :pointer, :uint], :void
+
+      attach_function :glGenVertexArrays, [:int, :pointer], :void
+      attach_function :glDeleteVertexArrays, [:int, :pointer], :void
+      attach_function :glBindVertexArray, [:uint], :void
+      attach_function :glEnableVertexAttribArray, [:uint], :void
+      attach_function :glVertexAttribPointer, [:uint, :int, :uint, :uchar, :int, :pointer], :void
+
+      attach_function :glCreateShader, [:uint], :uint
+      attach_function :glDeleteShader, [:uint], :void
+      attach_function :glShaderSource, [:uint, :int, :pointer, :pointer], :void
+      attach_function :glCompileShader, [:uint], :void
+      attach_function :glGetShaderiv, [:uint, :uint, :pointer], :void
+      attach_function :glGetShaderInfoLog, [:uint, :int, :pointer, :pointer], :void
+
+      attach_function :glCreateProgram, [], :uint
+      attach_function :glDeleteProgram, [:uint], :void
+      attach_function :glAttachShader, [:uint, :uint], :void
+      attach_function :glLinkProgram, [:uint], :void
+      attach_function :glUseProgram, [:uint], :void
+      attach_function :glGetProgramiv, [:uint, :uint, :pointer], :void
+      attach_function :glGetProgramInfoLog, [:uint, :int, :pointer, :pointer], :void
+
+      attach_function :glGetUniformLocation, [:uint, :string], :int
+      attach_function :glGetAttribLocation, [:uint, :string], :int
+      attach_function :glUniform1i, [:int, :int], :void
+      attach_function :glUniform1f, [:int, :float], :void
+      attach_function :glUniform2f, [:int, :float, :float], :void
+      attach_function :glUniform3f, [:int, :float, :float, :float], :void
+      attach_function :glUniform4f, [:int, :float, :float, :float, :float], :void
+      attach_function :glUniformMatrix4fv, [:int, :int, :uchar, :pointer], :void
+
+      attach_function :glDrawArrays, [:uint, :int, :int], :void
+      attach_function :glDrawElements, [:uint, :int, :uint, :pointer], :void
+      attach_function :glGetError, [], :uint
+
+      GL_NO_ERROR = 0
+      GL_INVALID_ENUM = 0x0500
+      GL_INVALID_VALUE = 0x0501
+      GL_INVALID_OPERATION = 0x0502
+      GL_OUT_OF_MEMORY = 0x0505
+
+      GL_TEXTURE_2D = 0x0DE1
+      GL_TEXTURE0 = 0x84C0
+      GL_TEXTURE_MIN_FILTER = 0x2801
+      GL_TEXTURE_MAG_FILTER = 0x2800
+      GL_TEXTURE_WRAP_S = 0x2802
+      GL_TEXTURE_WRAP_T = 0x2803
+      GL_NEAREST = 0x2600
+      GL_LINEAR = 0x2601
+      GL_REPEAT = 0x2901
+      GL_CLAMP_TO_EDGE = 0x812F
+
+      GL_RGBA = 0x1908
+      GL_RGBA32F = 0x8814
+
+      GL_FRAMEBUFFER = 0x8D40
+      GL_COLOR_ATTACHMENT0 = 0x8CE0
+      GL_FRAMEBUFFER_COMPLETE = 0x8CD5
+
+      attach_function :glGenTextures, [:int, :pointer], :void
+      attach_function :glDeleteTextures, [:int, :pointer], :void
+      attach_function :glBindTexture, [:uint, :uint], :void
+      attach_function :glTexImage2D, [:uint, :int, :int, :int, :int, :int, :uint, :uint, :pointer], :void
+      attach_function :glTexParameteri, [:uint, :uint, :int], :void
+      attach_function :glActiveTexture, [:uint], :void
+
+      attach_function :glGenFramebuffers, [:int, :pointer], :void
+      attach_function :glDeleteFramebuffers, [:int, :pointer], :void
+      attach_function :glBindFramebuffer, [:uint, :uint], :void
+      attach_function :glFramebufferTexture2D, [:uint, :uint, :uint, :uint, :int], :void
+      attach_function :glCheckFramebufferStatus, [:uint], :uint
+
+      def self.check_error(context = "")
+        error = glGetError
+        return if error == GL_NO_ERROR
+
+        error_name = case error
+        when GL_INVALID_ENUM then "GL_INVALID_ENUM"
+        when GL_INVALID_VALUE then "GL_INVALID_VALUE"
+        when GL_INVALID_OPERATION then "GL_INVALID_OPERATION"
+        when GL_OUT_OF_MEMORY then "GL_OUT_OF_MEMORY"
+        else "Unknown error #{error}"
+        end
+        puts "OpenGL Error [#{context}]: #{error_name}"
+      end
+
+      def self.gen_buffer
+        buf = FFI::MemoryPointer.new(:uint)
+        glGenBuffers(1, buf)
+        buf.read_uint
+      end
+
+      def self.gen_vertex_array
+        buf = FFI::MemoryPointer.new(:uint)
+        glGenVertexArrays(1, buf)
+        buf.read_uint
+      end
+
+      def self.delete_buffer(id)
+        buf = FFI::MemoryPointer.new(:uint)
+        buf.write_uint(id)
+        glDeleteBuffers(1, buf)
+      end
+
+      def self.delete_vertex_array(id)
+        buf = FFI::MemoryPointer.new(:uint)
+        buf.write_uint(id)
+        glDeleteVertexArrays(1, buf)
+      end
+
+      def self.get_shader_iv(shader, pname)
+        buf = FFI::MemoryPointer.new(:int)
+        glGetShaderiv(shader, pname, buf)
+        buf.read_int
+      end
+
+      def self.get_program_iv(program, pname)
+        buf = FFI::MemoryPointer.new(:int)
+        glGetProgramiv(program, pname, buf)
+        buf.read_int
+      end
+
+      def self.get_shader_info_log(shader)
+        len = get_shader_iv(shader, GL_INFO_LOG_LENGTH)
+        return "" if len <= 0
+
+        buf = FFI::MemoryPointer.new(:char, len)
+        glGetShaderInfoLog(shader, len, nil, buf)
+        buf.read_string
+      end
+
+      def self.get_program_info_log(program)
+        len = get_program_iv(program, GL_INFO_LOG_LENGTH)
+        return "" if len <= 0
+
+        buf = FFI::MemoryPointer.new(:char, len)
+        glGetProgramInfoLog(program, len, nil, buf)
+        buf.read_string
+      end
+
+      def self.shader_source(shader, source)
+        src_ptr = FFI::MemoryPointer.from_string(source)
+        src_array = FFI::MemoryPointer.new(:pointer)
+        src_array.write_pointer(src_ptr)
+        glShaderSource(shader, 1, src_array, nil)
+      end
+
+      def self.buffer_data(target, data, usage)
+        if data.is_a?(Array)
+          if data.first.is_a?(Integer)
+            packed = data.pack('L*')
+          else
+            packed = data.pack('f*')
+          end
+        else
+          packed = data
+        end
+
+        ptr = FFI::MemoryPointer.new(:char, packed.bytesize)
+        ptr.put_bytes(0, packed)
+        glBufferData(target, packed.bytesize, ptr, usage)
+        packed.bytesize
+      end
+
+      def self.uniform_matrix4fv(location, matrix)
+        data = matrix.is_a?(Array) ? matrix : matrix.to_a
+        ptr = FFI::MemoryPointer.new(:float, 16)
+        ptr.put_array_of_float(0, data)
+        glUniformMatrix4fv(location, 1, GL_FALSE, ptr)
+      end
+    end
+  end
+end

data/lib/arcanoae/cameras/arc_rotate_camera.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Arcanoae
+  module Cameras
+    class ArcRotateCamera < Camera
+      attr_accessor :alpha, :beta, :radius, :target
+      attr_accessor :lower_alpha_limit, :upper_alpha_limit
+      attr_accessor :lower_beta_limit, :upper_beta_limit
+      attr_accessor :lower_radius_limit, :upper_radius_limit
+      attr_accessor :panning_inertia, :wheel_precision
+
+      def initialize(name, alpha, beta, radius, target, scene = nil)
+        super(name, compute_position(alpha, beta, radius, target), scene)
+        @alpha = alpha
+        @beta = beta
+        @radius = radius
+        @target = target.clone
+
+        @lower_alpha_limit = nil
+        @upper_alpha_limit = nil
+        @lower_beta_limit = 0.01
+        @upper_beta_limit = ::Math::PI - 0.01
+        @lower_radius_limit = 0.01
+        @upper_radius_limit = nil
+        @panning_inertia = 0.9
+        @wheel_precision = 3.0
+        @fov = ::Math::PI / 4
+        @aspect_ratio = 16.0 / 9.0
+
+        rebuild_position
+      end
+
+      attr_accessor :fov, :aspect_ratio
+
+      def set_position(position)
+        @position = position.clone
+        rebuild_angles_and_radius
+        self
+      end
+
+      def set_target(target)
+        @target = target.clone
+        rebuild_position
+        self
+      end
+
+      def zoom_on(meshes)
+        return self if meshes.empty?
+
+        min = Math::Vector3.new(Float::INFINITY, Float::INFINITY, Float::INFINITY)
+        max = Math::Vector3.new(-Float::INFINITY, -Float::INFINITY, -Float::INFINITY)
+
+        meshes.each do |mesh|
+          info = mesh.bounding_info
+          next unless info
+
+          box = info[:bounding_box]
+          min = Math::Vector3.new([min.x, box.min.x].min, [min.y, box.min.y].min, [min.z, box.min.z].min)
+          max = Math::Vector3.new([max.x, box.max.x].max, [max.y, box.max.y].max, [max.z, box.max.z].max)
+        end
+
+        center = Math::Vector3.new(
+          (min.x + max.x) / 2,
+          (min.y + max.y) / 2,
+          (min.z + max.z) / 2
+        )
+
+        @target = center
+        distance = max.distance_to(min)
+        @radius = distance / (2 * ::Math.tan(@fov / 2))
+        rebuild_position
+        self
+      end
+
+      def view_matrix
+        Math::Matrix4.look_at(@position, @target, Math::Vector3.up)
+      end
+
+      def projection_matrix
+        aspect = compute_aspect_ratio
+        Math::Matrix4.perspective(@fov, aspect, @min_z, @max_z)
+      end
+
+      def compute_aspect_ratio
+        if @scene&.engine
+          @scene.engine.render_width.to_f / @scene.engine.render_height
+        else
+          @aspect_ratio
+        end
+      end
+
+      private
+
+      def rebuild_angles_and_radius
+        diff = @position - @target
+        @radius = diff.length
+        return if @radius.zero?
+
+        @alpha = ::Math.atan2(diff.x, diff.z)
+        @beta = ::Math.acos(diff.y / @radius)
+      end
+
+      def rebuild_position
+        @beta = clamp_beta(@beta)
+        @alpha = clamp_alpha(@alpha)
+        @radius = clamp_radius(@radius)
+        @position = compute_position(@alpha, @beta, @radius, @target)
+      end
+
+      def compute_position(alpha, beta, radius, target)
+        x = target.x + radius * ::Math.sin(beta) * ::Math.sin(alpha)
+        y = target.y + radius * ::Math.cos(beta)
+        z = target.z + radius * ::Math.sin(beta) * ::Math.cos(alpha)
+        Math::Vector3.new(x, y, z)
+      end
+
+      def clamp_alpha(value)
+        return value unless @lower_alpha_limit && @upper_alpha_limit
+
+        [[value, @lower_alpha_limit].max, @upper_alpha_limit].min
+      end
+
+      def clamp_beta(value)
+        [[value, @lower_beta_limit].max, @upper_beta_limit].min
+      end
+
+      def clamp_radius(value)
+        min = @lower_radius_limit || 0.01
+        max = @upper_radius_limit || Float::INFINITY
+        [[value, min].max, max].min
+      end
+    end
+  end
+end

data/lib/arcanoae/cameras/camera.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Arcanoae
+  module Cameras
+    class Camera < Scene::TransformNode
+      attr_accessor :min_z, :max_z, :viewport, :inertia
+
+      def initialize(name, position, scene = nil)
+        super(name, scene)
+        @position = position.clone
+        @min_z = 0.1
+        @max_z = 10000.0
+        @viewport = { x: 0, y: 0, width: 1, height: 1 }
+        @inertia = 0.9
+        @attached = false
+
+        scene&.add_camera(self)
+      end
+
+      def attach_control(canvas = nil, no_prevent_default = false)
+        @attached = true
+      end
+
+      def detach_control
+        @attached = false
+      end
+
+      def attached?
+        @attached
+      end
+
+      def view_matrix
+        raise NotImplementedError, "Subclasses must implement view_matrix"
+      end
+
+      def projection_matrix
+        raise NotImplementedError, "Subclasses must implement projection_matrix"
+      end
+
+      def get_transform_matrix
+        view_matrix * projection_matrix
+      end
+
+      def dispose
+        return if disposed?
+
+        @scene&.remove_camera(self)
+        super
+      end
+    end
+  end
+end