rbgl_cocoa_bridge 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3ab4e46975fed72e539fffd29b860aeeba042a168256a0cb85abde601f79b7fc
+  data.tar.gz: ac539f4286672ed86f2d93fe62d6327cd271f4d320b2b0e54eccb7905ec5b06e
+SHA512:
+  metadata.gz: aa4c3b42c4234476db6421e3fed2cdbd1c182b9d2257d4a8c321c7247af6c56a6e262beb2b921be7acb9f1aaa996e9bd6a0cdad66075e2c3de5ae93193501db4
+  data.tar.gz: 7b18283f5a33fc0ac58e2c247691500e8223a099f5721d3fdcaa3848e1e62dc5549eb611303f7c85b6fd4184a86694127f51aa8bea2643f40021e7a78755562d

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Changelog
+
+## Unreleased
+
+## 0.1.0 - 2026-01-02
+
+- Initial release.

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Yudai Takada
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,162 @@
+# rbgl_cocoa_bridge
+
+A Ruby C extension providing native macOS window management and Metal GPU acceleration for graphics applications.
+
+## Requirements
+
+- macOS
+- Ruby 3.1+
+- Xcode Command Line Tools
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "rbgl_cocoa_bridge"
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+Or install it yourself as:
+
+```bash
+gem install rbgl_cocoa_bridge
+```
+
+## Usage
+
+### Basic Window
+
+```ruby
+require "rbgl_cocoa_bridge"
+
+# Initialize Cocoa
+RBGL::CocoaBridge.init
+
+# Create a window
+handle = RBGL::CocoaBridge.window_create(800, 600, "My Window")
+
+# Main loop
+until RBGL::CocoaBridge.should_close?(handle)
+  # Create pixel buffer (RGBA format)
+  width, height = 800, 600
+  buffer = "\xFF\x00\x00\xFF" * (width * height)  # Red
+
+  # Update pixels and present
+  RBGL::CocoaBridge.set_pixels(handle, buffer, width, height)
+  RBGL::CocoaBridge.present(handle)
+
+  # Handle events
+  events = RBGL::CocoaBridge.poll_events(handle)
+  events.each do |event|
+    case event[:type]
+    when :key_press
+      puts "Key pressed: #{event[:key]}"
+    when :mouse_press
+      puts "Mouse clicked at: #{event[:x]}, #{event[:y]}"
+    end
+  end
+end
+
+# Cleanup
+RBGL::CocoaBridge.window_destroy(handle)
+```
+
+### Metal Compute Shaders
+
+```ruby
+require "rbgl_cocoa_bridge"
+
+RBGL::CocoaBridge.init
+handle = RBGL::CocoaBridge.window_create(800, 600, "Compute Shader")
+
+# Check Metal availability
+if RBGL::CocoaBridge.metal_compute_available?(handle)
+  # Compile shader (MSL)
+  shader = <<~MSL
+    #include <metal_stdlib>
+    using namespace metal;
+
+    kernel void compute_shader(
+        texture2d<float, access::write> output [[texture(0)]],
+        constant float4 &uniforms [[buffer(0)]],
+        uint2 gid [[thread_position_in_grid]])
+    {
+        float2 uv = float2(gid) / float2(output.get_width(), output.get_height());
+        output.write(float4(uv.x, uv.y, uniforms.x, 1.0), gid);
+    }
+  MSL
+
+  RBGL::CocoaBridge.compile_compute_shader(handle, shader)
+
+  until RBGL::CocoaBridge.should_close?(handle)
+    # Dispatch with uniforms
+    time = Time.now.to_f
+    uniforms = [Math.sin(time) * 0.5 + 0.5, 0.0, 0.0, 1.0].pack("f4")
+    RBGL::CocoaBridge.dispatch_compute(handle, uniforms)
+    RBGL::CocoaBridge.present_compute(handle)
+    RBGL::CocoaBridge.poll_events(handle)
+  end
+end
+
+RBGL::CocoaBridge.window_destroy(handle)
+```
+
+## API Reference
+
+### Window Management
+
+| Method | Description |
+|--------|-------------|
+| `init` | Initialize Cocoa application |
+| `window_create(width, height, title)` | Create a new window, returns handle |
+| `window_destroy(handle)` | Destroy the window |
+| `should_close?(handle)` | Check if window should close |
+| `poll_events(handle)` | Poll and return pending events |
+
+### Rendering
+
+| Method | Description |
+|--------|-------------|
+| `set_pixels(handle, buffer, width, height)` | Set pixel data (RGBA format) |
+| `present(handle)` | Present the frame |
+
+### Compute Shaders
+
+| Method | Description |
+|--------|-------------|
+| `metal_compute_available?(handle)` | Check if Metal compute is available |
+| `compile_compute_shader(handle, msl_source)` | Compile MSL compute shader |
+| `dispatch_compute(handle, uniforms)` | Execute compute shader |
+| `present_compute(handle)` | Present compute shader output |
+| `has_compute_shader?(handle)` | Check if shader is compiled |
+
+### Event Types
+
+- `:key_press` - Key pressed (`:key`, `:char`)
+- `:key_release` - Key released (`:key`)
+- `:mouse_press` - Mouse button pressed (`:x`, `:y`, `:button`)
+- `:mouse_release` - Mouse button released (`:x`, `:y`, `:button`)
+- `:mouse_move` - Mouse moved (`:x`, `:y`)
+
+## Development
+
+```bash
+# Install dependencies
+bundle install
+
+# Compile native extension
+bundle exec rake compile
+
+# Run tests
+bundle exec rake test
+```
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](LICENSE).

data/Rakefile

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/extensiontask"
+require "rake/testtask"
+
+Rake::ExtensionTask.new("rbgl_cocoa_bridge") do |ext|
+  ext.lib_dir = "lib/rbgl_cocoa_bridge"
+end
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/test_*.rb"]
+end
+
+task test: :compile
+task default: :test

data/ext/rbgl_cocoa_bridge/extconf.rb

@@ -0,0 +1,6 @@
+require "mkmf"
+
+$CFLAGS << " -fobjc-arc"
+$LDFLAGS << " -framework Cocoa -framework Metal -framework QuartzCore"
+
+create_makefile("rbgl_cocoa_bridge/rbgl_cocoa_bridge")

data/ext/rbgl_cocoa_bridge/rbgl_cocoa_bridge.m

@@ -0,0 +1,566 @@
+/*
+ * RBGL Cocoa Bridge - Native macOS window support with Metal acceleration
+ */
+
+#import <Cocoa/Cocoa.h>
+#import <Metal/Metal.h>
+#import <QuartzCore/CAMetalLayer.h>
+#import <ruby.h>
+
+@interface RBGLMetalView : NSView
+@property (nonatomic, strong) CAMetalLayer *metalLayer;
+@property (nonatomic, strong) id<MTLDevice> device;
+@property (nonatomic, strong) id<MTLCommandQueue> commandQueue;
+@property (nonatomic, strong) id<MTLTexture> texture;
+@property (nonatomic, assign) int texWidth;
+@property (nonatomic, assign) int texHeight;
+// Compute shader support
+@property (nonatomic, strong) id<MTLComputePipelineState> computePipeline;
+@property (nonatomic, strong) id<MTLBuffer> uniformBuffer;
+@property (nonatomic, strong) id<MTLTexture> outputTexture;
+@property (nonatomic, assign) BOOL hasComputeShader;
+@end
+
+@implementation RBGLMetalView
+
+- (void)cleanup {
+    // Only cleanup if we have resources
+    if (!self.device) return;
+
+    // Wait for GPU to finish before releasing resources
+    if (self.commandQueue) {
+        @try {
+            id<MTLCommandBuffer> syncBuffer = [self.commandQueue commandBuffer];
+            if (syncBuffer) {
+                [syncBuffer commit];
+                [syncBuffer waitUntilCompleted];
+            }
+        } @catch (NSException *e) {
+            // Ignore exceptions during cleanup
+        }
+    }
+
+    // Clear all Metal resources
+    self.computePipeline = nil;
+    self.uniformBuffer = nil;
+    self.outputTexture = nil;
+    self.texture = nil;
+    self.commandQueue = nil;
+    self.metalLayer = nil;
+    self.device = nil;
+    self.hasComputeShader = NO;
+}
+
+// dealloc is handled automatically by ARC - no manual cleanup needed
+// cocoa_window_destroy handles synchronization with GPU before release
+
+- (instancetype)initWithFrame:(NSRect)frame device:(id<MTLDevice>)device width:(int)w height:(int)h {
+    self = [super initWithFrame:frame];
+    if (self) {
+        self.device = device;
+        self.texWidth = w;
+        self.texHeight = h;
+
+        self.wantsLayer = YES;
+        self.metalLayer = [CAMetalLayer layer];
+        self.metalLayer.device = device;
+        self.metalLayer.pixelFormat = MTLPixelFormatBGRA8Unorm;
+        self.metalLayer.framebufferOnly = NO;
+        self.metalLayer.displaySyncEnabled = NO;  // Disable VSync for max FPS
+        self.metalLayer.frame = frame;
+        self.metalLayer.drawableSize = CGSizeMake(w, h);
+        self.layer = self.metalLayer;
+
+        self.commandQueue = [device newCommandQueue];
+
+        // Create texture for pixel data
+        MTLTextureDescriptor *texDesc = [MTLTextureDescriptor texture2DDescriptorWithPixelFormat:MTLPixelFormatRGBA8Unorm
+                                                                                           width:w
+                                                                                          height:h
+                                                                                       mipmapped:NO];
+        texDesc.usage = MTLTextureUsageShaderRead;
+        self.texture = [device newTextureWithDescriptor:texDesc];
+    }
+    return self;
+}
+
+- (void)updatePixels:(const uint8_t *)data {
+    MTLRegion region = MTLRegionMake2D(0, 0, self.texWidth, self.texHeight);
+    [self.texture replaceRegion:region mipmapLevel:0 withBytes:data bytesPerRow:self.texWidth * 4];
+}
+
+- (void)present {
+    id<CAMetalDrawable> drawable = [self.metalLayer nextDrawable];
+    if (!drawable) return;
+
+    id<MTLCommandBuffer> commandBuffer = [self.commandQueue commandBuffer];
+
+    // Blit texture to drawable
+    id<MTLBlitCommandEncoder> blitEncoder = [commandBuffer blitCommandEncoder];
+
+    [blitEncoder copyFromTexture:self.texture
+                     sourceSlice:0
+                     sourceLevel:0
+                    sourceOrigin:MTLOriginMake(0, 0, 0)
+                      sourceSize:MTLSizeMake(self.texWidth, self.texHeight, 1)
+                       toTexture:drawable.texture
+                destinationSlice:0
+                destinationLevel:0
+               destinationOrigin:MTLOriginMake(0, 0, 0)];
+
+    [blitEncoder endEncoding];
+
+    [commandBuffer presentDrawable:drawable];
+    [commandBuffer commit];
+}
+
+#pragma mark - Compute Shader Support
+
+- (BOOL)compileComputeShader:(NSString *)mslSource error:(NSError **)error {
+    // Compile MSL source to library
+    id<MTLLibrary> library = [self.device newLibraryWithSource:mslSource
+                                                       options:nil
+                                                         error:error];
+    if (!library) return NO;
+
+    // Get compute function
+    id<MTLFunction> computeFunc = [library newFunctionWithName:@"compute_shader"];
+    if (!computeFunc) {
+        if (error) *error = [NSError errorWithDomain:@"RBGL" code:1
+                                            userInfo:@{NSLocalizedDescriptionKey: @"compute_shader function not found"}];
+        return NO;
+    }
+
+    // Create compute pipeline
+    self.computePipeline = [self.device newComputePipelineStateWithFunction:computeFunc error:error];
+    if (!self.computePipeline) return NO;
+
+    // Create output texture (writable)
+    MTLTextureDescriptor *texDesc = [MTLTextureDescriptor
+        texture2DDescriptorWithPixelFormat:MTLPixelFormatRGBA8Unorm
+                                     width:self.texWidth
+                                    height:self.texHeight
+                                 mipmapped:NO];
+    texDesc.usage = MTLTextureUsageShaderWrite | MTLTextureUsageShaderRead;
+    self.outputTexture = [self.device newTextureWithDescriptor:texDesc];
+
+    // Create uniform buffer (256 bytes should be enough for most shaders)
+    self.uniformBuffer = [self.device newBufferWithLength:256
+                                                  options:MTLResourceStorageModeShared];
+
+    self.hasComputeShader = YES;
+    return YES;
+}
+
+- (void)dispatchComputeWithUniforms:(const void *)uniformData length:(NSUInteger)length {
+    if (!self.hasComputeShader) return;
+
+    // Update uniform buffer
+    memcpy(self.uniformBuffer.contents, uniformData, MIN(length, 256));
+
+    id<MTLCommandBuffer> commandBuffer = [self.commandQueue commandBuffer];
+    id<MTLComputeCommandEncoder> computeEncoder = [commandBuffer computeCommandEncoder];
+
+    [computeEncoder setComputePipelineState:self.computePipeline];
+    [computeEncoder setTexture:self.outputTexture atIndex:0];
+    [computeEncoder setBuffer:self.uniformBuffer offset:0 atIndex:0];
+
+    // Calculate optimal thread group size
+    NSUInteger threadGroupSize = self.computePipeline.maxTotalThreadsPerThreadgroup;
+    NSUInteger threadGroupWidth = 16;
+    NSUInteger threadGroupHeight = 16;
+
+    if (threadGroupWidth * threadGroupHeight > threadGroupSize) {
+        threadGroupWidth = 8;
+        threadGroupHeight = 8;
+    }
+
+    MTLSize threadsPerGroup = MTLSizeMake(threadGroupWidth, threadGroupHeight, 1);
+    MTLSize threadGroups = MTLSizeMake(
+        (self.texWidth + threadGroupWidth - 1) / threadGroupWidth,
+        (self.texHeight + threadGroupHeight - 1) / threadGroupHeight,
+        1
+    );
+
+    [computeEncoder dispatchThreadgroups:threadGroups threadsPerThreadgroup:threadsPerGroup];
+    [computeEncoder endEncoding];
+
+    [commandBuffer commit];
+    [commandBuffer waitUntilCompleted];
+}
+
+- (void)presentCompute {
+    if (!self.hasComputeShader) return;
+
+    id<CAMetalDrawable> drawable = [self.metalLayer nextDrawable];
+    if (!drawable) return;
+
+    id<MTLCommandBuffer> commandBuffer = [self.commandQueue commandBuffer];
+    id<MTLBlitCommandEncoder> blitEncoder = [commandBuffer blitCommandEncoder];
+
+    // Blit from compute output to drawable
+    [blitEncoder copyFromTexture:self.outputTexture
+                     sourceSlice:0
+                     sourceLevel:0
+                    sourceOrigin:MTLOriginMake(0, 0, 0)
+                      sourceSize:MTLSizeMake(self.texWidth, self.texHeight, 1)
+                       toTexture:drawable.texture
+                destinationSlice:0
+                destinationLevel:0
+               destinationOrigin:MTLOriginMake(0, 0, 0)];
+
+    [blitEncoder endEncoding];
+    [commandBuffer presentDrawable:drawable];
+    [commandBuffer commit];
+}
+
+@end
+
+@interface RBGLWindow : NSWindow
+@property (nonatomic, assign) BOOL shouldClose;
+@property (nonatomic, strong) NSMutableArray *pendingEvents;
+@property (nonatomic, strong) RBGLMetalView *metalView;
+@property (nonatomic, assign) BOOL useMetal;
+// Fallback for non-Metal
+@property (nonatomic, strong) NSBitmapImageRep *bitmapRep;
+@property (nonatomic, strong) NSImageView *imageView;
+@end
+
+@implementation RBGLWindow
+
+- (instancetype)initWithWidth:(int)width height:(int)height title:(NSString *)title {
+    NSRect frame = NSMakeRect(100, 100, width, height);
+    self = [super initWithContentRect:frame
+                            styleMask:(NSWindowStyleMaskTitled |
+                                      NSWindowStyleMaskClosable |
+                                      NSWindowStyleMaskMiniaturizable)
+                              backing:NSBackingStoreBuffered
+                                defer:NO];
+    if (self) {
+        self.shouldClose = NO;
+        self.pendingEvents = [NSMutableArray array];
+        [self setTitle:title];
+        [self setDelegate:(id<NSWindowDelegate>)self];
+
+        // Try to use Metal
+        id<MTLDevice> device = MTLCreateSystemDefaultDevice();
+        if (device) {
+            self.useMetal = YES;
+            self.metalView = [[RBGLMetalView alloc] initWithFrame:NSMakeRect(0, 0, width, height)
+                                                           device:device
+                                                            width:width
+                                                           height:height];
+            [self setContentView:self.metalView];
+        } else {
+            // Fallback to bitmap
+            self.useMetal = NO;
+            self.bitmapRep = [[NSBitmapImageRep alloc]
+                initWithBitmapDataPlanes:NULL
+                              pixelsWide:width
+                              pixelsHigh:height
+                           bitsPerSample:8
+                         samplesPerPixel:4
+                                hasAlpha:YES
+                                isPlanar:NO
+                          colorSpaceName:NSDeviceRGBColorSpace
+                             bytesPerRow:width * 4
+                            bitsPerPixel:32];
+
+            NSImage *image = [[NSImage alloc] initWithSize:NSMakeSize(width, height)];
+            [image addRepresentation:self.bitmapRep];
+
+            self.imageView = [[NSImageView alloc] initWithFrame:NSMakeRect(0, 0, width, height)];
+            [self.imageView setImage:image];
+            [self.imageView setImageScaling:NSImageScaleAxesIndependently];
+            [self setContentView:self.imageView];
+        }
+
+        [self setAcceptsMouseMovedEvents:YES];
+        [self makeKeyAndOrderFront:nil];
+    }
+    return self;
+}
+
+- (BOOL)windowShouldClose:(id)sender {
+    self.shouldClose = YES;
+    return NO;
+}
+
+- (void)keyDown:(NSEvent *)event {
+    NSDictionary *eventDict = @{
+        @"type": @"key_press",
+        @"key": @([event keyCode]),
+        @"char": [event characters] ?: @""
+    };
+    [self.pendingEvents addObject:eventDict];
+}
+
+- (void)keyUp:(NSEvent *)event {
+    NSDictionary *eventDict = @{
+        @"type": @"key_release",
+        @"key": @([event keyCode])
+    };
+    [self.pendingEvents addObject:eventDict];
+}
+
+- (void)mouseDown:(NSEvent *)event {
+    NSPoint loc = [event locationInWindow];
+    NSDictionary *eventDict = @{
+        @"type": @"mouse_press",
+        @"x": @(loc.x),
+        @"y": @(loc.y),
+        @"button": @([event buttonNumber])
+    };
+    [self.pendingEvents addObject:eventDict];
+}
+
+- (void)mouseUp:(NSEvent *)event {
+    NSPoint loc = [event locationInWindow];
+    NSDictionary *eventDict = @{
+        @"type": @"mouse_release",
+        @"x": @(loc.x),
+        @"y": @(loc.y),
+        @"button": @([event buttonNumber])
+    };
+    [self.pendingEvents addObject:eventDict];
+}
+
+- (void)mouseMoved:(NSEvent *)event {
+    NSPoint loc = [event locationInWindow];
+    NSDictionary *eventDict = @{
+        @"type": @"mouse_move",
+        @"x": @(loc.x),
+        @"y": @(loc.y)
+    };
+    [self.pendingEvents addObject:eventDict];
+}
+
+- (BOOL)canBecomeKeyWindow { return YES; }
+- (BOOL)acceptsFirstResponder { return YES; }
+@end
+
+static VALUE cocoa_init(VALUE self) {
+    @autoreleasepool {
+        [NSApplication sharedApplication];
+        [NSApp setActivationPolicy:NSApplicationActivationPolicyRegular];
+        [NSApp activateIgnoringOtherApps:YES];
+    }
+    return Qnil;
+}
+
+static VALUE cocoa_window_create(VALUE self, VALUE width, VALUE height, VALUE title) {
+    @autoreleasepool {
+        int w = NUM2INT(width);
+        int h = NUM2INT(height);
+        NSString *t = [NSString stringWithUTF8String:StringValueCStr(title)];
+
+        RBGLWindow *window = [[RBGLWindow alloc] initWithWidth:w height:h title:t];
+        return ULONG2NUM((unsigned long)(__bridge_retained void *)window);
+    }
+}
+
+static VALUE cocoa_window_destroy(VALUE self, VALUE window_ptr) {
+    void *ptr = (void *)NUM2ULONG(window_ptr);
+    if (!ptr) return Qnil;
+
+    // Get window reference without transferring ownership yet
+    RBGLWindow *window = (__bridge RBGLWindow *)ptr;
+
+    // Synchronize GPU before cleanup (outside autoreleasepool)
+    if (window && window.useMetal && window.metalView) {
+        RBGLMetalView *metalView = window.metalView;
+        if (metalView.commandQueue) {
+            @try {
+                id<MTLCommandBuffer> syncBuffer = [metalView.commandQueue commandBuffer];
+                if (syncBuffer) {
+                    [syncBuffer commit];
+                    [syncBuffer waitUntilCompleted];
+                }
+            } @catch (NSException *e) {
+                // Ignore - GPU may already be done
+            }
+        }
+        // Mark that we've cleaned up the compute shader
+        metalView.hasComputeShader = NO;
+    }
+
+    // Close the window
+    if (window) {
+        [window close];
+    }
+
+    // Now transfer ownership to ARC - this will release the object
+    // Do this outside autoreleasepool to avoid double-release issues
+    (void)(__bridge_transfer id)ptr;
+
+    return Qnil;
+}
+
+static VALUE cocoa_set_pixels(VALUE self, VALUE window_ptr, VALUE buffer, VALUE width, VALUE height) {
+    @autoreleasepool {
+        RBGLWindow *window = (__bridge RBGLWindow *)(void *)NUM2ULONG(window_ptr);
+        int w = NUM2INT(width);
+        int h = NUM2INT(height);
+
+        Check_Type(buffer, T_STRING);
+        const unsigned char *data = (const unsigned char *)RSTRING_PTR(buffer);
+        long len = RSTRING_LEN(buffer);
+
+        if (len < w * h * 4) {
+            rb_raise(rb_eArgError, "Buffer too small");
+        }
+
+        if (window.useMetal) {
+            [window.metalView updatePixels:data];
+        } else {
+            unsigned char *bitmapData = [window.bitmapRep bitmapData];
+            memcpy(bitmapData, data, w * h * 4);
+        }
+    }
+    return Qnil;
+}
+
+static VALUE cocoa_present(VALUE self, VALUE window_ptr) {
+    @autoreleasepool {
+        RBGLWindow *window = (__bridge RBGLWindow *)(void *)NUM2ULONG(window_ptr);
+
+        if (window.useMetal) {
+            [window.metalView present];
+        } else {
+            [window.imageView setNeedsDisplay:YES];
+            [window displayIfNeeded];
+        }
+    }
+    return Qnil;
+}
+
+static VALUE cocoa_poll_events(VALUE self, VALUE window_ptr) {
+    @autoreleasepool {
+        RBGLWindow *window = (__bridge RBGLWindow *)(void *)NUM2ULONG(window_ptr);
+
+        NSEvent *event;
+        while ((event = [NSApp nextEventMatchingMask:NSEventMaskAny
+                                           untilDate:nil
+                                              inMode:NSDefaultRunLoopMode
+                                             dequeue:YES])) {
+            [NSApp sendEvent:event];
+        }
+
+        [[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode
+                                 beforeDate:[NSDate dateWithTimeIntervalSinceNow:0.001]];
+        [NSApp updateWindows];
+
+        VALUE events = rb_ary_new();
+        for (NSDictionary *dict in window.pendingEvents) {
+            VALUE hash = rb_hash_new();
+
+            NSString *type = dict[@"type"];
+            rb_hash_aset(hash, ID2SYM(rb_intern("type")),
+                        ID2SYM(rb_intern([type UTF8String])));
+
+            if (dict[@"key"]) {
+                rb_hash_aset(hash, ID2SYM(rb_intern("key")), INT2NUM([dict[@"key"] intValue]));
+            }
+            if (dict[@"char"]) {
+                rb_hash_aset(hash, ID2SYM(rb_intern("char")),
+                           rb_str_new_cstr([dict[@"char"] UTF8String]));
+            }
+            if (dict[@"x"]) {
+                rb_hash_aset(hash, ID2SYM(rb_intern("x")), DBL2NUM([dict[@"x"] doubleValue]));
+            }
+            if (dict[@"y"]) {
+                rb_hash_aset(hash, ID2SYM(rb_intern("y")), DBL2NUM([dict[@"y"] doubleValue]));
+            }
+            if (dict[@"button"]) {
+                rb_hash_aset(hash, ID2SYM(rb_intern("button")), INT2NUM([dict[@"button"] intValue]));
+            }
+
+            rb_ary_push(events, hash);
+        }
+
+        [window.pendingEvents removeAllObjects];
+        return events;
+    }
+}
+
+static VALUE cocoa_should_close(VALUE self, VALUE window_ptr) {
+    RBGLWindow *window = (__bridge RBGLWindow *)(void *)NUM2ULONG(window_ptr);
+    return window.shouldClose ? Qtrue : Qfalse;
+}
+
+// ========== Compute Shader Bridge Functions ==========
+
+static VALUE cocoa_metal_compute_available(VALUE self, VALUE window_ptr) {
+    RBGLWindow *window = (__bridge RBGLWindow *)(void *)NUM2ULONG(window_ptr);
+    return (window.useMetal && window.metalView.device) ? Qtrue : Qfalse;
+}
+
+static VALUE cocoa_compile_compute_shader(VALUE self, VALUE window_ptr, VALUE msl_source) {
+    @autoreleasepool {
+        RBGLWindow *window = (__bridge RBGLWindow *)(void *)NUM2ULONG(window_ptr);
+        if (!window.useMetal) {
+            rb_raise(rb_eRuntimeError, "Metal not available");
+        }
+
+        Check_Type(msl_source, T_STRING);
+        NSString *source = [NSString stringWithUTF8String:StringValueCStr(msl_source)];
+        NSError *error = nil;
+
+        if (![window.metalView compileComputeShader:source error:&error]) {
+            rb_raise(rb_eRuntimeError, "Failed to compile shader: %s",
+                     [[error localizedDescription] UTF8String]);
+        }
+    }
+    return Qtrue;
+}
+
+static VALUE cocoa_dispatch_compute(VALUE self, VALUE window_ptr, VALUE uniform_data) {
+    @autoreleasepool {
+        RBGLWindow *window = (__bridge RBGLWindow *)(void *)NUM2ULONG(window_ptr);
+        if (!window.useMetal || !window.metalView.hasComputeShader) {
+            rb_raise(rb_eRuntimeError, "Compute shader not compiled");
+        }
+
+        Check_Type(uniform_data, T_STRING);
+        const void *data = RSTRING_PTR(uniform_data);
+        long length = RSTRING_LEN(uniform_data);
+
+        [window.metalView dispatchComputeWithUniforms:data length:length];
+    }
+    return Qnil;
+}
+
+static VALUE cocoa_present_compute(VALUE self, VALUE window_ptr) {
+    @autoreleasepool {
+        RBGLWindow *window = (__bridge RBGLWindow *)(void *)NUM2ULONG(window_ptr);
+        if (window.useMetal && window.metalView.hasComputeShader) {
+            [window.metalView presentCompute];
+        }
+    }
+    return Qnil;
+}
+
+static VALUE cocoa_has_compute_shader(VALUE self, VALUE window_ptr) {
+    RBGLWindow *window = (__bridge RBGLWindow *)(void *)NUM2ULONG(window_ptr);
+    return (window.useMetal && window.metalView.hasComputeShader) ? Qtrue : Qfalse;
+}
+
+void Init_rbgl_cocoa_bridge(void) {
+    VALUE mRBGL = rb_define_module("RBGL");
+    VALUE mBridge = rb_define_module_under(mRBGL, "CocoaBridge");
+
+    rb_define_module_function(mBridge, "init", cocoa_init, 0);
+    rb_define_module_function(mBridge, "window_create", cocoa_window_create, 3);
+    rb_define_module_function(mBridge, "window_destroy", cocoa_window_destroy, 1);
+    rb_define_module_function(mBridge, "set_pixels", cocoa_set_pixels, 4);
+    rb_define_module_function(mBridge, "present", cocoa_present, 1);
+    rb_define_module_function(mBridge, "poll_events", cocoa_poll_events, 1);
+    rb_define_module_function(mBridge, "should_close?", cocoa_should_close, 1);
+
+    // Compute shader functions
+    rb_define_module_function(mBridge, "metal_compute_available?", cocoa_metal_compute_available, 1);
+    rb_define_module_function(mBridge, "compile_compute_shader", cocoa_compile_compute_shader, 2);
+    rb_define_module_function(mBridge, "dispatch_compute", cocoa_dispatch_compute, 2);
+    rb_define_module_function(mBridge, "present_compute", cocoa_present_compute, 1);
+    rb_define_module_function(mBridge, "has_compute_shader?", cocoa_has_compute_shader, 1);
+}

data/lib/rbgl_cocoa_bridge/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RBGL
+  module CocoaBridge
+    VERSION = "0.1.0"
+  end
+end

data/lib/rbgl_cocoa_bridge.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "rbgl_cocoa_bridge/version"
+
+begin
+  require "rbgl_cocoa_bridge/rbgl_cocoa_bridge"
+rescue LoadError
+  # Extension not compiled - this is expected on non-macOS platforms
+  module RBGL
+    module CocoaBridge
+      def self.init
+        raise LoadError, "Cocoa bridge is only available on macOS"
+      end
+
+      def self.window_create(_w, _h, _t)
+        raise LoadError, "Cocoa bridge is only available on macOS"
+      end
+
+      def self.window_destroy(_handle)
+        raise LoadError, "Cocoa bridge is only available on macOS"
+      end
+
+      def self.set_pixels(_handle, _data, _w, _h)
+        raise LoadError, "Cocoa bridge is only available on macOS"
+      end
+
+      def self.present(_handle)
+        raise LoadError, "Cocoa bridge is only available on macOS"
+      end
+
+      def self.poll_events(_handle)
+        raise LoadError, "Cocoa bridge is only available on macOS"
+      end
+
+      def self.should_close?(_handle)
+        raise LoadError, "Cocoa bridge is only available on macOS"
+      end
+    end
+  end
+end

data/rbgl_cocoa_bridge.gemspec

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "lib/rbgl_cocoa_bridge/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "rbgl_cocoa_bridge"
+  spec.version = RBGL::CocoaBridge::VERSION
+  spec.authors = ["Yudai Takada"]
+  spec.email = ["t.yudai92@gmail.com"]
+
+  spec.summary = "Native macOS Cocoa/Metal bridge for Ruby graphics applications"
+  spec.description = "A Ruby C extension providing native macOS window management and Metal GPU acceleration for graphics applications."
+  spec.homepage = "https://github.com/ydah/rbgl_cocoa_bridge"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.0.0"
+
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/CHANGELOG.md"
+
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[bin/ test/ spec/ features/ .git .github appveyor Gemfile])
+    end
+  end
+  spec.require_paths = ["lib"]
+  spec.extensions = ["ext/rbgl_cocoa_bridge/extconf.rb"]
+end

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: rbgl_cocoa_bridge
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yudai Takada
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: A Ruby C extension providing native macOS window management and Metal
+  GPU acceleration for graphics applications.
+email:
+- t.yudai92@gmail.com
+executables: []
+extensions:
+- ext/rbgl_cocoa_bridge/extconf.rb
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- Rakefile
+- ext/rbgl_cocoa_bridge/extconf.rb
+- ext/rbgl_cocoa_bridge/rbgl_cocoa_bridge.m
+- lib/rbgl_cocoa_bridge.rb
+- lib/rbgl_cocoa_bridge/version.rb
+- rbgl_cocoa_bridge.gemspec
+homepage: https://github.com/ydah/rbgl_cocoa_bridge
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/ydah/rbgl_cocoa_bridge
+  changelog_uri: https://github.com/ydah/rbgl_cocoa_bridge/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.3
+specification_version: 4
+summary: Native macOS Cocoa/Metal bridge for Ruby graphics applications
+test_files: []