ruby_rpg 0.0.1 → 0.0.2

data/lib/engine/components/ui_sprite_renderer.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Engine::Components
+  class UISpriteRenderer < Engine::Component
+    attr_reader :v1, :v2, :v3, :v4, :material
+
+    def ui_renderer?
+      true
+    end
+
+    def initialize(tl, tr, br, bl, material)
+      @v1 = tl
+      @v2 = tr
+      @v3 = br
+      @v4 = bl
+      @material = material
+    end
+
+    def start
+      setup_vertex_attribute_buffer
+      setup_vertex_buffer
+      setup_index_buffer
+    end
+
+    def update(delta_time)
+      GL.BindVertexArray(@vao)
+      GL.BindBuffer(GL::ELEMENT_ARRAY_BUFFER, @ebo)
+
+      set_material_per_frame_data
+
+      GL.DrawElements(GL::TRIANGLES, 6, GL::UNSIGNED_INT, 0)
+
+      GL.BindVertexArray(0)
+      GL.BindBuffer(GL::ELEMENT_ARRAY_BUFFER, 0)
+    end
+
+    private
+
+    def set_material_per_frame_data
+      set_camera_matrix
+      material.set_mat4("model", game_object.model_matrix)
+      material.update_shader
+    end
+
+    def set_camera_matrix
+      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
+      indices = [
+        0, 2, 1,
+        2, 0, 3
+      ]
+
+      ebo_buf = ' ' * 4
+      GL.GenBuffers(1, ebo_buf)
+      @ebo = ebo_buf.unpack('L')[0]
+      GL.BindBuffer(GL::ELEMENT_ARRAY_BUFFER, @ebo)
+      GL.BufferData(
+        GL::ELEMENT_ARRAY_BUFFER, 6 * Fiddle::SIZEOF_INT,
+        indices.pack('I*'), GL::STATIC_DRAW
+      )
+    end
+
+    def setup_vertex_attribute_buffer
+      va0_buf = ' ' * 4
+      GL.GenVertexArrays(1, va0_buf)
+      @vao = va0_buf.unpack('L')[0]
+      GL.BindVertexArray(@vao)
+    end
+
+    def setup_vertex_buffer
+      vbo_buf = ' ' * 4
+      GL.GenBuffers(1, vbo_buf)
+      vbo = vbo_buf.unpack('L')[0]
+      points = [
+        v1[0], v1[1], 0, 0, 0,
+        v2[0], v2[1], 0, 1, 0,
+        v3[0], v3[1], 0, 1, 1,
+        v4[0], v4[1], 0, 0, 1
+      ]
+
+      GL.BindBuffer(GL::ARRAY_BUFFER, vbo)
+      GL.BufferData(
+        GL::ARRAY_BUFFER, 4 * 5 * Fiddle::SIZEOF_FLOAT,
+        points.pack('F*'), GL::STATIC_DRAW
+      )
+
+      GL.VertexAttribPointer(0, 3, GL::FLOAT, GL::FALSE, 5 * Fiddle::SIZEOF_FLOAT, 0)
+      GL.VertexAttribPointer(1, 2, GL::FLOAT, GL::FALSE, 5 * Fiddle::SIZEOF_FLOAT, 3 * Fiddle::SIZEOF_FLOAT)
+      GL.EnableVertexAttribArray(0)
+      GL.EnableVertexAttribArray(1)
+    end
+  end
+end

data/lib/engine/cursor.rb

@@ -0,0 +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

data/lib/engine/engine.rb

@@ -0,0 +1,221 @@
+require 'opengl'
+require 'glfw'
+require 'concurrent'
+require 'os'
+
+require_relative 'rendering/render_pipeline'
+require_relative 'rendering/instance_renderer'
+require_relative 'screenshoter'
+require_relative 'input'
+require_relative "quaternion"
+require_relative 'game_object'
+require_relative 'texture'
+require_relative 'material'
+require_relative 'mesh'
+require_relative "font"
+require_relative 'path'
+require_relative 'polygon_mesh'
+require_relative 'importers/obj_file'
+require_relative 'tangent_calculator'
+require_relative 'shader'
+require_relative 'component'
+require_relative "camera"
+require_relative "window"
+require_relative "video_mode"
+require_relative "cursor"
+
+require_relative "components/orthographic_camera"
+require_relative "components/perspective_camera"
+require_relative "components/sprite_renderer"
+require_relative "components/ui_sprite_renderer"
+require_relative "components/mesh_renderer"
+require_relative "components/font_renderer"
+require_relative "components/ui_font_renderer"
+require_relative "components/point_light"
+require_relative "components/direction_light"
+
+require_relative "physics/physics_resolver"
+require_relative 'physics/collision'
+require_relative "physics/components/sphere_collider"
+require_relative "physics/components/cube_collider"
+require_relative "physics/components/rigidbody"
+
+if OS.windows?
+  GLFW.load_lib(File.expand_path(File.join(__dir__, "..", "..", "glfw-3.4.bin.WIN64", "lib-static-ucrt", "glfw3.dll")))
+elsif OS.mac?
+  GLFW.load_lib(File.expand_path(File.join(__dir__, "..", "..", "glfw-3.3.9.bin.MACOS", "lib-arm64", "libglfw.3.dylib")))
+end
+GLFW.Init
+
+module Engine
+  def self.start(base_dir:, &first_frame_block)
+    load(base_dir)
+    return if ENV["BUILDING"] == "true"
+
+    open_window
+    main_game_loop(&first_frame_block)
+    terminate
+  end
+
+  def self.engine_started?
+    @engine_started
+  end
+
+  def self.load(base_dir)
+    base_dir = File.expand_path(base_dir)
+    Dir[File.join(base_dir, "components", "**/*.rb")].each { |file| require file }
+    Dir[File.join(base_dir, "game_objects", "**/*.rb")].each { |file| require file }
+  end
+
+  def self.open_window
+    @old_time = Time.now
+    @time = Time.now
+    @key_callback = create_key_callbacks # This must be an instance variable to prevent garbage collection
+
+    Window.create_window
+    GLFW.MakeContextCurrent(Window.window)
+    GLFW.SetKeyCallback(Window.window, @key_callback)
+    GL.load_lib
+
+    set_opengl_blend_mode
+    @engine_started = true
+    GL.ClearColor(0.0, 0.0, 0.0, 1.0)
+
+    GL.Enable(GL::CULL_FACE)
+    GL.CullFace(GL::BACK)
+
+    GLFW.SwapInterval(0)
+
+    Cursor.hide
+  end
+
+  def self.main_game_loop(&first_frame_block)
+    @game_stopped = false
+    @old_time = Time.now
+    @time = Time.now
+    @fps = 0
+    Window.get_framebuffer_size
+    GL.Clear(GL::COLOR_BUFFER_BIT | GL::DEPTH_BUFFER_BIT)
+
+    until GLFW.WindowShouldClose(Window.window) == GLFW::TRUE || @game_stopped
+      if first_frame_block
+        first_frame_block.call
+        first_frame_block = nil
+      end
+
+      @old_time = @time || Time.now
+      @time = Time.now
+      delta_time = @time - @old_time
+
+      print_fps(delta_time)
+      Physics::PhysicsResolver.resolve
+      GameObject.update_all(delta_time)
+
+      @swap_buffers_promise.wait! if @swap_buffers_promise
+      GL.Clear(GL::COLOR_BUFFER_BIT | GL::DEPTH_BUFFER_BIT)
+      GL.Enable(GL::DEPTH_TEST)
+      GL.DepthFunc(GL::LESS)
+
+      Rendering::RenderPipeline.draw unless @game_stopped
+      GL.Disable(GL::DEPTH_TEST)
+      GameObject.render_ui(delta_time)
+
+      if Screenshoter.scheduled_screenshot
+        Screenshoter.take_screenshot
+      end
+
+      Window.get_framebuffer_size
+
+      if OS.windows?
+        GLFW.SwapBuffers(Window.window)
+      else
+        @swap_buffers_promise = Concurrent::Promise.new do
+          GLFW.SwapBuffers(Window.window)
+        end
+        @swap_buffers_promise.execute
+      end
+
+      Engine::Input.update_key_states
+      GLFW.PollEvents
+    end
+  end
+
+  def self.fps
+    @fps
+  end
+
+  def self.terminate
+    GLFW.DestroyWindow(Window.window)
+    GLFW.Terminate
+  end
+
+  def self.close
+    GameObject.destroy_all
+    GLFW.SetWindowShouldClose(Window.window, 1)
+  end
+
+  def self.stop_game
+    @game_stopped = true
+    @swap_buffers_promise.wait! if @swap_buffers_promise && !@swap_buffers_promise.complete?
+    GameObject.destroy_all
+  end
+
+  # 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
+
+  private
+
+  def self.print_fps(delta_time)
+    @time_since_last_fps_print = (@time_since_last_fps_print || 0) + delta_time
+    @frame = (@frame || 0) + 1
+    if @time_since_last_fps_print > 1
+      @fps = @frame / @time_since_last_fps_print
+      puts "FPS: #{@fps}"
+      @time_since_last_fps_print = 0
+      @frame = 0
+    end
+  end
+
+  def self.set_opengl_blend_mode
+    GL.Enable(GL::BLEND)
+    GL.BlendFunc(GL::SRC_ALPHA, GL::ONE_MINUS_SRC_ALPHA)
+  end
+
+  def self.create_key_callbacks
+    GLFW::create_callback(:GLFWkeyfun) do |window, key, scancode, action, mods|
+      Input.key_callback(key, action)
+    end
+  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

data/lib/engine/font.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Engine
+  class Font
+    TEXTURE_SIZE = 1024
+    GLYPH_COUNT = 16
+    CELL_SIZE = TEXTURE_SIZE / GLYPH_COUNT
+
+    def initialize(font_file_path)
+      @font_file_path = font_file_path
+    end
+
+    def texture
+      @texture ||=
+        begin
+          path = File.expand_path(File.join(ROOT, "_imported", @font_file_path.gsub(".ttf", ".png")))
+          Engine::Texture.for(path)
+        end
+    end
+
+    def vertex_data(string)
+      text_indices = string_indices(string)
+      offsets = string_offsets(string)
+      text_indices.zip(offsets).flatten
+    end
+
+    def string_indices(string)
+      string.chars.reject{|c| c == "\n"}.map { |char| index_table[char] }
+    end
+
+    def string_offsets(string)
+      offsets = []
+      scale_factor = 1 / (1024.0 * 2)
+      horizontal_offset = 0.0
+      vertical_offset = 0.0
+      font_path = File.expand_path(File.join(ROOT, "_imported", @font_file_path.gsub(".ttf", ".json")))
+      font_metrics = JSON.parse File.read(font_path)
+      string.chars.each do |char|
+        if char == "\n"
+          vertical_offset -= 1.0
+          horizontal_offset = 0.0
+          next
+        end
+        offsets << [horizontal_offset, vertical_offset]
+        horizontal_offset += 30 * scale_factor * font_metrics[index_table[char].to_s]["width"]
+      end
+      offsets
+    end
+
+    private
+
+    def character(index)
+      (index + 1).chr
+    end
+
+    def index_table
+      @index_table ||=
+        begin
+          hash = {}
+          GLYPH_COUNT.times do |x|
+            GLYPH_COUNT.times.each do |y|
+              index = x * GLYPH_COUNT + y
+              next if index >= 255
+              character = character(index)
+              hash[character] = index
+            end
+          end
+          hash
+        end
+    end
+  end
+end

data/lib/engine/game_object.rb

@@ -0,0 +1,198 @@
+require "matrix"
+
+module Engine
+  class GameObject
+    def self.method_added(name)
+      @methods ||= Set.new
+      return if name == :initialize || name == :destroyed?
+      @methods.add(name)
+    end
+
+    attr_accessor :name, :pos, :rotation, :scale, :components, :renderers, :ui_renderers, :created_at, :parent
+
+    def initialize(name = "Game Object", pos: Vector[0, 0, 0], rotation: 0, scale: Vector[1, 1, 1], components: [], parent: nil)
+      GameObject.object_spawned(self)
+      @pos = Vector[pos[0], pos[1], pos[2] || 0]
+      if rotation.is_a?(Numeric)
+        @rotation = Vector[0, 0, rotation]
+      else
+        @rotation = rotation
+      end
+      @scale = scale
+      @name = name
+      @components = components.select { |component| !component.renderer? && !component.ui_renderer? }
+      @renderers = components.select { |component| component.renderer? }
+      @ui_renderers = components.select { |component| component.ui_renderer? }
+      @created_at = Time.now
+      @parent = parent
+      parent.add_child(self) if parent
+
+      components.each { |component| component.set_game_object(self) }
+      components.each(&:start)
+    end
+
+    def to_s
+      @name
+    end
+
+    def children
+      @children ||= Set.new
+    end
+
+    def add_child(child)
+      child.parent = self
+      children << child
+    end
+
+    def parent=(parent)
+      @parent.children.delete(self) if @parent
+      @parent = parent
+      parent.children << self if parent
+    end
+
+    def x
+      @pos[0]
+    end
+
+    def x=(value)
+      @pos = Vector[value, y, z]
+    end
+
+    def y
+      @pos[1]
+    end
+
+    def y=(value)
+      @pos = Vector[x, value, z]
+    end
+
+    def z
+      @pos[2]
+    end
+
+    def z=(value)
+      @pos = Vector[x, y, value]
+    end
+
+    def local_to_world_coordinate(local)
+      local_x4 = Matrix[[local[0], local[1], local[2], 1.0]]
+      world = local_x4 * model_matrix
+      Vector[world[0, 0], world[0, 1], world[0, 2]]
+    end
+
+    def world_to_local_coordinate(world)
+      world_x4 = Matrix[[world[0], world[1], world[2], 1.0]]
+      local = world_x4 * model_matrix.inverse
+      Vector[local[0, 0], local[0, 1], local[0, 2]]
+    end
+
+    def local_to_world_direction(local)
+      local_to_world_coordinate(local) - pos
+    end
+
+    def rotate_around(axis, angle)
+      rotation_quaternion = Quaternion.from_angle_axis(angle, axis)
+
+      @rotation = (rotation_quaternion * Quaternion.from_euler(rotation)).to_euler
+    end
+
+    def model_matrix
+      cache_key = [@pos.dup, @rotation.dup, @scale.dup, @parent&.model_matrix&.to_a]
+      @model_matrix = nil if @model_matrix_cache_key != cache_key
+      @model_matrix_cache_key = cache_key
+      @model_matrix ||=
+        begin
+          rot = rotation * Math::PI / 180
+
+          cos_x = Math.cos(rot[0])
+          cos_y = Math.cos(rot[1])
+          cos_z = Math.cos(rot[2])
+
+          sin_x = Math.sin(rot[0])
+          sin_y = Math.sin(rot[1])
+          sin_z = Math.sin(rot[2])
+
+          Matrix[
+            [scale[0] * (cos_y * cos_z), scale[0] * (-cos_y * sin_z), scale[0] * sin_y, 0],
+            [scale[1] * (cos_x * sin_z + sin_x * sin_y * cos_z), scale[1] * (cos_x * cos_z - sin_x * sin_y * sin_z), scale[1] * -sin_x * cos_y, 0],
+            [scale[2] * (sin_x * sin_z - cos_x * sin_y * cos_z), scale[2] * (sin_x * cos_z + cos_x * sin_y * sin_z), scale[2] * cos_x * cos_y, 0],
+            [x, y, z, 1]
+          ]
+        end
+      if parent
+        @model_matrix * parent.model_matrix
+      else
+        @model_matrix
+      end
+    end
+
+    def destroyed?
+      @destroyed
+    end
+
+    def destroy!
+      return unless GameObject.objects.include?(self)
+      @destroyed = true
+      components.each(&:destroy!)
+      ui_renderers.each(&:destroy!)
+      renderers.each(&:destroy!)
+      GameObject.objects.delete(self)
+      parent.children.delete(self) if parent
+      children.each(&:destroy!)
+      self.class.instance_variable_get(:@methods).each do |method|
+        singleton_class.send(:undef_method, method)
+        singleton_class.send(:define_method, method) { raise "This object has been destroyed.  Object ID: #{self.object_id}" }
+      end
+    end
+
+    def up
+      return @up if @cached_up_rotation == rotation
+      @cached_up_rotation = rotation.dup
+      @up = local_to_world_direction(Vector[0, 1, 0])
+    end
+
+    def right
+      return @right if @cached_right_rotation == rotation
+      @cached_right_rotation = rotation.dup
+      @right = local_to_world_direction(Vector[1, 0, 0])
+    end
+
+    def forward
+      return @forward if @cached_forward_rotation == rotation
+      @cached_forward_rotation = rotation.dup
+      @forward = local_to_world_direction(Vector[0, 0, 1])
+    end
+
+    def self.destroy_all
+      GameObject.objects.dup.each do |object|
+        object.destroy! unless object.destroyed?
+      end
+    end
+
+    def self.update_all(delta_time)
+      GameObject.objects.each do |object|
+        object.components.each { |component| component.update(delta_time) }
+      end
+    end
+
+    def self.mesh_renderers
+      GameObject.objects.flat_map do |object|
+        object.renderers
+      end
+    end
+
+    def self.render_ui(delta_time)
+      GameObject.objects.each do |object|
+        object.ui_renderers.each { |renderer| renderer.update(delta_time) }
+      end
+    end
+
+    def self.object_spawned(object)
+      objects << object
+    end
+
+    def self.objects
+      @objects ||= []
+    end
+  end
+end

data/lib/engine/importers/font_importer.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+require 'json'
+
+module Engine
+  class FontImporter
+    TEXTURE_SIZE = 1024
+    GLYPH_COUNT = 16
+    CELL_SIZE = TEXTURE_SIZE / GLYPH_COUNT
+
+    attr_reader :source, :destination_image, :destination_metrics
+
+    def initialize(source, destination_image, destination_metrics)
+      @source = source
+      @destination_image = destination_image
+      @destination_metrics = destination_metrics
+    end
+
+    def import
+      image = Magick::Image.new(TEXTURE_SIZE, TEXTURE_SIZE,) do |options|
+        options.background_color = "transparent"
+      end
+      font_metrics = {}
+
+      draw = Magick::Draw.new
+      (0...GLYPH_COUNT).each do |x|
+        (0...GLYPH_COUNT).each do |y|
+          index = x * GLYPH_COUNT + y
+          next if index >= 255
+          character = character(index)
+          write_character(character, draw, image, coord(x), coord(y))
+
+          metric = draw.get_type_metrics(image, character)
+          if character.to_s == " "
+            font_metrics[index] = { width: metric.max_advance / 4.0 }
+          else
+            font_metrics[index] = { width: metric.width }
+          end
+        end
+      end
+
+      FileUtils.mkdir_p(File.dirname(destination_image)) unless File.directory?(File.dirname(destination_image))
+      image.write(destination_image)
+
+      File.write(destination_metrics, font_metrics.to_json)
+    end
+
+    private
+
+    def write_character(character, draw, image, x, y)
+      font_path = File.expand_path(source)
+
+      draw.annotate(image, CELL_SIZE, CELL_SIZE, x, y, character) do |_|
+        draw.gravity = Magick::WestGravity
+        draw.pointsize = CELL_SIZE - 5
+        draw.font = font_path
+        draw.fill = "white"
+        image.format = "PNG"
+      end
+    end
+
+    def character(index)
+      (index + 1).chr
+    end
+
+    def coord(x)
+      x * CELL_SIZE
+    end
+  end
+end