@dayme/bunraylib 0.1.0

package/src/c/audio.c

@@ -0,0 +1,344 @@
+#include "common.h"
+
+void InitAudioDeviceW() {
+    InitAudioDevice();
+}
+
+void CloseAudioDeviceW() {
+    CloseAudioDevice();
+}
+
+bool IsAudioDeviceReadyW() {
+    return IsAudioDeviceReady();
+}
+
+void SetMasterVolumeW(int volume) {
+    float f;
+    memcpy(&f, &volume, sizeof(float));
+    SetMasterVolume(f);
+}
+
+int GetMasterVolumeW() {
+    float f = GetMasterVolume();
+    int i;
+    memcpy(&i, &f, sizeof(float));
+    return i;
+}
+
+int LoadWaveW(const char* fileName) {
+    int slot = waveAlloc();
+    if (slot < 0) return -1;
+    waveRegistry[slot] = LoadWave(fileName);
+    return slot;
+}
+
+int LoadWaveFromMemoryW(const char* fileType, const unsigned char* fileData, int dataSize) {
+    int slot = waveAlloc();
+    if (slot < 0) return -1;
+    waveRegistry[slot] = LoadWaveFromMemory(fileType, fileData, dataSize);
+    return slot;
+}
+
+bool IsWaveValidW(int id) {
+    if (id < 0 || id >= MAX_WAVES || !waveUsed[id]) return false;
+    return IsWaveValid(waveRegistry[id]);
+}
+
+void UnloadWaveW(int id) {
+    if (id < 0 || id >= MAX_WAVES || !waveUsed[id]) return;
+    UnloadWave(waveRegistry[id]);
+    waveUsed[id] = false;
+}
+
+bool ExportWaveW(int id, const char* fileName) {
+    if (id < 0 || id >= MAX_WAVES || !waveUsed[id]) return false;
+    return ExportWave(waveRegistry[id], fileName);
+}
+
+bool ExportWaveAsCodeW(int id, const char* fileName) {
+    if (id < 0 || id >= MAX_WAVES || !waveUsed[id]) return false;
+    return ExportWaveAsCode(waveRegistry[id], fileName);
+}
+
+int WaveCopyW(int id) {
+    if (id < 0 || id >= MAX_WAVES || !waveUsed[id]) return -1;
+    int slot = waveAlloc();
+    if (slot < 0) return -1;
+    waveRegistry[slot] = WaveCopy(waveRegistry[id]);
+    return slot;
+}
+
+void WaveCropW(int id, int initFrame, int finalFrame) {
+    if (id < 0 || id >= MAX_WAVES || !waveUsed[id]) return;
+    WaveCrop(&waveRegistry[id], initFrame, finalFrame);
+}
+
+void WaveFormatW(int id, int sampleRate, int sampleSize, int channels) {
+    if (id < 0 || id >= MAX_WAVES || !waveUsed[id]) return;
+    WaveFormat(&waveRegistry[id], sampleRate, sampleSize, channels);
+}
+
+int LoadSoundW(const char* fileName) {
+    int slot = soundAlloc();
+    if (slot < 0) return -1;
+    soundRegistry[slot] = LoadSound(fileName);
+    return slot;
+}
+
+int LoadSoundFromWaveW(int waveId) {
+    if (waveId < 0 || waveId >= MAX_WAVES || !waveUsed[waveId]) return -1;
+    int slot = soundAlloc();
+    if (slot < 0) return -1;
+    soundRegistry[slot] = LoadSoundFromWave(waveRegistry[waveId]);
+    return slot;
+}
+
+int LoadSoundAliasW(int sourceId) {
+    if (sourceId < 0 || sourceId >= MAX_SOUNDS || !soundUsed[sourceId]) return -1;
+    int slot = soundAlloc();
+    if (slot < 0) return -1;
+    soundRegistry[slot] = LoadSoundAlias(soundRegistry[sourceId]);
+    return slot;
+}
+
+bool IsSoundValidW(int id) {
+    if (id < 0 || id >= MAX_SOUNDS || !soundUsed[id]) return false;
+    return IsSoundValid(soundRegistry[id]);
+}
+
+void UnloadSoundW(int id) {
+    if (id < 0 || id >= MAX_SOUNDS || !soundUsed[id]) return;
+    UnloadSound(soundRegistry[id]);
+    soundUsed[id] = false;
+}
+
+void UnloadSoundAliasW(int id) {
+    if (id < 0 || id >= MAX_SOUNDS || !soundUsed[id]) return;
+    UnloadSoundAlias(soundRegistry[id]);
+    soundUsed[id] = false;
+}
+
+void PlaySoundW(int id) {
+    if (id < 0 || id >= MAX_SOUNDS || !soundUsed[id]) return;
+    PlaySound(soundRegistry[id]);
+}
+
+void StopSoundW(int id) {
+    if (id < 0 || id >= MAX_SOUNDS || !soundUsed[id]) return;
+    StopSound(soundRegistry[id]);
+}
+
+void PauseSoundW(int id) {
+    if (id < 0 || id >= MAX_SOUNDS || !soundUsed[id]) return;
+    PauseSound(soundRegistry[id]);
+}
+
+void ResumeSoundW(int id) {
+    if (id < 0 || id >= MAX_SOUNDS || !soundUsed[id]) return;
+    ResumeSound(soundRegistry[id]);
+}
+
+bool IsSoundPlayingW(int id) {
+    if (id < 0 || id >= MAX_SOUNDS || !soundUsed[id]) return false;
+    return IsSoundPlaying(soundRegistry[id]);
+}
+
+void SetSoundVolumeW(int id, int volume) {
+    if (id < 0 || id >= MAX_SOUNDS || !soundUsed[id]) return;
+    float f;
+    memcpy(&f, &volume, sizeof(float));
+    SetSoundVolume(soundRegistry[id], f);
+}
+
+void SetSoundPitchW(int id, int pitch) {
+    if (id < 0 || id >= MAX_SOUNDS || !soundUsed[id]) return;
+    float f;
+    memcpy(&f, &pitch, sizeof(float));
+    SetSoundPitch(soundRegistry[id], f);
+}
+
+void SetSoundPanW(int id, int pan) {
+    if (id < 0 || id >= MAX_SOUNDS || !soundUsed[id]) return;
+    float f;
+    memcpy(&f, &pan, sizeof(float));
+    SetSoundPan(soundRegistry[id], f);
+}
+
+int LoadMusicStreamW(const char* fileName) {
+    int slot = musicAlloc();
+    if (slot < 0) return -1;
+    musicRegistry[slot] = LoadMusicStream(fileName);
+    return slot;
+}
+
+int LoadMusicStreamFromMemoryW(const char* fileType, const unsigned char* data, int dataSize) {
+    int slot = musicAlloc();
+    if (slot < 0) return -1;
+    musicRegistry[slot] = LoadMusicStreamFromMemory(fileType, data, dataSize);
+    return slot;
+}
+
+bool IsMusicValidW(int id) {
+    if (id < 0 || id >= MAX_MUSIC || !musicUsed[id]) return false;
+    return IsMusicValid(musicRegistry[id]);
+}
+
+void UnloadMusicStreamW(int id) {
+    if (id < 0 || id >= MAX_MUSIC || !musicUsed[id]) return;
+    UnloadMusicStream(musicRegistry[id]);
+    musicUsed[id] = false;
+}
+
+void PlayMusicStreamW(int id) {
+    if (id < 0 || id >= MAX_MUSIC || !musicUsed[id]) return;
+    PlayMusicStream(musicRegistry[id]);
+}
+
+bool IsMusicStreamPlayingW(int id) {
+    if (id < 0 || id >= MAX_MUSIC || !musicUsed[id]) return false;
+    return IsMusicStreamPlaying(musicRegistry[id]);
+}
+
+void UpdateMusicStreamW(int id) {
+    if (id < 0 || id >= MAX_MUSIC || !musicUsed[id]) return;
+    UpdateMusicStream(musicRegistry[id]);
+}
+
+void StopMusicStreamW(int id) {
+    if (id < 0 || id >= MAX_MUSIC || !musicUsed[id]) return;
+    StopMusicStream(musicRegistry[id]);
+}
+
+void PauseMusicStreamW(int id) {
+    if (id < 0 || id >= MAX_MUSIC || !musicUsed[id]) return;
+    PauseMusicStream(musicRegistry[id]);
+}
+
+void ResumeMusicStreamW(int id) {
+    if (id < 0 || id >= MAX_MUSIC || !musicUsed[id]) return;
+    ResumeMusicStream(musicRegistry[id]);
+}
+
+void SeekMusicStreamW(int id, int position) {
+    if (id < 0 || id >= MAX_MUSIC || !musicUsed[id]) return;
+    float f;
+    memcpy(&f, &position, sizeof(float));
+    SeekMusicStream(musicRegistry[id], f);
+}
+
+void SetMusicVolumeW(int id, int volume) {
+    if (id < 0 || id >= MAX_MUSIC || !musicUsed[id]) return;
+    float f;
+    memcpy(&f, &volume, sizeof(float));
+    SetMusicVolume(musicRegistry[id], f);
+}
+
+void SetMusicPitchW(int id, int pitch) {
+    if (id < 0 || id >= MAX_MUSIC || !musicUsed[id]) return;
+    float f;
+    memcpy(&f, &pitch, sizeof(float));
+    SetMusicPitch(musicRegistry[id], f);
+}
+
+void SetMusicPanW(int id, int pan) {
+    if (id < 0 || id >= MAX_MUSIC || !musicUsed[id]) return;
+    float f;
+    memcpy(&f, &pan, sizeof(float));
+    SetMusicPan(musicRegistry[id], f);
+}
+
+int GetMusicTimeLengthW(int id) {
+    if (id < 0 || id >= MAX_MUSIC || !musicUsed[id]) return 0;
+    float f = GetMusicTimeLength(musicRegistry[id]);
+    int i;
+    memcpy(&i, &f, sizeof(float));
+    return i;
+}
+
+int GetMusicTimePlayedW(int id) {
+    if (id < 0 || id >= MAX_MUSIC || !musicUsed[id]) return 0;
+    float f = GetMusicTimePlayed(musicRegistry[id]);
+    int i;
+    memcpy(&i, &f, sizeof(float));
+    return i;
+}
+
+int LoadAudioStreamW(unsigned int sampleRate, unsigned int sampleSize, unsigned int channels) {
+    int slot = audioStreamAlloc();
+    if (slot < 0) return -1;
+    audioStreamRegistry[slot] = LoadAudioStream(sampleRate, sampleSize, channels);
+    return slot;
+}
+
+bool IsAudioStreamValidW(int id) {
+    if (id < 0 || id >= MAX_AUDIOSTREAMS || !audioStreamUsed[id]) return false;
+    return IsAudioStreamValid(audioStreamRegistry[id]);
+}
+
+void UnloadAudioStreamW(int id) {
+    if (id < 0 || id >= MAX_AUDIOSTREAMS || !audioStreamUsed[id]) return;
+    UnloadAudioStream(audioStreamRegistry[id]);
+    audioStreamUsed[id] = false;
+}
+
+bool IsAudioStreamProcessedW(int id) {
+    if (id < 0 || id >= MAX_AUDIOSTREAMS || !audioStreamUsed[id]) return false;
+    return IsAudioStreamProcessed(audioStreamRegistry[id]);
+}
+
+void PlayAudioStreamW(int id) {
+    if (id < 0 || id >= MAX_AUDIOSTREAMS || !audioStreamUsed[id]) return;
+    PlayAudioStream(audioStreamRegistry[id]);
+}
+
+void PauseAudioStreamW(int id) {
+    if (id < 0 || id >= MAX_AUDIOSTREAMS || !audioStreamUsed[id]) return;
+    PauseAudioStream(audioStreamRegistry[id]);
+}
+
+void ResumeAudioStreamW(int id) {
+    if (id < 0 || id >= MAX_AUDIOSTREAMS || !audioStreamUsed[id]) return;
+    ResumeAudioStream(audioStreamRegistry[id]);
+}
+
+bool IsAudioStreamPlayingW(int id) {
+    if (id < 0 || id >= MAX_AUDIOSTREAMS || !audioStreamUsed[id]) return false;
+    return IsAudioStreamPlaying(audioStreamRegistry[id]);
+}
+
+void StopAudioStreamW(int id) {
+    if (id < 0 || id >= MAX_AUDIOSTREAMS || !audioStreamUsed[id]) return;
+    StopAudioStream(audioStreamRegistry[id]);
+}
+
+void SetAudioStreamVolumeW(int id, int volume) {
+    if (id < 0 || id >= MAX_AUDIOSTREAMS || !audioStreamUsed[id]) return;
+    float f;
+    memcpy(&f, &volume, sizeof(float));
+    SetAudioStreamVolume(audioStreamRegistry[id], f);
+}
+
+void SetAudioStreamPitchW(int id, int pitch) {
+    if (id < 0 || id >= MAX_AUDIOSTREAMS || !audioStreamUsed[id]) return;
+    float f;
+    memcpy(&f, &pitch, sizeof(float));
+    SetAudioStreamPitch(audioStreamRegistry[id], f);
+}
+
+void SetAudioStreamPanW(int id, int pan) {
+    if (id < 0 || id >= MAX_AUDIOSTREAMS || !audioStreamUsed[id]) return;
+    float f;
+    memcpy(&f, &pan, sizeof(float));
+    SetAudioStreamPan(audioStreamRegistry[id], f);
+}
+
+void SetAudioStreamBufferSizeDefaultW(int size) {
+    SetAudioStreamBufferSizeDefault(size);
+}
+
+float* LoadWaveSamplesW(int waveId) {
+    if (waveId < 0 || waveId >= MAX_WAVES || !waveUsed[waveId]) return NULL;
+    return LoadWaveSamples(waveRegistry[waveId]);
+}
+
+void UnloadWaveSamplesW(float* samples) { UnloadWaveSamples(samples); }

package/src/c/camera.c

@@ -0,0 +1,161 @@
+#include "common.h"
+
+void BeginMode2DW(int offX, int offY, int tarX, int tarY, int rotation, int zoom) {
+    float r, z;
+    memcpy(&r, &rotation, sizeof(float));
+    memcpy(&z, &zoom, sizeof(float));
+    Camera2D cam = { {offX, offY}, {tarX, tarY}, r, z };
+    BeginMode2D(cam);
+}
+
+void EndMode2DW() {
+    EndMode2D();
+}
+
+void BeginMode3DW(int posX, int posY, int posZ, int tarX, int tarY, int tarZ, int upX, int upY, int upZ, int fovy, int projection) {
+    Camera3D cam = { {i2f(posX), i2f(posY), i2f(posZ)}, {i2f(tarX), i2f(tarY), i2f(tarZ)}, {i2f(upX), i2f(upY), i2f(upZ)}, i2f(fovy), projection };
+    BeginMode3D(cam);
+}
+
+void EndMode3DW() {
+    EndMode3D();
+}
+
+void UpdateCameraW(float* pos, float* tar, float* up, float* fovy, int* projection, int mode) {
+    Camera3D cam = {
+        {pos[0], pos[1], pos[2]},
+        {tar[0], tar[1], tar[2]},
+        {up[0], up[1], up[2]},
+        fovy[0],
+        projection[0]
+    };
+    UpdateCamera(&cam, mode);
+    pos[0] = cam.position.x; pos[1] = cam.position.y; pos[2] = cam.position.z;
+    tar[0] = cam.target.x;   tar[1] = cam.target.y;   tar[2] = cam.target.z;
+    up[0]  = cam.up.x;       up[1]  = cam.up.y;       up[2]  = cam.up.z;
+    fovy[0] = cam.fovy;
+    projection[0] = cam.projection;
+}
+
+void UpdateCameraProW(float* pos, float* tar, float* up, float* fovy, int* projection,
+                      float mx, float my, float mz, float rx, float ry, float rz, float zoom) {
+    Camera3D cam = {
+        {pos[0], pos[1], pos[2]},
+        {tar[0], tar[1], tar[2]},
+        {up[0], up[1], up[2]},
+        fovy[0],
+        projection[0]
+    };
+    UpdateCameraPro(&cam, (Vector3){mx, my, mz}, (Vector3){rx, ry, rz}, zoom);
+    pos[0] = cam.position.x; pos[1] = cam.position.y; pos[2] = cam.position.z;
+    tar[0] = cam.target.x;   tar[1] = cam.target.y;   tar[2] = cam.target.z;
+    up[0]  = cam.up.x;       up[1]  = cam.up.y;       up[2]  = cam.up.z;
+    fovy[0] = cam.fovy;
+    projection[0] = cam.projection;
+}
+
+void GetScreenToWorldRayW(float* outPos, float* outDir, int screenX, int screenY,
+    int camPosX, int camPosY, int camPosZ, int camTarX, int camTarY, int camTarZ,
+    int camUpX, int camUpY, int camUpZ, int camFovy, int camProj) {
+    Camera3D cam = {
+        {i2f(camPosX), i2f(camPosY), i2f(camPosZ)},
+        {i2f(camTarX), i2f(camTarY), i2f(camTarZ)},
+        {i2f(camUpX), i2f(camUpY), i2f(camUpZ)},
+        i2f(camFovy), camProj
+    };
+    Ray r = GetScreenToWorldRay((Vector2){screenX, screenY}, cam);
+    outPos[0] = r.position.x; outPos[1] = r.position.y; outPos[2] = r.position.z;
+    outDir[0] = r.direction.x; outDir[1] = r.direction.y; outDir[2] = r.direction.z;
+}
+
+void GetWorldToScreenW(float* out, int posX, int posY, int posZ,
+    int camPosX, int camPosY, int camPosZ, int camTarX, int camTarY, int camTarZ,
+    int camUpX, int camUpY, int camUpZ, int camFovy, int camProj) {
+    Camera3D cam = {
+        {i2f(camPosX), i2f(camPosY), i2f(camPosZ)},
+        {i2f(camTarX), i2f(camTarY), i2f(camTarZ)},
+        {i2f(camUpX), i2f(camUpY), i2f(camUpZ)},
+        i2f(camFovy), camProj
+    };
+    Vector2 v = GetWorldToScreen((Vector3){i2f(posX), i2f(posY), i2f(posZ)}, cam);
+    out[0] = v.x; out[1] = v.y;
+}
+
+void GetWorldToScreen2DW(float* out, int posX, int posY,
+    int offX, int offY, int tarX, int tarY, int rotation, int zoom) {
+    float r, z;
+    memcpy(&r, &rotation, sizeof(float));
+    memcpy(&z, &zoom, sizeof(float));
+    Camera2D cam = { {offX, offY}, {tarX, tarY}, r, z };
+    Vector2 v = GetWorldToScreen2D((Vector2){posX, posY}, cam);
+    out[0] = v.x; out[1] = v.y;
+}
+
+void GetScreenToWorld2DW(float* out, int posX, int posY,
+    int offX, int offY, int tarX, int tarY, int rotation, int zoom) {
+    float r, z;
+    memcpy(&r, &rotation, sizeof(float));
+    memcpy(&z, &zoom, sizeof(float));
+    Camera2D cam = { {offX, offY}, {tarX, tarY}, r, z };
+    Vector2 v = GetScreenToWorld2D((Vector2){posX, posY}, cam);
+    out[0] = v.x; out[1] = v.y;
+}
+
+void GetScreenToWorldRayExW(float* outPos, float* outDir,
+    int screenX, int screenY, int screenW, int screenH,
+    int camPosX, int camPosY, int camPosZ,
+    int camTarX, int camTarY, int camTarZ,
+    int camUpX, int camUpY, int camUpZ,
+    int camFovy, int camProj) {
+    Camera3D cam = {
+        {i2f(camPosX), i2f(camPosY), i2f(camPosZ)},
+        {i2f(camTarX), i2f(camTarY), i2f(camTarZ)},
+        {i2f(camUpX), i2f(camUpY), i2f(camUpZ)},
+        i2f(camFovy), camProj
+    };
+    Ray r = GetScreenToWorldRayEx((Vector2){screenX, screenY}, cam, screenW, screenH);
+    outPos[0] = r.position.x; outPos[1] = r.position.y; outPos[2] = r.position.z;
+    outDir[0] = r.direction.x; outDir[1] = r.direction.y; outDir[2] = r.direction.z;
+}
+
+void GetWorldToScreenExW(float* out,
+    int posX, int posY, int posZ,
+    int camPosX, int camPosY, int camPosZ,
+    int camTarX, int camTarY, int camTarZ,
+    int camUpX, int camUpY, int camUpZ,
+    int camFovy, int camProj,
+    int screenW, int screenH) {
+    Camera3D cam = {
+        {i2f(camPosX), i2f(camPosY), i2f(camPosZ)},
+        {i2f(camTarX), i2f(camTarY), i2f(camTarZ)},
+        {i2f(camUpX), i2f(camUpY), i2f(camUpZ)},
+        i2f(camFovy), camProj
+    };
+    Vector2 v = GetWorldToScreenEx((Vector3){i2f(posX), i2f(posY), i2f(posZ)}, cam, screenW, screenH);
+    out[0] = v.x; out[1] = v.y;
+}
+
+void GetCameraMatrixW(float* out,
+    int camPosX, int camPosY, int camPosZ,
+    int camTarX, int camTarY, int camTarZ,
+    int camUpX, int camUpY, int camUpZ,
+    int camFovy, int camProj) {
+    Camera3D cam = {
+        {i2f(camPosX), i2f(camPosY), i2f(camPosZ)},
+        {i2f(camTarX), i2f(camTarY), i2f(camTarZ)},
+        {i2f(camUpX), i2f(camUpY), i2f(camUpZ)},
+        i2f(camFovy), camProj
+    };
+    Matrix m = GetCameraMatrix(cam);
+    memcpy(out, &m, sizeof(Matrix));
+}
+
+void GetCameraMatrix2DW(float* out,
+    int offX, int offY, int tarX, int tarY, int rotation, int zoom) {
+    float r, z;
+    memcpy(&r, &rotation, sizeof(float));
+    memcpy(&z, &zoom, sizeof(float));
+    Camera2D cam = { {offX, offY}, {tarX, tarY}, r, z };
+    Matrix m = GetCameraMatrix2D(cam);
+    memcpy(out, &m, sizeof(Matrix));
+}

package/src/c/collision.c

@@ -0,0 +1,176 @@
+#include "common.h"
+
+bool CheckCollisionRecsW(int x1, int y1, int w1, int h1, int x2, int y2, int w2, int h2) {
+    Rectangle r1 = { x1, y1, w1, h1 };
+    Rectangle r2 = { x2, y2, w2, h2 };
+    return CheckCollisionRecs(r1, r2);
+}
+
+bool CheckCollisionCirclesW(int cx1, int cy1, int r1, int cx2, int cy2, int r2) {
+    return CheckCollisionCircles((Vector2){cx1, cy1}, r1, (Vector2){cx2, cy2}, r2);
+}
+
+bool CheckCollisionCircleRecW(int cx, int cy, int radius, int rx, int ry, int rw, int rh) {
+    return CheckCollisionCircleRec((Vector2){cx, cy}, radius, (Rectangle){rx, ry, rw, rh});
+}
+
+bool CheckCollisionCircleLineW(int cx, int cy, int radius, int p1x, int p1y, int p2x, int p2y) {
+    return CheckCollisionCircleLine((Vector2){cx, cy}, radius, (Vector2){p1x, p1y}, (Vector2){p2x, p2y});
+}
+
+bool CheckCollisionPointRecW(int px, int py, int rx, int ry, int rw, int rh) {
+    return CheckCollisionPointRec((Vector2){px, py}, (Rectangle){rx, ry, rw, rh});
+}
+
+bool CheckCollisionPointCircleW(int px, int py, int cx, int cy, int radius) {
+    return CheckCollisionPointCircle((Vector2){px, py}, (Vector2){cx, cy}, radius);
+}
+
+bool CheckCollisionPointTriangleW(int px, int py, int p1x, int p1y, int p2x, int p2y, int p3x, int p3y) {
+    return CheckCollisionPointTriangle((Vector2){px, py}, (Vector2){p1x, p1y}, (Vector2){p2x, p2y}, (Vector2){p3x, p3y});
+}
+
+bool CheckCollisionPointLineW(int px, int py, int p1x, int p1y, int p2x, int p2y, int threshold) {
+    return CheckCollisionPointLine((Vector2){px, py}, (Vector2){p1x, p1y}, (Vector2){p2x, p2y}, threshold);
+}
+
+bool CheckCollisionPointPolyW(int px, int py, const float* points, int pointCount) {
+    return CheckCollisionPointPoly((Vector2){px, py}, (const Vector2*)points, pointCount);
+}
+
+bool CheckCollisionLinesW(float* out, int s1x, int s1y, int e1x, int e1y, int s2x, int s2y, int e2x, int e2y) {
+    Vector2 cp;
+    bool result = CheckCollisionLines((Vector2){s1x, s1y}, (Vector2){e1x, e1y}, (Vector2){s2x, s2y}, (Vector2){e2x, e2y}, &cp);
+    out[0] = cp.x;
+    out[1] = cp.y;
+    return result;
+}
+
+void GetCollisionRecW(float* out, int x1, int y1, int w1, int h1, int x2, int y2, int w2, int h2) {
+    Rectangle r1 = { x1, y1, w1, h1 };
+    Rectangle r2 = { x2, y2, w2, h2 };
+    Rectangle result = GetCollisionRec(r1, r2);
+    out[0] = result.x;
+    out[1] = result.y;
+    out[2] = result.width;
+    out[3] = result.height;
+}
+
+bool CheckCollisionSpheresW(int cx1, int cy1, int cz1, int r1, int cx2, int cy2, int cz2, int r2) {
+    return CheckCollisionSpheres(
+        (Vector3){i2f(cx1), i2f(cy1), i2f(cz1)}, i2f(r1),
+        (Vector3){i2f(cx2), i2f(cy2), i2f(cz2)}, i2f(r2));
+}
+
+bool CheckCollisionBoxesW(
+    int minX1, int minY1, int minZ1, int maxX1, int maxY1, int maxZ1,
+    int minX2, int minY2, int minZ2, int maxX2, int maxY2, int maxZ2) {
+    BoundingBox bb1 = {
+        {i2f(minX1), i2f(minY1), i2f(minZ1)},
+        {i2f(maxX1), i2f(maxY1), i2f(maxZ1)}
+    };
+    BoundingBox bb2 = {
+        {i2f(minX2), i2f(minY2), i2f(minZ2)},
+        {i2f(maxX2), i2f(maxY2), i2f(maxZ2)}
+    };
+    return CheckCollisionBoxes(bb1, bb2);
+}
+
+bool CheckCollisionBoxSphereW(
+    int minX, int minY, int minZ, int maxX, int maxY, int maxZ,
+    int cx, int cy, int cz, int radius) {
+    BoundingBox bb = {
+        {i2f(minX), i2f(minY), i2f(minZ)},
+        {i2f(maxX), i2f(maxY), i2f(maxZ)}
+    };
+    return CheckCollisionBoxSphere(bb,
+        (Vector3){i2f(cx), i2f(cy), i2f(cz)}, i2f(radius));
+}
+
+void GetRayCollisionSphereW(bool* outHit, float* outDist, float* outPt, float* outNorm,
+    int rPx, int rPy, int rPz, int rDx, int rDy, int rDz,
+    int cx, int cy, int cz, int radius) {
+    Ray ray = {
+        {i2f(rPx), i2f(rPy), i2f(rPz)},
+        {i2f(rDx), i2f(rDy), i2f(rDz)}
+    };
+    RayCollision rc = GetRayCollisionSphere(ray,
+        (Vector3){i2f(cx), i2f(cy), i2f(cz)}, i2f(radius));
+    *outHit = rc.hit;
+    outDist[0] = rc.distance;
+    outPt[0] = rc.point.x; outPt[1] = rc.point.y; outPt[2] = rc.point.z;
+    outNorm[0] = rc.normal.x; outNorm[1] = rc.normal.y; outNorm[2] = rc.normal.z;
+}
+
+void GetRayCollisionBoxW(bool* outHit, float* outDist, float* outPt, float* outNorm,
+    int rPx, int rPy, int rPz, int rDx, int rDy, int rDz,
+    int minX, int minY, int minZ, int maxX, int maxY, int maxZ) {
+    Ray ray = {
+        {i2f(rPx), i2f(rPy), i2f(rPz)},
+        {i2f(rDx), i2f(rDy), i2f(rDz)}
+    };
+    BoundingBox bb = {
+        {i2f(minX), i2f(minY), i2f(minZ)},
+        {i2f(maxX), i2f(maxY), i2f(maxZ)}
+    };
+    RayCollision rc = GetRayCollisionBox(ray, bb);
+    *outHit = rc.hit;
+    outDist[0] = rc.distance;
+    outPt[0] = rc.point.x; outPt[1] = rc.point.y; outPt[2] = rc.point.z;
+    outNorm[0] = rc.normal.x; outNorm[1] = rc.normal.y; outNorm[2] = rc.normal.z;
+}
+
+void GetRayCollisionTriangleW(bool* outHit, float* outDist, float* outPt, float* outNorm,
+    int rPx, int rPy, int rPz, int rDx, int rDy, int rDz,
+    int p1x, int p1y, int p1z, int p2x, int p2y, int p2z, int p3x, int p3y, int p3z) {
+    Ray ray = {
+        {i2f(rPx), i2f(rPy), i2f(rPz)},
+        {i2f(rDx), i2f(rDy), i2f(rDz)}
+    };
+    RayCollision rc = GetRayCollisionTriangle(ray,
+        (Vector3){i2f(p1x), i2f(p1y), i2f(p1z)},
+        (Vector3){i2f(p2x), i2f(p2y), i2f(p2z)},
+        (Vector3){i2f(p3x), i2f(p3y), i2f(p3z)});
+    *outHit = rc.hit;
+    outDist[0] = rc.distance;
+    outPt[0] = rc.point.x; outPt[1] = rc.point.y; outPt[2] = rc.point.z;
+    outNorm[0] = rc.normal.x; outNorm[1] = rc.normal.y; outNorm[2] = rc.normal.z;
+}
+
+void GetRayCollisionQuadW(bool* outHit, float* outDist, float* outPt, float* outNorm,
+    int rPx, int rPy, int rPz, int rDx, int rDy, int rDz,
+    int p1x, int p1y, int p1z, int p2x, int p2y, int p2z,
+    int p3x, int p3y, int p3z, int p4x, int p4y, int p4z) {
+    Ray ray = {
+        {i2f(rPx), i2f(rPy), i2f(rPz)},
+        {i2f(rDx), i2f(rDy), i2f(rDz)}
+    };
+    RayCollision rc = GetRayCollisionQuad(ray,
+        (Vector3){i2f(p1x), i2f(p1y), i2f(p1z)},
+        (Vector3){i2f(p2x), i2f(p2y), i2f(p2z)},
+        (Vector3){i2f(p3x), i2f(p3y), i2f(p3z)},
+        (Vector3){i2f(p4x), i2f(p4y), i2f(p4z)});
+    *outHit = rc.hit;
+    outDist[0] = rc.distance;
+    outPt[0] = rc.point.x; outPt[1] = rc.point.y; outPt[2] = rc.point.z;
+    outNorm[0] = rc.normal.x; outNorm[1] = rc.normal.y; outNorm[2] = rc.normal.z;
+}
+
+void GetRayCollisionMeshW(bool* outHit, float* outDist, float* outPt, float* outNorm,
+    int rPx, int rPy, int rPz, int rDx, int rDy, int rDz,
+    int meshId,
+    int im0, int im4, int im8, int im12,
+    int im1, int im5, int im9, int im13,
+    int im2, int im6, int im10, int im14,
+    int im3, int im7, int im11, int im15) {
+    Ray ray = { { i2f(rPx), i2f(rPy), i2f(rPz) }, { i2f(rDx), i2f(rDy), i2f(rDz) } };
+    Matrix transform = { i2f(im0), i2f(im1), i2f(im2), i2f(im3), i2f(im4), i2f(im5), i2f(im6), i2f(im7), i2f(im8), i2f(im9), i2f(im10), i2f(im11), i2f(im12), i2f(im13), i2f(im14), i2f(im15) };
+    if (meshId < 0 || meshId >= MAX_MESHES || !meshUsed[meshId]) {
+        *outHit = false; *outDist = 0; return;
+    }
+    RayCollision rc = GetRayCollisionMesh(ray, meshRegistry[meshId], transform);
+    *outHit = rc.hit;
+    *outDist = rc.distance;
+    outPt[0] = rc.point.x; outPt[1] = rc.point.y; outPt[2] = rc.point.z;
+    outNorm[0] = rc.normal.x; outNorm[1] = rc.normal.y; outNorm[2] = rc.normal.z;
+}