ruby_rpg 0.0.5 → 0.1.1

data/lib/engine/matrix_helpers.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Engine
+  module MatrixHelpers
+    def look_at(eye, center, up)
+      f = (center - eye).normalize
+      s = f.cross(up).normalize
+      u = s.cross(f)
+
+      Matrix[
+        [s[0], s[1], s[2], -s.dot(eye)],
+        [u[0], u[1], u[2], -u.dot(eye)],
+        [-f[0], -f[1], -f[2], f.dot(eye)],
+        [0, 0, 0, 1]
+      ]
+    end
+
+    def perspective(fov, aspect, near, far)
+      tan_half_fov = Math.tan(fov / 2.0)
+
+      Matrix[
+        [1.0 / (aspect * tan_half_fov), 0, 0, 0],
+        [0, 1.0 / tan_half_fov, 0, 0],
+        [0, 0, -(far + near) / (far - near), -(2.0 * far * near) / (far - near)],
+        [0, 0, -1, 0]
+      ]
+    end
+
+    def ortho(left, right, bottom, top, near, far)
+      Matrix[
+        [2.0 / (right - left), 0, 0, -(right + left) / (right - left)],
+        [0, 2.0 / (top - bottom), 0, -(top + bottom) / (top - bottom)],
+        [0, 0, -2.0 / (far - near), -(far + near) / (far - near)],
+        [0, 0, 0, 1]
+      ]
+    end
+  end
+end

data/lib/engine/mesh.rb

@@ -1,43 +1,68 @@
-# 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(GAME_DIR, "_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(GAME_DIR, "_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
+# frozen_string_literal: true
+
+module Engine
+  class Mesh
+    include Serializable
+
+    attr_reader :mesh_file, :source
+
+    def self.from_serializable_data(data)
+      self.for(data[:mesh_file], source: (data[:source] || :game).to_sym)
+    end
+
+    def serializable_data
+      { mesh_file: @mesh_file, source: @source }
+    end
+
+    def vertex_data
+      @vertex_data ||= Mesh.load_vertex(base_path)
+    end
+
+    def index_data
+      @index_data ||= Mesh.load_index(base_path)
+    end
+
+    def self.for(mesh_file, source: :game)
+      cache_key = [mesh_file, source]
+      mesh_cache[cache_key] ||= create(mesh_file: mesh_file, source: source)
+    end
+
+    def self.mesh_cache
+      @mesh_cache ||= {}
+    end
+
+    def self.load_vertex(base_path)
+      vertex_cache[base_path + ".vertex_data"]
+    end
+
+    def self.vertex_cache
+      @vertex_cache ||= Hash.new do |hash, key|
+        hash[key] = File.readlines(key).reject{|l| l == ""}.map(&:to_f)
+      end
+    end
+
+    def self.load_index(base_path)
+      index_cache[base_path + ".index_data"]
+    end
+
+    def self.index_cache
+      @index_cache ||= Hash.new do |hash, key|
+        hash[key] = File.readlines(key).reject{|l| l == ""}.map(&:to_i)
+      end
+    end
+
+    def self.quad
+      @quad ||= QuadMesh.new
+    end
+
+    private
+
+    def base_path
+      @base_path ||= if @source == :engine
+        File.join(ENGINE_DIR, "assets", "_imported", @mesh_file)
+      else
+        File.join(GAME_DIR, "_imported", @mesh_file)
+      end
+    end
+  end
+end

data/lib/engine/metal/compute_shader.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require_relative 'device'
+
+module Engine
+  module Metal
+    class ComputeShader
+      include Fiddle
+
+      def initialize(shader_path)
+        @device = Device.instance
+        @uniform_buffer_data = {}
+
+        path = File.expand_path(File.join(GAME_DIR, shader_path))
+        source = File.read(path)
+
+        @library = @device.new_library_with_source(source)
+        @pipeline = @device.new_compute_pipeline(@library, 'computeMain')
+
+        # Get thread execution width for optimal dispatch
+        @thread_width = ObjC.msg(@pipeline, 'threadExecutionWidth').to_i
+        @thread_height = ObjC.msg(@pipeline, 'maxTotalThreadsPerThreadgroup').to_i / @thread_width
+      end
+
+      def dispatch(width, height, depth, textures: [], floats: {}, ints: {})
+        command_buffer = @device.new_command_buffer
+        encoder = ObjC.msg(command_buffer, 'computeCommandEncoder')
+
+        # Set the pipeline state
+        ObjC.msg(encoder, 'setComputePipelineState:', @pipeline)
+
+        # Set textures (extract metal_texture from ComputeTexture objects)
+        textures.each_with_index do |texture, index|
+          next if texture.nil?
+          metal_tex = texture.respond_to?(:metal_texture) ? texture.metal_texture : texture
+          ObjC.msg(encoder, 'setTexture:atIndex:', metal_tex, index)
+        end
+
+        # Create uniform buffer with floats and ints
+        if floats.any? || ints.any?
+          uniform_data = create_uniform_buffer(floats, ints)
+          uniform_buffer = create_metal_buffer(uniform_data)
+          ObjC.msg(encoder, 'setBuffer:offset:atIndex:', uniform_buffer, 0, 0)
+        end
+
+        # Calculate thread groups
+        # Use dispatchThreads for simpler dispatch (Metal 2.0+)
+        threads = create_mtl_size_ptr(width, height, depth)
+        threads_per_group = create_mtl_size_ptr(@thread_width, @thread_height, 1)
+
+        # Use objc_msgSend_stret variant for struct-passing methods
+        dispatch_threads(encoder, threads, threads_per_group)
+
+        ObjC.msg(encoder, 'endEncoding')
+        ObjC.msg(command_buffer, 'commit')
+        ObjC.msg(command_buffer, 'waitUntilCompleted')
+
+        # Sync textures to make results available for OpenGL rendering
+        textures.each { |tex| tex.sync if tex.respond_to?(:sync) }
+      end
+
+      private
+
+      def create_uniform_buffer(floats, ints)
+        # Pack uniforms into a byte buffer
+        # Layout: all floats first, then ints (aligned to 4 bytes)
+        data = []
+        floats.each_value { |v| data.concat([v].pack('f').bytes) }
+        ints.each_value { |v| data.concat([v].pack('i').bytes) }
+        data.pack('C*')
+      end
+
+      def create_metal_buffer(data)
+        data_ptr = Pointer[data]
+        ObjC.msg(
+          @device.device,
+          'newBufferWithBytes:length:options:',
+          data_ptr,
+          data.bytesize,
+          0 # MTLResourceStorageModeShared
+        )
+      end
+
+      def create_mtl_size_ptr(width, height, depth)
+        # MTLSize is a struct { width, height, depth } - 3 NSUInteger (64-bit each)
+        data = [width, height, depth].pack('Q3')
+        ptr = Pointer.malloc(24)
+        ptr[0, 24] = data
+        ptr
+      end
+
+      def dispatch_threads(encoder, threads, threads_per_group)
+        # dispatchThreads:threadsPerThreadgroup: passes MTLSize structs
+        # On ARM64, structs > 16 bytes are passed by pointer in x8
+        # We need to use objc_msgSend directly with proper calling convention
+
+        sel = ObjC.sel('dispatchThreads:threadsPerThreadgroup:')
+
+        # Build a function that takes the struct values directly
+        # ARM64 ABI: first 8 args in x0-x7, structs by value if <= 16 bytes, else by pointer
+        # MTLSize is 24 bytes, so passed by pointer
+
+        func = Fiddle::Function.new(
+          ObjC::OBJC_MSGSEND_ADDR,
+          [
+            Fiddle::TYPE_VOIDP,  # self (encoder)
+            Fiddle::TYPE_VOIDP,  # _cmd (selector)
+            Fiddle::TYPE_VOIDP,  # threads (pointer to MTLSize)
+            Fiddle::TYPE_VOIDP   # threadsPerThreadgroup (pointer to MTLSize)
+          ],
+          Fiddle::TYPE_VOID
+        )
+
+        func.call(encoder, sel, threads, threads_per_group)
+      end
+    end
+  end
+end

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