ruby_rpg 0.0.1 → 0.0.3

data/lib/engine/components/ui_font_renderer.rb

@@ -0,0 +1,140 @@
+module Engine::Components
+  class UIFontRenderer < Engine::Component
+    attr_reader :mesh, :texture
+
+    def ui_renderer?
+      true
+    end
+
+    def initialize(font, string)
+      @mesh = Engine::PolygonMesh.new([Vector[-0.5, 0.5], Vector[0.5, 0.5], Vector[0.5, -0.5], Vector[-0.5, -0.5]], [[0, 0], [1, 0], [1, 1], [0, 1]])
+      @texture = font.texture.texture
+      @string = string
+      @font = font
+    end
+
+    def start
+      setup_vertex_attribute_buffer
+      setup_vertex_buffer
+      setup_index_buffer
+    end
+
+    def update_string(string)
+      @string = string
+      update_vbo_buf
+    end
+
+    def update(delta_time)
+      shader.use
+      GL.BindVertexArray(@vao)
+      GL.BindBuffer(GL::ELEMENT_ARRAY_BUFFER, @ebo)
+
+      set_shader_per_frame_data
+
+      GL.DrawElementsInstanced(GL::TRIANGLES, mesh.index_data.length, GL::UNSIGNED_INT, 0, @string.length)
+      GL.BindVertexArray(0)
+      GL.BindBuffer(GL::ELEMENT_ARRAY_BUFFER, 0)
+    end
+
+    private
+
+    def shader
+      @shader ||= Engine::Shader.new('./shaders/text_vertex.glsl', './shaders/text_frag.glsl')
+    end
+
+    def set_shader_per_frame_data
+      set_shader_camera_matrix
+      set_shader_model_matrix
+      set_shader_texture
+    end
+
+    def set_shader_model_matrix
+      shader.set_mat4("model", game_object.model_matrix)
+    end
+
+    def set_shader_texture
+      GL.ActiveTexture(GL::TEXTURE0)
+      GL.BindTexture(GL::TEXTURE_2D, texture)
+      shader.set_int("fontTexture", 0)
+    end
+
+    def set_shader_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]
+      ]
+      shader.set_mat4("camera", camera_matrix)
+    end
+
+    def setup_index_buffer
+      indices = mesh.index_data
+
+      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, indices.length * Fiddle::SIZEOF_INT,
+        indices.pack('I*'), GL::STATIC_DRAW
+      )
+    end
+
+    def setup_vertex_attribute_buffer
+      vao_buf = ' ' * 4
+      GL.GenVertexArrays(1, vao_buf)
+      @vao = vao_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 = mesh.vertex_data
+
+      GL.BindBuffer(GL::ARRAY_BUFFER, vbo)
+      GL.BufferData(
+        GL::ARRAY_BUFFER, @mesh.vertex_data.length * 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)
+
+      generate_instance_vbo_buf
+    end
+
+    def generate_instance_vbo_buf
+      @instance_vbo = set_instance_vbo_buf
+      update_vbo_buf
+    end
+
+    def set_instance_vbo_buf
+      instance_vbo_buf = ' ' * 4
+      GL.GenBuffers(1, instance_vbo_buf)
+      instance_vbo_buf.unpack('L')[0]
+    end
+
+    def update_vbo_buf
+      vertex_data = @font.vertex_data(@string)
+      string_length = @string.chars.reject{|c| c == "\n"}.length
+
+      GL.BindBuffer(GL::ARRAY_BUFFER, @instance_vbo)
+      vertex_size = Fiddle::SIZEOF_INT + (Fiddle::SIZEOF_FLOAT * 2)
+      GL.BufferData(
+        GL::ARRAY_BUFFER, string_length * vertex_size,
+        vertex_data.pack('IFF' * string_length), GL::STATIC_DRAW
+      )
+      GL.VertexAttribIPointer(2, 1, GL::INT, vertex_size, 0)
+      GL.VertexAttribPointer(3, 2, GL::FLOAT, GL::FALSE, vertex_size, Fiddle::SIZEOF_INT)
+      GL.EnableVertexAttribArray(2)
+      GL.EnableVertexAttribArray(3)
+      GL.VertexAttribDivisor(2, 1)
+      GL.VertexAttribDivisor(3, 1)
+    end
+  end
+end

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/debugging.rb

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

data/lib/engine/engine.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+GAME_DIR = File.expand_path(File.dirname($PROGRAM_NAME))
+
+module Engine
+  def self.start(&first_frame_block)
+    Engine::AutoLoader.load
+    return if ENV["BUILDING"] == "true"
+
+    open_window
+    main_game_loop(&first_frame_block)
+    terminate
+  end
+
+  def self.engine_started?
+    @engine_started
+  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.close
+    GameObject.destroy_all
+    Component.erase_destroyed_components
+    GameObject.erase_destroyed_objects
+    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
+    Component.erase_destroyed_components
+    GameObject.erase_destroyed_objects
+  end
+
+  private
+
+  def self.terminate
+    GLFW.DestroyWindow(Window.window)
+    GLFW.Terminate
+  end
+
+  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
+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.join("_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(GAME_DIR, "_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