@dayme/bunraylib 0.1.0

package/src/c/texture.c

@@ -0,0 +1,139 @@
+#include "common.h"
+
+void LoadTextureW(unsigned int* outId, int* outW, int* outH, const char* fileName) {
+    Texture2D tex = LoadTexture(fileName);
+    *outId = tex.id;
+    *outW = tex.width;
+    *outH = tex.height;
+}
+
+void UnloadTextureW(unsigned int id) {
+    Texture2D tex = { id, 0, 0, 0, 0 };
+    UnloadTexture(tex);
+}
+
+bool IsTextureValidW(unsigned int id, int w, int h) {
+    Texture2D tex = { id, w, h, 1, 7 };
+    return IsTextureValid(tex);
+}
+
+void LoadRenderTextureW(unsigned int* outId, unsigned int* outTexId, int* outW, int* outH, int width, int height) {
+    RenderTexture2D rt = LoadRenderTexture(width, height);
+    *outId = rt.id;
+    *outTexId = rt.texture.id;
+    *outW = rt.texture.width;
+    *outH = rt.texture.height;
+}
+
+void UnloadRenderTextureW(unsigned int id) {
+    RenderTexture2D rt = { id, {0, 0, 0, 0, 0}, {0, 0, 0, 0, 0} };
+    UnloadRenderTexture(rt);
+}
+
+bool IsRenderTextureValidW(unsigned int id) {
+    RenderTexture2D rt = { id, {0}, {0} };
+    return IsRenderTextureValid(rt);
+}
+
+void GenTextureMipmapsW(unsigned int id) {
+    Texture2D tex = { id, 0, 0, 0, 0 };
+    GenTextureMipmaps(&tex);
+}
+
+void SetTextureFilterW(unsigned int id, int filter) {
+    Texture2D tex = { id, 0, 0, 0, 0 };
+    SetTextureFilter(tex, filter);
+}
+
+void SetTextureWrapW(unsigned int id, int wrap) {
+    Texture2D tex = { id, 0, 0, 0, 0 };
+    SetTextureWrap(tex, wrap);
+}
+
+void DrawTextureW(unsigned int id, int w, int h, int posX, int posY, Color tint) {
+    Texture2D tex = { id, w, h, 1, 7 };
+    DrawTexture(tex, posX, posY, tint);
+}
+
+void DrawTextureVW(unsigned int id, int w, int h, int posX, int posY, Color tint) {
+    Texture2D tex = { id, w, h, 1, 7 };
+    DrawTextureV(tex, (Vector2){posX, posY}, tint);
+}
+
+void DrawTextureExW(unsigned int id, int w, int h, int posX, int posY, int rotation, int scale, Color tint) {
+    float r, s;
+    memcpy(&r, &rotation, sizeof(float));
+    memcpy(&s, &scale, sizeof(float));
+    Texture2D tex = { id, w, h, 1, 7 };
+    DrawTextureEx(tex, (Vector2){posX, posY}, r, s, tint);
+}
+
+void DrawTextureRecW(unsigned int id, int w, int h, int srcX, int srcY, int srcW, int srcH, int posX, int posY, Color tint) {
+    Texture2D tex = { id, w, h, 1, 7 };
+    Rectangle src = { srcX, srcY, srcW, srcH };
+    DrawTextureRec(tex, src, (Vector2){posX, posY}, tint);
+}
+
+void DrawTextureProW(unsigned int id, int w, int h,
+    int srcX, int srcY, int srcW, int srcH,
+    int dstX, int dstY, int dstW, int dstH,
+    int originX, int originY, int rotation, Color tint) {
+    float r;
+    memcpy(&r, &rotation, sizeof(float));
+    Texture2D tex = { id, w, h, 1, 7 };
+    Rectangle src = { srcX, srcY, srcW, srcH };
+    Rectangle dst = { dstX, dstY, dstW, dstH };
+    DrawTexturePro(tex, src, dst, (Vector2){originX, originY}, r, tint);
+}
+
+void LoadTextureFromImageW(unsigned int* outId, int* outW, int* outH, int imageId) {
+    *outId = 0; *outW = 0; *outH = 0;
+    if (imageId < 0 || imageId >= MAX_IMAGES || !imageUsed[imageId]) return;
+    Texture2D tex = LoadTextureFromImage(imageRegistry[imageId]);
+    *outId = tex.id;
+    *outW = tex.width;
+    *outH = tex.height;
+}
+
+void LoadTextureCubemapW(unsigned int* outId, int* outW, int* outH, int imageId, int layout) {
+    *outId = 0; *outW = 0; *outH = 0;
+    if (imageId < 0 || imageId >= MAX_IMAGES || !imageUsed[imageId]) return;
+    Texture2D tex = LoadTextureCubemap(imageRegistry[imageId], layout);
+    *outId = tex.id;
+    *outW = tex.width;
+    *outH = tex.height;
+}
+
+void UpdateTextureW(unsigned int id, int w, int h, const void* pixels) {
+    Texture2D tex = { id, w, h, 1, 7 };
+    UpdateTexture(tex, pixels);
+}
+
+void UpdateTextureRecW(unsigned int id, int w, int h, int rx, int ry, int rw, int rh, const void* pixels) {
+    Texture2D tex = { id, w, h, 1, 7 };
+    Rectangle rec = { rx, ry, rw, rh };
+    UpdateTextureRec(tex, rec, pixels);
+}
+
+void DrawTextureNPatchW(unsigned int id, int w, int h,
+    int srcX, int srcY, int srcW, int srcH,
+    int left, int top, int right, int bottom, int layout,
+    int dstX, int dstY, int dstW, int dstH,
+    int originX, int originY, int rotation, Color tint) {
+    float r;
+    memcpy(&r, &rotation, sizeof(float));
+    Texture2D tex = { id, w, h, 1, 7 };
+    Rectangle src = { srcX, srcY, srcW, srcH };
+    NPatchInfo npi = { src, left, top, right, bottom, layout };
+    Rectangle dst = { dstX, dstY, dstW, dstH };
+    DrawTextureNPatch(tex, npi, dst, (Vector2){originX, originY}, r, tint);
+}
+
+int GetPixelColorW(const void* srcPtr, int format) {
+    Color c = GetPixelColor((void*)srcPtr, format);
+    return *((int*)&c);
+}
+
+void SetPixelColorW(void* dstPtr, Color color, int format) {
+    SetPixelColor(dstPtr, color, format);
+}

package/src/c/window.c

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

package/src/constants.ts

@@ -0,0 +1,396 @@
+import { color } from "./utils";
+
+export const PI = 3.141592653589793;
+export const DEG2RAD = PI / 180;
+export const RAD2DEG = 180 / PI;
+
+export const COLORS = {
+  LIGHTGRAY: color(200, 200, 200),
+  GRAY: color(130, 130, 130),
+  DARKGRAY: color(80, 80, 80),
+  YELLOW: color(253, 249, 0),
+  GOLD: color(255, 203, 0),
+  ORANGE: color(255, 161, 0),
+  PINK: color(255, 109, 194),
+  RED: color(230, 41, 55),
+  MAROON: color(190, 33, 55),
+  GREEN: color(0, 228, 48),
+  LIME: color(0, 158, 47),
+  DARKGREEN: color(0, 117, 44),
+  SKYBLUE: color(102, 191, 255),
+  BLUE: color(0, 121, 241),
+  DARKBLUE: color(0, 82, 172),
+  PURPLE: color(200, 122, 255),
+  VIOLET: color(135, 60, 190),
+  DARKPURPLE: color(112, 31, 126),
+  BEIGE: color(211, 176, 131),
+  BROWN: color(127, 106, 79),
+  DARKBROWN: color(76, 63, 47),
+  WHITE: color(255, 255, 255),
+  BLACK: color(0, 0, 0),
+  BLANK: color(0, 0, 0, 0),
+  MAGENTA: color(255, 0, 255),
+  RAYWHITE: color(245, 245, 245),
+  CYAN: color(0, 255, 255),
+} as const;
+
+export const KEYS = {
+  NULL: 0,
+  APOSTROPHE: 39,
+  COMMA: 44,
+  MINUS: 45,
+  PERIOD: 46,
+  SLASH: 47,
+  ZERO: 48,
+  ONE: 49,
+  TWO: 50,
+  THREE: 51,
+  FOUR: 52,
+  FIVE: 53,
+  SIX: 54,
+  SEVEN: 55,
+  EIGHT: 56,
+  NINE: 57,
+  SEMICOLON: 59,
+  EQUAL: 61,
+  A: 65,
+  B: 66,
+  C: 67,
+  D: 68,
+  E: 69,
+  F: 70,
+  G: 71,
+  H: 72,
+  I: 73,
+  J: 74,
+  K: 75,
+  L: 76,
+  M: 77,
+  N: 78,
+  O: 79,
+  P: 80,
+  Q: 81,
+  R: 82,
+  S: 83,
+  T: 84,
+  U: 85,
+  V: 86,
+  W: 87,
+  X: 88,
+  Y: 89,
+  Z: 90,
+  LEFT_BRACKET: 91,
+  BACKSLASH: 92,
+  RIGHT_BRACKET: 93,
+  GRAVE: 96,
+  SPACE: 32,
+  ESCAPE: 256,
+  ENTER: 257,
+  TAB: 258,
+  BACKSPACE: 259,
+  INSERT: 260,
+  DELETE: 261,
+  RIGHT: 262,
+  LEFT: 263,
+  DOWN: 264,
+  UP: 265,
+  PAGE_UP: 266,
+  PAGE_DOWN: 267,
+  HOME: 268,
+  END: 269,
+  CAPS_LOCK: 280,
+  SCROLL_LOCK: 281,
+  NUM_LOCK: 282,
+  PRINT_SCREEN: 283,
+  PAUSE: 284,
+  F1: 290,
+  F2: 291,
+  F3: 292,
+  F4: 293,
+  F5: 294,
+  F6: 295,
+  F7: 296,
+  F8: 297,
+  F9: 298,
+  F10: 299,
+  F11: 300,
+  F12: 301,
+  LEFT_SHIFT: 340,
+  LEFT_CONTROL: 341,
+  LEFT_ALT: 342,
+  LEFT_SUPER: 343,
+  RIGHT_SHIFT: 344,
+  RIGHT_CONTROL: 345,
+  RIGHT_ALT: 346,
+  RIGHT_SUPER: 347,
+  KB_MENU: 348,
+  KP_0: 320,
+  KP_1: 321,
+  KP_2: 322,
+  KP_3: 323,
+  KP_4: 324,
+  KP_5: 325,
+  KP_6: 326,
+  KP_7: 327,
+  KP_8: 328,
+  KP_9: 329,
+  KP_DECIMAL: 330,
+  KP_DIVIDE: 331,
+  KP_MULTIPLY: 332,
+  KP_SUBTRACT: 333,
+  KP_ADD: 334,
+  KP_ENTER: 335,
+  KP_EQUAL: 336,
+  BACK: 4,
+  MENU: 5,
+  VOLUME_UP: 24,
+  VOLUME_DOWN: 25,
+} as const;
+
+export const MOUSE = {
+  BUTTON_LEFT: 0,
+  BUTTON_RIGHT: 1,
+  BUTTON_MIDDLE: 2,
+  BUTTON_SIDE: 3,
+  BUTTON_EXTRA: 4,
+  BUTTON_FORWARD: 5,
+  BUTTON_BACK: 6,
+  LEFT_BUTTON: 0,
+  RIGHT_BUTTON: 1,
+  MIDDLE_BUTTON: 2,
+} as const;
+
+export const CURSOR = {
+  DEFAULT: 0,
+  ARROW: 1,
+  IBEAM: 2,
+  CROSSHAIR: 3,
+  POINTING_HAND: 4,
+  RESIZE_EW: 5,
+  RESIZE_NS: 6,
+  RESIZE_NWSE: 7,
+  RESIZE_NESW: 8,
+  RESIZE_ALL: 9,
+  NOT_ALLOWED: 10,
+} as const;
+
+export const GAMEPAD = {
+  BUTTON_UNKNOWN: 0,
+  BUTTON_LEFT_FACE_UP: 1,
+  BUTTON_LEFT_FACE_RIGHT: 2,
+  BUTTON_LEFT_FACE_DOWN: 3,
+  BUTTON_LEFT_FACE_LEFT: 4,
+  BUTTON_RIGHT_FACE_UP: 5,
+  BUTTON_RIGHT_FACE_RIGHT: 6,
+  BUTTON_RIGHT_FACE_DOWN: 7,
+  BUTTON_RIGHT_FACE_LEFT: 8,
+  BUTTON_LEFT_TRIGGER_1: 9,
+  BUTTON_LEFT_TRIGGER_2: 10,
+  BUTTON_RIGHT_TRIGGER_1: 11,
+  BUTTON_RIGHT_TRIGGER_2: 12,
+  BUTTON_MIDDLE_LEFT: 13,
+  BUTTON_MIDDLE: 14,
+  BUTTON_MIDDLE_RIGHT: 15,
+  BUTTON_LEFT_THUMB: 16,
+  BUTTON_RIGHT_THUMB: 17,
+  AXIS_LEFT_X: 0,
+  AXIS_LEFT_Y: 1,
+  AXIS_RIGHT_X: 2,
+  AXIS_RIGHT_Y: 3,
+  AXIS_LEFT_TRIGGER: 4,
+  AXIS_RIGHT_TRIGGER: 5,
+} as const;
+
+export const FLAGS = {
+  VSYNC_HINT: 0x00000040,
+  FULLSCREEN_MODE: 0x00000002,
+  WINDOW_RESIZABLE: 0x00000004,
+  WINDOW_UNDECORATED: 0x00000008,
+  WINDOW_HIDDEN: 0x00000080,
+  WINDOW_MINIMIZED: 0x00000200,
+  WINDOW_MAXIMIZED: 0x00000400,
+  WINDOW_UNFOCUSED: 0x00000800,
+  WINDOW_TOPMOST: 0x00001000,
+  WINDOW_ALWAYS_RUN: 0x00000100,
+  WINDOW_TRANSPARENT: 0x00000010,
+  WINDOW_HIGHDPI: 0x00002000,
+  WINDOW_MOUSE_PASSTHROUGH: 0x00004000,
+  BORDERLESS_WINDOWED_MODE: 0x00008000,
+  MSAA_4X_HINT: 0x00000020,
+  INTERLACED_HINT: 0x00010000,
+} as const;
+
+export const LOG = {
+  ALL: 0,
+  TRACE: 1,
+  DEBUG: 2,
+  INFO: 3,
+  WARNING: 4,
+  ERROR: 5,
+  FATAL: 6,
+  NONE: 7,
+} as const;
+
+export const BLEND = {
+  ALPHA: 0,
+  ADDITIVE: 1,
+  MULTIPLIED: 2,
+  ADD_COLORS: 3,
+  SUBTRACT_COLORS: 4,
+  ALPHA_PREMULTIPLY: 5,
+  CUSTOM: 6,
+  CUSTOM_SEPARATE: 7,
+} as const;
+
+export const GESTURE = {
+  NONE: 0,
+  TAP: 1,
+  DOUBLETAP: 2,
+  HOLD: 4,
+  DRAG: 8,
+  SWIPE_RIGHT: 16,
+  SWIPE_LEFT: 32,
+  SWIPE_UP: 64,
+  SWIPE_DOWN: 128,
+  PINCH_IN: 256,
+  PINCH_OUT: 512,
+} as const;
+
+export const CAMERA = {
+  CUSTOM: 0,
+  FREE: 1,
+  ORBITAL: 2,
+  FIRST_PERSON: 3,
+  THIRD_PERSON: 4,
+  PERSPECTIVE: 0,
+  ORTHOGRAPHIC: 1,
+} as const;
+
+export const PIXELFORMAT = {
+  UNCOMPRESSED_GRAYSCALE: 1,
+  UNCOMPRESSED_GRAY_ALPHA: 2,
+  UNCOMPRESSED_R5G6B5: 3,
+  UNCOMPRESSED_R8G8B8: 4,
+  UNCOMPRESSED_R5G5B5A1: 5,
+  UNCOMPRESSED_R4G4B4A4: 6,
+  UNCOMPRESSED_R8G8B8A8: 7,
+  UNCOMPRESSED_R32: 8,
+  UNCOMPRESSED_R32G32B32: 9,
+  UNCOMPRESSED_R32G32B32A32: 10,
+  UNCOMPRESSED_R16: 11,
+  UNCOMPRESSED_R16G16B16: 12,
+  UNCOMPRESSED_R16G16B16A16: 13,
+  COMPRESSED_DXT1_RGB: 14,
+  COMPRESSED_DXT1_RGBA: 15,
+  COMPRESSED_DXT3_RGBA: 16,
+  COMPRESSED_DXT5_RGBA: 17,
+  COMPRESSED_ETC1_RGB: 18,
+  COMPRESSED_ETC2_RGB: 19,
+  COMPRESSED_ETC2_EAC_RGBA: 20,
+  COMPRESSED_PVRT_RGB: 21,
+  COMPRESSED_PVRT_RGBA: 22,
+  COMPRESSED_ASTC_4x4_RGBA: 23,
+  COMPRESSED_ASTC_8x8_RGBA: 24,
+} as const;
+
+export const TEXTURE = {
+  FILTER_POINT: 0,
+  FILTER_BILINEAR: 1,
+  FILTER_TRILINEAR: 2,
+  FILTER_ANISOTROPIC_4X: 3,
+  FILTER_ANISOTROPIC_8X: 4,
+  FILTER_ANISOTROPIC_16X: 5,
+  WRAP_REPEAT: 0,
+  WRAP_CLAMP: 1,
+  WRAP_MIRROR_REPEAT: 2,
+  WRAP_MIRROR_CLAMP: 3,
+} as const;
+
+export const CUBEMAP = {
+  AUTO_DETECT: 0,
+  LINE_VERTICAL: 1,
+  LINE_HORIZONTAL: 2,
+  CROSS_THREE_BY_FOUR: 3,
+  CROSS_FOUR_BY_THREE: 4,
+} as const;
+
+export const FONT = {
+  DEFAULT: 0,
+  BITMAP: 1,
+  SDF: 2,
+} as const;
+
+export const MATERIAL_MAP = {
+  ALBEDO: 0,
+  METALNESS: 1,
+  NORMAL: 2,
+  ROUGHNESS: 3,
+  OCCLUSION: 4,
+  EMISSION: 5,
+  HEIGHT: 6,
+  CUBEMAP: 7,
+  IRRADIANCE: 8,
+  PREFILTER: 9,
+  BRDF: 10,
+  DIFFUSE: 0,
+  SPECULAR: 1,
+} as const;
+
+export const SHADER_LOC = {
+  VERTEX_POSITION: 0,
+  VERTEX_TEXCOORD01: 1,
+  VERTEX_TEXCOORD02: 2,
+  VERTEX_NORMAL: 3,
+  VERTEX_TANGENT: 4,
+  VERTEX_COLOR: 5,
+  MATRIX_MVP: 6,
+  MATRIX_VIEW: 7,
+  MATRIX_PROJECTION: 8,
+  MATRIX_MODEL: 9,
+  MATRIX_NORMAL: 10,
+  VECTOR_VIEW: 11,
+  COLOR_DIFFUSE: 12,
+  COLOR_SPECULAR: 13,
+  COLOR_AMBIENT: 14,
+  MAP_ALBEDO: 15,
+  MAP_METALNESS: 16,
+  MAP_NORMAL: 17,
+  MAP_ROUGHNESS: 18,
+  MAP_OCCLUSION: 19,
+  MAP_EMISSION: 20,
+  MAP_HEIGHT: 21,
+  MAP_CUBEMAP: 22,
+  MAP_IRRADIANCE: 23,
+  MAP_PREFILTER: 24,
+  MAP_BRDF: 25,
+  VERTEX_BONEIDS: 26,
+  VERTEX_BONEWEIGHTS: 27,
+  BONE_MATRICES: 28,
+  MAP_DIFFUSE: 15,
+  MAP_SPECULAR: 16,
+} as const;
+
+export const SHADER_UNIFORM = {
+  FLOAT: 0,
+  VEC2: 1,
+  VEC3: 2,
+  VEC4: 3,
+  INT: 4,
+  IVEC2: 5,
+  IVEC3: 6,
+  IVEC4: 7,
+  SAMPLER2D: 8,
+} as const;
+
+export const SHADER_ATTRIB = {
+  FLOAT: 0,
+  VEC2: 1,
+  VEC3: 2,
+  VEC4: 3,
+} as const;
+
+export const NPATCH = {
+  NINE_PATCH: 0,
+  THREE_PATCH_VERTICAL: 1,
+  THREE_PATCH_HORIZONTAL: 2,
+} as const;

package/src/index.ts

@@ -0,0 +1,29 @@
+export { Raylib } from "./Raylib";
+export { configure, getSymbols } from "./symbols";
+export type { RaylibConfig } from "./symbols";
+export { cstr, color } from "./utils";
+export type {
+  CameraProjection,
+  Vec2,
+  Vec3,
+  Vec4,
+  Rectangle,
+  Color,
+  Texture2D,
+  RenderTexture2D,
+  Model,
+  BoundingBox,
+  Font,
+  Image,
+  Shader,
+  Wave,
+  Sound,
+  Music,
+  AudioStream,
+  Material,
+  Mesh,
+  ModelAnimation,
+  RayCollision,
+  GlyphInfo,
+} from "./types";
+export * from "./constants";