@dayme/bunraylib 0.1.0 → 1.0.0

package/src/{c/image.c → modules/image/wrapper.c}

@@ -1,4 +1,4 @@
-#include "common.h"
+#include "../../c/common.h"
 
 int LoadImageW(const char* fileName) {
     int slot = imageAlloc();
@@ -78,21 +78,17 @@ int GenImageGradientLinearW(int width, int height, int direction, Color start, C
     return slot;
 }
 
-int GenImageGradientRadialW(int width, int height, int density, Color inner, Color outer) {
-    float d;
-    memcpy(&d, &density, sizeof(float));
+int GenImageGradientRadialW(int width, int height, float density, Color inner, Color outer) {
     int slot = imageAlloc();
     if (slot < 0) return -1;
-    imageRegistry[slot] = GenImageGradientRadial(width, height, d, inner, outer);
+    imageRegistry[slot] = GenImageGradientRadial(width, height, density, inner, outer);
     return slot;
 }
 
-int GenImageGradientSquareW(int width, int height, int density, Color inner, Color outer) {
-    float d;
-    memcpy(&d, &density, sizeof(float));
+int GenImageGradientSquareW(int width, int height, float density, Color inner, Color outer) {
     int slot = imageAlloc();
     if (slot < 0) return -1;
-    imageRegistry[slot] = GenImageGradientSquare(width, height, d, inner, outer);
+    imageRegistry[slot] = GenImageGradientSquare(width, height, density, inner, outer);
     return slot;
 }
 
@@ -103,21 +99,17 @@ int GenImageCheckedW(int width, int height, int checksX, int checksY, Color col1
     return slot;
 }
 
-int GenImageWhiteNoiseW(int width, int height, int factor) {
-    float f;
-    memcpy(&f, &factor, sizeof(float));
+int GenImageWhiteNoiseW(int width, int height, float factor) {
     int slot = imageAlloc();
     if (slot < 0) return -1;
-    imageRegistry[slot] = GenImageWhiteNoise(width, height, f);
+    imageRegistry[slot] = GenImageWhiteNoise(width, height, factor);
     return slot;
 }
 
-int GenImagePerlinNoiseW(int width, int height, int offsetX, int offsetY, int scale) {
-    float s;
-    memcpy(&s, &scale, sizeof(float));
+int GenImagePerlinNoiseW(int width, int height, int offsetX, int offsetY, float scale) {
     int slot = imageAlloc();
     if (slot < 0) return -1;
-    imageRegistry[slot] = GenImagePerlinNoise(width, height, offsetX, offsetY, s);
+    imageRegistry[slot] = GenImagePerlinNoise(width, height, offsetX, offsetY, scale);
     return slot;
 }
 
@@ -167,12 +159,10 @@ int ImageTextW(const char* text, int fontSize, Color color) {
     return slot;
 }
 
-int ImageTextExW(int fontId, const char* text, int fontSize, int spacing, Color tint) {
-    float sp;
-    memcpy(&sp, &spacing, sizeof(float));
+int ImageTextExW(int fontId, const char* text, int fontSize, float spacing, Color tint) {
     int slot = imageAlloc();
     if (slot < 0) return -1;
-    imageRegistry[slot] = ImageTextEx(fontRegistry[fontId], text, fontSize, sp, tint);
+    imageRegistry[slot] = ImageTextEx(fontRegistry[fontId], text, fontSize, spacing, tint);
     return slot;
 }
 
@@ -187,18 +177,14 @@ void ImageCropW(int id, int rx, int ry, int rw, int rh) {
     ImageCrop(&imageRegistry[id], rec);
 }
 
-void ImageAlphaCropW(int id, int threshold) {
+void ImageAlphaCropW(int id, float threshold) {
     if (id < 0 || id >= MAX_IMAGES || !imageUsed[id]) return;
-    float t;
-    memcpy(&t, &threshold, sizeof(float));
-    ImageAlphaCrop(&imageRegistry[id], t);
+    ImageAlphaCrop(&imageRegistry[id], threshold);
 }
 
-void ImageAlphaClearW(int id, Color color, int threshold) {
+void ImageAlphaClearW(int id, Color color, float threshold) {
     if (id < 0 || id >= MAX_IMAGES || !imageUsed[id]) return;
-    float t;
-    memcpy(&t, &threshold, sizeof(float));
-    ImageAlphaClear(&imageRegistry[id], color, t);
+    ImageAlphaClear(&imageRegistry[id], color, threshold);
 }
 
 void ImageAlphaMaskW(int id, int alphaMaskId) {
@@ -252,11 +238,9 @@ void ImageFlipHorizontalW(int id) {
     ImageFlipHorizontal(&imageRegistry[id]);
 }
 
-void ImageRotateW(int id, int degrees) {
+void ImageRotateW(int id, float degrees) {
     if (id < 0 || id >= MAX_IMAGES || !imageUsed[id]) return;
-    float d;
-    memcpy(&d, &degrees, sizeof(float));
-    ImageRotate(&imageRegistry[id], d);
+    ImageRotate(&imageRegistry[id], degrees);
 }
 
 void ImageRotateCWW(int id) {
@@ -284,11 +268,9 @@ void ImageColorGrayscaleW(int id) {
     ImageColorGrayscale(&imageRegistry[id]);
 }
 
-void ImageColorContrastW(int id, int contrast) {
+void ImageColorContrastW(int id, float contrast) {
     if (id < 0 || id >= MAX_IMAGES || !imageUsed[id]) return;
-    float c;
-    memcpy(&c, &contrast, sizeof(float));
-    ImageColorContrast(&imageRegistry[id], c);
+    ImageColorContrast(&imageRegistry[id], contrast);
 }
 
 void ImageColorBrightnessW(int id, int brightness) {
@@ -301,12 +283,10 @@ void ImageColorReplaceW(int id, Color color, Color replace) {
     ImageColorReplace(&imageRegistry[id], color, replace);
 }
 
-void GetImageAlphaBorderW(float* out, int id, int threshold) {
+void GetImageAlphaBorderW(float* out, int id, float threshold) {
     Rectangle rec = {0};
     if (id >= 0 && id < MAX_IMAGES && imageUsed[id]) {
-        float t;
-        memcpy(&t, &threshold, sizeof(float));
-        rec = GetImageAlphaBorder(imageRegistry[id], t);
+        rec = GetImageAlphaBorder(imageRegistry[id], threshold);
     }
     out[0] = rec.x; out[1] = rec.y; out[2] = rec.width; out[3] = rec.height;
 }
@@ -427,11 +407,9 @@ void ImageDrawTextW(int dstId, const char* text, int posX, int posY, int fontSiz
     ImageDrawText(&imageRegistry[dstId], text, posX, posY, fontSize, color);
 }
 
-void ImageDrawTextExW(int dstId, int fontId, const char* text, int posX, int posY, int fontSize, int spacing, Color tint) {
+void ImageDrawTextExW(int dstId, int fontId, const char* text, int posX, int posY, int fontSize, float spacing, Color tint) {
     if (dstId < 0 || dstId >= MAX_IMAGES || !imageUsed[dstId]) return;
-    float sp;
-    memcpy(&sp, &spacing, sizeof(float));
-    ImageDrawTextEx(&imageRegistry[dstId], fontRegistry[fontId], text, (Vector2){posX, posY}, fontSize, sp, tint);
+    ImageDrawTextEx(&imageRegistry[dstId], fontRegistry[fontId], text, (Vector2){posX, posY}, fontSize, spacing, tint);
 }
 
 void ImageToPOTW(int id, int fill) {

package/src/modules/input/InputModule.ts

@@ -0,0 +1,160 @@
+import { getSymbols } from '../../symbols';
+import { bufs as b, cstr, f, i } from '../../utils';
+import { CString } from 'bun:ffi';
+import type { Vec2 } from '../../types';
+
+const r = () => getSymbols();
+
+export class InputModule {
+  static isKeyPressed(key: number): boolean {
+    return r().symbols.IsKeyPressed(i(key));
+  }
+  static isKeyPressedRepeat(key: number): boolean {
+    return r().symbols.IsKeyPressedRepeat(i(key));
+  }
+  static isKeyDown(key: number): boolean {
+    return r().symbols.IsKeyDown(i(key));
+  }
+  static isKeyReleased(key: number): boolean {
+    return r().symbols.IsKeyReleased(i(key));
+  }
+  static isKeyUp(key: number): boolean {
+    return r().symbols.IsKeyUp(i(key));
+  }
+  static getKeyPressed(): number {
+    return r().symbols.GetKeyPressed();
+  }
+  static getCharPressed(): number {
+    return r().symbols.GetCharPressed();
+  }
+  static setExitKey(key: number): void {
+    r().symbols.SetExitKey(i(key));
+  }
+  static isGamepadAvailable(gamepad: number): boolean {
+    return r().symbols.IsGamepadAvailable(i(gamepad));
+  }
+  static getGamepadName(gamepad: number): string {
+    const ptr = r().symbols.GetGamepadName(i(gamepad));
+    if (!ptr) return '';
+    return new CString(ptr).toString();
+  }
+  static isGamepadButtonPressed(gamepad: number, button: number): boolean {
+    return r().symbols.IsGamepadButtonPressed(i(gamepad), i(button));
+  }
+  static isGamepadButtonDown(gamepad: number, button: number): boolean {
+    return r().symbols.IsGamepadButtonDown(i(gamepad), i(button));
+  }
+  static isGamepadButtonReleased(gamepad: number, button: number): boolean {
+    return r().symbols.IsGamepadButtonReleased(i(gamepad), i(button));
+  }
+  static isGamepadButtonUp(gamepad: number, button: number): boolean {
+    return r().symbols.IsGamepadButtonUp(i(gamepad), i(button));
+  }
+  static getGamepadButtonPressed(): number {
+    return r().symbols.GetGamepadButtonPressed();
+  }
+  static getGamepadAxisCount(gamepad: number): number {
+    return r().symbols.GetGamepadAxisCount(i(gamepad));
+  }
+  static getGamepadAxisMovement(gamepad: number, axis: number): number {
+    return r().symbols.GetGamepadAxisMovement(i(gamepad), i(axis));
+  }
+  static setGamepadMappings(mappings: string): number {
+    return r().symbols.SetGamepadMappings(cstr(mappings));
+  }
+  static isMouseButtonPressed(button: number): boolean {
+    return r().symbols.IsMouseButtonPressed(i(button));
+  }
+  static isMouseButtonDown(button: number): boolean {
+    return r().symbols.IsMouseButtonDown(i(button));
+  }
+  static isMouseButtonReleased(button: number): boolean {
+    return r().symbols.IsMouseButtonReleased(i(button));
+  }
+  static isMouseButtonUp(button: number): boolean {
+    return r().symbols.IsMouseButtonUp(i(button));
+  }
+  static getMouseX(): number {
+    return r().symbols.GetMouseX();
+  }
+  static getMouseY(): number {
+    return r().symbols.GetMouseY();
+  }
+  static getMousePosition(): Vec2 {
+    r().symbols.GetMousePositionW(b._vec2Buf);
+    return { x: b._vec2Buf[0]!, y: b._vec2Buf[1]! };
+  }
+  static getMouseDelta(): Vec2 {
+    r().symbols.GetMouseDeltaW(b._vec2Buf);
+    return { x: b._vec2Buf[0]!, y: b._vec2Buf[1]! };
+  }
+  static setMousePosition(x: number, y: number): void {
+    r().symbols.SetMousePosition(i(x), i(y));
+  }
+  static setMouseOffset(x: number, y: number): void {
+    r().symbols.SetMouseOffset(i(x), i(y));
+  }
+  static setMouseScale(scaleX: number, scaleY: number): void {
+    r().symbols.SetMouseScale(f(scaleX), f(scaleY));
+  }
+  static getMouseWheelMove(): number {
+    return r().symbols.GetMouseWheelMove();
+  }
+  static getMouseWheelMoveV(): Vec2 {
+    r().symbols.GetMouseWheelMoveVW(b._vec2Buf);
+    return { x: b._vec2Buf[0]!, y: b._vec2Buf[1]! };
+  }
+  static setMouseCursor(cursor: number): void {
+    r().symbols.SetMouseCursor(i(cursor));
+  }
+  static getTouchX(): number {
+    return r().symbols.GetTouchX();
+  }
+  static getTouchY(): number {
+    return r().symbols.GetTouchY();
+  }
+  static getTouchPosition(index: number): Vec2 {
+    r().symbols.GetTouchPositionW(b._vec2Buf, i(index));
+    return { x: b._vec2Buf[0]!, y: b._vec2Buf[1]! };
+  }
+  static getTouchPointId(index: number): number {
+    return r().symbols.GetTouchPointId(i(index));
+  }
+  static getTouchPointCount(): number {
+    return r().symbols.GetTouchPointCount();
+  }
+  static setGesturesEnabled(flags: number): void {
+    r().symbols.SetGesturesEnabled(i(flags));
+  }
+  static isGestureDetected(gesture: number): boolean {
+    return r().symbols.IsGestureDetected(i(gesture));
+  }
+  static getGestureDetected(): number {
+    return r().symbols.GetGestureDetected();
+  }
+  static getGestureHoldDuration(): number {
+    return r().symbols.GetGestureHoldDuration();
+  }
+  static getGestureDragVector(): Vec2 {
+    r().symbols.GetGestureDragVectorW(b._vec2Buf);
+    return { x: b._vec2Buf[0]!, y: b._vec2Buf[1]! };
+  }
+  static getGestureDragAngle(): number {
+    return r().symbols.GetGestureDragAngle();
+  }
+  static getGesturePinchVector(): Vec2 {
+    r().symbols.GetGesturePinchVectorW(b._vec2Buf);
+    return { x: b._vec2Buf[0]!, y: b._vec2Buf[1]! };
+  }
+  static getGesturePinchAngle(): number {
+    return r().symbols.GetGesturePinchAngle();
+  }
+  static setGamepadVibration(
+    gamepad: number,
+    leftMotor: number,
+    rightMotor: number,
+    duration: number,
+  ): void {
+    r().symbols.SetGamepadVibration(i(gamepad), f(leftMotor), f(rightMotor), f(duration));
+  }
+}

package/src/modules/input/symbols.ts

@@ -0,0 +1,54 @@
+import { FFIType } from 'bun:ffi';
+const { i32, cstring, bool, f32, ptr } = FFIType;
+
+export const inputDirectSymbols = {
+  IsKeyPressed: { args: [i32], returns: bool },
+  IsKeyPressedRepeat: { args: [i32], returns: bool },
+  IsKeyDown: { args: [i32], returns: bool },
+  IsKeyReleased: { args: [i32], returns: bool },
+  IsKeyUp: { args: [i32], returns: bool },
+  GetKeyPressed: { args: [], returns: i32 },
+  GetCharPressed: { args: [], returns: i32 },
+  SetExitKey: { args: [i32], returns: FFIType.void },
+  IsGamepadAvailable: { args: [i32], returns: bool },
+  GetGamepadName: { args: [i32], returns: ptr },
+  IsGamepadButtonPressed: { args: [i32, i32], returns: bool },
+  IsGamepadButtonDown: { args: [i32, i32], returns: bool },
+  IsGamepadButtonReleased: { args: [i32, i32], returns: bool },
+  IsGamepadButtonUp: { args: [i32, i32], returns: bool },
+  GetGamepadButtonPressed: { args: [], returns: i32 },
+  GetGamepadAxisCount: { args: [i32], returns: i32 },
+  GetGamepadAxisMovement: { args: [i32, i32], returns: f32 },
+  SetGamepadMappings: { args: [cstring], returns: i32 },
+  SetGamepadVibration: { args: [i32, f32, f32, f32], returns: FFIType.void },
+  IsMouseButtonPressed: { args: [i32], returns: bool },
+  IsMouseButtonDown: { args: [i32], returns: bool },
+  IsMouseButtonReleased: { args: [i32], returns: bool },
+  IsMouseButtonUp: { args: [i32], returns: bool },
+  GetMouseX: { args: [], returns: i32 },
+  GetMouseY: { args: [], returns: i32 },
+  SetMousePosition: { args: [i32, i32], returns: FFIType.void },
+  SetMouseOffset: { args: [i32, i32], returns: FFIType.void },
+  SetMouseScale: { args: [f32, f32], returns: FFIType.void },
+  GetMouseWheelMove: { args: [], returns: f32 },
+  SetMouseCursor: { args: [i32], returns: FFIType.void },
+  GetTouchX: { args: [], returns: i32 },
+  GetTouchY: { args: [], returns: i32 },
+  GetTouchPointId: { args: [i32], returns: i32 },
+  GetTouchPointCount: { args: [], returns: i32 },
+  SetGesturesEnabled: { args: [i32], returns: FFIType.void },
+  IsGestureDetected: { args: [i32], returns: bool },
+  GetGestureDetected: { args: [], returns: i32 },
+  GetGestureHoldDuration: { args: [], returns: f32 },
+  GetGestureDragAngle: { args: [], returns: f32 },
+  GetGesturePinchAngle: { args: [], returns: f32 },
+} as const;
+
+export const inputWrapperSymbols = {
+  GetMousePositionW: { args: [ptr], returns: FFIType.void },
+  GetMouseDeltaW: { args: [ptr], returns: FFIType.void },
+  GetMouseWheelMoveVW: { args: [ptr], returns: FFIType.void },
+  GetTouchPositionW: { args: [ptr, i32], returns: FFIType.void },
+  GetGestureDragVectorW: { args: [ptr], returns: FFIType.void },
+  GetGesturePinchVectorW: { args: [ptr], returns: FFIType.void },
+} as const;

package/src/modules/input/wrapper.c

@@ -0,0 +1,31 @@
+#include <raylib.h>
+
+void GetMousePositionW(float* out) {
+    Vector2 v = GetMousePosition();
+    out[0] = v.x; out[1] = v.y;
+}
+
+void GetMouseDeltaW(float* out) {
+    Vector2 v = GetMouseDelta();
+    out[0] = v.x; out[1] = v.y;
+}
+
+void GetMouseWheelMoveVW(float* out) {
+    Vector2 v = GetMouseWheelMoveV();
+    out[0] = v.x; out[1] = v.y;
+}
+
+void GetTouchPositionW(float* out, int index) {
+    Vector2 v = GetTouchPosition(index);
+    out[0] = v.x; out[1] = v.y;
+}
+
+void GetGestureDragVectorW(float* out) {
+    Vector2 v = GetGestureDragVector();
+    out[0] = v.x; out[1] = v.y;
+}
+
+void GetGesturePinchVectorW(float* out) {
+    Vector2 v = GetGesturePinchVector();
+    out[0] = v.x; out[1] = v.y;
+}

package/src/modules/model/ModelModule.ts

@@ -0,0 +1,228 @@
+import { getSymbols } from '../../symbols';
+import { bufs as b, cstr, f, i } from '../../utils';
+import type {
+  Vec3,
+  Texture2D,
+  Model,
+  BoundingBox,
+  Image,
+  Material,
+  Mesh,
+  ModelAnimation,
+  Color,
+} from '../../types';
+
+const r = () => getSymbols();
+
+export class ModelModule {
+  static loadModel(fileName: string): Model {
+    return r().symbols.LoadModelW(cstr(fileName));
+  }
+  static unloadModel(model: Model): void {
+    r().symbols.UnloadModelW(i(model));
+  }
+  static isModelValid(model: Model): boolean {
+    return r().symbols.IsModelValidW(i(model));
+  }
+  static getModelBoundingBox(model: Model): BoundingBox {
+    r().symbols.GetModelBoundingBoxW(b._bbMin, b._bbMax, i(model));
+    return {
+      min: { x: b._bbMin[0]!, y: b._bbMin[1]!, z: b._bbMin[2]! },
+      max: { x: b._bbMax[0]!, y: b._bbMax[1]!, z: b._bbMax[2]! },
+    };
+  }
+  static drawModel(model: Model, position: Vec3, scale: number, tint: Color): void {
+    r().symbols.DrawModelW(
+      i(model),
+      f(position.x),
+      f(position.y),
+      f(position.z),
+      f(scale),
+      i(tint),
+    );
+  }
+  static drawModelEx(
+    model: Model,
+    position: Vec3,
+    rotationAxis: Vec3,
+    rotationAngle: number,
+    scale: Vec3,
+    tint: Color,
+  ): void {
+    r().symbols.DrawModelExW(
+      i(model),
+      f(position.x),
+      f(position.y),
+      f(position.z),
+      f(rotationAxis.x),
+      f(rotationAxis.y),
+      f(rotationAxis.z),
+      f(rotationAngle),
+      f(scale.x),
+      f(scale.y),
+      f(scale.z),
+      i(tint),
+    );
+  }
+  static drawModelWires(model: Model, position: Vec3, scale: number, tint: Color): void {
+    r().symbols.DrawModelWiresW(
+      i(model),
+      f(position.x),
+      f(position.y),
+      f(position.z),
+      f(scale),
+      i(tint),
+    );
+  }
+  static drawModelWiresEx(
+    model: Model,
+    position: Vec3,
+    rotationAxis: Vec3,
+    rotationAngle: number,
+    scale: Vec3,
+    tint: Color,
+  ): void {
+    r().symbols.DrawModelWiresExW(
+      i(model),
+      f(position.x),
+      f(position.y),
+      f(position.z),
+      f(rotationAxis.x),
+      f(rotationAxis.y),
+      f(rotationAxis.z),
+      f(rotationAngle),
+      f(scale.x),
+      f(scale.y),
+      f(scale.z),
+      i(tint),
+    );
+  }
+  static drawMesh(mesh: Mesh, material: Material, transform: Float32Array): void {
+    r().symbols.DrawMeshW(i(mesh), i(material), transform);
+  }
+  static drawMeshInstanced(
+    mesh: Mesh,
+    material: Material,
+    transforms: Float32Array,
+    instances: number,
+  ): void {
+    r().symbols.DrawMeshInstancedW(i(mesh), i(material), transforms, i(instances));
+  }
+  static loadModelFromMesh(mesh: Mesh): Model {
+    return r().symbols.LoadModelFromMeshW(i(mesh));
+  }
+  static unloadMesh(mesh: Mesh): void {
+    r().symbols.UnloadMeshW(i(mesh));
+  }
+  static uploadMesh(mesh: Mesh, dynamic: boolean): void {
+    r().symbols.UploadMeshW(i(mesh), dynamic);
+  }
+  static getMeshBoundingBox(mesh: Mesh): BoundingBox {
+    r().symbols.GetMeshBoundingBoxW(b._bbMin, b._bbMax, i(mesh));
+    return {
+      min: { x: b._bbMin[0]!, y: b._bbMin[1]!, z: b._bbMin[2]! },
+      max: { x: b._bbMax[0]!, y: b._bbMax[1]!, z: b._bbMax[2]! },
+    };
+  }
+  static genMeshTangents(mesh: Mesh): void {
+    r().symbols.GenMeshTangentsW(i(mesh));
+  }
+  static exportMesh(mesh: Mesh, fileName: string): boolean {
+    return r().symbols.ExportMeshW(i(mesh), cstr(fileName));
+  }
+  static exportMeshAsCode(mesh: Mesh, fileName: string): boolean {
+    return r().symbols.ExportMeshAsCodeW(i(mesh), cstr(fileName));
+  }
+  static genMeshPoly(sides: number, radius: number): Mesh {
+    return r().symbols.GenMeshPolyW(i(sides), f(radius));
+  }
+  static genMeshPlane(width: number, length: number, resX: number, resZ: number): Mesh {
+    return r().symbols.GenMeshPlaneW(f(width), f(length), i(resX), i(resZ));
+  }
+  static genMeshCube(width: number, height: number, length: number): Mesh {
+    return r().symbols.GenMeshCubeW(f(width), f(height), f(length));
+  }
+  static genMeshSphere(radius: number, rings: number, slices: number): Mesh {
+    return r().symbols.GenMeshSphereW(f(radius), i(rings), i(slices));
+  }
+  static genMeshHemiSphere(radius: number, rings: number, slices: number): Mesh {
+    return r().symbols.GenMeshHemiSphereW(f(radius), i(rings), i(slices));
+  }
+  static genMeshCylinder(radius: number, height: number, slices: number): Mesh {
+    return r().symbols.GenMeshCylinderW(f(radius), f(height), i(slices));
+  }
+  static genMeshCone(radius: number, height: number, slices: number): Mesh {
+    return r().symbols.GenMeshConeW(f(radius), f(height), i(slices));
+  }
+  static genMeshTorus(radius: number, size: number, radSeg: number, sides: number): Mesh {
+    return r().symbols.GenMeshTorusW(f(radius), f(size), i(radSeg), i(sides));
+  }
+  static genMeshKnot(radius: number, size: number, radSeg: number, sides: number): Mesh {
+    return r().symbols.GenMeshKnotW(f(radius), f(size), i(radSeg), i(sides));
+  }
+  static genMeshHeightmap(heightmap: Image, size: Vec3): Mesh {
+    return r().symbols.GenMeshHeightmapW(i(heightmap), f(size.x), f(size.y), f(size.z));
+  }
+  static genMeshCubicmap(cubicmap: Image, cubeSize: Vec3): Mesh {
+    return r().symbols.GenMeshCubicmapW(i(cubicmap), f(cubeSize.x), f(cubeSize.y), f(cubeSize.z));
+  }
+  static loadMaterialDefault(): Material {
+    return r().symbols.LoadMaterialDefaultW();
+  }
+  static isMaterialValid(material: Material): boolean {
+    return r().symbols.IsMaterialValidW(i(material));
+  }
+  static unloadMaterial(material: Material): void {
+    r().symbols.UnloadMaterialW(i(material));
+  }
+  static setMaterialTexture(material: Material, mapType: number, texture: Texture2D): void {
+    r().symbols.SetMaterialTextureW(
+      i(material),
+      i(mapType),
+      i(texture.id),
+      i(texture.width),
+      i(texture.height),
+    );
+  }
+  static setModelMeshMaterial(model: Model, meshId: number, materialId: number): void {
+    r().symbols.SetModelMeshMaterialW(i(model), i(meshId), i(materialId));
+  }
+  static loadModelAnimations(fileName: string): { startSlot: number; count: number } {
+    r().symbols.LoadModelAnimationsW(b._animSlotStart, b._animCount, cstr(fileName));
+    return { startSlot: b._animSlotStart[0]!, count: b._animCount[0]! };
+  }
+  static updateModelAnimation(model: Model, anim: ModelAnimation, frame: number): void {
+    r().symbols.UpdateModelAnimationW(i(model), i(anim), f(frame));
+  }
+  static updateModelAnimationEx(
+    model: Model,
+    animA: ModelAnimation,
+    frameA: number,
+    animB: ModelAnimation,
+    frameB: number,
+    blend: number,
+  ): void {
+    r().symbols.UpdateModelAnimationExW(
+      i(model),
+      i(animA),
+      f(frameA),
+      i(animB),
+      f(frameB),
+      f(blend),
+    );
+  }
+  static unloadModelAnimations(startSlot: number, count: number): void {
+    r().symbols.UnloadModelAnimationsW(i(startSlot), i(count));
+  }
+  static isModelAnimationValid(model: Model, anim: ModelAnimation): boolean {
+    return r().symbols.IsModelAnimationValidW(i(model), i(anim));
+  }
+  static updateMeshBuffer(
+    mesh: Mesh,
+    index: number,
+    data: Buffer | Uint8Array,
+    offset: number,
+  ): void {
+    r().symbols.UpdateMeshBufferW(i(mesh), i(index), data, i(data.length), i(offset));
+  }
+}

package/src/{symbols/model.ts → modules/model/symbols.ts}

@@ -1,4 +1,4 @@
-import { FFIType } from "bun:ffi";
+import { FFIType } from 'bun:ffi';
 const { i32, cstring, bool, ptr } = FFIType;
 
 export const modelSymbols = {
@@ -13,17 +13,17 @@ export const modelSymbols = {
   GenMeshTangentsW: { args: [i32], returns: FFIType.void },
   ExportMeshW: { args: [i32, cstring], returns: bool },
   ExportMeshAsCodeW: { args: [i32, cstring], returns: bool },
-  GenMeshPolyW: { args: [i32, i32], returns: i32 },
-  GenMeshPlaneW: { args: [i32, i32, i32, i32], returns: i32 },
-  GenMeshCubeW: { args: [i32, i32, i32], returns: i32 },
-  GenMeshSphereW: { args: [i32, i32, i32], returns: i32 },
-  GenMeshHemiSphereW: { args: [i32, i32, i32], returns: i32 },
-  GenMeshCylinderW: { args: [i32, i32, i32], returns: i32 },
-  GenMeshConeW: { args: [i32, i32, i32], returns: i32 },
-  GenMeshTorusW: { args: [i32, i32, i32, i32], returns: i32 },
-  GenMeshKnotW: { args: [i32, i32, i32, i32], returns: i32 },
-  GenMeshHeightmapW: { args: [i32, i32, i32, i32], returns: i32 },
-  GenMeshCubicmapW: { args: [i32, i32, i32, i32], returns: i32 },
+  GenMeshPolyW: { args: [i32, FFIType.f32], returns: i32 },
+  GenMeshPlaneW: { args: [FFIType.f32, FFIType.f32, i32, i32], returns: i32 },
+  GenMeshCubeW: { args: [FFIType.f32, FFIType.f32, FFIType.f32], returns: i32 },
+  GenMeshSphereW: { args: [FFIType.f32, i32, i32], returns: i32 },
+  GenMeshHemiSphereW: { args: [FFIType.f32, i32, i32], returns: i32 },
+  GenMeshCylinderW: { args: [FFIType.f32, FFIType.f32, i32], returns: i32 },
+  GenMeshConeW: { args: [FFIType.f32, FFIType.f32, i32], returns: i32 },
+  GenMeshTorusW: { args: [FFIType.f32, FFIType.f32, i32, i32], returns: i32 },
+  GenMeshKnotW: { args: [FFIType.f32, FFIType.f32, i32, i32], returns: i32 },
+  GenMeshHeightmapW: { args: [i32, FFIType.f32, FFIType.f32, FFIType.f32], returns: i32 },
+  GenMeshCubicmapW: { args: [i32, FFIType.f32, FFIType.f32, FFIType.f32], returns: i32 },
   UpdateMeshBufferW: { args: [i32, i32, ptr, i32, i32], returns: FFIType.void },
   LoadMaterialDefaultW: { args: [], returns: i32 },
   IsMaterialValidW: { args: [i32], returns: bool },
@@ -31,8 +31,11 @@ export const modelSymbols = {
   SetMaterialTextureW: { args: [i32, i32, i32, i32, i32], returns: FFIType.void },
   SetModelMeshMaterialW: { args: [i32, i32, i32], returns: FFIType.void },
   LoadModelAnimationsW: { args: [ptr, ptr, cstring], returns: FFIType.void },
-  UpdateModelAnimationW: { args: [i32, i32, i32], returns: FFIType.void },
-  UpdateModelAnimationExW: { args: [i32, i32, i32, i32, i32, i32], returns: FFIType.void },
+  UpdateModelAnimationW: { args: [i32, i32, FFIType.f32], returns: FFIType.void },
+  UpdateModelAnimationExW: {
+    args: [i32, i32, FFIType.f32, i32, FFIType.f32, FFIType.f32],
+    returns: FFIType.void,
+  },
   UnloadModelAnimationsW: { args: [i32, i32], returns: FFIType.void },
   IsModelAnimationValidW: { args: [i32, i32], returns: bool },
 } as const;