ruby_rpg 0.0.1 → 0.0.2

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.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

data/lib/engine/mesh.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Engine
+  class Mesh
+    attr_reader :vertex_data, :index_data
+    private_class_method :new
+
+    def initialize(mesh_file)
+      @vertex_data = Mesh.open_vertex(mesh_file)
+      @index_data = Mesh.open_index(mesh_file)
+    end
+
+    def self.for(mesh_file)
+      mesh_cache[mesh_file]
+    end
+
+    def self.mesh_cache
+      @mesh_cache ||= Hash.new do |hash, key|
+        hash[key] = new(key)
+      end
+    end
+
+    def self.open_vertex(mesh_file)
+      vertex_cache[File.join(ROOT, "_imported", mesh_file + ".vertex_data")]
+    end
+
+    def self.vertex_cache
+      @index_data_cache ||= Hash.new do |hash, key|
+        hash[key] = File.readlines(key).reject{|l| l == ""}.map(&:to_f)
+      end
+    end
+
+    def self.open_index(mesh_file)
+      index_cache[File.join(ROOT, "_imported", mesh_file + ".index_data")]
+    end
+
+    def self.index_cache
+      @index_data_cache ||= Hash.new do |hash, key|
+        hash[key] = File.readlines(key).reject{|l| l == ""}.map(&:to_i)
+      end
+    end
+  end
+end

data/lib/engine/path.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Engine
+  class NoEarsException < StandardError; end
+
+  class Path
+    attr_reader :points
+
+    def initialize(points)
+      optimised_points = remove_colinear(points)
+      if optimised_points.length <= 3
+        @points = points
+      else
+        @points = optimised_points
+      end
+      #@points = points
+    end
+
+    def point_string(p)
+      "#{20 * (p[0] + 3)}, #{50 * (p[1] + 2)}"
+    end
+
+    def length
+      points.length
+    end
+
+    def find_ear
+      triangles = points.map.with_index do |point, i|
+        a = points[i - 1]
+        b = point
+        c = points[(i + 1) % points.length]
+        [a, b, c]
+      end
+
+      triangles.each do |triangle|
+        if is_ear?(triangle)
+          new_points = points.reject { |point| point == triangle[1] }
+          return triangle, Path.new(new_points)
+        end
+      end
+      raise NoEarsException
+    end
+
+    def is_ear?(triangle)
+      return false unless clockwise?(triangle)
+      points.each do |point|
+        next if triangle.include?(point)
+        return false if point_in_triangle?(point, triangle)
+      end
+      true
+    end
+
+    private
+
+    def remove_colinear(points)
+      points.reject.with_index do |point, i|
+        a = points[i - 1]
+        b = point
+        c = points[(i + 1) % points.length]
+
+        cross_product(a, b, c).zero?
+      end
+    end
+
+    def anti_clockwise?(triangle)
+      a, b, c = triangle
+      cross_product = (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0])
+      cross_product > 0
+    end
+
+    def clockwise?(triangle)
+      !anti_clockwise?(triangle)
+    end
+
+    def point_in_triangle?(point, triangle)
+      a, b, c = triangle
+      pab = cross_product(point, a, b)
+      pbc = cross_product(point, b, c)
+      pca = cross_product(point, c, a)
+
+      same_sign?(pab, pbc) && same_sign?(pbc, pca)
+    end
+
+    def cross_product(a, b, c)
+      (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0])
+    end
+
+    def same_sign?(a, b)
+      a.negative? == b.negative?
+    end
+  end
+end

data/lib/engine/physics/collision.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Engine::Physics
+  class Collision
+    attr_accessor :impulse, :point
+
+    def initialize(impulse, point)
+      @impulse = impulse
+      @point = point
+    end
+  end
+end

data/lib/engine/physics/components/cube_collider.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Engine::Physics::Components
+  class CubeCollider < Engine::Component
+  end
+end

data/lib/engine/physics/components/rigidbody.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Engine::Physics::Components
+  class Rigidbody < Engine::Component
+    attr_accessor :velocity,
+                  :angular_velocity,
+                  :force,
+                  :impulses,
+                  :mass,
+                  :coefficient_of_restitution,
+                  :coefficient_of_friction
+
+    def initialize(
+      velocity: Vector[0, 0, 0],
+      angular_velocity: Vector[0, 0, 0],
+      mass: 1,
+      inertia_tensor: nil,
+      gravity: Vector[0, -9.81, 0],
+      coefficient_of_restitution: 1,
+      coefficient_of_friction: 0
+    )
+      @velocity = velocity
+      @angular_velocity = angular_velocity
+      @force = gravity * mass
+      @gravity = gravity
+      @impulses = []
+      @angular_impulses = []
+      @mass = mass
+      @inertia_tensor = inertia_tensor || Matrix[
+        [1, 0, 0],
+        [0, 1, 0],
+        [0, 0, 1]
+      ] * mass
+      @coefficient_of_restitution = coefficient_of_restitution
+      @coefficient_of_friction = coefficient_of_friction
+    end
+
+    def update(delta_time)
+      @velocity += acceleration * delta_time
+      @velocity += @impulses.reduce(Vector[0, 0, 0]) { |acc, impulse| acc + impulse } / @mass
+      @impulses = []
+      @game_object.pos += @velocity * delta_time
+
+      total_angular_impulse = @angular_impulses.reduce(Vector[0, 0, 0]) { |acc, impulse| acc + impulse }
+      if total_angular_impulse.magnitude > 0
+        angular_inertia =
+          if moment_of_inertia == 0
+            impulse_direction = total_angular_impulse.normalize
+            impulse_direction.dot(@inertia_tensor * impulse_direction)
+          else
+            moment_of_inertia
+          end
+        @angular_velocity += total_angular_impulse / angular_inertia
+      end
+      @angular_impulses = []
+      @game_object.rotate_around(angular_velocity, delta_time * angular_velocity.magnitude) if angular_velocity.magnitude > 0
+    end
+
+    def apply_impulse(impulse, point)
+      @impulses << impulse
+      @angular_impulses << (game_object.pos - point).cross(impulse)
+    end
+
+    def apply_angular_impulse(impulse)
+      @angular_impulses << impulse
+    end
+
+    def colliders
+      @game_object.components.select { |c| c.is_a?(SphereCollider) }
+    end
+
+    def kinetic_energy
+      0.5 * @mass * @velocity.magnitude ** 2 +
+        0.5 * moment_of_inertia * @angular_velocity.magnitude ** 2
+    end
+
+    def momentum
+      @mass * @velocity
+    end
+
+    def angular_momentum(origin = Vector[0, 0, 0])
+      moment_of_inertia * @angular_velocity +
+        (game_object.pos - origin).cross(momentum)
+    end
+
+    def velocity_at_point(point)
+      velocity + (angular_velocity.cross(game_object.pos - point) * Math::PI / 180)
+    end
+
+    private
+
+    def acceleration
+      @force / @mass
+    end
+
+    def moment_of_inertia
+      return 0 if @angular_velocity.magnitude == 0
+
+      angular_velocity_direction = @angular_velocity.normalize
+      angular_velocity_direction.dot(@inertia_tensor * angular_velocity_direction)
+    end
+  end
+end