ruby_rpg 0.0.1 → 0.0.2

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Engine::Physics::Components
+  class SphereCollider < Engine::Component
+    attr_accessor :radius
+
+    def initialize(radius)
+      @radius = radius
+    end
+
+    def collision_for(other_collider)
+      distance = (game_object.pos - other_collider.game_object.pos).magnitude
+      min_distance = radius + other_collider.radius
+
+      return nil if distance >= min_distance
+
+      direction = (other_collider.game_object.pos - game_object.pos).normalize
+      collision_point = collision_point(direction, min_distance - distance)
+      magnitude = normal_impulse_magnitude(direction, other_collider, collision_point)
+
+      return nil if magnitude <= 0
+
+      normal_impulse = -direction * magnitude
+      tangential_impulse = tangential_impulse(other_collider, normal_impulse, collision_point)
+
+      puts "normal_impulse: #{normal_impulse}"
+      puts "tangential_impulse: #{tangential_impulse}"
+      puts "total impulse: #{normal_impulse + tangential_impulse}"
+
+      Engine::Physics::Collision.new(normal_impulse + tangential_impulse, collision_point)
+    end
+
+    def static?
+      rigidbody.nil?
+    end
+
+    def inverse_mass
+      1.0 / rigidbody.mass
+    end
+
+    def velocity(pos)
+      rigidbody&.velocity_at_point(pos) || Vector[0, 0, 0]
+    end
+
+    def rigidbody
+      game_object.components.find { |c| c.is_a?(Rigidbody) }
+    end
+
+    private
+
+    def combined_coefficient_of_restitution(other_collider)
+      return rigidbody.coefficient_of_restitution if other_collider.static?
+
+      rigidbody.coefficient_of_restitution * other_collider.rigidbody.coefficient_of_restitution
+    end
+
+    def combined_coefficient_of_friction(other_collider)
+      return rigidbody.coefficient_of_friction if other_collider.static?
+
+      rigidbody.coefficient_of_friction * other_collider.rigidbody.coefficient_of_friction
+    end
+
+    def collision_point(direction, overlap)
+      game_object.pos + direction * (radius - overlap / 2)
+    end
+
+    def normal_impulse_magnitude(direction, other_collider, collision_point)
+      (
+        if other_collider.static?
+          v_r = velocity(collision_point)
+          (v_r.dot(direction) * 2) / inverse_mass
+        else
+          v_r = velocity(collision_point) - other_collider.velocity(collision_point)
+          (v_r.dot(direction) * 2) / (inverse_mass + other_collider.inverse_mass)
+        end) * combined_coefficient_of_restitution(other_collider)
+    end
+
+    def tangential_impulse(other_collider, normal_impulse, collision_point)
+      normal_direction = normal_impulse.normalize
+      v_t = if other_collider.static?
+              velocity(collision_point)
+            else
+              velocity(collision_point) - other_collider.velocity(collision_point)
+            end
+
+      v_t_without_normal = -((v_t - v_t.dot(normal_direction) * normal_direction))
+      return Vector[0, 0, 0] if v_t_without_normal.magnitude == 0
+
+      relevant_speed = [v_t_without_normal.magnitude, normal_impulse.magnitude * combined_coefficient_of_friction(other_collider)].min
+      v_t_without_normal.normalize * relevant_speed / 2
+    end
+  end
+end

data/lib/engine/physics/physics_resolver.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Engine::Physics
+  module PhysicsResolver
+    def self.resolve
+      rigidbodies.each do |rb|
+        apply_collisions(rb)
+      end
+    end
+
+    private
+
+    def self.apply_collisions(rigidbody)
+      other_colliders = colliders.reject { |c| rigidbody.colliders.include?(c) }
+
+      rigidbody.colliders.map do |collider|
+        other_colliders.map do |other_collider|
+          collider.collision_for(other_collider)
+        end.compact
+      end.flatten.each do |collision|
+        rigidbody.apply_impulse(collision.impulse, collision.point)
+      end
+    end
+
+    def self.rigidbodies
+      Engine::GameObject.objects.map do |go|
+        go.components.find { |c| c.is_a?(Engine::Physics::Components::Rigidbody) }
+      end.compact
+    end
+
+    def self.colliders
+      Engine::GameObject.objects.map do |go|
+        go.components.select { |c| c.is_a?(Components::SphereCollider) }
+      end.flatten
+    end
+  end
+end

data/lib/engine/polygon_mesh.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Engine
+  class PolygonMesh
+    attr_reader :points, :uvs
+
+    def initialize(points, uvs)
+      @points = points
+      @uvs = uvs
+    end
+
+    def vertex_data
+      @vertex_data ||= generate_vertex_data
+    end
+
+    def index_data
+      @index_data ||= (0..vertices.length - 1).to_a
+    end
+
+    private
+
+    def generate_vertex_data
+      vertices.map do |point|
+        uv = uvs[points.index(point)]
+        [point[0], point[1], 0.0, uv[0], uv[1]]
+      end.flatten
+    end
+
+    def vertices
+      @vertices ||=
+        begin
+          path = Path.new(@points)
+          vertices = []
+          until path.length == 3
+            ear, new_path = path.find_ear
+            ear = ear.reverse!
+            vertices << ear
+            path = new_path
+          end
+          vertices += path.points.reverse
+          vertices.flatten(1)
+        end
+    end
+  end
+end

data/lib/engine/quaternion.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+module Engine
+  class Quaternion
+    EULER_ORDER = "XYZ"
+    attr_accessor :w, :x, :y, :z, :euler_order
+
+    def initialize(w, x, y, z)
+      @w = w
+      @x = x
+      @y = y
+      @z = z
+    end
+
+    def to_s
+      "Quaternion(w: #{@w}, x: #{@x}, y: #{@y}, z: #{@z})"
+    end
+
+    def *(other)
+      Quaternion.new(
+        @w * other.w - @x * other.x - @y * other.y - @z * other.z,
+        @w * other.x + @x * other.w + @y * other.z - @z * other.y,
+        @w * other.y - @x * other.z + @y * other.w + @z * other.x,
+        @w * other.z + @x * other.y - @y * other.x + @z * other.w
+      )
+    end
+
+    # taken from https://github.com/mrdoob/three.js/blob/134ff886792734a75c0a9b30aa816d19270f8526/src/math/Quaternion.js#L229
+    def self.from_euler(euler)
+      e_1 = euler[0] * Math::PI / 180
+      e_2 = euler[1] * Math::PI / 180
+      e_3 = euler[2] * Math::PI / 180
+
+      c_1 = Math.cos(e_1 / 2)
+      c_2 = Math.cos(e_2 / 2)
+      c_3 = Math.cos(e_3 / 2)
+
+      s_1 = Math.sin(e_1 / 2)
+      s_2 = Math.sin(e_2 / 2)
+      s_3 = Math.sin(e_3 / 2)
+
+      case EULER_ORDER
+      when "XYZ"
+        Quaternion.new(
+          c_1 * c_2 * c_3 - s_1 * s_2 * s_3,
+          s_1 * c_2 * c_3 + c_1 * s_2 * s_3,
+          c_1 * s_2 * c_3 - s_1 * c_2 * s_3,
+          c_1 * c_2 * s_3 + s_1 * s_2 * c_3
+        )
+      when "YXZ"
+        Quaternion.new(
+          c_1 * c_2 * c_3 + s_1 * s_2 * s_3,
+          s_1 * c_2 * c_3 + c_1 * s_2 * s_3,
+          c_1 * s_2 * c_3 - s_1 * c_2 * s_3,
+          c_1 * c_2 * s_3 - s_1 * s_2 * c_3
+        )
+      when "ZXY"
+        Quaternion.new(
+          c_1 * c_2 * c_3 - s_1 * s_2 * s_3,
+          s_1 * c_2 * c_3 - c_1 * s_2 * s_3,
+          c_1 * s_2 * c_3 + s_1 * c_2 * s_3,
+          c_1 * c_2 * s_3 + s_1 * s_2 * c_3
+        )
+      when "ZYX"
+        Quaternion.new(
+          c_1 * c_2 * c_3 + s_1 * s_2 * s_3,
+          s_1 * c_2 * c_3 - c_1 * s_2 * s_3,
+          c_1 * s_2 * c_3 + s_1 * c_2 * s_3,
+          c_1 * c_2 * s_3 - s_1 * s_2 * c_3
+        )
+      when "YZX"
+        Quaternion.new(
+          s_1 * c_2 * c_3 + c_1 * s_2 * s_3,
+          c_1 * s_2 * c_3 + s_1 * c_2 * s_3,
+          c_1 * c_2 * s_3 - s_1 * s_2 * c_3,
+          c_1 * c_2 * c_3 - s_1 * s_2 * s_3
+        )
+      when "XZY"
+        Quaternion.new(
+          c_1 * c_2 * c_3 + s_1 * s_2 * s_3,
+          s_1 * c_2 * c_3 - c_1 * s_2 * s_3,
+          c_1 * s_2 * c_3 - s_1 * c_2 * s_3,
+          c_1 * c_2 * s_3 + s_1 * s_2 * c_3
+        )
+      end
+    end
+
+    # taken from https://github.com/mrdoob/three.js/blob/134ff886792734a75c0a9b30aa816d19270f8526/src/math/Euler.js#L134
+    def to_euler
+      m11 = te[0]
+      m12 = te[4]
+      m13 = te[8]
+      m21 = te[1]
+      m22 = te[5]
+      m23 = te[9]
+      m31 = te[2]
+      m32 = te[6]
+      m33 = te[10]
+
+      case EULER_ORDER
+      when "XYZ"
+        e_y = Math.asin(m13.clamp(-1, 1))
+
+        if m13.abs < 0.9999999
+          e_x = Math.atan2(-m23, m33)
+          e_z = Math.atan2(-m12, m11)
+        else
+          e_x = Math.atan2(m32, m22)
+          e_z = 0
+        end
+      when "YXZ"
+        e_x = Math.asin(-m23.clamp(-1, 1))
+
+        if m23.abs < 0.9999999
+          e_y = Math.atan2(m13, m33)
+          e_z = Math.atan2(m21, m22)
+        else
+          e_y = Math.atan2(-m31, m11)
+          e_z = 0
+        end
+      when "ZXY"
+        e_x = Math.asin(m32.clamp(-1, 1))
+
+        if m32.abs < 0.9999999
+          e_y = Math.atan2(-m31, m33)
+          e_z = Math.atan2(-m12, m22)
+        else
+          e_y = 0
+          e_z = Math.atan2(m21, m11)
+        end
+      when "ZYX"
+        e_y = Math.asin(-m31.clamp(-1, 1))
+
+        if m31.abs < 0.9999999
+          e_x = Math.atan2(m32, m33)
+          e_z = Math.atan2(m21, m11)
+        else
+          e_x = 0
+          e_z = Math.atan2(-m12, m22)
+        end
+      when "YZX"
+        e_z = Math.asin(m21.clamp(-1, 1))
+
+        if m21.abs < 0.9999999
+          e_x = Math.atan2(-m23, m22)
+          e_y = Math.atan2(-m31, m11)
+        else
+          e_x = 0
+          e_y = Math.atan2(m13, m33)
+        end
+      when "XZY"
+        e_z = Math.asin(-m12.clamp(-1, 1))
+
+        if m12.abs < 0.9999999
+          e_x = Math.atan2(m32, m22)
+          e_y = Math.atan2(m13, m11)
+        else
+          e_x = Math.atan2(-m23, m33)
+          e_y = 0
+        end
+      end
+
+      Vector[e_x, e_y, e_z] * 180 / Math::PI
+    end
+
+    def te
+      x2 = x + x
+      y2 = y + y
+      z2 = z + z
+
+      xx = x * x2
+      xy = x * y2
+      xz = x * z2
+      yy = y * y2
+      yz = y * z2
+      zz = z * z2
+      wx = w * x2
+      wy = w * y2
+      wz = w * z2
+
+      [
+        1 - (yy + zz),
+        xy + wz,
+        xz - wy,
+        0,
+
+        xy - wz,
+        1 - (xx + zz),
+        yz + wx,
+        0,
+
+        xz + wy,
+        yz - wx,
+        1 - (xx + yy),
+        0,
+
+        0,
+        0,
+        0,
+        1,
+      ]
+    end
+
+    def self.from_angle_axis(angle, axis)
+      axis = axis.normalize
+      angle = angle * Math::PI / 180
+
+      half_angle = angle / 2
+      sin_half_angle = Math.sin(half_angle)
+      cos_half_angle = Math.cos(half_angle)
+
+      Quaternion.new(
+        cos_half_angle,
+        axis[0] * sin_half_angle,
+        axis[1] * sin_half_angle,
+        axis[2] * sin_half_angle
+      )
+    end
+
+    def to_angle_axis
+      angle = 2 * Math.acos(@w)
+      s = Math.sqrt(1 - @w * @w)
+      s = 1 if s < 0.0001
+      axis = Vector[@x / s, @y / s, @z / s]
+      [angle * 180 / Math::PI, axis]
+    end
+  end
+end

data/lib/engine/rendering/instance_renderer.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module Rendering
+  class InstanceRenderer
+    attr_reader :mesh, :material
+
+    def initialize(mesh, material)
+      @mesh = mesh
+      @material = material
+      @mesh_renderers = []
+      @mesh_matrix_data = []
+
+      setup_vertex_attribute_buffer
+      setup_vertex_buffer
+      setup_index_buffer
+      generate_instance_vbo_buf
+    end
+
+    def add_instance(mesh_renderer)
+      @mesh_renderers << mesh_renderer
+      @mesh_matrix_data += mesh_renderer.game_object.model_matrix.to_a.flatten
+    end
+
+    def remove_instance(mesh_renderer)
+      index = @mesh_renderers.index(mesh_renderer)
+      @mesh_renderers.delete_at(index)
+      @mesh_matrix_data[index * 16, 16] = []
+    end
+
+    def update_instance(mesh_renderer)
+      index = @mesh_renderers.index(mesh_renderer)
+      @mesh_matrix_data[index * 16, 16] = mesh_renderer.game_object.model_matrix.to_a.flatten
+    end
+
+    def draw_all
+      set_material_per_frame_data
+
+      GL.BindVertexArray(@vao)
+      update_vbo_buf
+      GL.BindBuffer(GL::ELEMENT_ARRAY_BUFFER, @ebo)
+      GL.BindBuffer(GL::ARRAY_BUFFER, @instance_vbo)
+
+      GL.DrawElementsInstanced(GL::TRIANGLES, mesh.index_data.length, GL::UNSIGNED_INT, 0, @mesh_renderers.count)
+      GL.BindVertexArray(0)
+      GL.BindBuffer(GL::ELEMENT_ARRAY_BUFFER, 0)
+    end
+
+    private
+
+    def set_material_per_frame_data
+      material.set_mat4("camera", Engine::Camera.instance.matrix)
+      material.set_vec3("cameraPos", Engine::Camera.instance.game_object.pos)
+
+      update_light_data
+      material.update_shader
+    end
+
+    def update_light_data
+      Engine::Components::PointLight.point_lights.each_with_index do |light, i|
+        material.set_float("pointLights[#{i}].sqrRange", light.range * light.range)
+        material.set_vec3("pointLights[#{i}].position", light.game_object.pos)
+        material.set_vec3("pointLights[#{i}].colour", light.colour)
+      end
+      Engine::Components::DirectionLight.direction_lights.each_with_index do |light, i|
+        material.set_vec3("directionalLights[#{i}].direction", light.game_object.forward)
+        material.set_vec3("directionalLights[#{i}].colour", light.colour)
+      end
+    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
+      )
+      vertex_data_size = 20 * Fiddle::SIZEOF_FLOAT
+
+      GL.VertexAttribPointer(0, 3, GL::FLOAT, GL::FALSE, vertex_data_size, 0)
+      GL.VertexAttribPointer(1, 2, GL::FLOAT, GL::FALSE, vertex_data_size, 3 * Fiddle::SIZEOF_FLOAT)
+      GL.VertexAttribPointer(2, 3, GL::FLOAT, GL::FALSE, vertex_data_size, 5 * Fiddle::SIZEOF_FLOAT)
+      GL.VertexAttribPointer(3, 3, GL::FLOAT, GL::FALSE, vertex_data_size, 8 * Fiddle::SIZEOF_FLOAT)
+      GL.VertexAttribPointer(4, 3, GL::FLOAT, GL::FALSE, vertex_data_size, 11 * Fiddle::SIZEOF_FLOAT)
+      GL.VertexAttribPointer(5, 3, GL::FLOAT, GL::FALSE, vertex_data_size, 14 * Fiddle::SIZEOF_FLOAT)
+      GL.VertexAttribPointer(6, 3, GL::FLOAT, GL::FALSE, vertex_data_size, 17 * Fiddle::SIZEOF_FLOAT)
+      GL.EnableVertexAttribArray(0)
+      GL.EnableVertexAttribArray(1)
+      GL.EnableVertexAttribArray(2)
+      GL.EnableVertexAttribArray(3)
+      GL.EnableVertexAttribArray(4)
+      GL.EnableVertexAttribArray(5)
+      GL.EnableVertexAttribArray(6)
+    end
+
+    def generate_instance_vbo_buf
+      instance_vbo_buf = ' ' * 4
+      GL.GenBuffers(1, instance_vbo_buf)
+      @instance_vbo = instance_vbo_buf.unpack('L')[0]
+      update_vbo_buf
+    end
+
+    def update_vbo_buf
+      vertex_data = @mesh_matrix_data
+
+      GL.BindBuffer(GL::ARRAY_BUFFER, @instance_vbo)
+      GL.BufferData(
+        GL::ARRAY_BUFFER, vertex_data.length * Fiddle::SIZEOF_FLOAT,
+        vertex_data.pack('F*'), GL::STATIC_DRAW
+      )
+
+      vec4_size = Fiddle::SIZEOF_FLOAT * 4
+
+      GL.EnableVertexAttribArray(7)
+      GL.EnableVertexAttribArray(8)
+      GL.EnableVertexAttribArray(9)
+      GL.EnableVertexAttribArray(10)
+
+      GL.VertexAttribPointer(7, 4, GL::FLOAT, GL::FALSE, 4 * vec4_size, 0)
+      GL.VertexAttribPointer(8, 4, GL::FLOAT, GL::FALSE, 4 * vec4_size, 1 * vec4_size)
+      GL.VertexAttribPointer(9, 4, GL::FLOAT, GL::FALSE, 4 * vec4_size, 2 * vec4_size)
+      GL.VertexAttribPointer(10, 4, GL::FLOAT, GL::FALSE, 4 * vec4_size, 3 * vec4_size)
+
+      GL.VertexAttribDivisor(7, 1)
+      GL.VertexAttribDivisor(8, 1)
+      GL.VertexAttribDivisor(9, 1)
+      GL.VertexAttribDivisor(10, 1)
+    end
+  end
+end

data/lib/engine/rendering/render_pipeline.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Rendering
+  module RenderPipeline
+    def self.draw
+      Engine::GameObject.mesh_renderers.each do |mesh_renderer|
+        mesh_renderer.update(0)
+      end
+
+      instance_renderers.values.each do |renderer|
+        renderer.draw_all
+      end
+    end
+
+    def self.add_instance(mesh_renderer)
+      instance_renderers[[mesh_renderer.mesh, mesh_renderer.material]].add_instance(mesh_renderer)
+    end
+
+    def self.remove_instance(mesh_renderer)
+      instance_renderers[[mesh_renderer.mesh, mesh_renderer.material]].remove_instance(mesh_renderer)
+    end
+
+    def self.update_instance(mesh_renderer)
+      instance_renderers[[mesh_renderer.mesh, mesh_renderer.material]].update_instance(mesh_renderer)
+    end
+
+    private
+
+    def self.instance_renderers
+      @instance_renderers ||= Hash.new do |hash, key|
+        hash[key] = InstanceRenderer.new(key[0], key[1])
+      end
+    end
+  end
+end

data/lib/engine/screenshoter.rb

@@ -0,0 +1,34 @@
+module Engine
+  class Screenshoter
+    def self.screenshot(&block)
+      @after_screenshot = block
+    end
+
+    def self.scheduled_screenshot
+      @after_screenshot != nil
+    end
+
+    def self.take_screenshot
+      @scheduled_screenshot = nil
+      width = Engine::Window.framebuffer_width
+      height = Engine::Window.framebuffer_height
+      pixels = ' ' * (width * height * 3)
+      GL.ReadPixels(0, 0, width, height, GL::RGB, GL::UNSIGNED_BYTE, pixels)
+      png = ChunkyPNG::Image.new(width, height, ChunkyPNG::Color::TRANSPARENT)
+      pixels = pixels.bytes.map { |b| b.to_i }
+      x = 0
+      y = 0
+      pixels.each_slice(3) do |r, g, b|
+        png[x, height - y - 1] = ChunkyPNG::Color.rgb(r, g, b)
+        x += 1
+        if x >= width
+          x = 0
+          y += 1
+        end
+      end
+      block = @after_screenshot
+      @after_screenshot = nil
+      block.call(png)
+    end
+  end
+end