ruby_rpg 0.0.5 → 0.1.0

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

@@ -1,93 +1,103 @@
-# 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
+# frozen_string_literal: true
+
+module Engine::Physics::Components
+  class SphereCollider < Engine::Component
+    serialize :radius
+
+    attr_accessor :radius
+
+    def awake
+      @radius ||= 1
+    end
+
+    def start
+      Engine::Physics::PhysicsResolver.register_collider(self)
+    end
+
+    def destroy
+      Engine::Physics::PhysicsResolver.unregister_collider(self)
+    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.component(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

@@ -1,37 +1,49 @@
-# 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
+# frozen_string_literal: true
+
+module Engine::Physics
+  module PhysicsResolver
+    def self.resolve
+      rigidbodies.each do |rb|
+        apply_collisions(rb)
+      end
+    end
+
+    def self.rigidbodies
+      @cached_rigidbodies ||= []
+    end
+
+    def self.colliders
+      @cached_colliders ||= []
+    end
+
+    def self.register_rigidbody(rigidbody)
+      rigidbodies << rigidbody
+    end
+
+    def self.unregister_rigidbody(rigidbody)
+      rigidbodies.delete(rigidbody)
+    end
+
+    def self.register_collider(collider)
+      colliders << collider
+    end
+
+    def self.unregister_collider(collider)
+      colliders.delete(collider)
+    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
+  end
+end

data/lib/engine/polygon_mesh.rb

@@ -1,45 +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
+# 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