@dayme/bunraylib 0.1.0

package/src/c/model.c

@@ -0,0 +1,243 @@
+#include "common.h"
+
+int LoadModelW(const char* fileName) {
+    int slot = modelAlloc();
+    if (slot < 0) return -1;
+    modelRegistry[slot] = LoadModel(fileName);
+    return slot;
+}
+
+void UnloadModelW(int id) {
+    if (id < 0 || id >= MAX_MODELS || !modelUsed[id]) return;
+    UnloadModel(modelRegistry[id]);
+    modelUsed[id] = false;
+}
+
+bool IsModelValidW(int id) {
+    if (id < 0 || id >= MAX_MODELS || !modelUsed[id]) return false;
+    return IsModelValid(modelRegistry[id]);
+}
+
+void GetModelBoundingBoxW(float* outMin, float* outMax, int id) {
+    BoundingBox bb = {0};
+    if (id >= 0 && id < MAX_MODELS && modelUsed[id]) {
+        bb = GetModelBoundingBox(modelRegistry[id]);
+    }
+    outMin[0] = bb.min.x; outMin[1] = bb.min.y; outMin[2] = bb.min.z;
+    outMax[0] = bb.max.x; outMax[1] = bb.max.y; outMax[2] = bb.max.z;
+}
+
+int LoadModelFromMeshW(int meshId) {
+    if (meshId < 0 || meshId >= MAX_MESHES || !meshUsed[meshId]) return -1;
+    int slot = modelAlloc();
+    if (slot < 0) return -1;
+    modelRegistry[slot] = LoadModelFromMesh(meshRegistry[meshId]);
+    return slot;
+}
+
+void UnloadMeshW(int id) {
+    if (id < 0 || id >= MAX_MESHES || !meshUsed[id]) return;
+    UnloadMesh(meshRegistry[id]);
+    meshUsed[id] = false;
+}
+
+void UploadMeshW(int id, bool dynamic) {
+    if (id < 0 || id >= MAX_MESHES || !meshUsed[id]) return;
+    UploadMesh(&meshRegistry[id], dynamic);
+}
+
+void GetMeshBoundingBoxW(float* outMin, float* outMax, int id) {
+    BoundingBox bb = {0};
+    if (id >= 0 && id < MAX_MESHES && meshUsed[id]) {
+        bb = GetMeshBoundingBox(meshRegistry[id]);
+    }
+    outMin[0] = bb.min.x; outMin[1] = bb.min.y; outMin[2] = bb.min.z;
+    outMax[0] = bb.max.x; outMax[1] = bb.max.y; outMax[2] = bb.max.z;
+}
+
+void GenMeshTangentsW(int id) {
+    if (id < 0 || id >= MAX_MESHES || !meshUsed[id]) return;
+    GenMeshTangents(&meshRegistry[id]);
+}
+
+bool ExportMeshW(int id, const char* fileName) {
+    if (id < 0 || id >= MAX_MESHES || !meshUsed[id]) return false;
+    return ExportMesh(meshRegistry[id], fileName);
+}
+
+bool ExportMeshAsCodeW(int id, const char* fileName) {
+    if (id < 0 || id >= MAX_MESHES || !meshUsed[id]) return false;
+    return ExportMeshAsCode(meshRegistry[id], fileName);
+}
+
+int GenMeshPolyW(int sides, int radius) {
+    int slot = meshAlloc();
+    if (slot < 0) return -1;
+    meshRegistry[slot] = GenMeshPoly(sides, i2f(radius));
+    return slot;
+}
+
+int GenMeshPlaneW(int width, int length, int resX, int resZ) {
+    int slot = meshAlloc();
+    if (slot < 0) return -1;
+    meshRegistry[slot] = GenMeshPlane(i2f(width), i2f(length), resX, resZ);
+    return slot;
+}
+
+int GenMeshCubeW(int width, int height, int length) {
+    int slot = meshAlloc();
+    if (slot < 0) return -1;
+    meshRegistry[slot] = GenMeshCube(i2f(width), i2f(height), i2f(length));
+    return slot;
+}
+
+int GenMeshSphereW(int radius, int rings, int slices) {
+    int slot = meshAlloc();
+    if (slot < 0) return -1;
+    meshRegistry[slot] = GenMeshSphere(i2f(radius), rings, slices);
+    return slot;
+}
+
+int GenMeshHemiSphereW(int radius, int rings, int slices) {
+    int slot = meshAlloc();
+    if (slot < 0) return -1;
+    meshRegistry[slot] = GenMeshHemiSphere(i2f(radius), rings, slices);
+    return slot;
+}
+
+int GenMeshCylinderW(int radius, int height, int slices) {
+    int slot = meshAlloc();
+    if (slot < 0) return -1;
+    meshRegistry[slot] = GenMeshCylinder(i2f(radius), i2f(height), slices);
+    return slot;
+}
+
+int GenMeshConeW(int radius, int height, int slices) {
+    int slot = meshAlloc();
+    if (slot < 0) return -1;
+    meshRegistry[slot] = GenMeshCone(i2f(radius), i2f(height), slices);
+    return slot;
+}
+
+int GenMeshTorusW(int radius, int size, int radSeg, int sides) {
+    int slot = meshAlloc();
+    if (slot < 0) return -1;
+    meshRegistry[slot] = GenMeshTorus(i2f(radius), i2f(size), radSeg, sides);
+    return slot;
+}
+
+int GenMeshKnotW(int radius, int size, int radSeg, int sides) {
+    int slot = meshAlloc();
+    if (slot < 0) return -1;
+    meshRegistry[slot] = GenMeshKnot(i2f(radius), i2f(size), radSeg, sides);
+    return slot;
+}
+
+int GenMeshHeightmapW(int imageId, int sizeX, int sizeY, int sizeZ) {
+    if (imageId < 0 || imageId >= MAX_IMAGES || !imageUsed[imageId]) return -1;
+    int slot = meshAlloc();
+    if (slot < 0) return -1;
+    meshRegistry[slot] = GenMeshHeightmap(imageRegistry[imageId],
+        (Vector3){i2f(sizeX), i2f(sizeY), i2f(sizeZ)});
+    return slot;
+}
+
+int GenMeshCubicmapW(int imageId, int sizeX, int sizeY, int sizeZ) {
+    if (imageId < 0 || imageId >= MAX_IMAGES || !imageUsed[imageId]) return -1;
+    int slot = meshAlloc();
+    if (slot < 0) return -1;
+    meshRegistry[slot] = GenMeshCubicmap(imageRegistry[imageId],
+        (Vector3){i2f(sizeX), i2f(sizeY), i2f(sizeZ)});
+    return slot;
+}
+
+void UpdateMeshBufferW(int meshId, int index, const void* data, int dataSize, int offset) {
+    if (meshId < 0 || meshId >= MAX_MESHES || !meshUsed[meshId]) return;
+    UpdateMeshBuffer(meshRegistry[meshId], index, data, dataSize, offset);
+}
+
+int LoadMaterialDefaultW() {
+    int slot = materialAlloc();
+    if (slot < 0) return -1;
+    materialRegistry[slot] = LoadMaterialDefault();
+    return slot;
+}
+
+bool IsMaterialValidW(int id) {
+    if (id < 0 || id >= MAX_MATERIALS || !materialUsed[id]) return false;
+    return IsMaterialValid(materialRegistry[id]);
+}
+
+void UnloadMaterialW(int id) {
+    if (id < 0 || id >= MAX_MATERIALS || !materialUsed[id]) return;
+    UnloadMaterial(materialRegistry[id]);
+    materialUsed[id] = false;
+}
+
+void SetMaterialTextureW(int id, int mapType, unsigned int texId, int texW, int texH) {
+    if (id < 0 || id >= MAX_MATERIALS || !materialUsed[id]) return;
+    Texture2D tex = { texId, texW, texH, 1, 7 };
+    SetMaterialTexture(&materialRegistry[id], mapType, tex);
+}
+
+void SetModelMeshMaterialW(int modelId, int meshId, int materialId) {
+    if (modelId < 0 || modelId >= MAX_MODELS || !modelUsed[modelId]) return;
+    if (materialId < 0 || materialId >= MAX_MATERIALS || !materialUsed[materialId]) return;
+    SetModelMeshMaterial(&modelRegistry[modelId], meshId, materialId);
+}
+
+void LoadModelAnimationsW(int* outSlotStart, int* outAnimCount, const char* fileName) {
+    int count = 0;
+    ModelAnimation* anims = LoadModelAnimations(fileName, &count);
+    int startSlot = -1;
+    int allocated = 0;
+    for (int i = 0; i < count; i++) {
+        int slot = animAlloc();
+        if (slot < 0) break;
+        if (startSlot < 0) startSlot = slot;
+        animRegistry[slot] = anims[i];
+        allocated++;
+    }
+    if (allocated < count && startSlot >= 0) {
+        for (int i = 0; i < allocated; i++) {
+            animUsed[startSlot + i] = false;
+        }
+        startSlot = -1;
+        allocated = 0;
+    }
+    *outSlotStart = startSlot;
+    *outAnimCount = allocated;
+    if (anims && count > 0) UnloadModelAnimations(anims, count);
+}
+
+void UpdateModelAnimationW(int modelId, int animId, int frame) {
+    if (modelId < 0 || modelId >= MAX_MODELS || !modelUsed[modelId]) return;
+    if (animId < 0 || animId >= MAX_ANIMATIONS || !animUsed[animId]) return;
+    UpdateModelAnimation(modelRegistry[modelId], animRegistry[animId], i2f(frame));
+}
+
+void UpdateModelAnimationExW(int modelId, int animAId, int frameA, int animBId, int frameB, int blend) {
+    if (modelId < 0 || modelId >= MAX_MODELS || !modelUsed[modelId]) return;
+    if (animAId < 0 || animAId >= MAX_ANIMATIONS || !animUsed[animAId]) return;
+    if (animBId < 0 || animBId >= MAX_ANIMATIONS || !animUsed[animBId]) return;
+    UpdateModelAnimationEx(
+        modelRegistry[modelId],
+        animRegistry[animAId], i2f(frameA),
+        animRegistry[animBId], i2f(frameB),
+        i2f(blend));
+}
+
+void UnloadModelAnimationsW(int startSlot, int count) {
+    for (int i = 0; i < count; i++) {
+        int id = startSlot + i;
+        if (id < 0 || id >= MAX_ANIMATIONS || !animUsed[id]) continue;
+        UnloadModelAnimations(&animRegistry[id], 1);
+        animUsed[id] = false;
+    }
+}
+
+bool IsModelAnimationValidW(int modelId, int animId) {
+    if (modelId < 0 || modelId >= MAX_MODELS || !modelUsed[modelId]) return false;
+    if (animId < 0 || animId >= MAX_ANIMATIONS || !animUsed[animId]) return false;
+    return IsModelAnimationValid(modelRegistry[modelId], animRegistry[animId]);
+}

package/src/c/registries.c

@@ -0,0 +1,111 @@
+#include "common.h"
+
+Model modelRegistry[MAX_MODELS] = {0};
+bool modelUsed[MAX_MODELS] = {0};
+
+int modelAlloc(void) {
+    for (int i = 0; i < MAX_MODELS; i++) {
+        if (!modelUsed[i]) { modelUsed[i] = true; return i; }
+    }
+    return -1;
+}
+
+Font fontRegistry[MAX_FONTS] = {0};
+bool fontUsed[MAX_FONTS] = {0};
+
+int fontAlloc(void) {
+    for (int i = 0; i < MAX_FONTS; i++) {
+        if (!fontUsed[i]) { fontUsed[i] = true; return i; }
+    }
+    return -1;
+}
+
+Image imageRegistry[MAX_IMAGES];
+bool imageUsed[MAX_IMAGES] = {0};
+
+int imageAlloc(void) {
+    for (int i = 0; i < MAX_IMAGES; i++) {
+        if (!imageUsed[i]) { imageUsed[i] = true; return i; }
+    }
+    return -1;
+}
+
+Mesh meshRegistry[MAX_MESHES];
+bool meshUsed[MAX_MESHES] = {0};
+
+int meshAlloc(void) {
+    for (int i = 0; i < MAX_MESHES; i++) {
+        if (!meshUsed[i]) { meshUsed[i] = true; return i; }
+    }
+    return -1;
+}
+
+Material materialRegistry[MAX_MATERIALS];
+bool materialUsed[MAX_MATERIALS] = {0};
+
+int materialAlloc(void) {
+    for (int i = 0; i < MAX_MATERIALS; i++) {
+        if (!materialUsed[i]) { materialUsed[i] = true; return i; }
+    }
+    return -1;
+}
+
+ModelAnimation animRegistry[MAX_ANIMATIONS];
+bool animUsed[MAX_ANIMATIONS] = {0};
+
+int animAlloc(void) {
+    for (int i = 0; i < MAX_ANIMATIONS; i++) {
+        if (!animUsed[i]) { animUsed[i] = true; return i; }
+    }
+    return -1;
+}
+
+Shader shaderRegistry[MAX_SHADERS];
+bool shaderUsed[MAX_SHADERS] = {0};
+
+int shaderAlloc(void) {
+    for (int i = 0; i < MAX_SHADERS; i++) {
+        if (!shaderUsed[i]) { shaderUsed[i] = true; return i; }
+    }
+    return -1;
+}
+
+Wave waveRegistry[MAX_WAVES] = {0};
+bool waveUsed[MAX_WAVES] = {0};
+
+int waveAlloc(void) {
+    for (int i = 0; i < MAX_WAVES; i++) {
+        if (!waveUsed[i]) { waveUsed[i] = true; return i; }
+    }
+    return -1;
+}
+
+Sound soundRegistry[MAX_SOUNDS] = {0};
+bool soundUsed[MAX_SOUNDS] = {0};
+
+int soundAlloc(void) {
+    for (int i = 0; i < MAX_SOUNDS; i++) {
+        if (!soundUsed[i]) { soundUsed[i] = true; return i; }
+    }
+    return -1;
+}
+
+Music musicRegistry[MAX_MUSIC] = {0};
+bool musicUsed[MAX_MUSIC] = {0};
+
+int musicAlloc(void) {
+    for (int i = 0; i < MAX_MUSIC; i++) {
+        if (!musicUsed[i]) { musicUsed[i] = true; return i; }
+    }
+    return -1;
+}
+
+AudioStream audioStreamRegistry[MAX_AUDIOSTREAMS] = {0};
+bool audioStreamUsed[MAX_AUDIOSTREAMS] = {0};
+
+int audioStreamAlloc(void) {
+    for (int i = 0; i < MAX_AUDIOSTREAMS; i++) {
+        if (!audioStreamUsed[i]) { audioStreamUsed[i] = true; return i; }
+    }
+    return -1;
+}

package/src/c/shader.c

@@ -0,0 +1,56 @@
+#include "common.h"
+
+int LoadShaderW(const char* vsFileName, const char* fsFileName) {
+    int slot = shaderAlloc();
+    if (slot < 0) return -1;
+    shaderRegistry[slot] = LoadShader(vsFileName, fsFileName);
+    return slot;
+}
+
+int LoadShaderFromMemoryW(const char* vsCode, const char* fsCode) {
+    int slot = shaderAlloc();
+    if (slot < 0) return -1;
+    shaderRegistry[slot] = LoadShaderFromMemory(vsCode, fsCode);
+    return slot;
+}
+
+bool IsShaderValidW(int id) {
+    if (id < 0 || id >= MAX_SHADERS || !shaderUsed[id]) return false;
+    return IsShaderValid(shaderRegistry[id]);
+}
+
+int GetShaderLocationW(int id, const char* uniformName) {
+    if (id < 0 || id >= MAX_SHADERS || !shaderUsed[id]) return -1;
+    return GetShaderLocation(shaderRegistry[id], uniformName);
+}
+
+int GetShaderLocationAttribW(int id, const char* attribName) {
+    if (id < 0 || id >= MAX_SHADERS || !shaderUsed[id]) return -1;
+    return GetShaderLocationAttrib(shaderRegistry[id], attribName);
+}
+
+void SetShaderValueMatrixW(int id, int locIndex, const float* mat) {
+    if (id < 0 || id >= MAX_SHADERS || !shaderUsed[id]) return;
+    Matrix m;
+    memcpy(&m, mat, sizeof(Matrix));
+    SetShaderValueMatrix(shaderRegistry[id], locIndex, m);
+}
+
+void SetShaderValueTextureW(int id, int locIndex, unsigned int texId, int texW, int texH) {
+    if (id < 0 || id >= MAX_SHADERS || !shaderUsed[id]) return;
+    Texture2D tex = { texId, texW, texH, 1, 7 };
+    SetShaderValueTexture(shaderRegistry[id], locIndex, tex);
+}
+
+void UnloadShaderW(int id) {
+    if (id < 0 || id >= MAX_SHADERS || !shaderUsed[id]) return;
+    UnloadShader(shaderRegistry[id]);
+    shaderUsed[id] = false;
+}
+
+void BeginShaderModeW(int id) {
+    if (id < 0 || id >= MAX_SHADERS || !shaderUsed[id]) return;
+    BeginShaderMode(shaderRegistry[id]);
+}
+
+void EndShaderModeW() { EndShaderMode(); }

package/src/c/shapes.c

@@ -0,0 +1,283 @@
+#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); }