@dayme/bunraylib 0.1.0

package/src/c/color.c

@@ -0,0 +1,100 @@
+#include "common.h"
+
+int ColorToIntW(Color color) { return ColorToInt(color); }
+
+void ColorNormalizeW(float* out, Color color) {
+    Vector4 v = ColorNormalize(color);
+    out[0] = v.x; out[1] = v.y; out[2] = v.z; out[3] = v.w;
+}
+
+int ColorFromNormalizedW(int x, int y, int z, int w) {
+    float fx, fy, fz, fw;
+    memcpy(&fx, &x, sizeof(float));
+    memcpy(&fy, &y, sizeof(float));
+    memcpy(&fz, &z, sizeof(float));
+    memcpy(&fw, &w, sizeof(float));
+    Color c = ColorFromNormalized((Vector4){fx, fy, fz, fw});
+    return *((int*)&c);
+}
+
+void ColorToHSWW(float* out, Color color) {
+    Vector3 v = ColorToHSV(color);
+    out[0] = v.x; out[1] = v.y; out[2] = v.z;
+}
+
+int ColorFromHSWW(int hue, int saturation, int value) {
+    float h, s, v;
+    memcpy(&h, &hue, sizeof(float));
+    memcpy(&s, &saturation, sizeof(float));
+    memcpy(&v, &value, sizeof(float));
+    Color c = ColorFromHSV(h, s, v);
+    return *((int*)&c);
+}
+
+int ColorTintW(Color color, Color tint) {
+    Color c = ColorTint(color, tint);
+    return *((int*)&c);
+}
+
+int ColorBrightnessW(Color color, int factor) {
+    float f;
+    memcpy(&f, &factor, sizeof(float));
+    Color c = ColorBrightness(color, f);
+    return *((int*)&c);
+}
+
+int ColorContrastW(Color color, int contrast) {
+    float c_val;
+    memcpy(&c_val, &contrast, sizeof(float));
+    Color c = ColorContrast(color, c_val);
+    return *((int*)&c);
+}
+
+int ColorAlphaW(Color color, int alpha) {
+    float a;
+    memcpy(&a, &alpha, sizeof(float));
+    Color c = ColorAlpha(color, a);
+    return *((int*)&c);
+}
+
+int ColorAlphaBlendW(Color dst, Color src, Color tint) {
+    Color c = ColorAlphaBlend(dst, src, tint);
+    return *((int*)&c);
+}
+
+int ColorLerpW(Color color1, Color color2, int factor) {
+    float f;
+    memcpy(&f, &factor, sizeof(float));
+    Color c = ColorLerp(color1, color2, f);
+    return *((int*)&c);
+}
+
+int GetColorW(unsigned int hexValue) {
+    Color c = GetColor(hexValue);
+    return *((int*)&c);
+}
+
+int FadeW(Color color, int alpha) {
+    float a;
+    memcpy(&a, &alpha, sizeof(float));
+    Color c = Fade(color, a);
+    return *((int*)&c);
+}
+
+bool ColorIsEqualW(Color col1, Color col2) { return ColorIsEqual(col1, col2); }
+
+int GetPixelDataSizeW(int width, int height, int format) { return GetPixelDataSize(width, height, format); }
+
+void ColorToHSVW(float* out, Color color) {
+    Vector3 v = ColorToHSV(color);
+    out[0] = v.x; out[1] = v.y; out[2] = v.z;
+}
+
+int ColorFromHSVW(int hue, int saturation, int value) {
+    float h, s, v;
+    memcpy(&h, &hue, sizeof(float));
+    memcpy(&s, &saturation, sizeof(float));
+    memcpy(&v, &value, sizeof(float));
+    Color c = ColorFromHSV(h, s, v);
+    return *((int*)&c);
+}

package/src/c/common.h

@@ -0,0 +1,67 @@
+#ifndef COMMON_H
+#define COMMON_H
+
+#include <string.h>
+#include <raylib.h>
+
+static inline float i2f(int i) { float f; memcpy(&f, &i, sizeof(float)); return f; }
+
+#ifndef CONFIG_H
+#define MAX_MODELS 64
+#define MAX_FONTS 32
+#define MAX_IMAGES 128
+#define MAX_MESHES 64
+#define MAX_MATERIALS 32
+#define MAX_ANIMATIONS 32
+#define MAX_SHADERS 32
+#define MAX_WAVES 32
+#define MAX_SOUNDS 32
+#define MAX_MUSIC 16
+#define MAX_AUDIOSTREAMS 16
+#endif
+
+extern Model modelRegistry[MAX_MODELS];
+extern bool modelUsed[MAX_MODELS];
+int modelAlloc(void);
+
+extern Font fontRegistry[MAX_FONTS];
+extern bool fontUsed[MAX_FONTS];
+int fontAlloc(void);
+
+extern Image imageRegistry[MAX_IMAGES];
+extern bool imageUsed[MAX_IMAGES];
+int imageAlloc(void);
+
+extern Mesh meshRegistry[MAX_MESHES];
+extern bool meshUsed[MAX_MESHES];
+int meshAlloc(void);
+
+extern Material materialRegistry[MAX_MATERIALS];
+extern bool materialUsed[MAX_MATERIALS];
+int materialAlloc(void);
+
+extern ModelAnimation animRegistry[MAX_ANIMATIONS];
+extern bool animUsed[MAX_ANIMATIONS];
+int animAlloc(void);
+
+extern Shader shaderRegistry[MAX_SHADERS];
+extern bool shaderUsed[MAX_SHADERS];
+int shaderAlloc(void);
+
+extern Wave waveRegistry[MAX_WAVES];
+extern bool waveUsed[MAX_WAVES];
+int waveAlloc(void);
+
+extern Sound soundRegistry[MAX_SOUNDS];
+extern bool soundUsed[MAX_SOUNDS];
+int soundAlloc(void);
+
+extern Music musicRegistry[MAX_MUSIC];
+extern bool musicUsed[MAX_MUSIC];
+int musicAlloc(void);
+
+extern AudioStream audioStreamRegistry[MAX_AUDIOSTREAMS];
+extern bool audioStreamUsed[MAX_AUDIOSTREAMS];
+int audioStreamAlloc(void);
+
+#endif

package/src/c/draw3d.c

@@ -0,0 +1,222 @@
+#include "common.h"
+
+void DrawLine3DW(int sx, int sy, int sz, int ex, int ey, int ez, Color color) {
+    DrawLine3D((Vector3){i2f(sx), i2f(sy), i2f(sz)}, (Vector3){i2f(ex), i2f(ey), i2f(ez)}, color);
+}
+
+void DrawPoint3DW(int px, int py, int pz, Color color) {
+    DrawPoint3D((Vector3){i2f(px), i2f(py), i2f(pz)}, color);
+}
+
+void DrawCircle3DW(int cx, int cy, int cz, int radius, int rax, int ray_, int raz, int angle, Color color) {
+    DrawCircle3D((Vector3){i2f(cx), i2f(cy), i2f(cz)}, i2f(radius), (Vector3){i2f(rax), i2f(ray_), i2f(raz)}, i2f(angle), color);
+}
+
+void DrawTriangle3DW(int v1x, int v1y, int v1z, int v2x, int v2y, int v2z, int v3x, int v3y, int v3z, Color color) {
+    DrawTriangle3D(
+        (Vector3){i2f(v1x), i2f(v1y), i2f(v1z)},
+        (Vector3){i2f(v2x), i2f(v2y), i2f(v2z)},
+        (Vector3){i2f(v3x), i2f(v3y), i2f(v3z)},
+        color
+    );
+}
+
+void DrawTriangleStrip3DW(const float* points, int pointCount, Color color) {
+    DrawTriangleStrip3D((const Vector3*)points, pointCount, color);
+}
+
+void DrawCubeW(int px, int py, int pz, int w, int h, int l, Color color) {
+    DrawCube((Vector3){i2f(px), i2f(py), i2f(pz)}, i2f(w), i2f(h), i2f(l), color);
+}
+
+void DrawCubeVW(int px, int py, int pz, int sx, int sy, int sz, Color color) {
+    DrawCubeV((Vector3){i2f(px), i2f(py), i2f(pz)}, (Vector3){i2f(sx), i2f(sy), i2f(sz)}, color);
+}
+
+void DrawCubeWiresW(int px, int py, int pz, int w, int h, int l, Color color) {
+    DrawCubeWires((Vector3){i2f(px), i2f(py), i2f(pz)}, i2f(w), i2f(h), i2f(l), color);
+}
+
+void DrawCubeWiresVW(int px, int py, int pz, int sx, int sy, int sz, Color color) {
+    DrawCubeWiresV((Vector3){i2f(px), i2f(py), i2f(pz)}, (Vector3){i2f(sx), i2f(sy), i2f(sz)}, color);
+}
+
+void DrawSphereW(int cx, int cy, int cz, int radius, Color color) {
+    DrawSphere((Vector3){i2f(cx), i2f(cy), i2f(cz)}, i2f(radius), color);
+}
+
+void DrawSphereExW(int cx, int cy, int cz, int radius, int rings, int slices, Color color) {
+    DrawSphereEx((Vector3){i2f(cx), i2f(cy), i2f(cz)}, i2f(radius), rings, slices, color);
+}
+
+void DrawSphereWiresW(int cx, int cy, int cz, int radius, int rings, int slices, Color color) {
+    DrawSphereWires((Vector3){i2f(cx), i2f(cy), i2f(cz)}, i2f(radius), rings, slices, color);
+}
+
+void DrawCylinderW(int px, int py, int pz, int rt, int rb, int h, int slices, Color color) {
+    DrawCylinder((Vector3){i2f(px), i2f(py), i2f(pz)}, i2f(rt), i2f(rb), i2f(h), slices, color);
+}
+
+void DrawCylinderExW(int sx, int sy, int sz, int ex, int ey, int ez, int sr, int er, int sides, Color color) {
+    DrawCylinderEx((Vector3){i2f(sx), i2f(sy), i2f(sz)}, (Vector3){i2f(ex), i2f(ey), i2f(ez)}, i2f(sr), i2f(er), sides, color);
+}
+
+void DrawCylinderWiresW(int px, int py, int pz, int rt, int rb, int h, int slices, Color color) {
+    DrawCylinderWires((Vector3){i2f(px), i2f(py), i2f(pz)}, i2f(rt), i2f(rb), i2f(h), slices, color);
+}
+
+void DrawCylinderWiresExW(int sx, int sy, int sz, int ex, int ey, int ez, int sr, int er, int sides, Color color) {
+    DrawCylinderWiresEx((Vector3){i2f(sx), i2f(sy), i2f(sz)}, (Vector3){i2f(ex), i2f(ey), i2f(ez)}, i2f(sr), i2f(er), sides, color);
+}
+
+void DrawCapsuleW(int sx, int sy, int sz, int ex, int ey, int ez, int radius, int slices, int rings, Color color) {
+    DrawCapsule((Vector3){i2f(sx), i2f(sy), i2f(sz)}, (Vector3){i2f(ex), i2f(ey), i2f(ez)}, i2f(radius), slices, rings, color);
+}
+
+void DrawCapsuleWiresW(int sx, int sy, int sz, int ex, int ey, int ez, int radius, int slices, int rings, Color color) {
+    DrawCapsuleWires((Vector3){i2f(sx), i2f(sy), i2f(sz)}, (Vector3){i2f(ex), i2f(ey), i2f(ez)}, i2f(radius), slices, rings, color);
+}
+
+void DrawPlaneW(int cx, int cy, int cz, int sw, int sh, Color color) {
+    DrawPlane((Vector3){i2f(cx), i2f(cy), i2f(cz)}, (Vector2){i2f(sw), i2f(sh)}, color);
+}
+
+void DrawRayW(int px, int py, int pz, int dx, int dy, int dz, Color color) {
+    Ray ray = { {i2f(px), i2f(py), i2f(pz)}, {i2f(dx), i2f(dy), i2f(dz)} };
+    DrawRay(ray, color);
+}
+
+void DrawGridW(int slices, int spacing) {
+    DrawGrid(slices, spacing);
+}
+
+void DrawModelW(int id, int posX, int posY, int posZ, int scale, Color tint) {
+    if (id < 0 || id >= MAX_MODELS || !modelUsed[id]) return;
+    float s;
+    memcpy(&s, &scale, sizeof(float));
+    DrawModel(modelRegistry[id], (Vector3){i2f(posX), i2f(posY), i2f(posZ)}, s, tint);
+}
+
+void DrawModelExW(int id,
+    int posX, int posY, int posZ,
+    int rotAxisX, int rotAxisY, int rotAxisZ, int rotAngle,
+    int scaleX, int scaleY, int scaleZ, Color tint) {
+    if (id < 0 || id >= MAX_MODELS || !modelUsed[id]) return;
+    float ra, sx, sy, sz;
+    memcpy(&ra, &rotAngle, sizeof(float));
+    memcpy(&sx, &scaleX, sizeof(float));
+    memcpy(&sy, &scaleY, sizeof(float));
+    memcpy(&sz, &scaleZ, sizeof(float));
+    DrawModelEx(modelRegistry[id],
+        (Vector3){i2f(posX), i2f(posY), i2f(posZ)},
+        (Vector3){i2f(rotAxisX), i2f(rotAxisY), i2f(rotAxisZ)}, ra,
+        (Vector3){sx, sy, sz}, tint);
+}
+
+void DrawModelWiresW(int id, int posX, int posY, int posZ, int scale, Color tint) {
+    if (id < 0 || id >= MAX_MODELS || !modelUsed[id]) return;
+    float s;
+    memcpy(&s, &scale, sizeof(float));
+    DrawModelWires(modelRegistry[id], (Vector3){i2f(posX), i2f(posY), i2f(posZ)}, s, tint);
+}
+
+void DrawModelWiresExW(int id,
+    int posX, int posY, int posZ,
+    int rotAxisX, int rotAxisY, int rotAxisZ, int rotAngle,
+    int scaleX, int scaleY, int scaleZ, Color tint) {
+    if (id < 0 || id >= MAX_MODELS || !modelUsed[id]) return;
+    float ra, sx, sy, sz;
+    memcpy(&ra, &rotAngle, sizeof(float));
+    memcpy(&sx, &scaleX, sizeof(float));
+    memcpy(&sy, &scaleY, sizeof(float));
+    memcpy(&sz, &scaleZ, sizeof(float));
+    DrawModelWiresEx(modelRegistry[id],
+        (Vector3){i2f(posX), i2f(posY), i2f(posZ)},
+        (Vector3){i2f(rotAxisX), i2f(rotAxisY), i2f(rotAxisZ)}, ra,
+        (Vector3){sx, sy, sz}, tint);
+}
+
+void DrawBoundingBoxW(int minX, int minY, int minZ, int maxX, int maxY, int maxZ, Color color) {
+    BoundingBox bb = {
+        {i2f(minX), i2f(minY), i2f(minZ)},
+        {i2f(maxX), i2f(maxY), i2f(maxZ)}
+    };
+    DrawBoundingBox(bb, color);
+}
+
+void DrawBillboardW(
+    int camPosX, int camPosY, int camPosZ,
+    int camTarX, int camTarY, int camTarZ,
+    int camUpX, int camUpY, int camUpZ,
+    int camFovy, int camProj,
+    unsigned int texId, int texW, int texH,
+    int posX, int posY, int posZ,
+    int scale, Color tint) {
+    Camera3D cam = {
+        {i2f(camPosX), i2f(camPosY), i2f(camPosZ)},
+        {i2f(camTarX), i2f(camTarY), i2f(camTarZ)},
+        {i2f(camUpX), i2f(camUpY), i2f(camUpZ)},
+        i2f(camFovy), camProj
+    };
+    Texture2D tex = { texId, texW, texH, 1, 7 };
+    float s;
+    memcpy(&s, &scale, sizeof(float));
+    DrawBillboard(cam, tex, (Vector3){i2f(posX), i2f(posY), i2f(posZ)}, s, tint);
+}
+
+void DrawBillboardRecW(
+    int camPosX, int camPosY, int camPosZ,
+    int camTarX, int camTarY, int camTarZ,
+    int camUpX, int camUpY, int camUpZ,
+    int camFovy, int camProj,
+    unsigned int texId, int texW, int texH,
+    int srcX, int srcY, int srcW, int srcH,
+    int posX, int posY, int posZ,
+    int sizeX, int sizeY, Color tint) {
+    Camera3D cam = {
+        {i2f(camPosX), i2f(camPosY), i2f(camPosZ)},
+        {i2f(camTarX), i2f(camTarY), i2f(camTarZ)},
+        {i2f(camUpX), i2f(camUpY), i2f(camUpZ)},
+        i2f(camFovy), camProj
+    };
+    Texture2D tex = { texId, texW, texH, 1, 7 };
+    Rectangle src = { srcX, srcY, srcW, srcH };
+    float sx, sy;
+    memcpy(&sx, &sizeX, sizeof(float));
+    memcpy(&sy, &sizeY, sizeof(float));
+    DrawBillboardRec(cam, tex, src, (Vector3){i2f(posX), i2f(posY), i2f(posZ)}, (Vector2){sx, sy}, tint);
+}
+
+void DrawBillboardProW(
+    int camPosX, int camPosY, int camPosZ,
+    int camTarX, int camTarY, int camTarZ,
+    int camUpX, int camUpY, int camUpZ,
+    int camFovy, int camProj,
+    unsigned int texId, int texW, int texH,
+    int srcX, int srcY, int srcW, int srcH,
+    int posX, int posY, int posZ,
+    int upX, int upY, int upZ,
+    int sizeX, int sizeY,
+    int originX, int originY,
+    int rotation, Color tint) {
+    Camera3D cam = {
+        {i2f(camPosX), i2f(camPosY), i2f(camPosZ)},
+        {i2f(camTarX), i2f(camTarY), i2f(camTarZ)},
+        {i2f(camUpX), i2f(camUpY), i2f(camUpZ)},
+        i2f(camFovy), camProj
+    };
+    Texture2D tex = { texId, texW, texH, 1, 7 };
+    Rectangle src = { srcX, srcY, srcW, srcH };
+    float sx, sy, ox, oy, rot;
+    memcpy(&sx, &sizeX, sizeof(float));
+    memcpy(&sy, &sizeY, sizeof(float));
+    memcpy(&ox, &originX, sizeof(float));
+    memcpy(&oy, &originY, sizeof(float));
+    memcpy(&rot, &rotation, sizeof(float));
+    DrawBillboardPro(cam, tex, src,
+        (Vector3){i2f(posX), i2f(posY), i2f(posZ)},
+        (Vector3){i2f(upX), i2f(upY), i2f(upZ)},
+        (Vector2){sx, sy},
+        (Vector2){ox, oy},
+        rot, tint);
+}

package/src/c/filesystem.c

@@ -0,0 +1,36 @@
+#include "common.h"
+
+bool FileExistsW(const char* fileName) { return FileExists(fileName); }
+bool DirectoryExistsW(const char* dirPath) { return DirectoryExists(dirPath); }
+bool IsFileExtensionW(const char* fileName, const char* ext) { return IsFileExtension(fileName, ext); }
+int GetFileLengthW(const char* fileName) { return GetFileLength(fileName); }
+const char* GetFileExtensionW(const char* fileName) { return GetFileExtension(fileName); }
+const char* GetFileNameW(const char* filePath) { return GetFileName(filePath); }
+const char* GetFileNameWithoutExtW(const char* filePath) { return GetFileNameWithoutExt(filePath); }
+const char* GetDirectoryPathW(const char* filePath) { return GetDirectoryPath(filePath); }
+const char* GetPrevDirectoryPathW(const char* dirPath) { return GetPrevDirectoryPath(dirPath); }
+const char* GetWorkingDirectoryW() { return GetWorkingDirectory(); }
+const char* GetApplicationDirectoryW() { return GetApplicationDirectory(); }
+int MakeDirectoryW(const char* dirPath) { return MakeDirectory(dirPath); }
+bool ChangeDirectoryW(const char* dir) { return ChangeDirectory(dir); }
+bool IsPathFileW(const char* path) { return IsPathFile(path); }
+bool IsFileNameValidW(const char* fileName) { return IsFileNameValid(fileName); }
+long GetFileModTimeW(const char* fileName) { return GetFileModTime(fileName); }
+
+const char* LoadFileTextW(const char* fileName) { return LoadFileText(fileName); }
+void UnloadFileTextW(const char* text) { UnloadFileText((char*)text); }
+bool SaveFileTextW(const char* fileName, const char* text) { return SaveFileText((char*)fileName, (char*)text); }
+
+unsigned int ComputeCRC32W(const unsigned char* data, int dataSize) { return ComputeCRC32((unsigned char*)data, dataSize); }
+
+void UnloadRandomSequenceW(int* sequence) { UnloadRandomSequence(sequence); }
+void MemFreeW(void* ptr) { MemFree(ptr); }
+void UnloadFileDataW(unsigned char* data) { UnloadFileData(data); }
+
+bool SaveFileDataW(const char* fileName, const void* data, int dataSize) {
+    return SaveFileData(fileName, (void*)data, dataSize);
+}
+
+bool ExportDataAsCodeW(const unsigned char* data, int dataSize, const char* fileName) {
+    return ExportDataAsCode(data, dataSize, fileName);
+}

package/src/c/font.c

@@ -0,0 +1,163 @@
+#include "common.h"
+
+int LoadFontW(const char* fileName) {
+    int slot = fontAlloc();
+    if (slot < 0) return -1;
+    fontRegistry[slot] = LoadFont(fileName);
+    return slot;
+}
+
+int LoadFontExW(const char* fileName, int fontSize) {
+    int slot = fontAlloc();
+    if (slot < 0) return -1;
+    fontRegistry[slot] = LoadFontEx(fileName, fontSize, NULL, 0);
+    return slot;
+}
+
+int GetFontDefaultW() {
+    int slot = fontAlloc();
+    if (slot < 0) return -1;
+    fontRegistry[slot] = GetFontDefault();
+    return slot;
+}
+
+void UnloadFontW(int id) {
+    if (id < 0 || id >= MAX_FONTS || !fontUsed[id]) return;
+    UnloadFont(fontRegistry[id]);
+    fontUsed[id] = false;
+}
+
+bool IsFontValidW(int id) {
+    if (id < 0 || id >= MAX_FONTS || !fontUsed[id]) return false;
+    return IsFontValid(fontRegistry[id]);
+}
+
+int MeasureTextW(const char* text, int fontSize) {
+    return MeasureText(text, fontSize);
+}
+
+void MeasureTextExW(float* out, int fontId, const char* text, int fontSize, int spacing) {
+    float sp;
+    memcpy(&sp, &spacing, sizeof(float));
+    Vector2 v = MeasureTextEx(fontRegistry[fontId], text, fontSize, sp);
+    out[0] = v.x; out[1] = v.y;
+}
+
+void DrawTextExW(int fontId, const char* text, int posX, int posY, int fontSize, int spacing, Color tint) {
+    float sp;
+    memcpy(&sp, &spacing, sizeof(float));
+    DrawTextEx(fontRegistry[fontId], text, (Vector2){posX, posY}, fontSize, sp, tint);
+}
+
+void DrawTextProW(int fontId, const char* text, int posX, int posY, int originX, int originY, int rotation, int fontSize, int spacing, Color tint) {
+    float rot, sp;
+    memcpy(&rot, &rotation, sizeof(float));
+    memcpy(&sp, &spacing, sizeof(float));
+    DrawTextPro(fontRegistry[fontId], text, (Vector2){posX, posY}, (Vector2){originX, originY}, rot, fontSize, sp, tint);
+}
+
+void SetTextLineSpacingW(int spacing) { SetTextLineSpacing(spacing); }
+
+int LoadFontFromImageW(int imageId, Color key, int firstChar) {
+    if (imageId < 0 || imageId >= MAX_IMAGES || !imageUsed[imageId]) return -1;
+    int slot = fontAlloc();
+    if (slot < 0) return -1;
+    fontRegistry[slot] = LoadFontFromImage(imageRegistry[imageId], key, firstChar);
+    return slot;
+}
+
+int LoadFontFromMemoryW(const char* fileType, const unsigned char* fileData, int dataSize, int fontSize) {
+    int slot = fontAlloc();
+    if (slot < 0) return -1;
+    fontRegistry[slot] = LoadFontFromMemory(fileType, fileData, dataSize, fontSize, NULL, 0);
+    return slot;
+}
+
+bool ExportFontAsCodeW(int fontId, const char* fileName) {
+    if (fontId < 0 || fontId >= MAX_FONTS || !fontUsed[fontId]) return false;
+    return ExportFontAsCode(fontRegistry[fontId], fileName);
+}
+
+void DrawTextCodepointW(int fontId, int codepoint, int posX, int posY, int fontSize, Color tint) {
+    float fs;
+    memcpy(&fs, &fontSize, sizeof(float));
+    DrawTextCodepoint(fontRegistry[fontId], codepoint, (Vector2){posX, posY}, fs, tint);
+}
+
+void DrawTextCodepointsW(int fontId, const int* codepoints, int count, int posX, int posY, int fontSize, int spacing, Color tint) {
+    float fs, sp;
+    memcpy(&fs, &fontSize, sizeof(float));
+    memcpy(&sp, &spacing, sizeof(float));
+    DrawTextCodepoints(fontRegistry[fontId], codepoints, count, (Vector2){posX, posY}, fs, sp, tint);
+}
+
+int GetGlyphIndexW(int fontId, int codepoint) {
+    return GetGlyphIndex(fontRegistry[fontId], codepoint);
+}
+
+void GetGlyphInfoW(int* outValue, int* outOffsetX, int* outOffsetY, int* outAdvanceX, int* outImageSlot, int fontId, int codepoint) {
+    GlyphInfo info = GetGlyphInfo(fontRegistry[fontId], codepoint);
+    *outValue = info.value;
+    *outOffsetX = info.offsetX;
+    *outOffsetY = info.offsetY;
+    *outAdvanceX = info.advanceX;
+    int imgSlot = imageAlloc();
+    if (imgSlot >= 0) {
+        imageRegistry[imgSlot] = info.image;
+    }
+    *outImageSlot = imgSlot;
+}
+
+void GetGlyphAtlasRecW(float* out, int fontId, int codepoint) {
+    Rectangle rec = GetGlyphAtlasRec(fontRegistry[fontId], codepoint);
+    out[0] = rec.x; out[1] = rec.y; out[2] = rec.width; out[3] = rec.height;
+}
+
+int GetCodepointW(const char* text, int* outSize) {
+    return GetCodepoint(text, outSize);
+}
+
+int GetCodepointNextW(const char* text, int* outSize) {
+    return GetCodepointNext(text, outSize);
+}
+
+int GetCodepointPreviousW(const char* text, int* outSize) {
+    return GetCodepointPrevious(text, outSize);
+}
+
+int GetCodepointCountW(const char* text) {
+    return GetCodepointCount(text);
+}
+
+bool TextIsEqualW(const char* text1, const char* text2) {
+    return TextIsEqual(text1, text2);
+}
+
+unsigned int TextLengthW(const char* text) {
+    return TextLength(text);
+}
+
+int TextToIntegerW(const char* text) {
+    return TextToInteger(text);
+}
+
+float TextToFloatW(const char* text) {
+    return TextToFloat(text);
+}
+
+int TextFindIndexW(const char* text, const char* find) {
+    return TextFindIndex(text, find);
+}
+
+void UnloadFontDataW(void* ptr, int glyphCount) {
+    UnloadFontData((GlyphInfo*)ptr, glyphCount);
+}
+
+void UnloadUTF8W(char* text) { UnloadUTF8(text); }
+void UnloadCodepointsW(int* codepoints) { UnloadCodepoints(codepoints); }
+
+int TextCopyW(char* dst, const char* src) { return TextCopy(dst, src); }
+
+void TextAppendW(char* text, const char* append, int* position) {
+    TextAppend(text, append, position);
+}