@dayme/bunraylib 0.1.0 → 1.0.0

package/src/modules/shapes/symbols.ts

@@ -0,0 +1,161 @@
+import { FFIType } from 'bun:ffi';
+const { i32, ptr, f32 } = FFIType;
+
+export const shapesDirectSymbols = {
+  DrawFPS: { args: [i32, i32], returns: FFIType.void },
+  DrawRectangle: { args: [i32, i32, i32, i32, i32], returns: FFIType.void },
+  DrawText: { args: [FFIType.cstring, i32, i32, i32, i32], returns: FFIType.void },
+  DrawPixel: { args: [i32, i32, i32], returns: FFIType.void },
+  DrawLine: { args: [i32, i32, i32, i32, i32], returns: FFIType.void },
+  DrawLineStrip: { args: [ptr, i32, i32], returns: FFIType.void },
+  DrawCircle: { args: [i32, i32, f32, i32], returns: FFIType.void },
+  DrawCircleLines: { args: [i32, i32, f32, i32], returns: FFIType.void },
+  DrawEllipse: { args: [i32, i32, f32, f32, i32], returns: FFIType.void },
+  DrawEllipseLines: { args: [i32, i32, f32, f32, i32], returns: FFIType.void },
+  DrawRectangleGradientV: { args: [i32, i32, i32, i32, i32, i32], returns: FFIType.void },
+  DrawRectangleGradientH: { args: [i32, i32, i32, i32, i32, i32], returns: FFIType.void },
+  DrawRectangleLines: { args: [i32, i32, i32, i32, i32], returns: FFIType.void },
+  DrawTriangleFan: { args: [ptr, i32, i32], returns: FFIType.void },
+  DrawTriangleStrip: { args: [ptr, i32, i32], returns: FFIType.void },
+  DrawSplineLinear: { args: [ptr, i32, f32, i32], returns: FFIType.void },
+  DrawSplineBasis: { args: [ptr, i32, f32, i32], returns: FFIType.void },
+  DrawSplineCatmullRom: { args: [ptr, i32, f32, i32], returns: FFIType.void },
+  DrawSplineBezierQuadratic: { args: [ptr, i32, f32, i32], returns: FFIType.void },
+  DrawSplineBezierCubic: { args: [ptr, i32, f32, i32], returns: FFIType.void },
+} as const;
+
+export const shapesWrapperSymbols = {
+  DrawLineExW: {
+    args: [f32, f32, f32, f32, f32, i32],
+    returns: FFIType.void,
+  },
+  DrawLineBezierW: {
+    args: [f32, f32, f32, f32, f32, i32],
+    returns: FFIType.void,
+  },
+  DrawLineDashedW: { args: [f32, f32, f32, f32, i32, i32, i32], returns: FFIType.void },
+  DrawCircleSectorW: {
+    args: [f32, f32, f32, f32, f32, i32, i32],
+    returns: FFIType.void,
+  },
+  DrawCircleSectorLinesW: {
+    args: [f32, f32, f32, f32, f32, i32, i32],
+    returns: FFIType.void,
+  },
+  DrawCircleGradientW: {
+    args: [f32, f32, f32, i32, i32],
+    returns: FFIType.void,
+  },
+  DrawEllipseVW: { args: [f32, f32, f32, f32, i32], returns: FFIType.void },
+  DrawEllipseLinesVW: { args: [f32, f32, f32, f32, i32], returns: FFIType.void },
+  DrawRingW: {
+    args: [f32, f32, f32, f32, f32, f32, i32, i32],
+    returns: FFIType.void,
+  },
+  DrawRingLinesW: {
+    args: [f32, f32, f32, f32, f32, f32, i32, i32],
+    returns: FFIType.void,
+  },
+  DrawRectangleProW: {
+    args: [f32, f32, f32, f32, f32, f32, f32, i32],
+    returns: FFIType.void,
+  },
+  DrawRectangleGradientExW: {
+    args: [f32, f32, f32, f32, i32, i32, i32, i32],
+    returns: FFIType.void,
+  },
+  DrawRectangleLinesExW: {
+    args: [f32, f32, f32, f32, f32, i32],
+    returns: FFIType.void,
+  },
+  DrawRectangleRoundedW: {
+    args: [f32, f32, f32, f32, f32, i32, i32],
+    returns: FFIType.void,
+  },
+  DrawRectangleRoundedLinesW: {
+    args: [f32, f32, f32, f32, f32, i32, i32],
+    returns: FFIType.void,
+  },
+  DrawRectangleRoundedLinesExW: {
+    args: [f32, f32, f32, f32, f32, i32, f32, i32],
+    returns: FFIType.void,
+  },
+  DrawTriangleW: {
+    args: [f32, f32, f32, f32, f32, f32, i32],
+    returns: FFIType.void,
+  },
+  DrawTriangleLinesW: {
+    args: [f32, f32, f32, f32, f32, f32, i32],
+    returns: FFIType.void,
+  },
+  DrawPolyW: {
+    args: [f32, f32, i32, f32, f32, i32],
+    returns: FFIType.void,
+  },
+  DrawPolyLinesW: {
+    args: [f32, f32, i32, f32, f32, i32],
+    returns: FFIType.void,
+  },
+  DrawPolyLinesExW: {
+    args: [f32, f32, i32, f32, f32, f32, i32],
+    returns: FFIType.void,
+  },
+  DrawSplineSegmentLinearW: {
+    args: [f32, f32, f32, f32, f32, i32],
+    returns: FFIType.void,
+  },
+  DrawSplineSegmentBasisW: {
+    args: [f32, f32, f32, f32, f32, f32, f32, f32, f32, i32],
+    returns: FFIType.void,
+  },
+  DrawSplineSegmentCatmullRomW: {
+    args: [f32, f32, f32, f32, f32, f32, f32, f32, f32, i32],
+    returns: FFIType.void,
+  },
+  DrawSplineSegmentBezierQuadraticW: {
+    args: [f32, f32, f32, f32, f32, f32, f32, i32],
+    returns: FFIType.void,
+  },
+  DrawSplineSegmentBezierCubicW: {
+    args: [f32, f32, f32, f32, f32, f32, f32, f32, f32, i32],
+    returns: FFIType.void,
+  },
+  GetSplinePointLinearW: {
+    args: [ptr, f32, f32, f32, f32, f32],
+    returns: FFIType.void,
+  },
+  GetSplinePointBasisW: {
+    args: [ptr, f32, f32, f32, f32, f32, f32, f32, f32, f32],
+    returns: FFIType.void,
+  },
+  GetSplinePointCatmullRomW: {
+    args: [ptr, f32, f32, f32, f32, f32, f32, f32, f32, f32],
+    returns: FFIType.void,
+  },
+  GetSplinePointBezierQuadW: {
+    args: [ptr, f32, f32, f32, f32, f32, f32, f32],
+    returns: FFIType.void,
+  },
+  GetSplinePointBezierCubicW: {
+    args: [ptr, f32, f32, f32, f32, f32, f32, f32, f32, f32],
+    returns: FFIType.void,
+  },
+  DrawPixelVW: { args: [f32, f32, i32], returns: FFIType.void },
+  DrawLineVW: {
+    args: [f32, f32, f32, f32, i32],
+    returns: FFIType.void,
+  },
+  DrawCircleVW: { args: [i32, i32, f32, i32], returns: FFIType.void },
+  DrawCircleLinesVW: { args: [f32, f32, f32, i32], returns: FFIType.void },
+  DrawRectangleVW: {
+    args: [f32, f32, f32, f32, i32],
+    returns: FFIType.void,
+  },
+  DrawRectangleRecW: {
+    args: [f32, f32, f32, f32, i32],
+    returns: FFIType.void,
+  },
+  SetShapesTextureW: { args: [i32, i32, i32, i32, i32, i32, i32], returns: FFIType.void },
+  GetShapesTextureW: { args: [ptr, ptr, ptr], returns: FFIType.void },
+  GetShapesTextureRectangleW: { args: [ptr], returns: FFIType.void },
+} as const;

package/src/modules/shapes/wrapper.c

@@ -0,0 +1,183 @@
+#include <raylib.h>
+
+void DrawPixelVW(float x, float y, Color color) {
+    DrawPixelV((Vector2){x, y}, color);
+}
+
+void DrawLineVW(float startX, float startY, float endX, float endY, Color color) {
+    DrawLineV((Vector2){startX, startY}, (Vector2){endX, endY}, color);
+}
+
+void DrawLineExW(float startX, float startY, float endX, float endY, float thick, Color color) {
+    DrawLineEx((Vector2){startX, startY}, (Vector2){endX, endY}, thick, color);
+}
+
+void DrawLineBezierW(float startX, float startY, float endX, float endY, float thick, Color color) {
+    DrawLineBezier((Vector2){startX, startY}, (Vector2){endX, endY}, thick, color);
+}
+
+void DrawLineDashedW(float startX, float startY, float endX, float endY, int dashSize, int spaceSize, Color color) {
+  DrawLineDashed((Vector2){startX, startY}, (Vector2){endX, endY}, dashSize, spaceSize, color);
+}
+
+void DrawCircleVW(int x, int y, float radius, Color color) {
+    DrawCircleV((Vector2){x, y}, radius, color);
+}
+
+void DrawCircleSectorW(float centerX, float centerY, float radius, float startAngle, float endAngle, int segments, Color color) {
+    DrawCircleSector((Vector2){centerX, centerY}, radius, startAngle, endAngle, segments, color);
+}
+
+void DrawCircleSectorLinesW(float centerX, float centerY, float radius, float startAngle, float endAngle, int segments, Color color) {
+    DrawCircleSectorLines((Vector2){centerX, centerY}, radius, startAngle, endAngle, segments, color);
+}
+
+void DrawCircleGradientW(float centerX, float centerY, float radius, Color inner, Color outer) {
+    DrawCircleGradient((Vector2){centerX, centerY}, radius, inner, outer);
+}
+
+void DrawCircleLinesVW(float x, float y, float radius, Color color) {
+    DrawCircleLinesV((Vector2){x, y}, radius, color);
+}
+
+void DrawEllipseVW(float centerX, float centerY, float radiusH, float radiusV, Color color) {
+  DrawEllipseV((Vector2){ centerX, centerY }, radiusH, radiusV, color);
+}
+
+void DrawEllipseLinesVW(float centerX, float centerY, float radiusH, float radiusV, Color color) {
+  DrawEllipseLinesV((Vector2){ centerX, centerY }, radiusH, radiusV, color);
+}
+
+void DrawRingW(float centerX, float centerY, float innerRadius, float outerRadius, float startAngle, float endAngle, int segments, Color color) {
+    DrawRing((Vector2){centerX, centerY}, innerRadius, outerRadius, startAngle, endAngle, segments, color);
+}
+
+void DrawRingLinesW(float centerX, float centerY, float innerRadius, float outerRadius, float startAngle, float endAngle, int segments, Color color) {
+    DrawRingLines((Vector2){centerX, centerY}, innerRadius, outerRadius, startAngle, endAngle, segments, color);
+}
+
+void DrawRectangleVW(float posX, float posY, float sizeX, float sizeY, Color color) {
+    DrawRectangleV((Vector2){posX, posY}, (Vector2){sizeX, sizeY}, color);
+}
+
+void DrawRectangleRecW(float x, float y, float w, float h, Color color) {
+    DrawRectangleRec((Rectangle){x, y, w, h}, color);
+}
+
+void DrawRectangleProW(float x, float y, float width, float height, float originX, float originY, float rotation, Color color) {
+    Rectangle rec = {x, y, width, height};
+    DrawRectanglePro(rec, (Vector2){originX, originY}, rotation, color);
+}
+
+void DrawRectangleGradientExW(float x, float y, float width, float height, Color topLeft, Color bottomLeft, Color topRight, Color bottomRight) {
+    Rectangle rec = {x, y, width, height};
+    DrawRectangleGradientEx(rec, topLeft, bottomLeft, topRight, bottomRight);
+}
+
+void DrawRectangleLinesExW(float x, float y, float width, float height, float lineThick, Color color) {
+    Rectangle rec = {x, y, width, height};
+    DrawRectangleLinesEx(rec, lineThick, color);
+}
+
+void DrawRectangleRoundedW(float x, float y, float width, float height, float roundness, int segments, Color color) {
+    Rectangle rec = {x, y, width, height};
+    DrawRectangleRounded(rec, roundness, segments, color);
+}
+
+void DrawRectangleRoundedLinesW(float x, float y, float width, float height, float roundness, int segments, Color color) {
+    Rectangle rec = {x, y, width, height};
+    DrawRectangleRoundedLines(rec, roundness, segments, color);
+}
+
+void DrawRectangleRoundedLinesExW(float x, float y, float width, float height, float roundness, int segments, float lineThick, Color color) {
+    Rectangle rec = {x, y, width, height};
+    DrawRectangleRoundedLinesEx(rec, roundness, segments, lineThick, color);
+}
+
+void DrawTriangleW(float x1, float y1, float x2, float y2, float x3, float y3, Color color) {
+    DrawTriangle((Vector2){x1, y1}, (Vector2){x2, y2}, (Vector2){x3, y3}, color);
+}
+
+void DrawTriangleLinesW(float x1, float y1, float x2, float y2, float x3, float y3, Color color) {
+    DrawTriangleLines((Vector2){x1, y1}, (Vector2){x2, y2}, (Vector2){x3, y3}, color);
+}
+
+void DrawPolyW(float centerX, float centerY, int sides, float radius, float rotation, Color color) {
+    DrawPoly((Vector2){centerX, centerY}, sides, radius, rotation, color);
+}
+
+void DrawPolyLinesW(float centerX, float centerY, int sides, float radius, float rotation, Color color) {
+    DrawPolyLines((Vector2){centerX, centerY}, sides, radius, rotation, color);
+}
+
+void DrawPolyLinesExW(float centerX, float centerY, int sides, float radius, float rotation, float lineThick, Color color) {
+    DrawPolyLinesEx((Vector2){centerX, centerY}, sides, radius, rotation, lineThick, color);
+}
+
+void DrawSplineSegmentLinearW(float p1x, float p1y, float p2x, float p2y, float thick, Color color) {
+    DrawSplineSegmentLinear((Vector2){p1x, p1y}, (Vector2){p2x, p2y}, thick, color);
+}
+
+void DrawSplineSegmentBasisW(float p1x, float p1y, float p2x, float p2y, float p3x, float p3y, float p4x, float p4y, float thick, Color color) {
+    DrawSplineSegmentBasis((Vector2){p1x, p1y}, (Vector2){p2x, p2y}, (Vector2){p3x, p3y}, (Vector2){p4x, p4y}, thick, color);
+}
+
+void DrawSplineSegmentCatmullRomW(float p1x, float p1y, float p2x, float p2y, float p3x, float p3y, float p4x, float p4y, float thick, Color color) {
+    DrawSplineSegmentCatmullRom((Vector2){p1x, p1y}, (Vector2){p2x, p2y}, (Vector2){p3x, p3y}, (Vector2){p4x, p4y}, thick, color);
+}
+
+void DrawSplineSegmentBezierQuadraticW(float p1x, float p1y, float c2x, float c2y, float p3x, float p3y, float thick, Color color) {
+    DrawSplineSegmentBezierQuadratic((Vector2){p1x, p1y}, (Vector2){c2x, c2y}, (Vector2){p3x, p3y}, thick, color);
+}
+
+void DrawSplineSegmentBezierCubicW(float p1x, float p1y, float c2x, float c2y, float c3x, float c3y, float p4x, float p4y, float thick, Color color) {
+    DrawSplineSegmentBezierCubic((Vector2){p1x, p1y}, (Vector2){c2x, c2y}, (Vector2){c3x, c3y}, (Vector2){p4x, p4y}, thick, color);
+}
+
+void GetSplinePointLinearW(float* out, float startPx, float startPy, float endPx, float endPy, float t) {
+    Vector2 result = GetSplinePointLinear((Vector2){startPx, startPy}, (Vector2){endPx, endPy}, t);
+    out[0] = result.x;
+    out[1] = result.y;
+}
+
+void GetSplinePointBasisW(float* out, float p1x, float p1y, float p2x, float p2y, float p3x, float p3y, float p4x, float p4y, float t) {
+    Vector2 result = GetSplinePointBasis((Vector2){p1x, p1y}, (Vector2){p2x, p2y}, (Vector2){p3x, p3y}, (Vector2){p4x, p4y}, t);
+    out[0] = result.x;
+    out[1] = result.y;
+}
+
+void GetSplinePointCatmullRomW(float* out, float p1x, float p1y, float p2x, float p2y, float p3x, float p3y, float p4x, float p4y, float t) {
+    Vector2 result = GetSplinePointCatmullRom((Vector2){p1x, p1y}, (Vector2){p2x, p2y}, (Vector2){p3x, p3y}, (Vector2){p4x, p4y}, t);
+    out[0] = result.x;
+    out[1] = result.y;
+}
+
+void GetSplinePointBezierQuadW(float* out, float p1x, float p1y, float c2x, float c2y, float p3x, float p3y, float t) {
+    Vector2 result = GetSplinePointBezierQuad((Vector2){p1x, p1y}, (Vector2){c2x, c2y}, (Vector2){p3x, p3y}, t);
+    out[0] = result.x;
+    out[1] = result.y;
+}
+
+void GetSplinePointBezierCubicW(float* out, float p1x, float p1y, float c2x, float c2y, float c3x, float c3y, float p4x, float p4y, float t) {
+    Vector2 result = GetSplinePointBezierCubic((Vector2){p1x, p1y}, (Vector2){c2x, c2y}, (Vector2){c3x, c3y}, (Vector2){p4x, p4y}, t);
+    out[0] = result.x;
+    out[1] = result.y;
+}
+
+void SetShapesTextureW(unsigned int texId, int texW, int texH, int recX, int recY, int recW, int recH) {
+    Texture2D tex = { texId, texW, texH, 1, 7 };
+    Rectangle rec = { recX, recY, recW, recH };
+    SetShapesTexture(tex, rec);
+}
+
+void GetShapesTextureW(unsigned int* outId, int* outW, int* outH) {
+    Texture2D tex = GetShapesTexture();
+    *outId = tex.id;
+    *outW = tex.width;
+    *outH = tex.height;
+}
+
+void GetShapesTextureRectangleW(float* out) {
+    Rectangle rec = GetShapesTextureRectangle();
+    out[0] = rec.x; out[1] = rec.y; out[2] = rec.width; out[3] = rec.height;
+}

package/src/modules/texture/TextureModule.ts

@@ -0,0 +1,190 @@
+import { getSymbols } from '../../symbols';
+import { bufs as b, cstr, f, i } from '../../utils';
+import type { Vec2, Rectangle, Texture2D, RenderTexture2D, Image, Color } from '../../types';
+
+const r = () => getSymbols();
+
+export class TextureModule {
+  static loadTexture(fileName: string): Texture2D {
+    r().symbols.LoadTextureW(b._texOutId, b._texOutW, b._texOutH, cstr(fileName));
+    return {
+      id: b._texOutId[0]!,
+      width: b._texOutW[0]!,
+      height: b._texOutH[0]!,
+    };
+  }
+  static unloadTexture(texture: Texture2D): void {
+    r().symbols.UnloadTextureW(i(texture.id));
+  }
+  static isTextureValid(texture: Texture2D): boolean {
+    return r().symbols.IsTextureValidW(i(texture.id), i(texture.width), i(texture.height));
+  }
+  static loadRenderTexture(width: number, height: number): RenderTexture2D {
+    r().symbols.LoadRenderTextureW(
+      b._texOutId,
+      b._texOutTexId,
+      b._texOutW,
+      b._texOutH,
+      i(width),
+      i(height),
+    );
+    return {
+      id: b._texOutId[0]!,
+      texture: {
+        id: b._texOutTexId[0]!,
+        width: b._texOutW[0]!,
+        height: b._texOutH[0]!,
+      },
+    };
+  }
+  static unloadRenderTexture(target: RenderTexture2D): void {
+    r().symbols.UnloadRenderTextureW(i(target.id));
+  }
+  static isRenderTextureValid(target: RenderTexture2D): boolean {
+    return r().symbols.IsRenderTextureValidW(i(target.id));
+  }
+  static genTextureMipmaps(texture: Texture2D): void {
+    r().symbols.GenTextureMipmapsW(i(texture.id));
+  }
+  static setTextureFilter(texture: Texture2D, filter: number): void {
+    r().symbols.SetTextureFilterW(i(texture.id), i(filter));
+  }
+  static setTextureWrap(texture: Texture2D, wrap: number): void {
+    r().symbols.SetTextureWrapW(i(texture.id), i(wrap));
+  }
+  static drawTexture(texture: Texture2D, posX: number, posY: number, tint: Color): void {
+    r().symbols.DrawTextureW(
+      i(texture.id),
+      i(texture.width),
+      i(texture.height),
+      i(posX),
+      i(posY),
+      i(tint),
+    );
+  }
+  static drawTextureEx(
+    texture: Texture2D,
+    position: Vec2,
+    rotation: number,
+    scale: number,
+    tint: Color,
+  ): void {
+    r().symbols.DrawTextureExW(
+      i(texture.id),
+      i(texture.width),
+      i(texture.height),
+      i(position.x),
+      i(position.y),
+      f(rotation),
+      f(scale),
+      i(tint),
+    );
+  }
+  static drawTextureRec(texture: Texture2D, source: Rectangle, position: Vec2, tint: Color): void {
+    r().symbols.DrawTextureRecW(
+      i(texture.id),
+      i(texture.width),
+      i(texture.height),
+      i(source.x),
+      i(source.y),
+      i(source.width),
+      i(source.height),
+      i(position.x),
+      i(position.y),
+      i(tint),
+    );
+  }
+  static drawTexturePro(
+    texture: Texture2D,
+    source: Rectangle,
+    dest: Rectangle,
+    origin: Vec2,
+    rotation: number,
+    tint: Color,
+  ): void {
+    r().symbols.DrawTextureProW(
+      i(texture.id),
+      i(texture.width),
+      i(texture.height),
+      i(source.x),
+      i(source.y),
+      i(source.width),
+      i(source.height),
+      i(dest.x),
+      i(dest.y),
+      i(dest.width),
+      i(dest.height),
+      i(origin.x),
+      i(origin.y),
+      f(rotation),
+      i(tint),
+    );
+  }
+  static loadTextureFromImage(image: Image): Texture2D {
+    r().symbols.LoadTextureFromImageW(b._texOutId, b._texOutW, b._texOutH, i(image));
+    return { id: b._texOutId[0]!, width: b._texOutW[0]!, height: b._texOutH[0]! };
+  }
+  static loadTextureCubemap(image: Image, layout: number): Texture2D {
+    r().symbols.LoadTextureCubemapW(b._texOutId, b._texOutW, b._texOutH, i(image), i(layout));
+    return { id: b._texOutId[0]!, width: b._texOutW[0]!, height: b._texOutH[0]! };
+  }
+  static updateTexture(texture: Texture2D, pixels: Uint8Array): void {
+    r().symbols.UpdateTextureW(i(texture.id), i(texture.width), i(texture.height), pixels);
+  }
+  static updateTextureRec(texture: Texture2D, rec: Rectangle, pixels: Uint8Array): void {
+    r().symbols.UpdateTextureRecW(
+      i(texture.id),
+      i(texture.width),
+      i(texture.height),
+      i(rec.x),
+      i(rec.y),
+      i(rec.width),
+      i(rec.height),
+      pixels,
+    );
+  }
+  static drawTextureNPatch(
+    texture: Texture2D,
+    nPatchInfo: {
+      source: Rectangle;
+      left: number;
+      top: number;
+      right: number;
+      bottom: number;
+      layout: number;
+    },
+    dest: Rectangle,
+    origin: Vec2,
+    rotation: number,
+    tint: Color,
+  ): void {
+    r().symbols.DrawTextureNPatchW(
+      i(texture.id),
+      i(texture.width),
+      i(texture.height),
+      i(nPatchInfo.source.x),
+      i(nPatchInfo.source.y),
+      i(nPatchInfo.source.width),
+      i(nPatchInfo.source.height),
+      i(nPatchInfo.left),
+      i(nPatchInfo.top),
+      i(nPatchInfo.right),
+      i(nPatchInfo.bottom),
+      i(nPatchInfo.layout),
+      i(dest.x),
+      i(dest.y),
+      i(dest.width),
+      i(dest.height),
+      i(origin.x),
+      i(origin.y),
+      f(rotation),
+      i(tint),
+    );
+  }
+  static getPixelColor(srcPtr: number, format: number): Color {
+    return r().symbols.GetPixelColor(srcPtr as unknown as Buffer, i(format));
+  }
+  static setPixelColor(dstPtr: number, color: Color, format: number): void {
+    r().symbols.SetPixelColor(dstPtr as unknown as Buffer, i(color), i(format));
+  }
+}

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

@@ -1,8 +1,13 @@
-import { FFIType } from "bun:ffi";
-const { i32, ptr, bool } = FFIType;
+import { FFIType } from 'bun:ffi';
+const { i32, ptr, bool, cstring, f32 } = FFIType;
 
-export const textureSymbols = {
-  LoadTextureW: { args: [ptr, ptr, ptr, FFIType.cstring], returns: FFIType.void },
+export const textureDirectSymbols = {
+  GetPixelColor: { args: [ptr, i32], returns: i32 },
+  SetPixelColor: { args: [ptr, i32, i32], returns: FFIType.void },
+} as const;
+
+export const textureWrapperSymbols = {
+  LoadTextureW: { args: [ptr, ptr, ptr, cstring], returns: FFIType.void },
   UnloadTextureW: { args: [i32], returns: FFIType.void },
   IsTextureValidW: { args: [i32, i32, i32], returns: bool },
   LoadRenderTextureW: { args: [ptr, ptr, ptr, ptr, i32, i32], returns: FFIType.void },
@@ -13,13 +18,16 @@ export const textureSymbols = {
   SetTextureWrapW: { args: [i32, i32], returns: FFIType.void },
   DrawTextureW: { args: [i32, i32, i32, i32, i32, i32], returns: FFIType.void },
   DrawTextureVW: { args: [i32, i32, i32, i32, i32, i32], returns: FFIType.void },
-  DrawTextureExW: { args: [i32, i32, i32, i32, i32, i32, i32, i32], returns: FFIType.void },
+  DrawTextureExW: {
+    args: [i32, i32, i32, i32, i32, f32, f32, i32],
+    returns: FFIType.void,
+  },
   DrawTextureRecW: {
     args: [i32, i32, i32, i32, i32, i32, i32, i32, i32, i32],
     returns: FFIType.void,
   },
   DrawTextureProW: {
-    args: [i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32],
+    args: [i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, f32, i32],
     returns: FFIType.void,
   },
   LoadTextureFromImageW: { args: [ptr, ptr, ptr, i32], returns: FFIType.void },
@@ -46,11 +54,9 @@ export const textureSymbols = {
       i32,
       i32,
       i32,
-      i32,
+      f32,
       i32,
     ],
     returns: FFIType.void,
   },
-  GetPixelColorW: { args: [ptr, i32], returns: i32 },
-  SetPixelColorW: { args: [ptr, i32, i32], returns: FFIType.void },
 } as const;

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

@@ -1,4 +1,4 @@
-#include "common.h"
+#include "../../c/common.h"
 
 void LoadTextureW(unsigned int* outId, int* outW, int* outH, const char* fileName) {
     Texture2D tex = LoadTexture(fileName);
@@ -60,12 +60,9 @@ void DrawTextureVW(unsigned int id, int w, int h, int posX, int posY, Color tint
     DrawTextureV(tex, (Vector2){posX, posY}, tint);
 }
 
-void DrawTextureExW(unsigned int id, int w, int h, int posX, int posY, int rotation, int scale, Color tint) {
-    float r, s;
-    memcpy(&r, &rotation, sizeof(float));
-    memcpy(&s, &scale, sizeof(float));
+void DrawTextureExW(unsigned int id, int w, int h, int posX, int posY, float rotation, float scale, Color tint) {
     Texture2D tex = { id, w, h, 1, 7 };
-    DrawTextureEx(tex, (Vector2){posX, posY}, r, s, tint);
+    DrawTextureEx(tex, (Vector2){posX, posY}, rotation, scale, tint);
 }
 
 void DrawTextureRecW(unsigned int id, int w, int h, int srcX, int srcY, int srcW, int srcH, int posX, int posY, Color tint) {
@@ -77,13 +74,11 @@ void DrawTextureRecW(unsigned int id, int w, int h, int srcX, int srcY, int srcW
 void DrawTextureProW(unsigned int id, int w, int h,
     int srcX, int srcY, int srcW, int srcH,
     int dstX, int dstY, int dstW, int dstH,
-    int originX, int originY, int rotation, Color tint) {
-    float r;
-    memcpy(&r, &rotation, sizeof(float));
+    int originX, int originY, float rotation, Color tint) {
     Texture2D tex = { id, w, h, 1, 7 };
     Rectangle src = { srcX, srcY, srcW, srcH };
     Rectangle dst = { dstX, dstY, dstW, dstH };
-    DrawTexturePro(tex, src, dst, (Vector2){originX, originY}, r, tint);
+    DrawTexturePro(tex, src, dst, (Vector2){originX, originY}, rotation, tint);
 }
 
 void LoadTextureFromImageW(unsigned int* outId, int* outW, int* outH, int imageId) {
@@ -119,21 +114,11 @@ void DrawTextureNPatchW(unsigned int id, int w, int h,
     int srcX, int srcY, int srcW, int srcH,
     int left, int top, int right, int bottom, int layout,
     int dstX, int dstY, int dstW, int dstH,
-    int originX, int originY, int rotation, Color tint) {
-    float r;
-    memcpy(&r, &rotation, sizeof(float));
+    int originX, int originY, float rotation, Color tint) {
     Texture2D tex = { id, w, h, 1, 7 };
     Rectangle src = { srcX, srcY, srcW, srcH };
     NPatchInfo npi = { src, left, top, right, bottom, layout };
     Rectangle dst = { dstX, dstY, dstW, dstH };
-    DrawTextureNPatch(tex, npi, dst, (Vector2){originX, originY}, r, tint);
+    DrawTextureNPatch(tex, npi, dst, (Vector2){originX, originY}, rotation, tint);
 }
 
-int GetPixelColorW(const void* srcPtr, int format) {
-    Color c = GetPixelColor((void*)srcPtr, format);
-    return *((int*)&c);
-}
-
-void SetPixelColorW(void* dstPtr, Color color, int format) {
-    SetPixelColor(dstPtr, color, format);
-}