ruby_rpg 0.0.5 → 0.1.0

data/lib/engine/opengl/compute_shader.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Engine
+  module OpenGL
+    class ComputeShader
+      def initialize(shader_path)
+        @uniform_locations = {}
+        @compute_shader = compile_shader(shader_path)
+        @program = Engine::GL.CreateProgram
+        Engine::GL.AttachShader(@program, @compute_shader)
+        Engine::GL.LinkProgram(@program)
+
+        linked_buf = ' ' * 4
+        Engine::GL.GetProgramiv(@program, Engine::GL::LINK_STATUS, linked_buf)
+        linked = linked_buf.unpack('L')[0]
+        if linked == 0
+          compile_log = ' ' * 1024
+          Engine::GL.GetProgramInfoLog(@program, 1023, nil, compile_log)
+          compute_log = ' ' * 1024
+          Engine::GL.GetShaderInfoLog(@compute_shader, 1023, nil, compute_log)
+          raise "Shader program failed to link:\n#{compile_log.strip}\n#{compute_log.strip}"
+        end
+        @uniform_cache = {}
+        @uniform_locations = {}
+      end
+
+      def dispatch(width, height, depth, textures: [], floats: {}, ints: {})
+        # Extract gl_texture from ComputeTexture objects
+        textures.each_with_index do |texture, slot|
+          gl_tex = texture.respond_to?(:gl_texture) ? texture.gl_texture : texture
+          set_texture(slot, gl_tex)
+        end
+
+        Engine::GL.UseProgram(@program)
+
+        floats.each { |name, value| set_float(name, value) }
+        ints.each { |name, value| set_int(name, value) }
+
+        Engine::GL.DispatchCompute(width, height, depth)
+        Engine::GL.MemoryBarrier(Engine::GL::SHADER_IMAGE_ACCESS_BARRIER_BIT)
+      end
+
+      private
+
+      def compile_shader(shader_path)
+        handle = Engine::GL.CreateShader(Engine::GL::COMPUTE_SHADER)
+        path = File.expand_path(File.join(GAME_DIR, shader_path))
+        s_srcs = [File.read(path)].pack('p')
+        s_lens = [File.size(path)].pack('I')
+        Engine::GL.ShaderSource(handle, 1, s_srcs, s_lens)
+        Engine::GL.CompileShader(handle)
+        handle
+      end
+
+      def set_float(name, float)
+        Engine::GL.Uniform1f(uniform_location(name), float)
+      end
+
+      def set_texture(slot, texture)
+        Engine::GL.ActiveTexture(Object.const_get("Engine::GL::TEXTURE#{slot}"))
+        if texture
+          Engine::GL.BindImageTexture(slot, texture, 0, Engine::GL::FALSE, 0, Engine::GL::READ_WRITE, Engine::GL::RGBA32F)
+        else
+          Engine::GL.BindImageTexture(slot, 0, 0, Engine::GL::FALSE, 0, Engine::GL::READ_WRITE, Engine::GL::RGBA32F)
+        end
+      end
+
+      def set_int(name, int)
+        Engine::GL.Uniform1i(uniform_location(name), int)
+      end
+
+      def uniform_location(name)
+        @uniform_locations[name] ||= Engine::GL.GetUniformLocation(@program, name)
+      end
+    end
+  end
+end

data/lib/engine/opengl/compute_texture.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Engine
+  module OpenGL
+    class ComputeTexture
+      attr_reader :width, :height, :gl_texture
+
+      def initialize(width, height)
+        @width = width
+        @height = height
+        create_texture
+      end
+
+      private
+
+      def create_texture
+        tex_buf = ' ' * 4
+        Engine::GL.GenTextures(1, tex_buf)
+        @gl_texture = tex_buf.unpack('L')[0]
+
+        Engine::GL.BindTexture(Engine::GL::TEXTURE_2D, @gl_texture)
+        Engine::GL.TexParameteri(Engine::GL::TEXTURE_2D, Engine::GL::TEXTURE_WRAP_S, Engine::GL::REPEAT)
+        Engine::GL.TexParameteri(Engine::GL::TEXTURE_2D, Engine::GL::TEXTURE_WRAP_T, Engine::GL::REPEAT)
+        Engine::GL.TexParameteri(Engine::GL::TEXTURE_2D, Engine::GL::TEXTURE_MIN_FILTER, Engine::GL::LINEAR)
+        Engine::GL.TexParameteri(Engine::GL::TEXTURE_2D, Engine::GL::TEXTURE_MAG_FILTER, Engine::GL::LINEAR)
+        Engine::GL.TexImage2D(Engine::GL::TEXTURE_2D, 0, Engine::GL::RGBA32F, @width, @height, 0, Engine::GL::RGBA, Engine::GL::FLOAT, nil)
+        Engine::GL.BindTexture(Engine::GL::TEXTURE_2D, 0)
+      end
+    end
+  end
+end

data/lib/engine/path.rb

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

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

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

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

@@ -1,103 +1,106 @@
-# 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
+# frozen_string_literal: true
+
+module Engine::Physics::Components
+  class Rigidbody < Engine::Component
+    serialize :velocity, :angular_velocity, :mass, :inertia_tensor, :gravity,
+              :coefficient_of_restitution, :coefficient_of_friction
+
+    attr_accessor :velocity,
+                  :angular_velocity,
+                  :force,
+                  :impulses,
+                  :mass,
+                  :coefficient_of_restitution,
+                  :coefficient_of_friction
+
+    def awake
+      @velocity ||= Vector[0, 0, 0]
+      @angular_velocity ||= Vector[0, 0, 0]
+      @mass ||= 1
+      @gravity ||= Vector[0, -9.81, 0]
+      @coefficient_of_restitution ||= 1
+      @coefficient_of_friction ||= 0
+      @inertia_tensor ||= Matrix[
+        [1, 0, 0],
+        [0, 1, 0],
+        [0, 0, 1]
+      ] * @mass
+      @force = @gravity * @mass
+      @impulses = []
+      @angular_impulses = []
+    end
+
+    def start
+      Engine::Physics::PhysicsResolver.register_rigidbody(self)
+    end
+
+    def destroy
+      Engine::Physics::PhysicsResolver.unregister_rigidbody(self)
+    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