ruby_rpg 0.0.1 → 0.0.3

data/lib/engine/game_object.rb

@@ -0,0 +1,218 @@
+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)
+      children.each(&:destroy!)
+      components.each(&:destroy!)
+      ui_renderers.each(&:destroy!)
+      renderers.each(&:destroy!)
+
+      GameObject.destroyed_objects << self unless @destroyed
+      @destroyed = true
+    end
+
+    def _erase!
+      GameObject.objects.delete(self)
+      parent.children.delete(self) if parent
+      name = @name
+      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: #{name}" }
+      end
+    end
+
+    def self.erase_destroyed_objects
+      destroyed_objects.each do |object|
+        object._erase!
+      end
+      @destroyed_objects = []
+    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
+      
+      Component.erase_destroyed_components
+      GameObject.erase_destroyed_objects
+    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
+
+    def self.destroyed_objects
+      @destroyed_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

data/lib/engine/importers/obj_file.rb

@@ -0,0 +1,244 @@
+# frozen_string_literal: true
+
+module Engine
+  class ObjFile
+    def initialize(file_path)
+      @mesh_data = File.readlines(file_path + ".obj")
+      if File.exist?(file_path + ".mtl")
+        @mtl_data = File.readlines(file_path + ".mtl").map(&:chomp)
+      else
+        @mtl_data = []
+      end
+    end
+
+    def vertices
+      @vertices ||=
+        @mesh_data.select { |line| line.start_with?("v ") }.map do |line|
+          _, x, y, z = line.split(" ")
+          Vector[x.to_f, y.to_f, z.to_f]
+        end
+    end
+
+    def normals
+      @normals ||=
+        @mesh_data.select { |line| line.start_with?("vn ") }.map do |line|
+          _, x, y, z = line.split(" ")
+          Vector[x.to_f, y.to_f, z.to_f]
+        end
+    end
+
+    def tangents
+      @tangents ||=
+        (0...vertex_indices.length).each_slice(3).map do |i1, i2, i3|
+          vertex1 = vertices[vertex_indices[i1]]
+          normal1 = normals[normal_indices[i1]]
+          texture_coord1 = texture_coords[texture_indices[i1]]
+
+          vertex2 = vertices[vertex_indices[i2]]
+          normal2 = normals[normal_indices[i2]]
+          texture_coord2 = texture_coords[texture_indices[i2]]
+
+          vertex3 = vertices[vertex_indices[i3]]
+          normal3 = normals[normal_indices[i3]]
+          texture_coord3 = texture_coords[texture_indices[i3]]
+
+          triangle_vertices = [vertex1, vertex2, vertex3]
+          triangle_normals = [normal1, normal2, normal3]
+          triangle_texture_coords = [texture_coord1, texture_coord2, texture_coord3]
+
+          Engine::TangentCalculator.new(triangle_vertices, triangle_normals, triangle_texture_coords).calculate_tangents
+        end.flatten(1)
+    end
+
+    def texture_coords
+      @texture_coords ||=
+        @mesh_data.select { |line| line.start_with?("vt ") }.map do |line|
+          _, x, y = line.split(" ")
+          Vector[x.to_f, y.to_f]
+        end
+    end
+
+    def face_lines
+      @face_lines ||=
+        begin
+          split_faces(@mesh_data).select { |line| line.start_with?("f ") }
+        end
+    end
+
+    def split_faces(lines)
+      lines.map.with_index do |line, line_number|
+        if line.start_with?("f ")
+          new_faces = split_face(line)
+          (new_faces.length * 3).times do
+            material_names << material_for_line(line_number)
+          end
+          new_faces
+        else
+          line
+        end
+      end.flatten
+    end
+
+    def split_face(face)
+      face_vertices = face.split(" ")[1..-1]
+      return [face] if face_vertices.length == 3
+
+      world_points = face_vertices.map { |v| v.split("/")[0] }
+              .map { |i| vertices[i.to_i - 1] }
+      plane = plane_matrix(world_points)
+      flat_points = world_points.map { |point| plane * point }
+      packed_points = face_vertices.map.with_index do |v, i|
+        { point_string: face_vertices[i], 0 => flat_points[i][0], 1 => flat_points[i][1] }
+      end
+
+      path = Path.new(packed_points.reverse)
+      begin
+        decompose_path(path, true)
+      rescue NoEarsException
+        decompose_path(Path.new(packed_points), false)
+      end
+    end
+
+    def decompose_path(path, reverse)
+      decomposed_vertices = []
+      depth = 100
+      until path.length == 3 || depth == 0
+        depth -= 1
+        ear_result = path.find_ear
+        ear = ear_result.first
+        new_path = ear_result.last
+        ear = ear.reverse! if reverse
+        ear_area = triangle_area(ear[0], ear[1], ear[2])
+        decomposed_vertices << ear unless ear_area < 0.0001
+        path = new_path
+      end
+      if reverse
+        decomposed_vertices << path.points.reverse
+      else
+        decomposed_vertices << path.points
+      end
+      decomposed_vertices.map do |triangle|
+        "f #{triangle.map { |v| v[:point_string] }.join(" ")}"
+      end
+    end
+
+    def triangle_area(a, b, c)
+      (a[0] * (b[1] - c[1]) + b[0] * (c[1] - a[1]) + c[0] * (a[1] - b[1])).abs / 2.0
+    end
+
+    def plane_matrix(points)
+      raise "Not enough points to create a plane" if points.length < 3
+
+      origin_point = points[0]
+      a = points[1] - origin_point
+      b = nil
+      points[2..-1].each do |point|
+        diff = point - origin_point
+        b = diff if a.cross(diff).magnitude > 0.0001
+      end
+      raise "Points are collinear" if b.nil?
+
+      normal = a.cross(b).normalize
+
+      Matrix[
+        [a[0], a[1], a[2]],
+        [b[0], b[1], b[2]],
+        [normal[0], normal[1], normal[2]]
+      ].transpose.inverse
+    end
+
+    def vertex_indices
+      @vertex_indices ||=
+        face_lines.map do |line|
+          _, v1, v2, v3 = line.split(" ")
+          v1, v2, v3 = [v1, v2, v3].map { |v| v.split("/").first.to_i }
+          [v1 - 1, v2 - 1, v3 - 1]
+        end.flatten
+    end
+
+    def texture_indices
+      @texture_indices ||=
+        face_lines.map do |line|
+          _, v1, v2, v3 = line.split(" ")
+          v1, v2, v3 = [v1, v2, v3].map { |v| v.split("/")[1].to_i }
+          [v1 - 1, v2 - 1, v3 - 1]
+        end.flatten
+    end
+
+    def normal_indices
+      @normal_indices ||=
+        face_lines.map do |line|
+          _, v1, v2, v3 = line.split(" ")
+          v1, v2, v3 = [v1, v2, v3].map { |v| v.split("/")[2].to_i }
+          [v1 - 1, v2 - 1, v3 - 1]
+        end.flatten
+    end
+
+
+    def material_for_line(line_number)
+      l = line_number
+      until l == 0
+        if @mesh_data[l].start_with?("usemtl ")
+          return @mesh_data[l].split(" ")[1]
+        end
+        l -= 1
+      end
+    end
+
+    def material_names
+      @material_names ||= []
+    end
+
+    def materials
+      @materials ||=
+        begin
+          current_material = nil
+          @mtl_data.each_with_object({}) do |line, materials|
+            if line.start_with?("newmtl ")
+              _, material_name = line.split(" ")
+              current_material = material_name
+              materials[material_name] = {}
+            elsif line.start_with?("Kd ")
+              _, r, g, b = line.split(" ")
+              materials[current_material][:diffuse] = Vector[r.to_f, g.to_f, b.to_f]
+            elsif line.start_with?("Ks ")
+              _, r, g, b = line.split(" ")
+              materials[current_material][:specular] = Vector[r.to_f, g.to_f, b.to_f]
+            elsif line.start_with?("Ka ")
+              _, r, g, b = line.split(" ")
+              materials[current_material][:albedo] = Vector[r.to_f, g.to_f, b.to_f]
+            end
+          end
+        end
+    end
+
+    def vertex_data
+      @vertex_data ||=
+        (0...vertex_indices.length).map do |i|
+          {
+            vertex: vertices[vertex_indices[i]],
+            normal: normals[normal_indices[i]],
+            texture_coord: texture_coords[texture_indices[i]],
+            tangent: tangents[i],
+            diffuse: materials.dig(material_names[i], :diffuse) || Vector[1, 1, 1],
+            specular: materials.dig(material_names[i], :specular) || Vector[1, 1, 1],
+            albedo: materials.dig(material_names[i], :albedo) || Vector[1, 1, 1],
+          }
+        end.map do |data|
+          [
+            data[:vertex][0], data[:vertex][1], data[:vertex][2],
+            data[:texture_coord][0], data[:texture_coord][1],
+            data[:normal][0], data[:normal][1], data[:normal][2],
+            data[:tangent][0].to_f, data[:tangent][1].to_f, data[:tangent][2].to_f,
+            data[:diffuse][0], data[:diffuse][1], data[:diffuse][2],
+            data[:specular][0], data[:specular][1], data[:specular][2],
+            data[:albedo][0], data[:albedo][1], data[:albedo][2],
+          ]
+        end.flatten
+    end
+
+    def index_data
+      @index_data ||= (0...vertex_indices.length).map(&:to_i)
+    end
+  end
+end

data/lib/engine/importers/obj_importer.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Engine
+  class ObjImporter
+    attr_reader :source, :destination_vertex, :destination_index
+
+    def initialize(source, destination_vertex, destination_index)
+      @source = source
+      @destination_vertex = destination_vertex
+      @destination_index = destination_index
+    end
+
+    def import
+      obj_file = Engine::ObjFile.new(source)
+
+      vertex_data = obj_file.vertex_data
+
+      FileUtils.mkdir_p(File.dirname(destination_vertex)) unless File.exist?(destination_vertex)
+      File.delete(destination_vertex) if File.exist?(destination_vertex)
+      File.open(destination_vertex, "w") do |file|
+        vertex_data.each { |d| file.puts d }
+      end
+
+      index_data = obj_file.index_data
+
+      FileUtils.mkdir_p(File.dirname(destination_index)) unless File.exist?(destination_index)
+      File.delete(destination_index) if File.exist?(destination_index)
+      File.open(destination_index, "w") do |file|
+        index_data.each { |i| file.puts i }
+      end
+    end
+  end
+end

data/lib/engine/input.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Engine
+  class Input
+    def self.key?(key)
+      keys[key] == :down || keys[key] == :held
+    end
+
+    def self.key_down?(key)
+      keys[key] == :down
+    end
+
+    def self.key_up?(key)
+      keys[key] == :up
+    end
+
+    def self._on_key_down(key)
+      keys[key] = :down
+      if key == GLFW::KEY_ESCAPE
+        Engine.close
+      end
+
+      if key == GLFW::KEY_BACKSPACE
+        Engine::Debugging.breakpoint { binding.pry }
+        # Engine.breakpoint { debugger }
+      end
+
+      if key == GLFW::KEY_F
+        Engine::Window.toggle_full_screen
+      end
+    end
+
+    def self._on_key_up(key)
+      keys[key] = :up
+    end
+
+    def self.key_callback(key, action)
+      if action == GLFW::PRESS
+        _on_key_down(key)
+      elsif action == GLFW::RELEASE
+        _on_key_up(key)
+      end
+    end
+
+    def self.update_key_states
+      keys.each do |key, state|
+        if state == :down
+          keys[key] = :held
+        elsif state == :up
+          keys.delete(key)
+        end
+      end
+    end
+
+    private
+
+    def self.keys
+      @keys ||= {}
+    end
+  end
+end

data/lib/engine/material.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Engine
+  class Material
+    attr_reader :shader
+
+    def initialize(shader)
+      @shader = shader
+    end
+
+    def set_mat4(name, value)
+      mat4s[name] = value
+    end
+
+    def set_vec3(name, value)
+      vec3s[name] = value
+    end
+
+    def set_vec4(name, value)
+      vec4s[name] = value
+    end
+
+    def set_float(name, value)
+      floats[name] = value
+    end
+
+    def set_texture(name, value)
+      textures[name] = value
+    end
+
+    def update_shader
+      shader.use
+
+      mat4s.each do |name, value|
+        shader.set_mat4(name, value)
+      end
+      vec3s.each do |name, value|
+        shader.set_vec3(name, value)
+      end
+      vec4s.each do |name, value|
+        shader.set_vec4(name, value)
+      end
+      floats.each do |name, value|
+        shader.set_float(name, value)
+      end
+      textures.each.with_index do |(name, value), slot|
+        GL.ActiveTexture(Object.const_get("GL::TEXTURE#{slot}"))
+        if value
+          GL.BindTexture(GL::TEXTURE_2D, value)
+        else
+          GL.BindTexture(GL::TEXTURE_2D, 0)
+        end
+        shader.set_int(name, slot)
+      end
+    end
+
+    private
+
+    def mat4s
+      @mat4s ||= {}
+    end
+
+    def vec3s
+      @vec3s ||= {}
+    end
+
+    def vec4s
+      @vec4s ||= {}
+    end
+
+    def floats
+      @floats ||= {}
+    end
+
+    def textures
+      @textures ||= {}
+    end
+  end
+end