ruby_rpg 0.0.4 → 0.1.0

data/lib/engine/metal/compute_texture.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+require_relative 'metal_bindings'
+require_relative 'device'
+
+module Engine
+  module Metal
+    class ComputeTexture
+      include Fiddle
+
+      attr_reader :width, :height, :gl_texture, :metal_texture
+
+      # IOSurface property keys
+      IOSURFACE_WIDTH = 'IOSurfaceWidth'
+      IOSURFACE_HEIGHT = 'IOSurfaceHeight'
+      IOSURFACE_BYTES_PER_ELEMENT = 'IOSurfaceBytesPerElement'
+      IOSURFACE_BYTES_PER_ROW = 'IOSurfaceBytesPerRow'
+      IOSURFACE_ALLOC_SIZE = 'IOSurfaceAllocSize'
+      IOSURFACE_PIXEL_FORMAT = 'IOSurfacePixelFormat'
+
+      # Pixel format for RGBA32F
+      PIXEL_FORMAT_RGBA32F = 0x52474241 # 'RGBA' as 32-bit int
+
+      def initialize(width, height)
+        @width = width
+        @height = height
+        @device = Device.instance
+
+        create_iosurface
+        create_metal_texture
+        create_gl_rect_texture
+        create_gl_2d_texture
+        setup_blit_fbo
+      end
+
+      def sync
+        Engine::GL.BindFramebuffer(Engine::GL::READ_FRAMEBUFFER, @read_fbo)
+        Engine::GL.BindFramebuffer(Engine::GL::DRAW_FRAMEBUFFER, @draw_fbo)
+
+        Engine::GL.BlitFramebuffer(
+          0, 0, @width, @height,
+          0, 0, @width, @height,
+          Engine::GL::COLOR_BUFFER_BIT,
+          Engine::GL::NEAREST
+        )
+
+        Engine::GL.BindFramebuffer(Engine::GL::FRAMEBUFFER, 0)
+        Engine::GL.Finish
+      end
+
+      private
+
+      def create_iosurface
+        props = create_iosurface_properties
+        @iosurface = IOSurfaceFramework.IOSurfaceCreate(props)
+
+        if @iosurface.null? || @iosurface.to_i == 0
+          raise "Failed to create IOSurface"
+        end
+
+        CoreFoundation.CFRelease(props)
+      end
+
+      def create_iosurface_properties
+        dict = CoreFoundation.CFDictionaryCreateMutable(nil, 0, nil, nil)
+
+        bytes_per_element = 16 # 4 floats * 4 bytes
+        bytes_per_row = @width * bytes_per_element
+        alloc_size = bytes_per_row * @height
+
+        set_dict_int(dict, IOSURFACE_WIDTH, @width)
+        set_dict_int(dict, IOSURFACE_HEIGHT, @height)
+        set_dict_int(dict, IOSURFACE_BYTES_PER_ELEMENT, bytes_per_element)
+        set_dict_int(dict, IOSURFACE_BYTES_PER_ROW, bytes_per_row)
+        set_dict_int(dict, IOSURFACE_ALLOC_SIZE, alloc_size)
+        set_dict_int(dict, IOSURFACE_PIXEL_FORMAT, PIXEL_FORMAT_RGBA32F)
+
+        dict
+      end
+
+      def set_dict_int(dict, key, value)
+        key_str = ObjC.msg(ObjC.cls('NSString'), 'stringWithUTF8String:', key)
+        num = CoreFoundation.create_int(value)
+        CoreFoundation.CFDictionarySetValue(dict, key_str, num)
+      end
+
+      def create_metal_texture
+        descriptor = ObjC.msg(ObjC.cls('MTLTextureDescriptor'), 'new')
+
+        # MTLPixelFormatRGBA32Float = 125
+        ObjC.msg(descriptor, 'setPixelFormat:', 125)
+        ObjC.msg(descriptor, 'setWidth:', @width)
+        ObjC.msg(descriptor, 'setHeight:', @height)
+        # MTLTextureUsageShaderRead | MTLTextureUsageShaderWrite = 1 | 2 = 3
+        ObjC.msg(descriptor, 'setUsage:', 3)
+        # MTLStorageModeShared = 0
+        ObjC.msg(descriptor, 'setStorageMode:', 0)
+
+        @metal_texture = ObjC.msg(
+          @device.device,
+          'newTextureWithDescriptor:iosurface:plane:',
+          descriptor,
+          @iosurface,
+          0
+        )
+
+        if @metal_texture.null? || @metal_texture.to_i == 0
+          raise "Failed to create Metal texture from IOSurface"
+        end
+      end
+
+      def create_gl_rect_texture
+        tex_buf = ' ' * 4
+        Engine::GL.GenTextures(1, tex_buf)
+        @gl_texture_rect = tex_buf.unpack('L')[0]
+
+        Engine::GL.BindTexture(Engine::GL::TEXTURE_RECTANGLE, @gl_texture_rect)
+        Engine::GL.TexParameteri(Engine::GL::TEXTURE_RECTANGLE, Engine::GL::TEXTURE_MIN_FILTER, Engine::GL::LINEAR)
+        Engine::GL.TexParameteri(Engine::GL::TEXTURE_RECTANGLE, Engine::GL::TEXTURE_MAG_FILTER, Engine::GL::LINEAR)
+        Engine::GL.TexParameteri(Engine::GL::TEXTURE_RECTANGLE, Engine::GL::TEXTURE_WRAP_S, Engine::GL::CLAMP_TO_EDGE)
+        Engine::GL.TexParameteri(Engine::GL::TEXTURE_RECTANGLE, Engine::GL::TEXTURE_WRAP_T, Engine::GL::CLAMP_TO_EDGE)
+
+        cgl_context = OpenGLBridge.CGLGetCurrentContext()
+
+        result = OpenGLBridge.CGLTexImageIOSurface2D(
+          cgl_context,
+          Engine::GL::TEXTURE_RECTANGLE,
+          Engine::GL::RGBA32F,
+          @width,
+          @height,
+          Engine::GL::RGBA,
+          Engine::GL::FLOAT,
+          @iosurface,
+          0
+        )
+
+        raise "Failed to bind IOSurface to GL texture: #{result}" unless result == 0
+
+        Engine::GL.BindTexture(Engine::GL::TEXTURE_RECTANGLE, 0)
+      end
+
+      def create_gl_2d_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_MIN_FILTER, Engine::GL::LINEAR)
+        Engine::GL.TexParameteri(Engine::GL::TEXTURE_2D, Engine::GL::TEXTURE_MAG_FILTER, Engine::GL::LINEAR)
+        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.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
+
+      def setup_blit_fbo
+        read_fbo_buf = ' ' * 4
+        Engine::GL.GenFramebuffers(1, read_fbo_buf)
+        @read_fbo = read_fbo_buf.unpack('L')[0]
+
+        Engine::GL.BindFramebuffer(Engine::GL::FRAMEBUFFER, @read_fbo)
+        Engine::GL.FramebufferTexture2D(Engine::GL::FRAMEBUFFER, Engine::GL::COLOR_ATTACHMENT0, Engine::GL::TEXTURE_RECTANGLE, @gl_texture_rect, 0)
+
+        draw_fbo_buf = ' ' * 4
+        Engine::GL.GenFramebuffers(1, draw_fbo_buf)
+        @draw_fbo = draw_fbo_buf.unpack('L')[0]
+
+        Engine::GL.BindFramebuffer(Engine::GL::FRAMEBUFFER, @draw_fbo)
+        Engine::GL.FramebufferTexture2D(Engine::GL::FRAMEBUFFER, Engine::GL::COLOR_ATTACHMENT0, Engine::GL::TEXTURE_2D, @gl_texture, 0)
+
+        Engine::GL.BindFramebuffer(Engine::GL::FRAMEBUFFER, 0)
+      end
+    end
+  end
+end

data/lib/engine/metal/device.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require_relative 'metal_bindings'
+
+module Engine
+  module Metal
+    class Device
+      include Fiddle
+
+      attr_reader :device, :command_queue
+
+      def self.instance
+        @instance ||= new
+      end
+
+      def initialize
+        @device = MetalFramework.create_system_default_device
+        raise "Failed to create Metal device" if @device.null?
+
+        @command_queue = ObjC.msg(@device, 'newCommandQueue')
+        raise "Failed to create command queue" if @command_queue.null?
+      end
+
+      def new_library_with_source(source)
+        # Create NSString from source
+        ns_string_class = ObjC.cls('NSString')
+        source_nsstring = ObjC.msg(
+          ns_string_class,
+          'stringWithUTF8String:',
+          source
+        )
+
+        # Create error pointer
+        error_ptr = Pointer.malloc(8)
+        error_ptr[0, 8] = [0].pack('Q')
+
+        # Compile the library
+        library = ObjC.msg(
+          @device,
+          'newLibraryWithSource:options:error:',
+          source_nsstring,
+          nil,
+          error_ptr
+        )
+
+        if library.null?
+          error = Pointer.new(error_ptr[0, 8].unpack('Q')[0])
+          unless error.null?
+            desc = ObjC.msg(error, 'localizedDescription')
+            utf8 = ObjC.msg(desc, 'UTF8String')
+            raise "Metal shader compilation failed: #{utf8.to_s}"
+          end
+          raise "Metal shader compilation failed with unknown error"
+        end
+
+        library
+      end
+
+      def new_compute_pipeline(library, function_name)
+        # Get function from library
+        func_name_nsstring = ObjC.msg(
+          ObjC.cls('NSString'),
+          'stringWithUTF8String:',
+          function_name
+        )
+        function = ObjC.msg(library, 'newFunctionWithName:', func_name_nsstring)
+        raise "Failed to find function '#{function_name}'" if function.null?
+
+        # Create compute pipeline
+        error_ptr = Pointer.malloc(8)
+        error_ptr[0, 8] = [0].pack('Q')
+
+        pipeline = ObjC.msg(
+          @device,
+          'newComputePipelineStateWithFunction:error:',
+          function,
+          error_ptr
+        )
+
+        if pipeline.null?
+          error = Pointer.new(error_ptr[0, 8].unpack('Q')[0])
+          unless error.null?
+            desc = ObjC.msg(error, 'localizedDescription')
+            utf8 = ObjC.msg(desc, 'UTF8String')
+            raise "Failed to create compute pipeline: #{utf8.to_s}"
+          end
+          raise "Failed to create compute pipeline with unknown error"
+        end
+
+        pipeline
+      end
+
+      def new_command_buffer
+        ObjC.msg(@command_queue, 'commandBuffer')
+      end
+    end
+  end
+end

data/lib/engine/metal/metal_bindings.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require 'fiddle'
+require 'fiddle/import'
+
+module Engine
+  module Metal
+    module ObjC
+      extend Fiddle::Importer
+      dlload '/usr/lib/libobjc.A.dylib'
+
+      extern 'void* objc_getClass(const char*)'
+      extern 'void* sel_registerName(const char*)'
+
+      # We need to handle objc_msgSend manually for variadic args
+      OBJC_LIB = Fiddle.dlopen('/usr/lib/libobjc.A.dylib')
+      OBJC_MSGSEND_ADDR = OBJC_LIB['objc_msgSend']
+
+      def self.cls(name)
+        objc_getClass(name)
+      end
+
+      def self.sel(name)
+        sel_registerName(name)
+      end
+
+      def self.msg(obj, selector, *args)
+        sel_ptr = sel(selector)
+
+        # Build argument types: obj, sel, then args
+        arg_types = [Fiddle::TYPE_VOIDP, Fiddle::TYPE_VOIDP]
+        call_args = [obj, sel_ptr]
+
+        args.each do |arg|
+          case arg
+          when Integer
+            arg_types << Fiddle::TYPE_LONG
+            call_args << arg
+          when Float
+            arg_types << Fiddle::TYPE_DOUBLE
+            call_args << arg
+          when String
+            arg_types << Fiddle::TYPE_VOIDP
+            call_args << Fiddle::Pointer[arg]
+          when Fiddle::Pointer
+            arg_types << Fiddle::TYPE_VOIDP
+            call_args << arg
+          when nil
+            arg_types << Fiddle::TYPE_VOIDP
+            call_args << Fiddle::Pointer.new(0)
+          else
+            # Assume it's a pointer-like thing
+            arg_types << Fiddle::TYPE_VOIDP
+            call_args << arg
+          end
+        end
+
+        func = Fiddle::Function.new(OBJC_MSGSEND_ADDR, arg_types, Fiddle::TYPE_VOIDP)
+        result = func.call(*call_args)
+        Fiddle::Pointer.new(result)
+      end
+    end
+
+    module MetalFramework
+      extend Fiddle::Importer
+      dlload '/System/Library/Frameworks/Metal.framework/Metal'
+      dlload '/System/Library/Frameworks/CoreGraphics.framework/CoreGraphics'
+
+      # Get default device via Objective-C runtime instead of C function
+      def self.create_system_default_device
+        # MTLCopyAllDevices returns an NSArray of devices, first one is default
+        devices = ObjC.msg(ObjC.cls('MTLCopyAllDevicesWithObserver'), 'alloc')
+        # Simpler: use the class method on MTLDevice protocol
+        # Actually, let's just call the C function through a different approach
+        metal_lib = Fiddle.dlopen('/System/Library/Frameworks/Metal.framework/Metal')
+        create_device = Fiddle::Function.new(
+          metal_lib['MTLCreateSystemDefaultDevice'],
+          [],
+          Fiddle::TYPE_VOIDP
+        )
+        create_device.call
+      end
+    end
+
+    module IOSurfaceFramework
+      extend Fiddle::Importer
+      dlload '/System/Library/Frameworks/IOSurface.framework/IOSurface'
+
+      extern 'void* IOSurfaceCreate(void*)'
+      extern 'int IOSurfaceLock(void*, int, void*)'
+      extern 'int IOSurfaceUnlock(void*, int, void*)'
+      extern 'void* IOSurfaceGetBaseAddress(void*)'
+      extern 'int IOSurfaceGetWidth(void*)'
+      extern 'int IOSurfaceGetHeight(void*)'
+      extern 'int IOSurfaceGetBytesPerRow(void*)'
+    end
+
+    module CoreFoundation
+      extend Fiddle::Importer
+      dlload '/System/Library/Frameworks/CoreFoundation.framework/CoreFoundation'
+
+      extern 'void* CFDictionaryCreateMutable(void*, long, void*, void*)'
+      extern 'void CFDictionarySetValue(void*, void*, void*)'
+      extern 'void* CFNumberCreate(void*, int, void*)'
+      extern 'void CFRelease(void*)'
+
+      # CFNumber types
+      CFNUMBER_INT_TYPE = 9
+      CFNUMBER_FLOAT_TYPE = 12
+
+      def self.create_int(value)
+        ptr = Fiddle::Pointer.malloc(4)
+        ptr[0, 4] = [value].pack('i')
+        CFNumberCreate(nil, CFNUMBER_INT_TYPE, ptr)
+      end
+    end
+
+    module OpenGLBridge
+      extend Fiddle::Importer
+      dlload '/System/Library/Frameworks/OpenGL.framework/OpenGL'
+
+      extern 'int CGLTexImageIOSurface2D(void*, int, int, int, int, int, int, void*, int)'
+      extern 'void* CGLGetCurrentContext()'
+    end
+  end
+end

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/physics/components/rigidbody.rb

@@ -2,6 +2,9 @@
 
 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,
@@ -10,29 +13,29 @@ module Engine::Physics::Components
                   :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[
+    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
-      @coefficient_of_restitution = coefficient_of_restitution
-      @coefficient_of_friction = coefficient_of_friction
+      ] * @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)

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

@@ -2,10 +2,20 @@
 
 module Engine::Physics::Components
   class SphereCollider < Engine::Component
+    serialize :radius
+
     attr_accessor :radius
 
-    def initialize(radius)
-      @radius = 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)
@@ -43,7 +53,7 @@ module Engine::Physics::Components
     end
 
     def rigidbody
-      game_object.components.find { |c| c.is_a?(Rigidbody) }
+      game_object.component(Rigidbody)
     end
 
     private

data/lib/engine/physics/physics_resolver.rb

@@ -8,6 +8,30 @@ module Engine::Physics
       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)
@@ -21,17 +45,5 @@ module Engine::Physics
         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