@dayme/bunraylib 0.1.0 → 1.0.0

package/src/modules/draw3d/symbols.ts

@@ -0,0 +1,199 @@
+import { FFIType } from 'bun:ffi';
+const { i32, f32, ptr } = FFIType;
+
+export const draw3dDirectSymbols = {
+  DrawGrid: { args: [i32, f32], returns: FFIType.void },
+  DrawTriangleStrip3D: { args: [ptr, i32, i32], returns: FFIType.void },
+} as const;
+
+export const draw3dSymbols = {
+  DrawLine3DW: {
+    args: [f32, f32, f32, f32, f32, f32, i32],
+    returns: FFIType.void,
+  },
+  DrawPoint3DW: { args: [f32, f32, f32, i32], returns: FFIType.void },
+  DrawCircle3DW: {
+    args: [f32, f32, f32, f32, f32, f32, f32, f32, i32],
+    returns: FFIType.void,
+  },
+  DrawTriangle3DW: {
+    args: [f32, f32, f32, f32, f32, f32, f32, f32, f32, i32],
+    returns: FFIType.void,
+  },
+  DrawCubeW: {
+    args: [f32, f32, f32, f32, f32, f32, i32],
+    returns: FFIType.void,
+  },
+  DrawCubeVW: {
+    args: [f32, f32, f32, f32, f32, f32, i32],
+    returns: FFIType.void,
+  },
+  DrawCubeWiresW: {
+    args: [f32, f32, f32, f32, f32, f32, i32],
+    returns: FFIType.void,
+  },
+  DrawCubeWiresVW: {
+    args: [f32, f32, f32, f32, f32, f32, i32],
+    returns: FFIType.void,
+  },
+  DrawSphereW: {
+    args: [f32, f32, f32, f32, i32],
+    returns: FFIType.void,
+  },
+  DrawSphereExW: {
+    args: [f32, f32, f32, f32, i32, i32, i32],
+    returns: FFIType.void,
+  },
+  DrawSphereWiresW: {
+    args: [f32, f32, f32, f32, i32, i32, i32],
+    returns: FFIType.void,
+  },
+  DrawCylinderW: {
+    args: [f32, f32, f32, f32, f32, f32, i32, i32],
+    returns: FFIType.void,
+  },
+  DrawCylinderExW: {
+    args: [f32, f32, f32, f32, f32, f32, f32, f32, i32, i32],
+    returns: FFIType.void,
+  },
+  DrawCylinderWiresW: {
+    args: [f32, f32, f32, f32, f32, f32, i32, i32],
+    returns: FFIType.void,
+  },
+  DrawCylinderWiresExW: {
+    args: [f32, f32, f32, f32, f32, f32, f32, f32, i32, i32],
+    returns: FFIType.void,
+  },
+  DrawCapsuleW: {
+    args: [f32, f32, f32, f32, f32, f32, f32, i32, i32, i32],
+    returns: FFIType.void,
+  },
+  DrawCapsuleWiresW: {
+    args: [f32, f32, f32, f32, f32, f32, f32, i32, i32, i32],
+    returns: FFIType.void,
+  },
+  DrawPlaneW: {
+    args: [f32, f32, f32, f32, f32, i32],
+    returns: FFIType.void,
+  },
+  DrawRayW: {
+    args: [f32, f32, f32, f32, f32, f32, i32],
+    returns: FFIType.void,
+  },
+  DrawModelW: {
+    args: [i32, f32, f32, f32, f32, i32],
+    returns: FFIType.void,
+  },
+  DrawModelExW: {
+    args: [i32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, i32],
+    returns: FFIType.void,
+  },
+  DrawModelWiresW: {
+    args: [i32, f32, f32, f32, f32, i32],
+    returns: FFIType.void,
+  },
+  DrawModelWiresExW: {
+    args: [i32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, i32],
+    returns: FFIType.void,
+  },
+  DrawBoundingBoxW: {
+    args: [f32, f32, f32, f32, f32, f32, i32],
+    returns: FFIType.void,
+  },
+  DrawBillboardW: {
+    args: [
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      i32,
+      i32,
+      i32,
+      i32,
+      f32,
+      f32,
+      f32,
+      f32,
+      i32,
+    ],
+    returns: FFIType.void,
+  },
+  DrawBillboardRecW: {
+    args: [
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      i32,
+      i32,
+      i32,
+      i32,
+      i32,
+      i32,
+      i32,
+      i32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      i32,
+    ],
+    returns: FFIType.void,
+  },
+  DrawBillboardProW: {
+    args: [
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      i32,
+      i32,
+      i32,
+      i32,
+      i32,
+      i32,
+      i32,
+      i32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      f32,
+      i32,
+    ],
+    returns: FFIType.void,
+  },
+  DrawMeshW: {
+    args: [i32, i32, ptr],
+    returns: FFIType.void,
+  },
+  DrawMeshInstancedW: {
+    args: [i32, i32, ptr, i32],
+    returns: FFIType.void,
+  },
+} as const;

package/src/modules/draw3d/wrapper.c

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

package/src/modules/font/FontModule.ts

@@ -0,0 +1,250 @@
+import { getSymbols } from '../../symbols';
+import { bufs as b, cstr, f, i } from '../../utils';
+import type { Vec2, Rectangle, Font, Image, GlyphInfo, Color } from '../../types';
+
+const r = () => getSymbols();
+
+export class FontModule {
+  static drawText(text: string, x: number, y: number, fontSize: number, col: Color): void {
+    r().symbols.DrawText(cstr(text), i(x), i(y), i(fontSize), i(col));
+  }
+  static loadFont(fileName: string): Font {
+    return r().symbols.LoadFontW(cstr(fileName));
+  }
+  static loadFontEx(fileName: string, fontSize: number): Font {
+    return r().symbols.LoadFontExW(cstr(fileName), i(fontSize));
+  }
+  static getFontDefault(): Font {
+    return r().symbols.GetFontDefaultW();
+  }
+  static unloadFont(font: Font): void {
+    r().symbols.UnloadFontW(i(font));
+  }
+  static isFontValid(font: Font): boolean {
+    return r().symbols.IsFontValidW(i(font));
+  }
+  static measureText(text: string, fontSize: number): number {
+    return r().symbols.MeasureText(cstr(text), i(fontSize));
+  }
+  static measureTextEx(font: Font, text: string, fontSize: number, spacing: number): Vec2 {
+    r().symbols.MeasureTextExW(b._vec2Buf, i(font), cstr(text), f(fontSize), f(spacing));
+    return { x: b._vec2Buf[0]!, y: b._vec2Buf[1]! };
+  }
+  static drawTextEx(
+    font: Font,
+    text: string,
+    position: Vec2,
+    fontSize: number,
+    spacing: number,
+    tint: Color,
+  ): void {
+    r().symbols.DrawTextExW(
+      i(font),
+      cstr(text),
+      f(position.x),
+      f(position.y),
+      f(fontSize),
+      f(spacing),
+      i(tint),
+    );
+  }
+  static drawTextPro(
+    font: Font,
+    text: string,
+    position: Vec2,
+    origin: Vec2,
+    rotation: number,
+    fontSize: number,
+    spacing: number,
+    tint: Color,
+  ): void {
+    r().symbols.DrawTextProW(
+      i(font),
+      cstr(text),
+      f(position.x),
+      f(position.y),
+      f(origin.x),
+      f(origin.y),
+      f(rotation),
+      f(fontSize),
+      f(spacing),
+      i(tint),
+    );
+  }
+  static setTextLineSpacing(spacing: number): void {
+    r().symbols.SetTextLineSpacing(i(spacing));
+  }
+  static loadFontFromImage(image: Image, key: Color, firstChar: number): Font {
+    return r().symbols.LoadFontFromImageW(i(image), i(key), i(firstChar));
+  }
+  static loadFontFromMemory(
+    fileType: string,
+    fileData: Uint8Array,
+    dataSize: number,
+    fontSize: number,
+  ): Font {
+    return r().symbols.LoadFontFromMemoryW(cstr(fileType), fileData, i(dataSize), i(fontSize));
+  }
+  static exportFontAsCode(font: Font, fileName: string): boolean {
+    return r().symbols.ExportFontAsCodeW(i(font), cstr(fileName));
+  }
+  static drawTextCodepoint(
+    font: Font,
+    codepoint: number,
+    position: Vec2,
+    fontSize: number,
+    tint: Color,
+  ): void {
+    r().symbols.DrawTextCodepointW(
+      i(font),
+      i(codepoint),
+      f(position.x),
+      f(position.y),
+      f(fontSize),
+      i(tint),
+    );
+  }
+  static drawTextCodepoints(
+    font: Font,
+    codepoints: Int32Array,
+    count: number,
+    position: Vec2,
+    fontSize: number,
+    spacing: number,
+    tint: Color,
+  ): void {
+    r().symbols.DrawTextCodepointsW(
+      i(font),
+      codepoints,
+      i(count),
+      f(position.x),
+      f(position.y),
+      f(fontSize),
+      f(spacing),
+      i(tint),
+    );
+  }
+  static getGlyphIndex(font: Font, codepoint: number): number {
+    return r().symbols.GetGlyphIndexW(i(font), i(codepoint));
+  }
+  static getGlyphInfo(font: Font, codepoint: number): GlyphInfo {
+    r().symbols.GetGlyphInfoW(
+      b._glyphValue,
+      b._glyphOffsetX,
+      b._glyphOffsetY,
+      b._glyphAdvanceX,
+      b._glyphImageSlot,
+      i(font),
+      i(codepoint),
+    );
+    return {
+      value: b._glyphValue[0]!,
+      offsetX: b._glyphOffsetX[0]!,
+      offsetY: b._glyphOffsetY[0]!,
+      advanceX: b._glyphAdvanceX[0]!,
+      image: b._glyphImageSlot[0]!,
+    };
+  }
+  static getGlyphAtlasRec(font: Font, codepoint: number): Rectangle {
+    r().symbols.GetGlyphAtlasRecW(b._recBuf, i(font), i(codepoint));
+    return {
+      x: b._recBuf[0]!,
+      y: b._recBuf[1]!,
+      width: b._recBuf[2]!,
+      height: b._recBuf[3]!,
+    };
+  }
+  static getCodepoint(text: string): { codepoint: number; size: number } {
+    const cp = r().symbols.GetCodepoint(cstr(text), b._cpSize);
+    return { codepoint: cp, size: b._cpSize[0]! };
+  }
+  static getCodepointNext(text: string): { codepoint: number; size: number } {
+    const cp = r().symbols.GetCodepointNext(cstr(text), b._cpSize);
+    return { codepoint: cp, size: b._cpSize[0]! };
+  }
+  static getCodepointPrevious(text: string): { codepoint: number; size: number } {
+    const cp = r().symbols.GetCodepointPrevious(cstr(text), b._cpSize);
+    return { codepoint: cp, size: b._cpSize[0]! };
+  }
+  static getCodepointCount(text: string): number {
+    return r().symbols.GetCodepointCount(cstr(text));
+  }
+  static textIsEqual(text1: string, text2: string): boolean {
+    return r().symbols.TextIsEqual(cstr(text1), cstr(text2));
+  }
+  static textLength(text: string): number {
+    return r().symbols.TextLength(cstr(text));
+  }
+  static textToInteger(text: string): number {
+    return r().symbols.TextToInteger(cstr(text));
+  }
+  static textToFloat(text: string): number {
+    return r().symbols.TextToFloat(cstr(text));
+  }
+  static textFindIndex(text: string, find: string): number {
+    return r().symbols.TextFindIndex(cstr(text), cstr(find));
+  }
+  static unloadFontData(ptr: number, glyphCount: number): void {
+    r().symbols.UnloadFontData(ptr as unknown as Buffer, i(glyphCount));
+  }
+  static unloadUTF8(ptr: number): void {
+    r().symbols.UnloadUTF8(ptr as unknown as Buffer);
+  }
+  static unloadCodepoints(ptr: number): void {
+    r().symbols.UnloadCodepoints(ptr as unknown as Buffer);
+  }
+  static textCopy(dst: Uint8Array, src: string): number {
+    return r().symbols.TextCopy(dst, cstr(src));
+  }
+  static textAppend(text: Uint8Array, append: string, position: number): number {
+    b._textAppendPos[0] = position;
+    r().symbols.TextAppend(text, cstr(append), b._textAppendPos);
+    return b._textAppendPos[0];
+  }
+  static genImageFontAtlas(
+    glyphs: GlyphInfo[],
+    fontSize: number,
+    padding: number,
+    packMethod: number,
+  ): { image: Image; glyphRecs: Float32Array } {
+    const glyphCount = glyphs.length;
+    const glyphData = new Int32Array(glyphCount * 5);
+    for (let idx = 0; idx < glyphCount; idx++) {
+      glyphData[idx * 5] = glyphs[idx]!.value;
+      glyphData[idx * 5 + 1] = glyphs[idx]!.offsetX;
+      glyphData[idx * 5 + 2] = glyphs[idx]!.offsetY;
+      glyphData[idx * 5 + 3] = glyphs[idx]!.advanceX;
+      glyphData[idx * 5 + 4] = glyphs[idx]!.image;
+    }
+    const recs = new Float32Array(glyphCount * 4);
+    const img = r().symbols.GenImageFontAtlasW(
+      recs,
+      glyphData,
+      i(glyphCount),
+      i(fontSize),
+      i(padding),
+      i(packMethod),
+    );
+    return { image: img, glyphRecs: recs };
+  }
+  static measureTextCodepoints(
+    font: Font,
+    codepoints: Int32Array,
+    length: number,
+    fontSize: number,
+    spacing: number,
+  ): Vec2 {
+    r().symbols.MeasureTextCodepointsW(
+      b._vec2Buf,
+      i(font),
+      codepoints,
+      i(length),
+      f(fontSize),
+      f(spacing),
+    );
+    return { x: b._vec2Buf[0]!, y: b._vec2Buf[1]! };
+  }
+  static unloadTextLines(text: number, lineCount: number): void {
+    r().symbols.UnloadTextLines(text as unknown as Buffer, i(lineCount));
+  }
+}

package/src/modules/font/symbols.ts

@@ -0,0 +1,46 @@
+import { FFIType } from 'bun:ffi';
+const { i32, cstring, f32, ptr } = FFIType;
+
+export const fontDirectSymbols = {
+  MeasureText: { args: [cstring, i32], returns: i32 },
+  SetTextLineSpacing: { args: [i32], returns: FFIType.void },
+  GetCodepoint: { args: [cstring, ptr], returns: i32 },
+  GetCodepointNext: { args: [cstring, ptr], returns: i32 },
+  GetCodepointPrevious: { args: [cstring, ptr], returns: i32 },
+  GetCodepointCount: { args: [cstring], returns: i32 },
+  TextIsEqual: { args: [cstring, cstring], returns: FFIType.bool },
+  TextLength: { args: [cstring], returns: i32 },
+  TextToInteger: { args: [cstring], returns: i32 },
+  TextToFloat: { args: [cstring], returns: f32 },
+  TextFindIndex: { args: [cstring, cstring], returns: i32 },
+  TextCopy: { args: [ptr, cstring], returns: i32 },
+  TextAppend: { args: [ptr, cstring, ptr], returns: FFIType.void },
+  UnloadUTF8: { args: [ptr], returns: FFIType.void },
+  UnloadCodepoints: { args: [ptr], returns: FFIType.void },
+  UnloadFontData: { args: [ptr, i32], returns: FFIType.void },
+  UnloadTextLines: { args: [ptr, i32], returns: FFIType.void },
+} as const;
+
+export const fontWrapperSymbols = {
+  LoadFontW: { args: [cstring], returns: i32 },
+  LoadFontExW: { args: [cstring, i32], returns: i32 },
+  GetFontDefaultW: { args: [], returns: i32 },
+  UnloadFontW: { args: [i32], returns: FFIType.void },
+  IsFontValidW: { args: [i32], returns: FFIType.bool },
+  MeasureTextExW: { args: [ptr, i32, cstring, f32, f32], returns: FFIType.void },
+  DrawTextExW: { args: [i32, cstring, f32, f32, f32, f32, i32], returns: FFIType.void },
+  DrawTextProW: {
+    args: [i32, cstring, f32, f32, f32, f32, f32, f32, f32, i32],
+    returns: FFIType.void,
+  },
+  LoadFontFromImageW: { args: [i32, i32, i32], returns: i32 },
+  LoadFontFromMemoryW: { args: [cstring, ptr, i32, i32], returns: i32 },
+  ExportFontAsCodeW: { args: [i32, cstring], returns: FFIType.bool },
+  DrawTextCodepointW: { args: [i32, i32, f32, f32, f32, i32], returns: FFIType.void },
+  DrawTextCodepointsW: { args: [i32, ptr, i32, f32, f32, f32, f32, i32], returns: FFIType.void },
+  GetGlyphIndexW: { args: [i32, i32], returns: i32 },
+  GetGlyphInfoW: { args: [ptr, ptr, ptr, ptr, ptr, i32, i32], returns: FFIType.void },
+  GetGlyphAtlasRecW: { args: [ptr, i32, i32], returns: FFIType.void },
+  GenImageFontAtlasW: { args: [ptr, ptr, i32, i32, i32, i32], returns: i32 },
+  MeasureTextCodepointsW: { args: [ptr, i32, ptr, i32, f32, f32], returns: FFIType.void },
+} as const;