@dayme/bunraylib 0.1.0 → 1.0.0

package/src/modules/window/WindowModule.ts

@@ -0,0 +1,248 @@
+import { getSymbols } from '../../symbols';
+import { bufs as b, cstr, f, i } from '../../utils';
+import { CString } from 'bun:ffi';
+import type { Vec2, RenderTexture2D, Image, Color } from '../../types';
+
+const r = () => getSymbols();
+
+export class WindowModule {
+  static initWindow(width: number, height: number, title: string): void {
+    r().symbols.InitWindow(i(width), i(height), cstr(title));
+  }
+  static closeWindow(): void {
+    r().symbols.CloseWindow();
+  }
+  static windowShouldClose(): boolean {
+    return r().symbols.WindowShouldClose();
+  }
+  static beginDrawing(): void {
+    r().symbols.BeginDrawing();
+  }
+  static endDrawing(): void {
+    r().symbols.EndDrawing();
+  }
+
+  static clearBackground(col: Color): void {
+    r().symbols.ClearBackground(i(col));
+  }
+  static setTargetFPS(fps: number): void {
+    r().symbols.SetTargetFPS(i(fps));
+  }
+  static getFrameTime(): number {
+    return r().symbols.GetFrameTime();
+  }
+  static isWindowReady(): boolean {
+    return r().symbols.IsWindowReady();
+  }
+  static isWindowFullscreen(): boolean {
+    return r().symbols.IsWindowFullscreen();
+  }
+  static isWindowHidden(): boolean {
+    return r().symbols.IsWindowHidden();
+  }
+  static isWindowMinimized(): boolean {
+    return r().symbols.IsWindowMinimized();
+  }
+  static isWindowMaximized(): boolean {
+    return r().symbols.IsWindowMaximized();
+  }
+  static isWindowFocused(): boolean {
+    return r().symbols.IsWindowFocused();
+  }
+  static isWindowResized(): boolean {
+    return r().symbols.IsWindowResized();
+  }
+  static isWindowState(flag: number): boolean {
+    return r().symbols.IsWindowState(i(flag));
+  }
+  static setWindowState(flags: number): void {
+    r().symbols.SetWindowState(i(flags));
+  }
+  static clearWindowState(flags: number): void {
+    r().symbols.ClearWindowState(i(flags));
+  }
+  static toggleFullscreen(): void {
+    r().symbols.ToggleFullscreen();
+  }
+  static toggleBorderlessWindowed(): void {
+    r().symbols.ToggleBorderlessWindowed();
+  }
+  static maximizeWindow(): void {
+    r().symbols.MaximizeWindow();
+  }
+  static minimizeWindow(): void {
+    r().symbols.MinimizeWindow();
+  }
+  static restoreWindow(): void {
+    r().symbols.RestoreWindow();
+  }
+  static setWindowTitle(title: string): void {
+    r().symbols.SetWindowTitle(cstr(title));
+  }
+  static setWindowPosition(x: number, y: number): void {
+    r().symbols.SetWindowPosition(i(x), i(y));
+  }
+  static setWindowMonitor(monitor: number): void {
+    r().symbols.SetWindowMonitor(i(monitor));
+  }
+  static setWindowMinSize(w: number, h: number): void {
+    r().symbols.SetWindowMinSize(i(w), i(h));
+  }
+  static setWindowMaxSize(w: number, h: number): void {
+    r().symbols.SetWindowMaxSize(i(w), i(h));
+  }
+  static setWindowSize(w: number, h: number): void {
+    r().symbols.SetWindowSize(i(w), i(h));
+  }
+  static setWindowOpacity(opacity: number): void {
+    r().symbols.SetWindowOpacity(f(opacity));
+  }
+  static setWindowFocused(): void {
+    r().symbols.SetWindowFocused();
+  }
+  static getScreenWidth(): number {
+    return r().symbols.GetScreenWidth();
+  }
+  static getScreenHeight(): number {
+    return r().symbols.GetScreenHeight();
+  }
+  static getRenderWidth(): number {
+    return r().symbols.GetRenderWidth();
+  }
+  static getRenderHeight(): number {
+    return r().symbols.GetRenderHeight();
+  }
+  static getMonitorCount(): number {
+    return r().symbols.GetMonitorCount();
+  }
+  static getCurrentMonitor(): number {
+    return r().symbols.GetCurrentMonitor();
+  }
+  static getMonitorPosition(monitor: number): Vec2 {
+    r().symbols.GetMonitorPositionW(b._vec2Buf, i(monitor));
+    return { x: b._vec2Buf[0]!, y: b._vec2Buf[1]! };
+  }
+  static getMonitorWidth(monitor: number): number {
+    return r().symbols.GetMonitorWidth(i(monitor));
+  }
+  static getMonitorHeight(monitor: number): number {
+    return r().symbols.GetMonitorHeight(i(monitor));
+  }
+  static getMonitorPhysicalWidth(monitor: number): number {
+    return r().symbols.GetMonitorPhysicalWidth(i(monitor));
+  }
+  static getMonitorPhysicalHeight(monitor: number): number {
+    return r().symbols.GetMonitorPhysicalHeight(i(monitor));
+  }
+  static getMonitorRefreshRate(monitor: number): number {
+    return r().symbols.GetMonitorRefreshRate(i(monitor));
+  }
+  static getWindowPosition(): Vec2 {
+    r().symbols.GetWindowPositionW(b._vec2Buf);
+    return { x: b._vec2Buf[0]!, y: b._vec2Buf[1]! };
+  }
+  static getWindowScaleDPI(): Vec2 {
+    r().symbols.GetWindowScaleDPIW(b._vec2Buf);
+    return { x: b._vec2Buf[0]!, y: b._vec2Buf[1]! };
+  }
+  static getMonitorName(monitor: number): string {
+    const ptr = r().symbols.GetMonitorName(i(monitor));
+    if (!ptr) return '';
+    return new CString(ptr).toString();
+  }
+  static setClipboardText(text: string): void {
+    r().symbols.SetClipboardText(cstr(text));
+  }
+  static getClipboardText(): string {
+    const ptr = r().symbols.GetClipboardText();
+    if (!ptr) return '';
+    return new CString(ptr).toString();
+  }
+  static enableEventWaiting(): void {
+    r().symbols.EnableEventWaiting();
+  }
+  static disableEventWaiting(): void {
+    r().symbols.DisableEventWaiting();
+  }
+  static showCursor(): void {
+    r().symbols.ShowCursor();
+  }
+  static hideCursor(): void {
+    r().symbols.HideCursor();
+  }
+  static isCursorHidden(): boolean {
+    return r().symbols.IsCursorHidden();
+  }
+  static enableCursor(): void {
+    r().symbols.EnableCursor();
+  }
+  static disableCursor(): void {
+    r().symbols.DisableCursor();
+  }
+  static isCursorOnScreen(): boolean {
+    return r().symbols.IsCursorOnScreen();
+  }
+  static beginTextureMode(target: RenderTexture2D): void {
+    r().symbols.BeginTextureModeW(i(target.id), i(target.texture.width), i(target.texture.height));
+  }
+  static endTextureMode(): void {
+    r().symbols.EndTextureMode();
+  }
+  static beginBlendMode(mode: number): void {
+    r().symbols.BeginBlendMode(i(mode));
+  }
+  static endBlendMode(): void {
+    r().symbols.EndBlendMode();
+  }
+  static beginScissorMode(x: number, y: number, w: number, h: number): void {
+    r().symbols.BeginScissorMode(i(x), i(y), i(w), i(h));
+  }
+  static endScissorMode(): void {
+    r().symbols.EndScissorMode();
+  }
+  static setConfigFlags(flags: number): void {
+    r().symbols.SetConfigFlags(i(flags));
+  }
+  static setWindowIcon(image: Image): void {
+    r().symbols.SetWindowIconW(i(image));
+  }
+  static getClipboardImage(): Image {
+    return r().symbols.GetClipboardImageW();
+  }
+  static setWindowIcons(images: number, count: number): void {
+    r().symbols.SetWindowIconsW(images as unknown as Buffer, i(count));
+  }
+  static getTime(): number {
+    return r().symbols.GetTime();
+  }
+  static getFPS(): number {
+    return r().symbols.GetFPS();
+  }
+  static swapScreenBuffer(): void {
+    r().symbols.SwapScreenBuffer();
+  }
+  static pollInputEvents(): void {
+    r().symbols.PollInputEvents();
+  }
+  static waitTime(seconds: number): void {
+    r().symbols.WaitTime(seconds);
+  }
+  static setRandomSeed(seed: number): void {
+    r().symbols.SetRandomSeed(i(seed));
+  }
+  static getRandomValue(min: number, max: number): number {
+    return r().symbols.GetRandomValue(i(min), i(max));
+  }
+  static takeScreenshot(fileName: string): void {
+    r().symbols.TakeScreenshot(cstr(fileName));
+  }
+  static openURL(url: string): void {
+    r().symbols.OpenURL(cstr(url));
+  }
+  static setTraceLogLevel(logLevel: number): void {
+    r().symbols.SetTraceLogLevel(i(logLevel));
+  }
+  static traceLog(logLevel: number, text: string): void {
+    r().symbols.TraceLogW(i(logLevel), cstr(text));
+  }
+}

package/src/modules/window/symbols.ts

@@ -0,0 +1,85 @@
+import { FFIType } from 'bun:ffi';
+const { i32, cstring, bool, f32, f64, ptr } = FFIType;
+
+export const windowDirectSymbols = {
+  InitWindow: { args: [i32, i32, cstring], returns: FFIType.void },
+  CloseWindow: { args: [], returns: FFIType.void },
+  WindowShouldClose: { args: [], returns: bool },
+  BeginDrawing: { args: [], returns: FFIType.void },
+  ClearBackground: { args: [i32], returns: FFIType.void },
+  EndDrawing: { args: [], returns: FFIType.void },
+  SetTargetFPS: { args: [i32], returns: FFIType.void },
+  GetFrameTime: { args: [], returns: f32 },
+  IsWindowReady: { args: [], returns: bool },
+  IsWindowFullscreen: { args: [], returns: bool },
+  IsWindowHidden: { args: [], returns: bool },
+  IsWindowMinimized: { args: [], returns: bool },
+  IsWindowMaximized: { args: [], returns: bool },
+  IsWindowFocused: { args: [], returns: bool },
+  IsWindowResized: { args: [], returns: bool },
+  IsWindowState: { args: [i32], returns: bool },
+  SetWindowState: { args: [i32], returns: FFIType.void },
+  ClearWindowState: { args: [i32], returns: FFIType.void },
+  ToggleFullscreen: { args: [], returns: FFIType.void },
+  ToggleBorderlessWindowed: { args: [], returns: FFIType.void },
+  MaximizeWindow: { args: [], returns: FFIType.void },
+  MinimizeWindow: { args: [], returns: FFIType.void },
+  RestoreWindow: { args: [], returns: FFIType.void },
+  SetWindowTitle: { args: [cstring], returns: FFIType.void },
+  SetWindowPosition: { args: [i32, i32], returns: FFIType.void },
+  SetWindowMonitor: { args: [i32], returns: FFIType.void },
+  SetWindowMinSize: { args: [i32, i32], returns: FFIType.void },
+  SetWindowMaxSize: { args: [i32, i32], returns: FFIType.void },
+  SetWindowSize: { args: [i32, i32], returns: FFIType.void },
+  SetWindowOpacity: { args: [f32], returns: FFIType.void },
+  SetWindowFocused: { args: [], returns: FFIType.void },
+  GetScreenWidth: { args: [], returns: i32 },
+  GetScreenHeight: { args: [], returns: i32 },
+  GetRenderWidth: { args: [], returns: i32 },
+  GetRenderHeight: { args: [], returns: i32 },
+  GetMonitorCount: { args: [], returns: i32 },
+  GetCurrentMonitor: { args: [], returns: i32 },
+  GetMonitorWidth: { args: [i32], returns: i32 },
+  GetMonitorHeight: { args: [i32], returns: i32 },
+  GetMonitorPhysicalWidth: { args: [i32], returns: i32 },
+  GetMonitorPhysicalHeight: { args: [i32], returns: i32 },
+  GetMonitorRefreshRate: { args: [i32], returns: i32 },
+  GetMonitorName: { args: [i32], returns: ptr },
+  SetClipboardText: { args: [cstring], returns: FFIType.void },
+  GetClipboardText: { args: [], returns: ptr },
+  EnableEventWaiting: { args: [], returns: FFIType.void },
+  DisableEventWaiting: { args: [], returns: FFIType.void },
+  ShowCursor: { args: [], returns: FFIType.void },
+  HideCursor: { args: [], returns: FFIType.void },
+  IsCursorHidden: { args: [], returns: bool },
+  EnableCursor: { args: [], returns: FFIType.void },
+  DisableCursor: { args: [], returns: FFIType.void },
+  IsCursorOnScreen: { args: [], returns: bool },
+  EndTextureMode: { args: [], returns: FFIType.void },
+  BeginBlendMode: { args: [i32], returns: FFIType.void },
+  EndBlendMode: { args: [], returns: FFIType.void },
+  BeginScissorMode: { args: [i32, i32, i32, i32], returns: FFIType.void },
+  EndScissorMode: { args: [], returns: FFIType.void },
+  GetTime: { args: [], returns: f64 },
+  GetFPS: { args: [], returns: i32 },
+  SwapScreenBuffer: { args: [], returns: FFIType.void },
+  PollInputEvents: { args: [], returns: FFIType.void },
+  WaitTime: { args: [f64], returns: FFIType.void },
+  SetRandomSeed: { args: [i32], returns: FFIType.void },
+  GetRandomValue: { args: [i32, i32], returns: i32 },
+  TakeScreenshot: { args: [cstring], returns: FFIType.void },
+  SetConfigFlags: { args: [i32], returns: FFIType.void },
+  OpenURL: { args: [cstring], returns: FFIType.void },
+  SetTraceLogLevel: { args: [i32], returns: FFIType.void },
+} as const;
+
+export const windowWrapperSymbols = {
+  GetMonitorPositionW: { args: [ptr, i32], returns: FFIType.void },
+  GetWindowPositionW: { args: [ptr], returns: FFIType.void },
+  GetWindowScaleDPIW: { args: [ptr], returns: FFIType.void },
+  BeginTextureModeW: { args: [i32, i32, i32], returns: FFIType.void },
+  TraceLogW: { args: [i32, cstring], returns: FFIType.void },
+  SetWindowIconW: { args: [i32], returns: FFIType.void },
+  GetClipboardImageW: { args: [], returns: i32 },
+  SetWindowIconsW: { args: [ptr, i32], returns: FFIType.void },
+} as const;

package/src/modules/window/wrapper.c

@@ -0,0 +1,39 @@
+#include "../../c/common.h"
+
+void GetMonitorPositionW(float* out, int monitor) {
+    Vector2 v = GetMonitorPosition(monitor);
+    out[0] = v.x; out[1] = v.y;
+}
+
+void GetWindowPositionW(float* out) {
+    Vector2 v = GetWindowPosition();
+    out[0] = v.x; out[1] = v.y;
+}
+
+void GetWindowScaleDPIW(float* out) {
+    Vector2 v = GetWindowScaleDPI();
+    out[0] = v.x; out[1] = v.y;
+}
+
+void BeginTextureModeW(unsigned int id, int w, int h) {
+    RenderTexture2D rt = { id, {id, w, h, 1, 7}, {0, 0, 0, 0, 0} };
+    BeginTextureMode(rt);
+}
+
+void TraceLogW(int logLevel, const char* text) {
+    TraceLog(logLevel, "%s", text);
+}
+
+void SetWindowIconW(int imageId) {
+    if (imageId < 0 || imageId >= MAX_IMAGES || !imageUsed[imageId]) return;
+    SetWindowIcon(imageRegistry[imageId]);
+}
+
+int GetClipboardImageW() {
+    int slot = imageAlloc();
+    if (slot < 0) return -1;
+    imageRegistry[slot] = GetClipboardImage();
+    return slot;
+}
+
+void SetWindowIconsW(Image* images, int count) { SetWindowIcons(images, count); }

package/src/symbols.ts

@@ -1,43 +1,54 @@
-import { cc } from "bun:ffi";
-import { writeFileSync, mkdirSync, existsSync } from "fs";
-import { join, dirname } from "path";
-import { tmpdir } from "os";
-
-import { windowSymbols } from "./symbols/window";
-import { shapesSymbols } from "./symbols/shapes";
-import { collisionSymbols } from "./symbols/collision";
-import { cameraSymbols } from "./symbols/camera";
-import { draw3dSymbols } from "./symbols/draw3d";
-import { textureSymbols } from "./symbols/texture";
-import { modelSymbols } from "./symbols/model";
-import { imageSymbols } from "./symbols/image";
-import { colorSymbols } from "./symbols/color";
-import { fontSymbols } from "./symbols/font";
-import { inputSymbols } from "./symbols/input";
-import { audioSymbols } from "./symbols/audio";
-import { shaderSymbols } from "./symbols/shader";
-import { filesystemSymbols } from "./symbols/filesystem";
-
-const allSymbols = {
-  ...windowSymbols,
-  ...shapesSymbols,
+import { cc, dlopen, suffix } from 'bun:ffi';
+import { writeFileSync, mkdirSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { tmpdir } from 'os';
+
+import { windowDirectSymbols, windowWrapperSymbols } from './modules/window/symbols';
+import { shapesDirectSymbols, shapesWrapperSymbols } from './modules/shapes/symbols';
+import { collisionSymbols } from './modules/collision/symbols';
+import { cameraWrapperSymbols, cameraDirectSymbols } from './modules/camera/symbols';
+import { draw3dDirectSymbols, draw3dSymbols } from './modules/draw3d/symbols';
+import { textureDirectSymbols, textureWrapperSymbols } from './modules/texture/symbols';
+import { modelSymbols } from './modules/model/symbols';
+import { imageSymbols } from './modules/image/symbols';
+import { colorSymbols, colorDirectSymbols } from './modules/color/symbols';
+import { inputDirectSymbols, inputWrapperSymbols } from './modules/input/symbols';
+import { fontDirectSymbols, fontWrapperSymbols } from './modules/font/symbols';
+import { audioDirectSymbols, audioWrapperSymbols } from './modules/audio/symbols';
+import { shaderSymbols } from './modules/shader/symbols';
+
+const allWrapperSymbols = {
+  ...windowWrapperSymbols,
+  ...shapesWrapperSymbols,
   ...collisionSymbols,
-  ...cameraSymbols,
+  ...cameraWrapperSymbols,
   ...draw3dSymbols,
-  ...textureSymbols,
+  ...textureWrapperSymbols,
   ...modelSymbols,
   ...imageSymbols,
   ...colorSymbols,
-  ...fontSymbols,
-  ...inputSymbols,
-  ...audioSymbols,
+  ...fontWrapperSymbols,
+  ...inputWrapperSymbols,
+  ...audioWrapperSymbols,
   ...shaderSymbols,
-  ...filesystemSymbols,
 };
 
-type SymbolsType = ReturnType<typeof cc<typeof allSymbols>>;
+const allDirectSymbols = {
+  ...windowDirectSymbols,
+  ...shapesDirectSymbols,
+  ...draw3dDirectSymbols,
+  ...textureDirectSymbols,
+  ...inputDirectSymbols,
+  ...fontDirectSymbols,
+  ...audioDirectSymbols,
+  ...cameraDirectSymbols,
+  ...colorDirectSymbols,
+};
+
+type WrapperSymbolsType = ReturnType<typeof cc<typeof allWrapperSymbols>>;
+type DirectSymbolsType = ReturnType<typeof dlopen<typeof allDirectSymbols>>;
 
-export interface RaylibConfig {
+export type RaylibConfig = {
   maxModels?: number;
   maxFonts?: number;
   maxImages?: number;
@@ -49,10 +60,17 @@ export interface RaylibConfig {
   maxSounds?: number;
   maxMusic?: number;
   maxAudioStreams?: number;
+  /** Path or library name for raylib. Examples:
+   *  - `"libraylib.so"` (Linux)
+   *  - `"libraylib.dylib"` (macOS)
+   *  - `"raylib.dll"` (Windows)
+   *  - `"/usr/local/lib/libraylib.so"` (absolute path)
+   *  - `"raylib"` (bare name — works for cc linking, dlopen resolves via platform default)
+   */
   raylibPath?: string;
-}
+};
 
-const defaults: Required<Omit<RaylibConfig, "raylibPath">> = {
+const defaults: Required<Omit<RaylibConfig, 'raylibPath'>> = {
   maxModels: 64,
   maxFonts: 32,
   maxImages: 128,
@@ -67,14 +85,14 @@ const defaults: Required<Omit<RaylibConfig, "raylibPath">> = {
 };
 
 let _config: RaylibConfig = {};
-let _r: SymbolsType | null = null;
+let _r: { symbols: WrapperSymbolsType['symbols'] & DirectSymbolsType['symbols'] } | null = null;
 
 export function configure(config: RaylibConfig): void {
-  if (_r) throw new Error("Raylib already initialized. Call configure() before any Raylib method.");
+  if (_r) throw new Error('Raylib already initialized. Call configure() before any Raylib method.');
   _config = config;
 }
 
-function generateConfigHeader(config: Required<Omit<RaylibConfig, "raylibPath">>): string {
+function generateConfigHeader(config: Required<Omit<RaylibConfig, 'raylibPath'>>): string {
   return `#ifndef CONFIG_H
 #define CONFIG_H
 
@@ -94,38 +112,60 @@ function generateConfigHeader(config: Required<Omit<RaylibConfig, "raylibPath">>
 `;
 }
 
-function buildCC(config: RaylibConfig): SymbolsType {
+function resolveDlopenPath(raylibPath?: string): string {
+  if (raylibPath) {
+    if (raylibPath.includes('/') || raylibPath.includes('\\') || raylibPath.includes('.')) {
+      return raylibPath;
+    }
+  }
+  return `libraylib.${suffix}`;
+}
+
+function buildCC(config: RaylibConfig) {
   const resolved = { ...defaults };
   for (const key of Object.keys(defaults) as (keyof typeof defaults)[]) {
-    if (config[key] != null) (resolved as any)[key] = config[key];
+    if (config[key] !== null && config[key] !== undefined) {
+      (resolved as unknown as Record<string, number>)[key] = config[key];
+    }
   }
 
   const configHeader = generateConfigHeader(resolved);
-  const cacheDir = join(tmpdir(), "rraylib");
-  const configHash = Object.values(resolved).join("_");
+  const cacheDir = join(tmpdir(), 'rraylib');
+  const configHash = Object.values(resolved).join('_');
   const headerPath = join(cacheDir, `config_${configHash}.h`);
 
   if (!existsSync(cacheDir)) mkdirSync(cacheDir, { recursive: true });
   writeFileSync(headerPath, configHeader);
 
   const srcDir = dirname(new URL(import.meta.url).pathname);
-  const cDir = join(srcDir, "c");
+  const cDir = join(srcDir, 'c');
+  const modulesDir = join(srcDir, 'modules');
 
-  const wrapperSrc = `#include "${headerPath}"\n#include "${cDir}/registries.c"\n#include "${cDir}/window.c"\n#include "${cDir}/shapes.c"\n#include "${cDir}/collision.c"\n#include "${cDir}/camera.c"\n#include "${cDir}/draw3d.c"\n#include "${cDir}/texture.c"\n#include "${cDir}/model.c"\n#include "${cDir}/image.c"\n#include "${cDir}/color.c"\n#include "${cDir}/font.c"\n#include "${cDir}/input.c"\n#include "${cDir}/audio.c"\n#include "${cDir}/shader.c"\n#include "${cDir}/filesystem.c"\n`;
+  const wrapperSrc = `#include "${headerPath}"\n#include "${cDir}/registries.c"\n#include "${modulesDir}/window/wrapper.c"\n#include "${modulesDir}/shapes/wrapper.c"\n#include "${modulesDir}/collision/wrapper.c"\n#include "${modulesDir}/camera/wrapper.c"\n#include "${modulesDir}/draw3d/wrapper.c"\n#include "${modulesDir}/texture/wrapper.c"\n#include "${modulesDir}/model/wrapper.c"\n#include "${modulesDir}/image/wrapper.c"\n#include "${modulesDir}/color/wrapper.c"\n#include "${modulesDir}/font/wrapper.c"\n#include "${modulesDir}/input/wrapper.c"\n#include "${modulesDir}/audio/wrapper.c"\n#include "${modulesDir}/shader/wrapper.c"\n`;
 
   const wrapperPath = join(cacheDir, `main_${configHash}.c`);
   writeFileSync(wrapperPath, wrapperSrc);
 
-  const library = config.raylibPath ? [config.raylibPath] : ["raylib"];
+  const ccLibrary = config.raylibPath ? [config.raylibPath] : [`libraylib.${suffix}`];
 
-  return cc({
+  const wrapperHandle = cc({
     source: wrapperPath,
-    library,
-    symbols: allSymbols,
+    library: ccLibrary,
+    symbols: allWrapperSymbols,
   });
+
+  const dlopenPath = resolveDlopenPath(config.raylibPath);
+  const directHandle = dlopen(dlopenPath, allDirectSymbols);
+
+  return {
+    symbols: {
+      ...directHandle.symbols,
+      ...wrapperHandle.symbols,
+    },
+  };
 }
 
-export function getSymbols(): SymbolsType {
+export function getSymbols() {
   if (!_r) _r = buildCC(_config);
   return _r;
 }

package/src/utils.ts

@@ -1,25 +1,73 @@
 export function cstr(str: string) {
-  return Buffer.from(str + "\0", "utf8");
+  return Buffer.from(str + '\0', 'utf8');
 }
 
-const _f2iBuf = new ArrayBuffer(4);
-const _f2iF32 = new Float32Array(_f2iBuf);
-const _f2iU32 = new Uint32Array(_f2iBuf);
-
-export function f2i(val: number): number {
-  _f2iF32[0] = val;
-  return _f2iU32[0]! | 0;
+/**
+ * Force heap-allocated double: adds/subtracts a tiny epsilon
+ * to kill V8 SMI-encoding without changing the numeric value.
+ * Ensures bun:ffi passes the correct f32/f64 bit pattern to C.
+ */
+export function f(n: number): number {
+  return n + 1e-300 - 1e-300;
 }
 
-const _i2fBuf = new ArrayBuffer(4);
-const _i2fU32 = new Uint32Array(_i2fBuf);
-const _i2fF32 = new Float32Array(_i2fBuf);
-
-export function i2f(val: number): number {
-  _i2fU32[0] = val >>> 0;
-  return _i2fF32[0]!;
+export function i(n: number): number {
+  return n | 0;
 }
 
 export const color = (r: number, g: number, b: number, a: number = 255) => {
   return (a << 24) | (b << 16) | (g << 8) | r;
 };
+
+export const bufs = {
+  _rcHit: new Uint8Array(1),
+  _rcDist: new Float32Array(1),
+  _rcPt: new Float32Array(3),
+  _rcNorm: new Float32Array(3),
+  _texOutId: new Uint32Array(1),
+  _texOutTexId: new Uint32Array(1),
+  _texOutW: new Int32Array(1),
+  _texOutH: new Int32Array(1),
+  _shapesTexId: new Uint32Array(1),
+  _shapesTexW: new Int32Array(1),
+  _shapesTexH: new Int32Array(1),
+  _rayPosBuf2: new Float32Array(3),
+  _rayDirBuf2: new Float32Array(3),
+  _animSlotStart: new Int32Array(1),
+  _animCount: new Int32Array(1),
+  _colPtBuf: new Float32Array(2),
+  _recBuf: new Float32Array(4),
+  _vec2Buf: new Float32Array(2),
+  _matBuf: new Float32Array(16),
+  _vec4Buf: new Float32Array(4),
+  _vec3Buf2: new Float32Array(3),
+  _imgAnimSlot: new Int32Array(1),
+  _imgAnimFrames: new Int32Array(1),
+  _glyphValue: new Int32Array(1),
+  _glyphOffsetX: new Int32Array(1),
+  _glyphOffsetY: new Int32Array(1),
+  _glyphAdvanceX: new Int32Array(1),
+  _glyphImageSlot: new Int32Array(1),
+  _cpSize: new Int32Array(1),
+  _textAppendPos: new Int32Array(1),
+  _bbMin: new Float32Array(3),
+  _bbMax: new Float32Array(3),
+};
+
+export function validatePoints(
+  name: string,
+  points: Float32Array,
+  stride: number,
+  minPoints: number,
+): void {
+  if (points.length % stride !== 0) {
+    throw new Error(
+      `${name}: points length must be a multiple of ${stride} (got ${points.length})`,
+    );
+  }
+  if (points.length < stride * minPoints) {
+    throw new Error(
+      `${name}: points must contain at least ${minPoints} points (got ${points.length / stride})`,
+    );
+  }
+}