@dayme/bunraylib 0.1.0 → 1.0.0

package/src/c/input.c

@@ -1,85 +0,0 @@
-#include "common.h"
-
-bool IsKeyPressedW(int key) { return IsKeyPressed(key); }
-bool IsKeyPressedRepeatW(int key) { return IsKeyPressedRepeat(key); }
-bool IsKeyDownW(int key) { return IsKeyDown(key); }
-bool IsKeyReleasedW(int key) { return IsKeyReleased(key); }
-bool IsKeyUpW(int key) { return IsKeyUp(key); }
-int GetKeyPressedW() { return GetKeyPressed(); }
-int GetCharPressedW() { return GetCharPressed(); }
-void SetExitKeyW(int key) { SetExitKey(key); }
-
-bool IsGamepadAvailableW(int gamepad) { return IsGamepadAvailable(gamepad); }
-const char* GetGamepadNameW(int gamepad) { return GetGamepadName(gamepad); }
-bool IsGamepadButtonPressedW(int gamepad, int button) { return IsGamepadButtonPressed(gamepad, button); }
-bool IsGamepadButtonDownW(int gamepad, int button) { return IsGamepadButtonDown(gamepad, button); }
-bool IsGamepadButtonReleasedW(int gamepad, int button) { return IsGamepadButtonReleased(gamepad, button); }
-bool IsGamepadButtonUpW(int gamepad, int button) { return IsGamepadButtonUp(gamepad, button); }
-int GetGamepadButtonPressedW() { return GetGamepadButtonPressed(); }
-int GetGamepadAxisCountW(int gamepad) { return GetGamepadAxisCount(gamepad); }
-float GetGamepadAxisMovementW(int gamepad, int axis) { return GetGamepadAxisMovement(gamepad, axis); }
-int SetGamepadMappingsW(const char* mappings) { return SetGamepadMappings(mappings); }
-
-void SetGamepadVibrationW(int gamepad, float leftMotor, float rightMotor, float duration) {
-    SetGamepadVibration(gamepad, leftMotor, rightMotor, duration);
-}
-
-bool IsMouseButtonPressedW(int button) { return IsMouseButtonPressed(button); }
-bool IsMouseButtonDownW(int button) { return IsMouseButtonDown(button); }
-bool IsMouseButtonReleasedW(int button) { return IsMouseButtonReleased(button); }
-bool IsMouseButtonUpW(int button) { return IsMouseButtonUp(button); }
-int GetMouseXW() { return GetMouseX(); }
-int GetMouseYW() { return GetMouseY(); }
-
-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 SetMousePositionW(int x, int y) { SetMousePosition(x, y); }
-void SetMouseOffsetW(int x, int y) { SetMouseOffset(x, y); }
-
-void SetMouseScaleW(float scaleX, float scaleY) { SetMouseScale(scaleX, scaleY); }
-float GetMouseWheelMoveW() { return GetMouseWheelMove(); }
-
-void GetMouseWheelMoveVW(float* out) {
-    Vector2 v = GetMouseWheelMoveV();
-    out[0] = v.x; out[1] = v.y;
-}
-
-void SetMouseCursorW(int cursor) { SetMouseCursor(cursor); }
-
-int GetTouchXW() { return GetTouchX(); }
-int GetTouchYW() { return GetTouchY(); }
-
-void GetTouchPositionW(float* out, int index) {
-    Vector2 v = GetTouchPosition(index);
-    out[0] = v.x; out[1] = v.y;
-}
-
-int GetTouchPointIdW(int index) { return GetTouchPointId(index); }
-int GetTouchPointCountW() { return GetTouchPointCount(); }
-
-void SetGesturesEnabledW(unsigned int flags) { SetGesturesEnabled(flags); }
-bool IsGestureDetectedW(unsigned int gesture) { return IsGestureDetected(gesture); }
-int GetGestureDetectedW() { return GetGestureDetected(); }
-float GetGestureHoldDurationW() { return GetGestureHoldDuration(); }
-
-void GetGestureDragVectorW(float* out) {
-    Vector2 v = GetGestureDragVector();
-    out[0] = v.x; out[1] = v.y;
-}
-
-float GetGestureDragAngleW() { return GetGestureDragAngle(); }
-
-void GetGesturePinchVectorW(float* out) {
-    Vector2 v = GetGesturePinchVector();
-    out[0] = v.x; out[1] = v.y;
-}
-
-float GetGesturePinchAngleW() { return GetGesturePinchAngle(); }

package/src/c/shapes.c

@@ -1,283 +0,0 @@
-#include <raylib.h>
-#include <string.h>
-
-void DrawRectangleW(int posX, int posY, int width, int height, Color color) {
-    DrawRectangle(posX, posY, width, height, color);
-}
-
-void DrawTextW(const char* text, int posX, int posY, int fontSize, Color color) {
-    DrawText(text, posX, posY, fontSize, color);
-}
-
-void DrawPixelW(int posX, int posY, Color color) {
-    DrawPixel(posX, posY, color);
-}
-
-void DrawLineW(int startPosX, int startPosY, int endPosX, int endPosY, Color color) {
-    DrawLine(startPosX, startPosY, endPosX, endPosY, color);
-}
-
-void DrawLineExW(int startX, int startY, int endX, int endY, int thick, Color color) {
-    DrawLineEx((Vector2){startX, startY}, (Vector2){endX, endY}, thick, color);
-}
-
-void DrawLineStripW(const float* points, int pointCount, Color color) {
-    DrawLineStrip((const Vector2*)points, pointCount, color);
-}
-
-void DrawLineBezierW(int startX, int startY, int endX, int endY, int thick, Color color) {
-    DrawLineBezier((Vector2){startX, startY}, (Vector2){endX, endY}, thick, color);
-}
-
-void DrawCircleW(int centerX, int centerY, int radius, Color color) {
-    DrawCircle(centerX, centerY, radius, color);
-}
-
-void DrawCircleSectorW(int centerX, int centerY, int radius, int startAngle, int endAngle, int segments, Color color) {
-    float sa, ea;
-    memcpy(&sa, &startAngle, sizeof(float));
-    memcpy(&ea, &endAngle, sizeof(float));
-    DrawCircleSector((Vector2){centerX, centerY}, radius, sa, ea, segments, color);
-}
-
-void DrawCircleSectorLinesW(int centerX, int centerY, int radius, int startAngle, int endAngle, int segments, Color color) {
-    float sa, ea;
-    memcpy(&sa, &startAngle, sizeof(float));
-    memcpy(&ea, &endAngle, sizeof(float));
-    DrawCircleSectorLines((Vector2){centerX, centerY}, radius, sa, ea, segments, color);
-}
-
-void DrawCircleGradientW(int centerX, int centerY, int radius, Color inner, Color outer) {
-    float r;
-    memcpy(&r, &radius, sizeof(float));
-    DrawCircleGradient((Vector2){centerX, centerY}, r, inner, outer);
-}
-
-void DrawCircleLinesW(int centerX, int centerY, int radius, Color color) {
-    DrawCircleLines(centerX, centerY, radius, color);
-}
-
-void DrawEllipseW(int centerX, int centerY, int radiusH, int radiusV, Color color) {
-    DrawEllipse(centerX, centerY, radiusH, radiusV, color);
-}
-
-void DrawEllipseLinesW(int centerX, int centerY, int radiusH, int radiusV, Color color) {
-    DrawEllipseLines(centerX, centerY, radiusH, radiusV, color);
-}
-
-void DrawRingW(int centerX, int centerY, int innerRadius, int outerRadius, int startAngle, int endAngle, int segments, Color color) {
-    float sa, ea;
-    memcpy(&sa, &startAngle, sizeof(float));
-    memcpy(&ea, &endAngle, sizeof(float));
-    DrawRing((Vector2){centerX, centerY}, innerRadius, outerRadius, sa, ea, segments, color);
-}
-
-void DrawRingLinesW(int centerX, int centerY, int innerRadius, int outerRadius, int startAngle, int endAngle, int segments, Color color) {
-    float sa, ea;
-    memcpy(&sa, &startAngle, sizeof(float));
-    memcpy(&ea, &endAngle, sizeof(float));
-    DrawRingLines((Vector2){centerX, centerY}, innerRadius, outerRadius, sa, ea, segments, color);
-}
-
-void DrawRectangleProW(int x, int y, int width, int height, int originX, int originY, int rotation, Color color) {
-    Rectangle rec = { x, y, width, height };
-    DrawRectanglePro(rec, (Vector2){originX, originY}, rotation, color);
-}
-
-void DrawRectangleGradientVW(int posX, int posY, int width, int height, Color top, Color bottom) {
-    DrawRectangleGradientV(posX, posY, width, height, top, bottom);
-}
-
-void DrawRectangleGradientHW(int posX, int posY, int width, int height, Color left, Color right) {
-    DrawRectangleGradientH(posX, posY, width, height, left, right);
-}
-
-void DrawRectangleGradientExW(int x, int y, int width, int height, Color topLeft, Color bottomLeft, Color topRight, Color bottomRight) {
-    Rectangle rec = { x, y, width, height };
-    DrawRectangleGradientEx(rec, topLeft, bottomLeft, topRight, bottomRight);
-}
-
-void DrawRectangleLinesW(int posX, int posY, int width, int height, Color color) {
-    DrawRectangleLines(posX, posY, width, height, color);
-}
-
-void DrawRectangleLinesExW(int x, int y, int width, int height, int lineThick, Color color) {
-    Rectangle rec = { x, y, width, height };
-    DrawRectangleLinesEx(rec, lineThick, color);
-}
-
-void DrawRectangleRoundedW(int x, int y, int width, int height, int roundness, int segments, Color color) {
-    Rectangle rec = { x, y, width, height };
-    DrawRectangleRounded(rec, roundness, segments, color);
-}
-
-void DrawRectangleRoundedLinesW(int x, int y, int width, int height, int roundness, int segments, Color color) {
-    Rectangle rec = { x, y, width, height };
-    DrawRectangleRoundedLines(rec, roundness, segments, color);
-}
-
-void DrawRectangleRoundedLinesExW(int x, int y, int width, int height, int roundness, int segments, int lineThick, Color color) {
-    Rectangle rec = { x, y, width, height };
-    DrawRectangleRoundedLinesEx(rec, roundness, segments, lineThick, color);
-}
-
-void DrawTriangleW(int x1, int y1, int x2, int y2, int x3, int y3, Color color) {
-    DrawTriangle((Vector2){x1, y1}, (Vector2){x2, y2}, (Vector2){x3, y3}, color);
-}
-
-void DrawTriangleLinesW(int x1, int y1, int x2, int y2, int x3, int y3, Color color) {
-    DrawTriangleLines((Vector2){x1, y1}, (Vector2){x2, y2}, (Vector2){x3, y3}, color);
-}
-
-void DrawTriangleFanW(const float* points, int pointCount, Color color) {
-    DrawTriangleFan((const Vector2*)points, pointCount, color);
-}
-
-void DrawTriangleStripW(const float* points, int pointCount, Color color) {
-    DrawTriangleStrip((const Vector2*)points, pointCount, color);
-}
-
-void DrawPolyW(int centerX, int centerY, int sides, int radius, int rotation, Color color) {
-    DrawPoly((Vector2){centerX, centerY}, sides, radius, rotation, color);
-}
-
-void DrawPolyLinesW(int centerX, int centerY, int sides, int radius, int rotation, Color color) {
-    DrawPolyLines((Vector2){centerX, centerY}, sides, radius, rotation, color);
-}
-
-void DrawPolyLinesExW(int centerX, int centerY, int sides, int radius, int rotation, int lineThick, Color color) {
-    DrawPolyLinesEx((Vector2){centerX, centerY}, sides, radius, rotation, lineThick, color);
-}
-
-void DrawSplineLinearW(const float* points, int pointCount, int thick, Color color) {
-    float t; memcpy(&t, &thick, sizeof(float));
-    DrawSplineLinear((const Vector2*)points, pointCount, t, color);
-}
-
-void DrawSplineBasisW(const float* points, int pointCount, int thick, Color color) {
-    float t; memcpy(&t, &thick, sizeof(float));
-    DrawSplineBasis((const Vector2*)points, pointCount, t, color);
-}
-
-void DrawSplineCatmullRomW(const float* points, int pointCount, int thick, Color color) {
-    float t; memcpy(&t, &thick, sizeof(float));
-    DrawSplineCatmullRom((const Vector2*)points, pointCount, t, color);
-}
-
-void DrawSplineBezierQuadraticW(const float* points, int pointCount, int thick, Color color) {
-    float t; memcpy(&t, &thick, sizeof(float));
-    DrawSplineBezierQuadratic((const Vector2*)points, pointCount, t, color);
-}
-
-void DrawSplineBezierCubicW(const float* points, int pointCount, int thick, Color color) {
-    float t; memcpy(&t, &thick, sizeof(float));
-    DrawSplineBezierCubic((const Vector2*)points, pointCount, t, color);
-}
-
-void DrawSplineSegmentLinearW(int p1x, int p1y, int p2x, int p2y, int thick, Color color) {
-    float t; memcpy(&t, &thick, sizeof(float));
-    DrawSplineSegmentLinear((Vector2){p1x, p1y}, (Vector2){p2x, p2y}, t, color);
-}
-
-void DrawSplineSegmentBasisW(int p1x, int p1y, int p2x, int p2y, int p3x, int p3y, int p4x, int p4y, int thick, Color color) {
-    float t; memcpy(&t, &thick, sizeof(float));
-    DrawSplineSegmentBasis((Vector2){p1x, p1y}, (Vector2){p2x, p2y}, (Vector2){p3x, p3y}, (Vector2){p4x, p4y}, t, color);
-}
-
-void DrawSplineSegmentCatmullRomW(int p1x, int p1y, int p2x, int p2y, int p3x, int p3y, int p4x, int p4y, int thick, Color color) {
-    float t; memcpy(&t, &thick, sizeof(float));
-    DrawSplineSegmentCatmullRom((Vector2){p1x, p1y}, (Vector2){p2x, p2y}, (Vector2){p3x, p3y}, (Vector2){p4x, p4y}, t, color);
-}
-
-void DrawSplineSegmentBezierQuadraticW(int p1x, int p1y, int c2x, int c2y, int p3x, int p3y, int thick, Color color) {
-    float t; memcpy(&t, &thick, sizeof(float));
-    DrawSplineSegmentBezierQuadratic((Vector2){p1x, p1y}, (Vector2){c2x, c2y}, (Vector2){p3x, p3y}, t, color);
-}
-
-void DrawSplineSegmentBezierCubicW(int p1x, int p1y, int c2x, int c2y, int c3x, int c3y, int p4x, int p4y, int thick, Color color) {
-    float t; memcpy(&t, &thick, sizeof(float));
-    DrawSplineSegmentBezierCubic((Vector2){p1x, p1y}, (Vector2){c2x, c2y}, (Vector2){c3x, c3y}, (Vector2){p4x, p4y}, t, color);
-}
-
-void GetSplinePointLinearW(float* out, int startPx, int startPy, int endPx, int endPy, int t) {
-    float tf; memcpy(&tf, &t, sizeof(float));
-    Vector2 result = GetSplinePointLinear((Vector2){startPx, startPy}, (Vector2){endPx, endPy}, tf);
-    out[0] = result.x;
-    out[1] = result.y;
-}
-
-void GetSplinePointBasisW(float* out, int p1x, int p1y, int p2x, int p2y, int p3x, int p3y, int p4x, int p4y, int t) {
-    float tf; memcpy(&tf, &t, sizeof(float));
-    Vector2 result = GetSplinePointBasis((Vector2){p1x, p1y}, (Vector2){p2x, p2y}, (Vector2){p3x, p3y}, (Vector2){p4x, p4y}, tf);
-    out[0] = result.x;
-    out[1] = result.y;
-}
-
-void GetSplinePointCatmullRomW(float* out, int p1x, int p1y, int p2x, int p2y, int p3x, int p3y, int p4x, int p4y, int t) {
-    float tf; memcpy(&tf, &t, sizeof(float));
-    Vector2 result = GetSplinePointCatmullRom((Vector2){p1x, p1y}, (Vector2){p2x, p2y}, (Vector2){p3x, p3y}, (Vector2){p4x, p4y}, tf);
-    out[0] = result.x;
-    out[1] = result.y;
-}
-
-void GetSplinePointBezierQuadW(float* out, int p1x, int p1y, int c2x, int c2y, int p3x, int p3y, int t) {
-    float tf; memcpy(&tf, &t, sizeof(float));
-    Vector2 result = GetSplinePointBezierQuad((Vector2){p1x, p1y}, (Vector2){c2x, c2y}, (Vector2){p3x, p3y}, tf);
-    out[0] = result.x;
-    out[1] = result.y;
-}
-
-void GetSplinePointBezierCubicW(float* out, int p1x, int p1y, int c2x, int c2y, int c3x, int c3y, int p4x, int p4y, int t) {
-    float tf; memcpy(&tf, &t, sizeof(float));
-    Vector2 result = GetSplinePointBezierCubic((Vector2){p1x, p1y}, (Vector2){c2x, c2y}, (Vector2){c3x, c3y}, (Vector2){p4x, p4y}, tf);
-    out[0] = result.x;
-    out[1] = result.y;
-}
-
-void DrawPixelVW(int x, int y, Color color) {
-    DrawPixelV((Vector2){x, y}, color);
-}
-
-void DrawLineVW(int startX, int startY, int endX, int endY, Color color) {
-    DrawLineV((Vector2){startX, startY}, (Vector2){endX, endY}, color);
-}
-
-void DrawCircleVW(int x, int y, int radius, Color color) {
-    float r;
-    memcpy(&r, &radius, sizeof(float));
-    DrawCircleV((Vector2){x, y}, r, color);
-}
-
-void DrawCircleLinesVW(int x, int y, int radius, Color color) {
-    float r;
-    memcpy(&r, &radius, sizeof(float));
-    DrawCircleLinesV((Vector2){x, y}, r, color);
-}
-
-void DrawRectangleVW(int posX, int posY, int sizeX, int sizeY, Color color) {
-    DrawRectangleV((Vector2){posX, posY}, (Vector2){sizeX, sizeY}, color);
-}
-
-void DrawRectangleRecW(int x, int y, int w, int h, Color color) {
-    DrawRectangleRec((Rectangle){x, y, w, h}, color);
-}
-
-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;
-}
-
-void DrawFPSW(int posX, int posY) { DrawFPS(posX, posY); }

package/src/c/window.c

@@ -1,150 +0,0 @@
-#include "common.h"
-
-void InitWindowW(int width, int height, const char* title) {
-    InitWindow(width, height, title);
-}
-
-void CloseWindowW() {
-    CloseWindow();
-}
-
-bool WindowShouldCloseW() {
-    return WindowShouldClose();
-}
-
-void BeginDrawingW() {
-    BeginDrawing();
-}
-
-void EndDrawingW() {
-    EndDrawing();
-}
-
-void ClearBackgroundW(Color color) {
-    ClearBackground(color);
-}
-
-void SetTargetFPSW(int fps) {
-    SetTargetFPS(fps);
-}
-
-float GetFrameTimeW() {
-    return GetFrameTime();
-}
-
-bool IsWindowReadyW() { return IsWindowReady(); }
-bool IsWindowFullscreenW() { return IsWindowFullscreen(); }
-bool IsWindowHiddenW() { return IsWindowHidden(); }
-bool IsWindowMinimizedW() { return IsWindowMinimized(); }
-bool IsWindowMaximizedW() { return IsWindowMaximized(); }
-bool IsWindowFocusedW() { return IsWindowFocused(); }
-bool IsWindowResizedW() { return IsWindowResized(); }
-bool IsWindowStateW(unsigned int flag) { return IsWindowState(flag); }
-
-void SetWindowStateW(unsigned int flags) { SetWindowState(flags); }
-void ClearWindowStateW(unsigned int flags) { ClearWindowState(flags); }
-void ToggleFullscreenW() { ToggleFullscreen(); }
-void ToggleBorderlessWindowedW() { ToggleBorderlessWindowed(); }
-void MaximizeWindowW() { MaximizeWindow(); }
-void MinimizeWindowW() { MinimizeWindow(); }
-void RestoreWindowW() { RestoreWindow(); }
-
-void SetWindowTitleW(const char* title) { SetWindowTitle(title); }
-void SetWindowPositionW(int x, int y) { SetWindowPosition(x, y); }
-void SetWindowMonitorW(int monitor) { SetWindowMonitor(monitor); }
-void SetWindowMinSizeW(int w, int h) { SetWindowMinSize(w, h); }
-void SetWindowMaxSizeW(int w, int h) { SetWindowMaxSize(w, h); }
-void SetWindowSizeW(int w, int h) { SetWindowSize(w, h); }
-void SetWindowOpacityW(float opacity) { SetWindowOpacity(opacity); }
-void SetWindowFocusedW() { SetWindowFocused(); }
-
-int GetScreenWidthW() { return GetScreenWidth(); }
-int GetScreenHeightW() { return GetScreenHeight(); }
-int GetRenderWidthW() { return GetRenderWidth(); }
-int GetRenderHeightW() { return GetRenderHeight(); }
-
-int GetMonitorCountW() { return GetMonitorCount(); }
-int GetCurrentMonitorW() { return GetCurrentMonitor(); }
-
-void GetMonitorPositionW(float* out, int monitor) {
-    Vector2 v = GetMonitorPosition(monitor);
-    out[0] = v.x; out[1] = v.y;
-}
-
-int GetMonitorWidthW(int monitor) { return GetMonitorWidth(monitor); }
-int GetMonitorHeightW(int monitor) { return GetMonitorHeight(monitor); }
-int GetMonitorPhysicalWidthW(int monitor) { return GetMonitorPhysicalWidth(monitor); }
-int GetMonitorPhysicalHeightW(int monitor) { return GetMonitorPhysicalHeight(monitor); }
-int GetMonitorRefreshRateW(int monitor) { return GetMonitorRefreshRate(monitor); }
-
-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;
-}
-
-const char* GetMonitorNameW(int monitor) { return GetMonitorName(monitor); }
-
-void SetClipboardTextW(const char* text) { SetClipboardText(text); }
-const char* GetClipboardTextW() { return GetClipboardText(); }
-
-void EnableEventWaitingW() { EnableEventWaiting(); }
-void DisableEventWaitingW() { DisableEventWaiting(); }
-
-void ShowCursorW() { ShowCursor(); }
-void HideCursorW() { HideCursor(); }
-bool IsCursorHiddenW() { return IsCursorHidden(); }
-void EnableCursorW() { EnableCursor(); }
-void DisableCursorW() { DisableCursor(); }
-bool IsCursorOnScreenW() { return IsCursorOnScreen(); }
-
-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 EndTextureModeW() { EndTextureMode(); }
-
-void BeginBlendModeW(int mode) { BeginBlendMode(mode); }
-void EndBlendModeW() { EndBlendMode(); }
-
-void BeginScissorModeW(int x, int y, int w, int h) { BeginScissorMode(x, y, w, h); }
-void EndScissorModeW() { EndScissorMode(); }
-
-double GetTimeW() { return GetTime(); }
-int GetFPSW() { return GetFPS(); }
-void SwapScreenBufferW() { SwapScreenBuffer(); }
-void PollInputEventsW() { PollInputEvents(); }
-void WaitTimeW(double seconds) { WaitTime(seconds); }
-
-void SetRandomSeedW(unsigned int seed) { SetRandomSeed(seed); }
-int GetRandomValueW(int min, int max) { return GetRandomValue(min, max); }
-
-void TakeScreenshotW(const char* fileName) { TakeScreenshot(fileName); }
-void SetConfigFlagsW(unsigned int flags) { SetConfigFlags(flags); }
-void OpenURLW(const char* url) { OpenURL(url); }
-
-void TraceLogW(int logLevel, const char* text) {
-    TraceLog(logLevel, "%s", text);
-}
-
-void SetTraceLogLevelW(int logLevel) {
-    SetTraceLogLevel(logLevel);
-}
-
-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/audio.ts

@@ -1,64 +0,0 @@
-import { FFIType } from "bun:ffi";
-const { i32, cstring, bool, ptr } = FFIType;
-
-export const audioSymbols = {
-  InitAudioDeviceW: { args: [], returns: FFIType.void },
-  CloseAudioDeviceW: { args: [], returns: FFIType.void },
-  IsAudioDeviceReadyW: { args: [], returns: bool },
-  SetMasterVolumeW: { args: [i32], returns: FFIType.void },
-  GetMasterVolumeW: { args: [], returns: i32 },
-  LoadWaveW: { args: [cstring], returns: i32 },
-  LoadWaveFromMemoryW: { args: [cstring, ptr, i32], returns: i32 },
-  IsWaveValidW: { args: [i32], returns: bool },
-  UnloadWaveW: { args: [i32], returns: FFIType.void },
-  ExportWaveW: { args: [i32, cstring], returns: bool },
-  ExportWaveAsCodeW: { args: [i32, cstring], returns: bool },
-  WaveCopyW: { args: [i32], returns: i32 },
-  WaveCropW: { args: [i32, i32, i32], returns: FFIType.void },
-  WaveFormatW: { args: [i32, i32, i32, i32], returns: FFIType.void },
-  LoadSoundW: { args: [cstring], returns: i32 },
-  LoadSoundFromWaveW: { args: [i32], returns: i32 },
-  LoadSoundAliasW: { args: [i32], returns: i32 },
-  IsSoundValidW: { args: [i32], returns: bool },
-  UnloadSoundW: { args: [i32], returns: FFIType.void },
-  UnloadSoundAliasW: { args: [i32], returns: FFIType.void },
-  PlaySoundW: { args: [i32], returns: FFIType.void },
-  StopSoundW: { args: [i32], returns: FFIType.void },
-  PauseSoundW: { args: [i32], returns: FFIType.void },
-  ResumeSoundW: { args: [i32], returns: FFIType.void },
-  IsSoundPlayingW: { args: [i32], returns: bool },
-  SetSoundVolumeW: { args: [i32, i32], returns: FFIType.void },
-  SetSoundPitchW: { args: [i32, i32], returns: FFIType.void },
-  SetSoundPanW: { args: [i32, i32], returns: FFIType.void },
-  LoadMusicStreamW: { args: [cstring], returns: i32 },
-  LoadMusicStreamFromMemoryW: { args: [cstring, ptr, i32], returns: i32 },
-  IsMusicValidW: { args: [i32], returns: bool },
-  UnloadMusicStreamW: { args: [i32], returns: FFIType.void },
-  PlayMusicStreamW: { args: [i32], returns: FFIType.void },
-  IsMusicStreamPlayingW: { args: [i32], returns: bool },
-  UpdateMusicStreamW: { args: [i32], returns: FFIType.void },
-  StopMusicStreamW: { args: [i32], returns: FFIType.void },
-  PauseMusicStreamW: { args: [i32], returns: FFIType.void },
-  ResumeMusicStreamW: { args: [i32], returns: FFIType.void },
-  SeekMusicStreamW: { args: [i32, i32], returns: FFIType.void },
-  SetMusicVolumeW: { args: [i32, i32], returns: FFIType.void },
-  SetMusicPitchW: { args: [i32, i32], returns: FFIType.void },
-  SetMusicPanW: { args: [i32, i32], returns: FFIType.void },
-  GetMusicTimeLengthW: { args: [i32], returns: i32 },
-  GetMusicTimePlayedW: { args: [i32], returns: i32 },
-  LoadAudioStreamW: { args: [i32, i32, i32], returns: i32 },
-  IsAudioStreamValidW: { args: [i32], returns: bool },
-  UnloadAudioStreamW: { args: [i32], returns: FFIType.void },
-  IsAudioStreamProcessedW: { args: [i32], returns: bool },
-  PlayAudioStreamW: { args: [i32], returns: FFIType.void },
-  PauseAudioStreamW: { args: [i32], returns: FFIType.void },
-  ResumeAudioStreamW: { args: [i32], returns: FFIType.void },
-  IsAudioStreamPlayingW: { args: [i32], returns: bool },
-  StopAudioStreamW: { args: [i32], returns: FFIType.void },
-  SetAudioStreamVolumeW: { args: [i32, i32], returns: FFIType.void },
-  SetAudioStreamPitchW: { args: [i32, i32], returns: FFIType.void },
-  SetAudioStreamPanW: { args: [i32, i32], returns: FFIType.void },
-  SetAudioStreamBufferSizeDefaultW: { args: [i32], returns: FFIType.void },
-  LoadWaveSamplesW: { args: [i32], returns: ptr },
-  UnloadWaveSamplesW: { args: [ptr], returns: FFIType.void },
-} as const;

package/src/symbols/camera.ts

@@ -1,46 +0,0 @@
-import { FFIType } from "bun:ffi";
-const { i32, ptr, f32 } = FFIType;
-
-export const cameraSymbols = {
-  BeginMode2DW: { args: [i32, i32, i32, i32, i32, i32], returns: FFIType.void },
-  EndMode2DW: { args: [], returns: FFIType.void },
-  BeginMode3DW: {
-    args: [i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32],
-    returns: FFIType.void,
-  },
-  EndMode3DW: { args: [], returns: FFIType.void },
-  UpdateCameraW: { args: [ptr, ptr, ptr, ptr, ptr, i32], returns: FFIType.void },
-  UpdateCameraProW: {
-    args: [ptr, ptr, ptr, ptr, ptr, f32, f32, f32, f32, f32, f32, f32],
-    returns: FFIType.void,
-  },
-  GetScreenToWorldRayW: {
-    args: [ptr, ptr, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32],
-    returns: FFIType.void,
-  },
-  GetWorldToScreenW: {
-    args: [ptr, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32],
-    returns: FFIType.void,
-  },
-  GetWorldToScreen2DW: {
-    args: [ptr, i32, i32, i32, i32, i32, i32, i32, i32],
-    returns: FFIType.void,
-  },
-  GetScreenToWorld2DW: {
-    args: [ptr, i32, i32, i32, i32, i32, i32, i32, i32],
-    returns: FFIType.void,
-  },
-  GetScreenToWorldRayExW: {
-    args: [ptr, ptr, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32],
-    returns: FFIType.void,
-  },
-  GetWorldToScreenExW: {
-    args: [ptr, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32],
-    returns: FFIType.void,
-  },
-  GetCameraMatrixW: {
-    args: [ptr, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32],
-    returns: FFIType.void,
-  },
-  GetCameraMatrix2DW: { args: [ptr, i32, i32, i32, i32, i32, i32], returns: FFIType.void },
-} as const;