Cheatsheet

Every function on one page, Zig on the left and C on the right. Each name links to its entry in the API reference.

core

Zig	C
`rl.initWindow(width: i32, height: i32, title: [:0]const u8) void`	`void InitWindow(int width, int height, const char *title)`
`rl.closeWindow() void`	`void CloseWindow(void)`
`rl.windowShouldClose() bool`	`bool WindowShouldClose(void)`
`rl.isWindowReady() bool`	`bool IsWindowReady(void)`
`rl.isWindowFullscreen() bool`	`bool IsWindowFullscreen(void)`
`rl.isWindowHidden() bool`	`bool IsWindowHidden(void)`
`rl.isWindowMinimized() bool`	`bool IsWindowMinimized(void)`
`rl.isWindowMaximized() bool`	`bool IsWindowMaximized(void)`
`rl.isWindowFocused() bool`	`bool IsWindowFocused(void)`
`rl.isWindowResized() bool`	`bool IsWindowResized(void)`
`rl.isWindowState(flag: ConfigFlags) bool`	`bool IsWindowState(unsigned int flag)`
`rl.setWindowState(flags: ConfigFlags) void`	`void SetWindowState(unsigned int flags)`
`rl.clearWindowState(flags: ConfigFlags) void`	`void ClearWindowState(unsigned int flags)`
`rl.toggleFullscreen() void`	`void ToggleFullscreen(void)`
`rl.toggleBorderlessWindowed() void`	`void ToggleBorderlessWindowed(void)`
`rl.maximizeWindow() void`	`void MaximizeWindow(void)`
`rl.minimizeWindow() void`	`void MinimizeWindow(void)`
`rl.restoreWindow() void`	`void RestoreWindow(void)`
`rl.setWindowIcon(image: Image) void`	`void SetWindowIcon(Image image)`
`rl.setWindowIcons(images: []Image) void`	`void SetWindowIcons(Image *images, int count)`
`rl.setWindowTitle(title: [:0]const u8) void`	`void SetWindowTitle(const char *title)`
`rl.setWindowPosition(x: i32, y: i32) void`	`void SetWindowPosition(int x, int y)`
`rl.setWindowMonitor(monitor: i32) void`	`void SetWindowMonitor(int monitor)`
`rl.setWindowMinSize(width: i32, height: i32) void`	`void SetWindowMinSize(int width, int height)`
`rl.setWindowMaxSize(width: i32, height: i32) void`	`void SetWindowMaxSize(int width, int height)`
`rl.setWindowSize(width: i32, height: i32) void`	`void SetWindowSize(int width, int height)`
`rl.setWindowOpacity(opacity: f32) void`	`void SetWindowOpacity(float opacity)`
`rl.setWindowFocused() void`	`void SetWindowFocused(void)`
`rl.getWindowHandle() ?*anyopaque`	`void *GetWindowHandle(void)`
`rl.getScreenWidth() i32`	`int GetScreenWidth(void)`
`rl.getScreenHeight() i32`	`int GetScreenHeight(void)`
`rl.getRenderWidth() i32`	`int GetRenderWidth(void)`
`rl.getRenderHeight() i32`	`int GetRenderHeight(void)`
`rl.getMonitorCount() i32`	`int GetMonitorCount(void)`
`rl.getCurrentMonitor() i32`	`int GetCurrentMonitor(void)`
`rl.getMonitorPosition(monitor: i32) Vector2`	`Vector2 GetMonitorPosition(int monitor)`
`rl.getMonitorWidth(monitor: i32) i32`	`int GetMonitorWidth(int monitor)`
`rl.getMonitorHeight(monitor: i32) i32`	`int GetMonitorHeight(int monitor)`
`rl.getMonitorPhysicalWidth(monitor: i32) i32`	`int GetMonitorPhysicalWidth(int monitor)`
`rl.getMonitorPhysicalHeight(monitor: i32) i32`	`int GetMonitorPhysicalHeight(int monitor)`
`rl.getMonitorRefreshRate(monitor: i32) i32`	`int GetMonitorRefreshRate(int monitor)`
`rl.getWindowPosition() Vector2`	`Vector2 GetWindowPosition(void)`
`rl.getWindowScaleDPI() Vector2`	`Vector2 GetWindowScaleDPI(void)`
`rl.getMonitorName(monitor: i32) [:0]const u8`	`const char *GetMonitorName(int monitor)`
`rl.setClipboardText(text: [:0]const u8) void`	`void SetClipboardText(const char *text)`
`rl.getClipboardText() ?[:0]const u8`	`const char *GetClipboardText(void)`
`rl.getClipboardImage() Image`	`Image GetClipboardImage(void)`
`rl.enableEventWaiting() void`	`void EnableEventWaiting(void)`
`rl.disableEventWaiting() void`	`void DisableEventWaiting(void)`
`rl.showCursor() void`	`void ShowCursor(void)`
`rl.hideCursor() void`	`void HideCursor(void)`
`rl.isCursorHidden() bool`	`bool IsCursorHidden(void)`
`rl.enableCursor() void`	`void EnableCursor(void)`
`rl.disableCursor() void`	`void DisableCursor(void)`
`rl.isCursorOnScreen() bool`	`bool IsCursorOnScreen(void)`
`rl.clearBackground(color: Color) void`	`void ClearBackground(Color color)`
`rl.beginDrawing() void`	`void BeginDrawing(void)`
`rl.endDrawing() void`	`void EndDrawing(void)`
`rl.beginMode2D(camera: Camera2D) void`	`void BeginMode2D(Camera2D camera)`
`rl.endMode2D() void`	`void EndMode2D(void)`
`rl.beginMode3D(camera: Camera3D) void`	`void BeginMode3D(Camera3D camera)`
`rl.endMode3D() void`	`void EndMode3D(void)`
`rl.beginTextureMode(target: RenderTexture2D) void`	`void BeginTextureMode(RenderTexture2D target)`
`rl.endTextureMode() void`	`void EndTextureMode(void)`
`rl.beginShaderMode(shader: Shader) void`	`void BeginShaderMode(Shader shader)`
`rl.endShaderMode() void`	`void EndShaderMode(void)`
`rl.beginBlendMode(mode: BlendMode) void`	`void BeginBlendMode(int mode)`
`rl.endBlendMode() void`	`void EndBlendMode(void)`
`rl.beginScissorMode(x: i32, y: i32, width: i32, height: i32) void`	`void BeginScissorMode(int x, int y, int width, int height)`
`rl.endScissorMode() void`	`void EndScissorMode(void)`
`rl.beginVrStereoMode(config: VrStereoConfig) void`	`void BeginVrStereoMode(VrStereoConfig config)`
`rl.endVrStereoMode() void`	`void EndVrStereoMode(void)`
`rl.loadVrStereoConfig(device: VrDeviceInfo) VrStereoConfig`	`VrStereoConfig LoadVrStereoConfig(VrDeviceInfo device)`
`rl.unloadVrStereoConfig(config: VrStereoConfig) void`	`void UnloadVrStereoConfig(VrStereoConfig config)`
`rl.loadShader(vsFileName: ?[:0]const u8, fsFileName: ?[:0]const u8) error{LoadFailed}!Shader`	`Shader LoadShader(const char vsFileName, const char fsFileName)`
`rl.loadShaderFromMemory(vsCode: ?[:0]const u8, fsCode: ?[:0]const u8) error{LoadFailed}!Shader`	`Shader LoadShaderFromMemory(const char vsCode, const char fsCode)`
`rl.isShaderValid(shader: Shader) bool`	`bool IsShaderValid(Shader shader)`
`rl.getShaderLocation(shader: Shader, uniformName: [:0]const u8) i32`	`int GetShaderLocation(Shader shader, const char *uniformName)`
`rl.getShaderLocationAttrib(shader: Shader, attribName: [:0]const u8) i32`	`int GetShaderLocationAttrib(Shader shader, const char *attribName)`
`rl.setShaderValue(shader: Shader, locIndex: i32, value: anytype) void`	`void SetShaderValue(Shader shader, int locIndex, const void *value, int uniformType)`
`rl.setShaderValueV(shader: Shader, locIndex: i32, values: anytype) void`	`void SetShaderValueV(Shader shader, int locIndex, const void *value, int uniformType, int count)`
`rl.setShaderValueMatrix(shader: Shader, locIndex: i32, mat: Matrix) void`	`void SetShaderValueMatrix(Shader shader, int locIndex, Matrix mat)`
`rl.setShaderValueTexture(shader: Shader, locIndex: i32, texture: Texture2D) void`	`void SetShaderValueTexture(Shader shader, int locIndex, Texture2D texture)`
`rl.unloadShader(shader: Shader) void`	`void UnloadShader(Shader shader)`
`rl.getScreenToWorldRay(position: Vector2, camera: Camera) Ray`	`Ray GetScreenToWorldRay(Vector2 position, Camera camera)`
`rl.getScreenToWorldRayEx(position: Vector2, camera: Camera, width: i32, height: i32) Ray`	`Ray GetScreenToWorldRayEx(Vector2 position, Camera camera, int width, int height)`
`rl.getWorldToScreen(position: Vector3, camera: Camera) Vector2`	`Vector2 GetWorldToScreen(Vector3 position, Camera camera)`
`rl.getWorldToScreenEx(position: Vector3, camera: Camera, width: i32, height: i32) Vector2`	`Vector2 GetWorldToScreenEx(Vector3 position, Camera camera, int width, int height)`
`rl.getWorldToScreen2D(position: Vector2, camera: Camera2D) Vector2`	`Vector2 GetWorldToScreen2D(Vector2 position, Camera2D camera)`
`rl.getScreenToWorld2D(position: Vector2, camera: Camera2D) Vector2`	`Vector2 GetScreenToWorld2D(Vector2 position, Camera2D camera)`
`rl.getCameraMatrix(camera: Camera) Matrix`	`Matrix GetCameraMatrix(Camera camera)`
`rl.getCameraMatrix2D(camera: Camera2D) Matrix`	`Matrix GetCameraMatrix2D(Camera2D camera)`
`rl.setTargetFPS(fps: i32) void`	`void SetTargetFPS(int fps)`
`rl.getFrameTime() f32`	`float GetFrameTime(void)`
`rl.getTime() f64`	`double GetTime(void)`
`rl.getFPS() i32`	`int GetFPS(void)`
`rl.swapScreenBuffer() void`	`void SwapScreenBuffer(void)`
`rl.pollInputEvents() void`	`void PollInputEvents(void)`
`rl.waitTime(seconds: f64) void`	`void WaitTime(double seconds)`
`rl.setRandomSeed(seed: u32) void`	`void SetRandomSeed(unsigned int seed)`
`rl.getRandomValue(min: i32, max: i32) i32`	`int GetRandomValue(int min, int max)`
`rl.loadRandomSequence(count: u32, min: i32, max: i32) error{LoadFailed}![]i32`	`int *LoadRandomSequence(unsigned int count, int min, int max)`
`rl.unloadRandomSequence(sequence: []i32) void`	`void UnloadRandomSequence(int *sequence)`
`rl.takeScreenshot(fileName: [:0]const u8) void`	`void TakeScreenshot(const char *fileName)`
`rl.setConfigFlags(flags: ConfigFlags) void`	`void SetConfigFlags(unsigned int flags)`
`rl.openURL(url: [:0]const u8) void`	`void OpenURL(const char *url)`
`rl.setTraceLogLevel(logLevel: TraceLogLevel) void`	`void SetTraceLogLevel(int logLevel)`
`rl.traceLog(logLevel: TraceLogLevel, comptime format: []const u8, args: anytype) void`	`void TraceLog(int logLevel, const char *text, ...)`
`rl.setTraceLogCallback(comptime callback: ?fn (logLevel: TraceLogLevel, text: [:0]const u8) void) void`	`void SetTraceLogCallback(TraceLogCallback callback)`
`rl.memAlloc(size: u32) ?*anyopaque`	`void *MemAlloc(unsigned int size)`
`rl.memRealloc(ptr: ?anyopaque, size: u32) ?anyopaque`	`void MemRealloc(void ptr, unsigned int size)`
`rl.memFree(ptr: *anyopaque) void`	`void MemFree(void *ptr)`
`rl.loadFileData(fileName: [:0]const u8) error{LoadFailed}![]u8`	`unsigned char LoadFileData(const char fileName, int *dataSize)`
`rl.unloadFileData(data: []u8) void`	`void UnloadFileData(unsigned char *data)`
`rl.saveFileData(fileName: [:0]const u8, data: []const u8) bool`	`bool SaveFileData(const char fileName, const void data, int dataSize)`
`rl.exportDataAsCode(data: []const u8, fileName: [:0]const u8) bool`	`bool ExportDataAsCode(const unsigned char data, int dataSize, const char fileName)`
`rl.loadFileText(fileName: [:0]const u8) error{LoadFailed}![:0]u8`	`char LoadFileText(const char fileName)`
`rl.unloadFileText(text: [:0]u8) void`	`void UnloadFileText(char *text)`
`rl.saveFileText(fileName: [:0]const u8, text: [:0]const u8) bool`	`bool SaveFileText(const char fileName, const char text)`
`rl.setLoadFileDataCallback(callback: LoadFileDataCallback) void`	`void SetLoadFileDataCallback(LoadFileDataCallback callback)`
`rl.setSaveFileDataCallback(callback: SaveFileDataCallback) void`	`void SetSaveFileDataCallback(SaveFileDataCallback callback)`
`rl.setLoadFileTextCallback(callback: LoadFileTextCallback) void`	`void SetLoadFileTextCallback(LoadFileTextCallback callback)`
`rl.setSaveFileTextCallback(callback: SaveFileTextCallback) void`	`void SetSaveFileTextCallback(SaveFileTextCallback callback)`
`rl.fileRename(fileName: [:0]const u8, newFileName: [:0]const u8) i32`	`int FileRename(const char fileName, const char fileRename)`
`rl.fileRemove(fileName: [:0]const u8) i32`	`int FileRemove(const char *fileName)`
`rl.fileCopy(srcPath: [:0]const u8, dstPath: [:0]const u8) i32`	`int FileCopy(const char srcPath, const char dstPath)`
`rl.fileMove(srcPath: [:0]const u8, dstPath: [:0]const u8) i32`	`int FileMove(const char srcPath, const char dstPath)`
`rl.fileTextReplace(fileName: [:0]const u8, search: [:0]const u8, replacement: [:0]const u8) i32`	`int FileTextReplace(const char fileName, const char search, const char *replacement)`
`rl.fileTextFindIndex(fileName: [:0]const u8, search: [:0]const u8) i32`	`int FileTextFindIndex(const char fileName, const char search)`
`rl.fileExists(fileName: [:0]const u8) bool`	`bool FileExists(const char *fileName)`
`rl.directoryExists(dirPath: [:0]const u8) bool`	`bool DirectoryExists(const char *dirPath)`
`rl.isFileExtension(fileName: [:0]const u8, ext: [:0]const u8) bool`	`bool IsFileExtension(const char fileName, const char ext)`
`rl.isFileHidden(filePath: [:0]const u8) bool`	`bool IsFileHidden(const char *filePath)`
`rl.getFileLength(fileName: [:0]const u8) i32`	`int GetFileLength(const char *fileName)`
`rl.getFileModTime(fileName: [:0]const u8) i64`	`long GetFileModTime(const char *fileName)`
`rl.getFileExtension(fileName: [:0]const u8) [:0]const u8`	`const char GetFileExtension(const char fileName)`
`rl.getFileName(filePath: [:0]const u8) [:0]const u8`	`const char GetFileName(const char filePath)`
`rl.getFileNameWithoutExt(filePath: [:0]const u8) [:0]const u8`	`const char GetFileNameWithoutExt(const char filePath)`
`rl.getDirectoryPath(filePath: [:0]const u8) [:0]const u8`	`const char GetDirectoryPath(const char filePath)`
`rl.getPrevDirectoryPath(dirPath: [:0]const u8) [:0]const u8`	`const char GetPrevDirectoryPath(const char dirPath)`
`rl.getWorkingDirectory() [:0]const u8`	`const char *GetWorkingDirectory(void)`
`rl.getApplicationDirectory() [:0]const u8`	`const char *GetApplicationDirectory(void)`
`rl.makeDirectory(dirPath: [:0]const u8) i32`	`int MakeDirectory(const char *dirPath)`
`rl.changeDirectory(dirPath: [:0]const u8) i32`	`int ChangeDirectory(const char *dirPath)`
`rl.isPathFile(path: [:0]const u8) bool`	`bool IsPathFile(const char *path)`
`rl.isPathDirectory(path: [:0]const u8) bool`	`bool IsPathDirectory(const char *path)`
`rl.isPathAbsolute(path: [:0]const u8) bool`	`bool IsPathAbsolute(const char *path)`
`rl.isFileNameValid(fileName: [:0]const u8) bool`	`bool IsFileNameValid(const char *fileName)`
`rl.loadDirectoryFiles(dirPath: [:0]const u8) FilePathList`	`FilePathList LoadDirectoryFiles(const char *dirPath)`
`rl.loadDirectoryFilesEx(basePath: [:0]const u8, filter: [:0]const u8, scanSubdirs: bool) FilePathList`	`FilePathList LoadDirectoryFilesEx(const char basePath, const char filter, bool scanSubdirs)`
`rl.unloadDirectoryFiles(files: FilePathList) void`	`void UnloadDirectoryFiles(FilePathList files)`
`rl.isFileDropped() bool`	`bool IsFileDropped(void)`
`rl.loadDroppedFiles() FilePathList`	`FilePathList LoadDroppedFiles(void)`
`rl.unloadDroppedFiles(files: FilePathList) void`	`void UnloadDroppedFiles(FilePathList files)`
`rl.getDirectoryFileCount(dirPath: [:0]const u8) u32`	`unsigned int GetDirectoryFileCount(const char *dirPath)`
`rl.getDirectoryFileCountEx(basePath: [:0]const u8, filter: [:0]const u8, scanSubdirs: bool) u32`	`unsigned int GetDirectoryFileCountEx(const char basePath, const char filter, bool scanSubdirs)`
`rl.compressData(data: []const u8) error{CompressFailed}![]u8`	`unsigned char CompressData(const unsigned char data, int dataSize, int *compDataSize)`
`rl.decompressData(compData: []const u8) error{DecompressFailed}![]u8`	`unsigned char DecompressData(const unsigned char compData, int compDataSize, int *dataSize)`
`rl.encodeDataBase64(data: []const u8) error{EncodeFailed}![:0]u8`	`char EncodeDataBase64(const unsigned char data, int dataSize, int *outputSize)`
`rl.decodeDataBase64(text: [:0]const u8) error{DecodeFailed}![]u8`	`unsigned char DecodeDataBase64(const char text, int *outputSize)`
`rl.computeCRC32(data: []const u8) u32`	`unsigned int ComputeCRC32(const unsigned char *data, int dataSize)`
`rl.computeMD5(data: []const u8) *const [4]u32`	`unsigned int ComputeMD5(const unsigned char data, int dataSize)`
`rl.computeSHA1(data: []const u8) *const [5]u32`	`unsigned int ComputeSHA1(const unsigned char data, int dataSize)`
`rl.computeSHA256(data: []const u8) *const [8]u32`	`unsigned int ComputeSHA256(const unsigned char data, int dataSize)`
`rl.loadAutomationEventList(fileName: ?[:0]const u8) AutomationEventList`	`AutomationEventList LoadAutomationEventList(const char *fileName)`
`rl.unloadAutomationEventList(list: AutomationEventList) void`	`void UnloadAutomationEventList(AutomationEventList list)`
`rl.exportAutomationEventList(list: AutomationEventList, fileName: [:0]const u8) bool`	`bool ExportAutomationEventList(AutomationEventList list, const char *fileName)`
`rl.setAutomationEventList(list: *AutomationEventList) void`	`void SetAutomationEventList(AutomationEventList *list)`
`rl.setAutomationEventBaseFrame(frame: i32) void`	`void SetAutomationEventBaseFrame(int frame)`
`rl.startAutomationEventRecording() void`	`void StartAutomationEventRecording(void)`
`rl.stopAutomationEventRecording() void`	`void StopAutomationEventRecording(void)`
`rl.playAutomationEvent(event: AutomationEvent) void`	`void PlayAutomationEvent(AutomationEvent event)`
`rl.isKeyPressed(key: KeyboardKey) bool`	`bool IsKeyPressed(int key)`
`rl.isKeyPressedRepeat(key: KeyboardKey) bool`	`bool IsKeyPressedRepeat(int key)`
`rl.isKeyDown(key: KeyboardKey) bool`	`bool IsKeyDown(int key)`
`rl.isKeyReleased(key: KeyboardKey) bool`	`bool IsKeyReleased(int key)`
`rl.isKeyUp(key: KeyboardKey) bool`	`bool IsKeyUp(int key)`
`rl.getKeyPressed() KeyboardKey`	`int GetKeyPressed(void)`
`rl.getCharPressed() i32`	`int GetCharPressed(void)`
`rl.getKeyName(key: KeyboardKey) ?[:0]const u8`	`const char *GetKeyName(int key)`
`rl.setExitKey(key: KeyboardKey) void`	`void SetExitKey(int key)`
`rl.isGamepadAvailable(gamepad: i32) bool`	`bool IsGamepadAvailable(int gamepad)`
`rl.getGamepadName(gamepad: i32) ?[:0]const u8`	`const char *GetGamepadName(int gamepad)`
`rl.isGamepadButtonPressed(gamepad: i32, button: GamepadButton) bool`	`bool IsGamepadButtonPressed(int gamepad, int button)`
`rl.isGamepadButtonDown(gamepad: i32, button: GamepadButton) bool`	`bool IsGamepadButtonDown(int gamepad, int button)`
`rl.isGamepadButtonReleased(gamepad: i32, button: GamepadButton) bool`	`bool IsGamepadButtonReleased(int gamepad, int button)`
`rl.isGamepadButtonUp(gamepad: i32, button: GamepadButton) bool`	`bool IsGamepadButtonUp(int gamepad, int button)`
`rl.getGamepadButtonPressed() GamepadButton`	`int GetGamepadButtonPressed(void)`
`rl.getGamepadAxisCount(gamepad: i32) i32`	`int GetGamepadAxisCount(int gamepad)`
`rl.getGamepadAxisMovement(gamepad: i32, axis: GamepadAxis) f32`	`float GetGamepadAxisMovement(int gamepad, int axis)`
`rl.setGamepadMappings(mappings: [:0]const u8) i32`	`int SetGamepadMappings(const char *mappings)`
`rl.setGamepadVibration(gamepad: i32, leftMotor: f32, rightMotor: f32, duration: f32) void`	`void SetGamepadVibration(int gamepad, float leftMotor, float rightMotor, float duration)`
`rl.isMouseButtonPressed(button: MouseButton) bool`	`bool IsMouseButtonPressed(int button)`
`rl.isMouseButtonDown(button: MouseButton) bool`	`bool IsMouseButtonDown(int button)`
`rl.isMouseButtonReleased(button: MouseButton) bool`	`bool IsMouseButtonReleased(int button)`
`rl.isMouseButtonUp(button: MouseButton) bool`	`bool IsMouseButtonUp(int button)`
`rl.getMouseX() i32`	`int GetMouseX(void)`
`rl.getMouseY() i32`	`int GetMouseY(void)`
`rl.getMousePosition() Vector2`	`Vector2 GetMousePosition(void)`
`rl.getMouseDelta() Vector2`	`Vector2 GetMouseDelta(void)`
`rl.setMousePosition(x: i32, y: i32) void`	`void SetMousePosition(int x, int y)`
`rl.setMouseOffset(offsetX: i32, offsetY: i32) void`	`void SetMouseOffset(int offsetX, int offsetY)`
`rl.setMouseScale(scaleX: f32, scaleY: f32) void`	`void SetMouseScale(float scaleX, float scaleY)`
`rl.getMouseWheelMove() f32`	`float GetMouseWheelMove(void)`
`rl.getMouseWheelMoveV() Vector2`	`Vector2 GetMouseWheelMoveV(void)`
`rl.setMouseCursor(cursor: MouseCursor) void`	`void SetMouseCursor(int cursor)`
`rl.getTouchX() i32`	`int GetTouchX(void)`
`rl.getTouchY() i32`	`int GetTouchY(void)`
`rl.getTouchPosition(index: i32) Vector2`	`Vector2 GetTouchPosition(int index)`
`rl.getTouchPointId(index: i32) i32`	`int GetTouchPointId(int index)`
`rl.getTouchPointCount() i32`	`int GetTouchPointCount(void)`

gestures

Zig	C
`rl.setGesturesEnabled(flags: u32) void`	`void SetGesturesEnabled(unsigned int flags)`
`rl.isGestureDetected(gesture: Gesture) bool`	`bool IsGestureDetected(unsigned int gesture)`
`rl.getGestureDetected() Gesture`	`int GetGestureDetected(void)`
`rl.getGestureHoldDuration() f32`	`float GetGestureHoldDuration(void)`
`rl.getGestureDragVector() Vector2`	`Vector2 GetGestureDragVector(void)`
`rl.getGestureDragAngle() f32`	`float GetGestureDragAngle(void)`
`rl.getGesturePinchVector() Vector2`	`Vector2 GetGesturePinchVector(void)`
`rl.getGesturePinchAngle() f32`	`float GetGesturePinchAngle(void)`

camera

Zig	C
`rl.updateCamera(camera: *Camera, mode: CameraMode) void`	`void UpdateCamera(Camera *camera, int mode)`
`rl.updateCameraPro(camera: *Camera, movement: Vector3, rotation: Vector3, zoom: f32) void`	`void UpdateCameraPro(Camera *camera, Vector3 movement, Vector3 rotation, float zoom)`
`rl.getCameraForward(camera: *Camera) Vector3`	`Vector3 GetCameraForward(Camera *camera)`
`rl.getCameraUp(camera: *Camera) Vector3`	`Vector3 GetCameraUp(Camera *camera)`
`rl.getCameraRight(camera: *Camera) Vector3`	`Vector3 GetCameraRight(Camera *camera)`
`rl.cameraMoveForward(camera: *Camera, distance: f32, moveInWorldPlane: bool) void`	`void CameraMoveForward(Camera *camera, float distance, bool moveInWorldPlane)`
`rl.cameraMoveUp(camera: *Camera, distance: f32) void`	`void CameraMoveUp(Camera *camera, float distance)`
`rl.cameraMoveRight(camera: *Camera, distance: f32, moveInWorldPlane: bool) void`	`void CameraMoveRight(Camera *camera, float distance, bool moveInWorldPlane)`
`rl.cameraMoveToTarget(camera: *Camera, delta: f32) void`	`void CameraMoveToTarget(Camera *camera, float delta)`
`rl.cameraYaw(camera: *Camera, angle: f32, rotateAroundTarget: bool) void`	`void CameraYaw(Camera *camera, float angle, bool rotateAroundTarget)`
`rl.cameraPitch(camera: *Camera, angle: f32, lockView: bool, rotateAroundTarget: bool, rotateUp: bool) void`	`void CameraPitch(Camera *camera, float angle, bool lockView, bool rotateAroundTarget, bool rotateUp)`
`rl.cameraRoll(camera: *Camera, angle: f32) void`	`void CameraRoll(Camera *camera, float angle)`
`rl.getCameraViewMatrix(camera: *Camera) Matrix`	`Matrix GetCameraViewMatrix(Camera *camera)`
`rl.getCameraProjectionMatrix(camera: *Camera, aspect: f32) Matrix`	`Matrix GetCameraProjectionMatrix(Camera *camera, float aspect)`

shapes

Zig	C
`rl.setShapesTexture(texture: Texture2D, rec: Rectangle) void`	`void SetShapesTexture(Texture2D texture, Rectangle rec)`
`rl.getShapesTexture() Texture2D`	`Texture2D GetShapesTexture(void)`
`rl.getShapesTextureRectangle() Rectangle`	`Rectangle GetShapesTextureRectangle(void)`
`rl.drawPixel(posX: i32, posY: i32, color: Color) void`	`void DrawPixel(int posX, int posY, Color color)`
`rl.drawPixelV(position: Vector2, color: Color) void`	`void DrawPixelV(Vector2 position, Color color)`
`rl.drawLine(startPosX: i32, startPosY: i32, endPosX: i32, endPosY: i32, color: Color) void`	`void DrawLine(int startPosX, int startPosY, int endPosX, int endPosY, Color color)`
`rl.drawLineV(startPos: Vector2, endPos: Vector2, color: Color) void`	`void DrawLineV(Vector2 startPos, Vector2 endPos, Color color)`
`rl.drawLineEx(startPos: Vector2, endPos: Vector2, thick: f32, color: Color) void`	`void DrawLineEx(Vector2 startPos, Vector2 endPos, float thick, Color color)`
`rl.drawLineStrip(points: []const Vector2, color: Color) void`	`void DrawLineStrip(const Vector2 *points, int pointCount, Color color)`
`rl.drawLineBezier(startPos: Vector2, endPos: Vector2, thick: f32, color: Color) void`	`void DrawLineBezier(Vector2 startPos, Vector2 endPos, float thick, Color color)`
`rl.drawLineDashed(startPos: Vector2, endPos: Vector2, dashSize: i32, spaceSize: i32, color: Color) void`	`void DrawLineDashed(Vector2 startPos, Vector2 endPos, int dashSize, int spaceSize, Color color)`
`rl.drawTriangle(v1: Vector2, v2: Vector2, v3: Vector2, color: Color) void`	`void DrawTriangle(Vector2 v1, Vector2 v2, Vector2 v3, Color color)`
`rl.drawTriangleGradient(v1: Vector2, v2: Vector2, v3: Vector2, c1: Color, c2: Color, c3: Color) void`	`void DrawTriangleGradient(Vector2 v1, Vector2 v2, Vector2 v3, Color c1, Color c2, Color c3)`
`rl.drawTriangleLines(v1: Vector2, v2: Vector2, v3: Vector2, color: Color) void`	`void DrawTriangleLines(Vector2 v1, Vector2 v2, Vector2 v3, Color color)`
`rl.drawTriangleLinesEx(v1: Vector2, v2: Vector2, v3: Vector2, thick: f32, color: Color) void`	`void DrawTriangleLinesEx(Vector2 v1, Vector2 v2, Vector2 v3, float thick, Color color)`
`rl.drawTriangleFan(points: []const Vector2, color: Color) void`	`void DrawTriangleFan(const Vector2 *points, int pointCount, Color color)`
`rl.drawTriangleStrip(points: []const Vector2, color: Color) void`	`void DrawTriangleStrip(const Vector2 *points, int pointCount, Color color)`
`rl.drawRectangle(posX: i32, posY: i32, width: i32, height: i32, color: Color) void`	`void DrawRectangle(int posX, int posY, int width, int height, Color color)`
`rl.drawRectangleV(position: Vector2, size: Vector2, color: Color) void`	`void DrawRectangleV(Vector2 position, Vector2 size, Color color)`
`rl.drawRectangleRec(rec: Rectangle, color: Color) void`	`void DrawRectangleRec(Rectangle rec, Color color)`
`rl.drawRectanglePro(rec: Rectangle, origin: Vector2, rotation: f32, color: Color) void`	`void DrawRectanglePro(Rectangle rec, Vector2 origin, float rotation, Color color)`
`rl.drawRectangleGradientV(posX: i32, posY: i32, width: i32, height: i32, top: Color, bottom: Color) void`	`void DrawRectangleGradientV(int posX, int posY, int width, int height, Color top, Color bottom)`
`rl.drawRectangleGradientH(posX: i32, posY: i32, width: i32, height: i32, left: Color, right: Color) void`	`void DrawRectangleGradientH(int posX, int posY, int width, int height, Color left, Color right)`
`rl.drawRectangleGradientEx(rec: Rectangle, col1: Color, col2: Color, col3: Color, col4: Color) void`	`void DrawRectangleGradientEx(Rectangle rec, Color col1, Color col2, Color col3, Color col4)`
`rl.drawRectangleLines(posX: i32, posY: i32, width: i32, height: i32, color: Color) void`	`void DrawRectangleLines(int posX, int posY, int width, int height, Color color)`
`rl.drawRectangleLinesEx(rec: Rectangle, thick: f32, color: Color) void`	`void DrawRectangleLinesEx(Rectangle rec, float thick, Color color)`
`rl.drawRectangleRounded(rec: Rectangle, roundness: f32, segments: i32, color: Color) void`	`void DrawRectangleRounded(Rectangle rec, float roundness, int segments, Color color)`
`rl.drawRectangleRoundedLines(rec: Rectangle, roundness: f32, segments: i32, color: Color) void`	`void DrawRectangleRoundedLines(Rectangle rec, float roundness, int segments, Color color)`
`rl.drawRectangleRoundedLinesEx(rec: Rectangle, roundness: f32, segments: i32, thick: f32, color: Color) void`	`void DrawRectangleRoundedLinesEx(Rectangle rec, float roundness, int segments, float thick, Color color)`
`rl.drawPoly(center: Vector2, sides: i32, radius: f32, rotation: f32, color: Color) void`	`void DrawPoly(Vector2 center, int sides, float radius, float rotation, Color color)`
`rl.drawPolyLines(center: Vector2, sides: i32, radius: f32, rotation: f32, color: Color) void`	`void DrawPolyLines(Vector2 center, int sides, float radius, float rotation, Color color)`
`rl.drawPolyLinesEx(center: Vector2, sides: i32, radius: f32, rotation: f32, thick: f32, color: Color) void`	`void DrawPolyLinesEx(Vector2 center, int sides, float radius, float rotation, float thick, Color color)`
`rl.drawCircle(centerX: i32, centerY: i32, radius: f32, color: Color) void`	`void DrawCircle(int centerX, int centerY, float radius, Color color)`
`rl.drawCircleV(center: Vector2, radius: f32, color: Color) void`	`void DrawCircleV(Vector2 center, float radius, Color color)`
`rl.drawCircleGradient(center: Vector2, radius: f32, inner: Color, outer: Color) void`	`void DrawCircleGradient(Vector2 center, float radius, Color inner, Color outer)`
`rl.drawCircleSector(center: Vector2, radius: f32, startAngle: f32, endAngle: f32, segments: i32, color: Color) void`	`void DrawCircleSector(Vector2 center, float radius, float startAngle, float endAngle, int segments, Color color)`
`rl.drawCircleSectorLines(center: Vector2, radius: f32, startAngle: f32, endAngle: f32, segments: i32, color: Color) void`	`void DrawCircleSectorLines(Vector2 center, float radius, float startAngle, float endAngle, int segments, Color color)`
`rl.drawCircleSectorLinesEx(center: Vector2, radius: f32, startAngle: f32, endAngle: f32, segments: i32, thick: f32, color: Color) void`	`void DrawCircleSectorLinesEx(Vector2 center, float radius, float startAngle, float endAngle, int segments, float thick, Color color)`
`rl.drawCircleLines(centerX: i32, centerY: i32, radius: f32, color: Color) void`	`void DrawCircleLines(int centerX, int centerY, float radius, Color color)`
`rl.drawCircleLinesV(center: Vector2, radius: f32, color: Color) void`	`void DrawCircleLinesV(Vector2 center, float radius, Color color)`
`rl.drawCircleLinesEx(center: Vector2, radius: f32, thick: f32, color: Color) void`	`void DrawCircleLinesEx(Vector2 center, float radius, float thick, Color color)`
`rl.drawEllipse(centerX: i32, centerY: i32, radiusH: f32, radiusV: f32, color: Color) void`	`void DrawEllipse(int centerX, int centerY, float radiusH, float radiusV, Color color)`
`rl.drawEllipseV(center: Vector2, radiusH: f32, radiusV: f32, color: Color) void`	`void DrawEllipseV(Vector2 center, float radiusH, float radiusV, Color color)`
`rl.drawEllipseLines(centerX: i32, centerY: i32, radiusH: f32, radiusV: f32, color: Color) void`	`void DrawEllipseLines(int centerX, int centerY, float radiusH, float radiusV, Color color)`
`rl.drawEllipseLinesV(center: Vector2, radiusH: f32, radiusV: f32, color: Color) void`	`void DrawEllipseLinesV(Vector2 center, float radiusH, float radiusV, Color color)`
`rl.drawEllipseLinesEx(center: Vector2, radiusH: f32, radiusV: f32, thick: f32, color: Color) void`	`void DrawEllipseLinesEx(Vector2 center, float radiusH, float radiusV, float thick, Color color)`
`rl.drawRing(center: Vector2, innerRadius: f32, outerRadius: f32, startAngle: f32, endAngle: f32, segments: i32, color: Color) void`	`void DrawRing(Vector2 center, float innerRadius, float outerRadius, float startAngle, float endAngle, int segments, Color color)`
`rl.drawRingLines(center: Vector2, innerRadius: f32, outerRadius: f32, startAngle: f32, endAngle: f32, segments: i32, color: Color) void`	`void DrawRingLines(Vector2 center, float innerRadius, float outerRadius, float startAngle, float endAngle, int segments, Color color)`
`rl.drawRingLinesEx(center: Vector2, innerRadius: f32, outerRadius: f32, startAngle: f32, endAngle: f32, segments: i32, thick: f32, color: Color) void`	`void DrawRingLinesEx(Vector2 center, float innerRadius, float outerRadius, float startAngle, float endAngle, int segments, float thick, Color color)`
`rl.drawSplineLinear(points: []const Vector2, thick: f32, color: Color) void`	`void DrawSplineLinear(const Vector2 *points, int pointCount, float thick, Color color)`
`rl.drawSplineBasis(points: []const Vector2, thick: f32, color: Color) void`	`void DrawSplineBasis(const Vector2 *points, int pointCount, float thick, Color color)`
`rl.drawSplineCatmullRom(points: []const Vector2, thick: f32, color: Color) void`	`void DrawSplineCatmullRom(const Vector2 *points, int pointCount, float thick, Color color)`
`rl.drawSplineBezierQuadratic(points: []const Vector2, thick: f32, color: Color) void`	`void DrawSplineBezierQuadratic(const Vector2 *points, int pointCount, float thick, Color color)`
`rl.drawSplineBezierCubic(points: []const Vector2, thick: f32, color: Color) void`	`void DrawSplineBezierCubic(const Vector2 *points, int pointCount, float thick, Color color)`
`rl.drawSplineSegmentLinear(p1: Vector2, p2: Vector2, thick: f32, color: Color) void`	`void DrawSplineSegmentLinear(Vector2 p1, Vector2 p2, float thick, Color color)`
`rl.drawSplineSegmentBasis(p1: Vector2, p2: Vector2, p3: Vector2, p4: Vector2, thick: f32, color: Color) void`	`void DrawSplineSegmentBasis(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, float thick, Color color)`
`rl.drawSplineSegmentCatmullRom(p1: Vector2, p2: Vector2, p3: Vector2, p4: Vector2, thick: f32, color: Color) void`	`void DrawSplineSegmentCatmullRom(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, float thick, Color color)`
`rl.drawSplineSegmentBezierQuadratic(p1: Vector2, c2: Vector2, p3: Vector2, thick: f32, color: Color) void`	`void DrawSplineSegmentBezierQuadratic(Vector2 p1, Vector2 c2, Vector2 p3, float thick, Color color)`
`rl.drawSplineSegmentBezierCubic(p1: Vector2, c2: Vector2, c3: Vector2, p4: Vector2, thick: f32, color: Color) void`	`void DrawSplineSegmentBezierCubic(Vector2 p1, Vector2 c2, Vector2 c3, Vector2 p4, float thick, Color color)`
`rl.getSplinePointLinear(startPos: Vector2, endPos: Vector2, t: f32) Vector2`	`Vector2 GetSplinePointLinear(Vector2 startPos, Vector2 endPos, float t)`
`rl.getSplinePointBasis(p1: Vector2, p2: Vector2, p3: Vector2, p4: Vector2, t: f32) Vector2`	`Vector2 GetSplinePointBasis(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, float t)`
`rl.getSplinePointCatmullRom(p1: Vector2, p2: Vector2, p3: Vector2, p4: Vector2, t: f32) Vector2`	`Vector2 GetSplinePointCatmullRom(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, float t)`
`rl.getSplinePointBezierQuadratic(p1: Vector2, c2: Vector2, p3: Vector2, t: f32) Vector2`	`Vector2 GetSplinePointBezierQuadratic(Vector2 p1, Vector2 c2, Vector2 p3, float t)`
`rl.getSplinePointBezierCubic(p1: Vector2, c2: Vector2, c3: Vector2, p4: Vector2, t: f32) Vector2`	`Vector2 GetSplinePointBezierCubic(Vector2 p1, Vector2 c2, Vector2 c3, Vector2 p4, float t)`
`rl.checkCollisionRecs(rec1: Rectangle, rec2: Rectangle) bool`	`bool CheckCollisionRecs(Rectangle rec1, Rectangle rec2)`
`rl.checkCollisionCircles(center1: Vector2, radius1: f32, center2: Vector2, radius2: f32) bool`	`bool CheckCollisionCircles(Vector2 center1, float radius1, Vector2 center2, float radius2)`
`rl.checkCollisionCircleRec(center: Vector2, radius: f32, rec: Rectangle) bool`	`bool CheckCollisionCircleRec(Vector2 center, float radius, Rectangle rec)`
`rl.checkCollisionCircleLine(center: Vector2, radius: f32, p1: Vector2, p2: Vector2) bool`	`bool CheckCollisionCircleLine(Vector2 center, float radius, Vector2 p1, Vector2 p2)`
`rl.checkCollisionPointRec(point: Vector2, rec: Rectangle) bool`	`bool CheckCollisionPointRec(Vector2 point, Rectangle rec)`
`rl.checkCollisionPointCircle(point: Vector2, center: Vector2, radius: f32) bool`	`bool CheckCollisionPointCircle(Vector2 point, Vector2 center, float radius)`
`rl.checkCollisionPointTriangle(point: Vector2, p1: Vector2, p2: Vector2, p3: Vector2) bool`	`bool CheckCollisionPointTriangle(Vector2 point, Vector2 p1, Vector2 p2, Vector2 p3)`
`rl.checkCollisionPointLine(point: Vector2, p1: Vector2, p2: Vector2, threshold: i32) bool`	`bool CheckCollisionPointLine(Vector2 point, Vector2 p1, Vector2 p2, int threshold)`
`rl.checkCollisionPointPoly(point: Vector2, points: []const Vector2) bool`	`bool CheckCollisionPointPoly(Vector2 point, const Vector2 *points, int pointCount)`
`rl.checkCollisionLines(startPos1: Vector2, endPos1: Vector2, startPos2: Vector2, endPos2: Vector2, collisionPoint: *Vector2) bool`	`bool CheckCollisionLines(Vector2 startPos1, Vector2 endPos1, Vector2 startPos2, Vector2 endPos2, Vector2 *collisionPoint)`
`rl.getCollisionRec(rec1: Rectangle, rec2: Rectangle) Rectangle`	`Rectangle GetCollisionRec(Rectangle rec1, Rectangle rec2)`

textures

Zig	C
`rl.loadImage(fileName: [:0]const u8) error{LoadFailed}!Image`	`Image LoadImage(const char *fileName)`
`rl.loadImageRaw(fileName: [:0]const u8, width: i32, height: i32, format: PixelFormat, headerSize: i32) error{LoadFailed}!Image`	`Image LoadImageRaw(const char *fileName, int width, int height, int format, int headerSize)`
`rl.loadImageAnim(fileName: [:0]const u8) error{LoadFailed}!ImageAnim`	`Image LoadImageAnim(const char fileName, int frames)`
`rl.loadImageAnimFromMemory(fileType: [:0]const u8, fileData: []const u8) error{LoadFailed}!ImageAnim`	`Image LoadImageAnimFromMemory(const char fileType, const unsigned char fileData, int dataSize, int *frames)`
`rl.loadImageFromMemory(fileType: [:0]const u8, fileData: []const u8) error{LoadFailed}!Image`	`Image LoadImageFromMemory(const char fileType, const unsigned char fileData, int dataSize)`
`rl.loadImageFromTexture(texture: Texture2D) error{LoadFailed}!Image`	`Image LoadImageFromTexture(Texture2D texture)`
`rl.loadImageFromScreen() error{LoadFailed}!Image`	`Image LoadImageFromScreen(void)`
`rl.isImageValid(image: Image) bool`	`bool IsImageValid(Image image)`
`rl.unloadImage(image: Image) void`	`void UnloadImage(Image image)`
`rl.exportImage(image: Image, fileName: [:0]const u8) bool`	`bool ExportImage(Image image, const char *fileName)`
`rl.exportImageToMemory(image: Image, fileType: [:0]const u8) error{ExportFailed}![]u8`	`unsigned char ExportImageToMemory(Image image, const char fileType, int *fileSize)`
`rl.exportImageAsCode(image: Image, fileName: [:0]const u8) bool`	`bool ExportImageAsCode(Image image, const char *fileName)`
`rl.genImageColor(width: i32, height: i32, color: Color) Image`	`Image GenImageColor(int width, int height, Color color)`
`rl.genImageGradientLinear(width: i32, height: i32, direction: i32, start: Color, end: Color) Image`	`Image GenImageGradientLinear(int width, int height, int direction, Color start, Color end)`
`rl.genImageGradientRadial(width: i32, height: i32, density: f32, inner: Color, outer: Color) Image`	`Image GenImageGradientRadial(int width, int height, float density, Color inner, Color outer)`
`rl.genImageGradientSquare(width: i32, height: i32, density: f32, inner: Color, outer: Color) Image`	`Image GenImageGradientSquare(int width, int height, float density, Color inner, Color outer)`
`rl.genImageChecked(width: i32, height: i32, checksX: i32, checksY: i32, col1: Color, col2: Color) Image`	`Image GenImageChecked(int width, int height, int checksX, int checksY, Color col1, Color col2)`
`rl.genImageWhiteNoise(width: i32, height: i32, factor: f32) Image`	`Image GenImageWhiteNoise(int width, int height, float factor)`
`rl.genImagePerlinNoise(width: i32, height: i32, offsetX: i32, offsetY: i32, scale: f32) Image`	`Image GenImagePerlinNoise(int width, int height, int offsetX, int offsetY, float scale)`
`rl.genImageCellular(width: i32, height: i32, tileSize: i32) Image`	`Image GenImageCellular(int width, int height, int tileSize)`
`rl.genImageText(width: i32, height: i32, text: [:0]const u8) Image`	`Image GenImageText(int width, int height, const char *text)`
`rl.imageCopy(image: Image) Image`	`Image ImageCopy(Image image)`
`rl.imageFromImage(image: Image, rec: Rectangle) Image`	`Image ImageFromImage(Image image, Rectangle rec)`
`rl.imageFromChannel(image: Image, selectedChannel: i32) Image`	`Image ImageFromChannel(Image image, int selectedChannel)`
`rl.imageText(text: [:0]const u8, fontSize: i32, color: Color) Image`	`Image ImageText(const char *text, int fontSize, Color color)`
`rl.imageTextEx(font: Font, text: [:0]const u8, fontSize: f32, spacing: f32, tint: Color) Image`	`Image ImageTextEx(Font font, const char *text, float fontSize, float spacing, Color tint)`
`rl.imageFormat(image: *Image, newFormat: PixelFormat) void`	`void ImageFormat(Image *image, int newFormat)`
`rl.imageToPOT(image: *Image, fill: Color) void`	`void ImageToPOT(Image *image, Color fill)`
`rl.imageCrop(image: *Image, crop: Rectangle) void`	`void ImageCrop(Image *image, Rectangle crop)`
`rl.imageAlphaCrop(image: *Image, threshold: f32) void`	`void ImageAlphaCrop(Image *image, float threshold)`
`rl.imageAlphaClear(image: *Image, color: Color, threshold: f32) void`	`void ImageAlphaClear(Image *image, Color color, float threshold)`
`rl.imageAlphaMask(image: *Image, alphaMask: Image) void`	`void ImageAlphaMask(Image *image, Image alphaMask)`
`rl.imageAlphaPremultiply(image: *Image) void`	`void ImageAlphaPremultiply(Image *image)`
`rl.imageBlurGaussian(image: *Image, blurSize: i32) void`	`void ImageBlurGaussian(Image *image, int blurSize)`
`rl.imageKernelConvolution(image: *Image, kernel: []const f32) void`	`void ImageKernelConvolution(Image image, const float kernel, int kernelSize)`
`rl.imageResize(image: *Image, newWidth: i32, newHeight: i32) void`	`void ImageResize(Image *image, int newWidth, int newHeight)`
`rl.imageResizeNN(image: *Image, newWidth: i32, newHeight: i32) void`	`void ImageResizeNN(Image *image, int newWidth, int newHeight)`
`rl.imageResizeCanvas(image: *Image, newWidth: i32, newHeight: i32, offsetX: i32, offsetY: i32, fill: Color) void`	`void ImageResizeCanvas(Image *image, int newWidth, int newHeight, int offsetX, int offsetY, Color fill)`
`rl.imageMipmaps(image: *Image) void`	`void ImageMipmaps(Image *image)`
`rl.imageDither(image: *Image, rBpp: i32, gBpp: i32, bBpp: i32, aBpp: i32) void`	`void ImageDither(Image *image, int rBpp, int gBpp, int bBpp, int aBpp)`
`rl.imageFlipVertical(image: *Image) void`	`void ImageFlipVertical(Image *image)`
`rl.imageFlipHorizontal(image: *Image) void`	`void ImageFlipHorizontal(Image *image)`
`rl.imageRotate(image: *Image, degrees: i32) void`	`void ImageRotate(Image *image, int degrees)`
`rl.imageRotateCW(image: *Image) void`	`void ImageRotateCW(Image *image)`
`rl.imageRotateCCW(image: *Image) void`	`void ImageRotateCCW(Image *image)`
`rl.imageColorTint(image: *Image, color: Color) void`	`void ImageColorTint(Image *image, Color color)`
`rl.imageColorInvert(image: *Image) void`	`void ImageColorInvert(Image *image)`
`rl.imageColorGrayscale(image: *Image) void`	`void ImageColorGrayscale(Image *image)`
`rl.imageColorContrast(image: *Image, contrast: i32) void`	`void ImageColorContrast(Image *image, int contrast)`
`rl.imageColorBrightness(image: *Image, brightness: i32) void`	`void ImageColorBrightness(Image *image, int brightness)`
`rl.imageColorReplace(image: *Image, color: Color, replace: Color) void`	`void ImageColorReplace(Image *image, Color color, Color replace)`
`rl.loadImageColors(image: Image) error{LoadFailed}![]Color`	`Color *LoadImageColors(Image image)`
`rl.loadImagePalette(image: Image, maxPaletteSize: i32) error{LoadFailed}![]Color`	`Color LoadImagePalette(Image image, int maxPaletteSize, int colorCount)`
`rl.unloadImageColors(colors: []Color) void`	`void UnloadImageColors(Color *colors)`
`rl.unloadImagePalette(colors: []Color) void`	`void UnloadImagePalette(Color *colors)`
`rl.getImageAlphaBorder(image: Image, threshold: f32) Rectangle`	`Rectangle GetImageAlphaBorder(Image image, float threshold)`
`rl.getImageColor(image: Image, x: i32, y: i32) Color`	`Color GetImageColor(Image image, int x, int y)`
`rl.imageClearBackground(dst: *Image, color: Color) void`	`void ImageClearBackground(Image *dst, Color color)`
`rl.imageDrawPixel(dst: *Image, posX: i32, posY: i32, color: Color) void`	`void ImageDrawPixel(Image *dst, int posX, int posY, Color color)`
`rl.imageDrawPixelV(dst: *Image, position: Vector2, color: Color) void`	`void ImageDrawPixelV(Image *dst, Vector2 position, Color color)`
`rl.imageDrawLine(dst: *Image, startPosX: i32, startPosY: i32, endPosX: i32, endPosY: i32, color: Color) void`	`void ImageDrawLine(Image *dst, int startPosX, int startPosY, int endPosX, int endPosY, Color color)`
`rl.imageDrawLineV(dst: *Image, start: Vector2, end: Vector2, color: Color) void`	`void ImageDrawLineV(Image *dst, Vector2 start, Vector2 end, Color color)`
`rl.imageDrawLineEx(dst: *Image, start: Vector2, end: Vector2, thick: i32, color: Color) void`	`void ImageDrawLineEx(Image *dst, Vector2 start, Vector2 end, int thick, Color color)`
`rl.imageDrawLineStrip(dst: *Image, points: []const Vector2, color: Color) void`	`void ImageDrawLineStrip(Image dst, const Vector2 points, int pointCount, Color color)`
`rl.imageDrawTriangle(dst: *Image, v1: Vector2, v2: Vector2, v3: Vector2, color: Color) void`	`void ImageDrawTriangle(Image *dst, Vector2 v1, Vector2 v2, Vector2 v3, Color color)`
`rl.imageDrawTriangleGradient(dst: *Image, v1: Vector2, v2: Vector2, v3: Vector2, c1: Color, c2: Color, c3: Color) void`	`void ImageDrawTriangleGradient(Image *dst, Vector2 v1, Vector2 v2, Vector2 v3, Color c1, Color c2, Color c3)`
`rl.imageDrawTriangleLines(dst: *Image, v1: Vector2, v2: Vector2, v3: Vector2, color: Color) void`	`void ImageDrawTriangleLines(Image *dst, Vector2 v1, Vector2 v2, Vector2 v3, Color color)`
`rl.imageDrawTriangleFan(dst: *Image, points: []const Vector2, color: Color) void`	`void ImageDrawTriangleFan(Image dst, const Vector2 points, int pointCount, Color color)`
`rl.imageDrawTriangleStrip(dst: *Image, points: []const Vector2, color: Color) void`	`void ImageDrawTriangleStrip(Image dst, const Vector2 points, int pointCount, Color color)`
`rl.imageDrawRectangle(dst: *Image, posX: i32, posY: i32, width: i32, height: i32, color: Color) void`	`void ImageDrawRectangle(Image *dst, int posX, int posY, int width, int height, Color color)`
`rl.imageDrawRectangleV(dst: *Image, position: Vector2, size: Vector2, color: Color) void`	`void ImageDrawRectangleV(Image *dst, Vector2 position, Vector2 size, Color color)`
`rl.imageDrawRectangleRec(dst: *Image, rec: Rectangle, color: Color) void`	`void ImageDrawRectangleRec(Image *dst, Rectangle rec, Color color)`
`rl.imageDrawRectanglePro(dst: *Image, rec: Rectangle, origin: Vector2, rotation: f32, color: Color) void`	`void ImageDrawRectanglePro(Image *dst, Rectangle rec, Vector2 origin, float rotation, Color color)`
`rl.imageDrawRectangleLines(dst: *Image, posX: i32, posY: i32, width: i32, height: i32, color: Color) void`	`void ImageDrawRectangleLines(Image *dst, int posX, int posY, int width, int height, Color color)`
`rl.imageDrawRectangleLinesEx(dst: *Image, rec: Rectangle, thick: i32, color: Color) void`	`void ImageDrawRectangleLinesEx(Image *dst, Rectangle rec, int thick, Color color)`
`rl.imageDrawRectangleGradientEx(dst: *Image, rec: Rectangle, col1: Color, col2: Color, col3: Color, col4: Color) void`	`void ImageDrawRectangleGradientEx(Image *dst, Rectangle rec, Color col1, Color col2, Color col3, Color col4)`
`rl.imageDrawCircle(dst: *Image, centerX: i32, centerY: i32, radius: i32, color: Color) void`	`void ImageDrawCircle(Image *dst, int centerX, int centerY, int radius, Color color)`
`rl.imageDrawCircleV(dst: *Image, center: Vector2, radius: i32, color: Color) void`	`void ImageDrawCircleV(Image *dst, Vector2 center, int radius, Color color)`
`rl.imageDrawCircleLines(dst: *Image, centerX: i32, centerY: i32, radius: i32, color: Color) void`	`void ImageDrawCircleLines(Image *dst, int centerX, int centerY, int radius, Color color)`
`rl.imageDrawCircleLinesV(dst: *Image, center: Vector2, radius: i32, color: Color) void`	`void ImageDrawCircleLinesV(Image *dst, Vector2 center, int radius, Color color)`
`rl.imageDrawCircleGradient(dst: *Image, center: Vector2, radius: f32, inner: Color, outer: Color) void`	`void ImageDrawCircleGradient(Image *dst, Vector2 center, float radius, Color inner, Color outer)`
`rl.imageDrawImage(dst: *Image, src: Image, posX: i32, posY: i32, tint: Color) void`	`void ImageDrawImage(Image *dst, Image src, int posX, int posY, Color tint)`
`rl.imageDrawImageEx(dst: *Image, src: Image, position: Vector2, rotation: f32, scale: f32, tint: Color) void`	`void ImageDrawImageEx(Image *dst, Image src, Vector2 position, float rotation, float scale, Color tint)`
`rl.imageDrawImageRec(dst: *Image, src: Image, srcRec: Rectangle, position: Vector2, tint: Color) void`	`void ImageDrawImageRec(Image *dst, Image src, Rectangle srcRec, Vector2 position, Color tint)`
`rl.imageDrawImagePro(dst: *Image, src: Image, srcRec: Rectangle, dstRec: Rectangle, origin: Vector2, rotation: f32, tint: Color) void`	`void ImageDrawImagePro(Image *dst, Image src, Rectangle srcRec, Rectangle dstRec, Vector2 origin, float rotation, Color tint)`
`rl.imageDrawText(dst: *Image, text: [:0]const u8, posX: i32, posY: i32, fontSize: i32, color: Color) void`	`void ImageDrawText(Image dst, const char text, int posX, int posY, int fontSize, Color color)`
`rl.imageDrawTextEx(dst: *Image, font: Font, text: [:0]const u8, position: Vector2, fontSize: f32, spacing: f32, tint: Color) void`	`void ImageDrawTextEx(Image dst, Font font, const char text, Vector2 position, float fontSize, float spacing, Color tint)`
`rl.imageDrawTextPro(dst: *Image, font: Font, text: [:0]const u8, position: Vector2, origin: Vector2, rotation: f32, fontSize: f32, spacing: f32, tint: Color) void`	`void ImageDrawTextPro(Image dst, Font font, const char text, Vector2 position, Vector2 origin, float rotation, float fontSize, float spacing, Color tint)`
`rl.loadTexture(fileName: [:0]const u8) error{LoadFailed}!Texture2D`	`Texture2D LoadTexture(const char *fileName)`
`rl.loadTextureFromImage(image: Image) error{LoadFailed}!Texture2D`	`Texture2D LoadTextureFromImage(Image image)`
`rl.loadTextureCubemap(image: Image, layout: CubemapLayout) error{LoadFailed}!TextureCubemap`	`TextureCubemap LoadTextureCubemap(Image image, int layout)`
`rl.loadRenderTexture(width: i32, height: i32) error{LoadFailed}!RenderTexture2D`	`RenderTexture2D LoadRenderTexture(int width, int height)`
`rl.loadRenderTextureEx(width: i32, height: i32, format: PixelFormat) error{LoadFailed}!RenderTexture2D`	`RenderTexture2D LoadRenderTextureEx(int width, int height, int format)`
`rl.isTextureValid(texture: Texture2D) bool`	`bool IsTextureValid(Texture2D texture)`
`rl.unloadTexture(texture: Texture2D) void`	`void UnloadTexture(Texture2D texture)`
`rl.isRenderTextureValid(target: RenderTexture2D) bool`	`bool IsRenderTextureValid(RenderTexture2D target)`
`rl.unloadRenderTexture(target: RenderTexture2D) void`	`void UnloadRenderTexture(RenderTexture2D target)`
`rl.updateTexture(texture: Texture2D, pixels: *const anyopaque) void`	`void UpdateTexture(Texture2D texture, const void *pixels)`
`rl.updateTextureRec(texture: Texture2D, rec: Rectangle, pixels: *const anyopaque) void`	`void UpdateTextureRec(Texture2D texture, Rectangle rec, const void *pixels)`
`rl.genTextureMipmaps(texture: *Texture2D) void`	`void GenTextureMipmaps(Texture2D *texture)`
`rl.setTextureFilter(texture: Texture2D, filter: TextureFilter) void`	`void SetTextureFilter(Texture2D texture, int filter)`
`rl.setTextureWrap(texture: Texture2D, wrap: TextureWrap) void`	`void SetTextureWrap(Texture2D texture, int wrap)`
`rl.drawTexture(texture: Texture2D, posX: i32, posY: i32, tint: Color) void`	`void DrawTexture(Texture2D texture, int posX, int posY, Color tint)`
`rl.drawTextureV(texture: Texture2D, position: Vector2, tint: Color) void`	`void DrawTextureV(Texture2D texture, Vector2 position, Color tint)`
`rl.drawTextureEx(texture: Texture2D, position: Vector2, rotation: f32, scale: f32, tint: Color) void`	`void DrawTextureEx(Texture2D texture, Vector2 position, float rotation, float scale, Color tint)`
`rl.drawTextureRec(texture: Texture2D, rec: Rectangle, position: Vector2, tint: Color) void`	`void DrawTextureRec(Texture2D texture, Rectangle rec, Vector2 position, Color tint)`
`rl.drawTexturePro(texture: Texture2D, srcrec: Rectangle, dstrec: Rectangle, origin: Vector2, rotation: f32, tint: Color) void`	`void DrawTexturePro(Texture2D texture, Rectangle srcrec, Rectangle dstrec, Vector2 origin, float rotation, Color tint)`
`rl.drawTextureNPatch(texture: Texture2D, nPatchInfo: NPatchInfo, dstrec: Rectangle, origin: Vector2, rotation: f32, tint: Color) void`	`void DrawTextureNPatch(Texture2D texture, NPatchInfo nPatchInfo, Rectangle dstrec, Vector2 origin, float rotation, Color tint)`
`rl.colorIsEqual(col1: Color, col2: Color) bool`	`bool ColorIsEqual(Color col1, Color col2)`
`rl.fade(color: Color, alpha: f32) Color`	`Color Fade(Color color, float alpha)`
`rl.colorToInt(color: Color) i32`	`int ColorToInt(Color color)`
`rl.colorNormalize(color: Color) Vector4`	`Vector4 ColorNormalize(Color color)`
`rl.colorFromNormalized(normalized: Vector4) Color`	`Color ColorFromNormalized(Vector4 normalized)`
`rl.colorToHSV(color: Color) Vector3`	`Vector3 ColorToHSV(Color color)`
`rl.colorFromHSV(hue: f32, saturation: f32, value: f32) Color`	`Color ColorFromHSV(float hue, float saturation, float value)`
`rl.colorTint(color: Color, tint: Color) Color`	`Color ColorTint(Color color, Color tint)`
`rl.colorBrightness(color: Color, factor: f32) Color`	`Color ColorBrightness(Color color, float factor)`
`rl.colorContrast(color: Color, contrast: f32) Color`	`Color ColorContrast(Color color, float contrast)`
`rl.colorAlpha(color: Color, alpha: f32) Color`	`Color ColorAlpha(Color color, float alpha)`
`rl.colorAlphaBlend(dst: Color, src: Color, tint: Color) Color`	`Color ColorAlphaBlend(Color dst, Color src, Color tint)`
`rl.colorLerp(color1: Color, color2: Color, factor: f32) Color`	`Color ColorLerp(Color color1, Color color2, float factor)`
`rl.getColor(hexValue: u32) Color`	`Color GetColor(unsigned int hexValue)`
`rl.getPixelColor(srcPtr: *const anyopaque, format: PixelFormat) Color`	`Color GetPixelColor(const void *srcPtr, int format)`
`rl.setPixelColor(dstPtr: *anyopaque, color: Color, format: PixelFormat) void`	`void SetPixelColor(void *dstPtr, Color color, int format)`
`rl.getPixelDataSize(width: i32, height: i32, format: PixelFormat) i32`	`int GetPixelDataSize(int width, int height, int format)`

text

Zig	C
`rl.getFontDefault() Font`	`Font GetFontDefault(void)`
`rl.loadFont(fileName: [:0]const u8) error{LoadFailed}!Font`	`Font LoadFont(const char *fileName)`
`rl.loadFontEx(fileName: [:0]const u8, fontSize: i32, codepoints: ?[]const i32) error{LoadFailed}!Font`	`Font LoadFontEx(const char fileName, int fontSize, const int codepoints, int codepointCount)`
`rl.loadFontFromImage(image: Image, key: Color, firstChar: i32) error{LoadFailed}!Font`	`Font LoadFontFromImage(Image image, Color key, int firstChar)`
`rl.loadFontFromMemory(fileType: [:0]const u8, fileData: []const u8, fontSize: i32, codepoints: ?[]const i32) error{LoadFailed}!Font`	`Font LoadFontFromMemory(const char fileType, const unsigned char fileData, int dataSize, int fontSize, const int *codepoints, int codepointCount)`
`rl.isFontValid(font: Font) bool`	`bool IsFontValid(Font font)`
`rl.loadFontData(fileData: []const u8, fontSize: i32, codepoints: ?[]const i32, @"type": FontType) error{LoadFailed}![]GlyphInfo`	`GlyphInfo LoadFontData(const unsigned char fileData, int dataSize, int fontSize, const int codepoints, int codepointCount, int type, int glyphCount)`
`rl.genImageFontAtlas(glyphs: []const GlyphInfo, glyphRecs: ?[]Rectangle, fontSize: i32, padding: i32, packMethod: i32) Image`	`Image GenImageFontAtlas(const GlyphInfo glyphs, Rectangle *glyphRecs, int glyphCount, int fontSize, int padding, int packMethod)`
`rl.unloadFontData(glyphs: []GlyphInfo) void`	`void UnloadFontData(GlyphInfo *glyphs, int glyphCount)`
`rl.unloadFont(font: Font) void`	`void UnloadFont(Font font)`
`rl.exportFontAsCode(font: Font, fileName: [:0]const u8) bool`	`bool ExportFontAsCode(Font font, const char *fileName)`
`rl.drawFPS(posX: i32, posY: i32) void`	`void DrawFPS(int posX, int posY)`
`rl.drawText(text: [:0]const u8, posX: i32, posY: i32, fontSize: i32, color: Color) void`	`void DrawText(const char *text, int posX, int posY, int fontSize, Color color)`
`rl.drawTextEx(font: Font, text: [:0]const u8, position: Vector2, fontSize: f32, spacing: f32, tint: Color) void`	`void DrawTextEx(Font font, const char *text, Vector2 position, float fontSize, float spacing, Color tint)`
`rl.drawTextPro(font: Font, text: [:0]const u8, position: Vector2, origin: Vector2, rotation: f32, fontSize: f32, spacing: f32, tint: Color) void`	`void DrawTextPro(Font font, const char *text, Vector2 position, Vector2 origin, float rotation, float fontSize, float spacing, Color tint)`
`rl.drawTextCodepoint(font: Font, codepoint: i32, position: Vector2, fontSize: f32, tint: Color) void`	`void DrawTextCodepoint(Font font, int codepoint, Vector2 position, float fontSize, Color tint)`
`rl.drawTextCodepoints(font: Font, codepoints: []const i32, position: Vector2, fontSize: f32, spacing: f32, tint: Color) void`	`void DrawTextCodepoints(Font font, const int *codepoints, int codepointCount, Vector2 position, float fontSize, float spacing, Color tint)`
`rl.setTextLineSpacing(spacing: i32) void`	`void SetTextLineSpacing(int spacing)`
`rl.measureText(text: [:0]const u8, fontSize: i32) i32`	`int MeasureText(const char *text, int fontSize)`
`rl.measureTextEx(font: Font, text: [:0]const u8, fontSize: f32, spacing: f32) Vector2`	`Vector2 MeasureTextEx(Font font, const char *text, float fontSize, float spacing)`
`rl.measureTextCodepoints(font: Font, codepoints: []const i32, fontSize: f32, spacing: f32) Vector2`	`Vector2 MeasureTextCodepoints(Font font, const int *codepoints, int length, float fontSize, float spacing)`
`rl.getGlyphIndex(font: Font, codepoint: i32) i32`	`int GetGlyphIndex(Font font, int codepoint)`
`rl.getGlyphInfo(font: Font, codepoint: i32) GlyphInfo`	`GlyphInfo GetGlyphInfo(Font font, int codepoint)`
`rl.getGlyphAtlasRec(font: Font, codepoint: i32) Rectangle`	`Rectangle GetGlyphAtlasRec(Font font, int codepoint)`
`rl.loadUTF8(codepoints: []const i32) error{LoadFailed}![:0]u8`	`char LoadUTF8(const int codepoints, int length)`
`rl.unloadUTF8(text: [:0]u8) void`	`void UnloadUTF8(char *text)`
`rl.loadCodepoints(text: [:0]const u8) error{LoadFailed}![]i32`	`int LoadCodepoints(const char text, int *count)`
`rl.unloadCodepoints(codepoints: []i32) void`	`void UnloadCodepoints(int *codepoints)`
`rl.getCodepointCount(text: [:0]const u8) i32`	`int GetCodepointCount(const char *text)`
`rl.getCodepoint(text: [:0]const u8) CodepointResult`	`int GetCodepoint(const char text, int codepointSize)`
`rl.getCodepointNext(text: [:0]const u8) CodepointResult`	`int GetCodepointNext(const char text, int codepointSize)`
`rl.getCodepointPrevious(text: [:0]const u8) CodepointResult`	`int GetCodepointPrevious(const char text, int codepointSize)`
`rl.codepointToUTF8(codepoint: i32) []const u8`	`const char CodepointToUTF8(int codepoint, int utf8Size)`
`rl.loadTextLines(text: [:0]const u8) error{LoadFailed}![][*:0]u8`	`char *LoadTextLines(const char text, int *count)`
`rl.unloadTextLines(lines: [][*:0]u8) void`	`void UnloadTextLines(char **text, int lineCount)`
`rl.textCopy(dst: [*]u8, src: [:0]const u8) i32`	`int TextCopy(char dst, const char src)`
`rl.textIsEqual(text1: [:0]const u8, text2: [:0]const u8) bool`	`bool TextIsEqual(const char text1, const char text2)`
`rl.textLength(text: [:0]const u8) u32`	`unsigned int TextLength(const char *text)`
`rl.textFormat(comptime format: []const u8, args: anytype) [:0]const u8`	`const char TextFormat(const char text, ...)`
`rl.textSubtext(text: [:0]const u8, position: i32, length: i32) [:0]const u8`	`const char TextSubtext(const char text, int position, int length)`
`rl.textRemoveSpaces(text: [:0]const u8) [:0]const u8`	`const char TextRemoveSpaces(const char text)`
`rl.getTextBetween(text: [:0]const u8, begin: [:0]const u8, end: [:0]const u8) [:0]const u8`	`char GetTextBetween(const char text, const char begin, const char end)`
`rl.textReplace(text: [:0]const u8, search: [:0]const u8, replacement: [:0]const u8) [:0]const u8`	`char TextReplace(const char text, const char search, const char replacement)`
`rl.textReplaceAlloc(text: [:0]const u8, search: [:0]const u8, replacement: [:0]const u8) ?[:0]u8`	`char TextReplaceAlloc(const char text, const char search, const char replacement)`
`rl.textReplaceBetween(text: [:0]const u8, begin: [:0]const u8, end: [:0]const u8, replacement: [:0]const u8) [:0]const u8`	`char TextReplaceBetween(const char text, const char begin, const char end, const char *replacement)`
`rl.textReplaceBetweenAlloc(text: [:0]const u8, begin: [:0]const u8, end: [:0]const u8, replacement: [:0]const u8) ?[:0]u8`	`char TextReplaceBetweenAlloc(const char text, const char begin, const char end, const char *replacement)`
`rl.textInsert(text: [:0]const u8, insert: [:0]const u8, position: i32) [:0]const u8`	`char TextInsert(const char text, const char *insert, int position)`
`rl.textInsertAlloc(text: [:0]const u8, insert: [:0]const u8, position: i32) ?[:0]u8`	`char TextInsertAlloc(const char text, const char *insert, int position)`
`rl.textJoin(textList: []const [*:0]const u8, delimiter: [:0]const u8) [:0]const u8`	`char TextJoin(char textList, int count, const char delimiter)`
`rl.textSplit(text: [:0]const u8, delimiter: u8) []const [*:0]const u8`	`char *TextSplit(const char text, char delimiter, int *count)`
`rl.textAppend(text: []u8, append: [:0]const u8, position: i32) void`	`void TextAppend(char text, const char append, int *position)`
`rl.textFindIndex(text: [:0]const u8, search: [:0]const u8) i32`	`int TextFindIndex(const char text, const char search)`
`rl.textToUpper(text: [:0]const u8) [:0]const u8`	`char TextToUpper(const char text)`
`rl.textToLower(text: [:0]const u8) [:0]const u8`	`char TextToLower(const char text)`
`rl.textToPascal(text: [:0]const u8) [:0]const u8`	`char TextToPascal(const char text)`
`rl.textToSnake(text: [:0]const u8) [:0]const u8`	`char TextToSnake(const char text)`
`rl.textToCamel(text: [:0]const u8) [:0]const u8`	`char TextToCamel(const char text)`
`rl.textToInteger(text: [:0]const u8) i32`	`int TextToInteger(const char *text)`
`rl.textToFloat(text: [:0]const u8) f32`	`float TextToFloat(const char *text)`

models

Zig	C
`rl.drawLine3D(startPos: Vector3, endPos: Vector3, color: Color) void`	`void DrawLine3D(Vector3 startPos, Vector3 endPos, Color color)`
`rl.drawPoint3D(position: Vector3, color: Color) void`	`void DrawPoint3D(Vector3 position, Color color)`
`rl.drawCircle3D(center: Vector3, radius: f32, rotationAxis: Vector3, rotationAngle: f32, color: Color) void`	`void DrawCircle3D(Vector3 center, float radius, Vector3 rotationAxis, float rotationAngle, Color color)`
`rl.drawTriangle3D(v1: Vector3, v2: Vector3, v3: Vector3, color: Color) void`	`void DrawTriangle3D(Vector3 v1, Vector3 v2, Vector3 v3, Color color)`
`rl.drawTriangleStrip3D(points: []const Vector3, color: Color) void`	`void DrawTriangleStrip3D(const Vector3 *points, int pointCount, Color color)`
`rl.drawCube(position: Vector3, width: f32, height: f32, length: f32, color: Color) void`	`void DrawCube(Vector3 position, float width, float height, float length, Color color)`
`rl.drawCubeV(position: Vector3, size: Vector3, color: Color) void`	`void DrawCubeV(Vector3 position, Vector3 size, Color color)`
`rl.drawCubeWires(position: Vector3, width: f32, height: f32, length: f32, color: Color) void`	`void DrawCubeWires(Vector3 position, float width, float height, float length, Color color)`
`rl.drawCubeWiresV(position: Vector3, size: Vector3, color: Color) void`	`void DrawCubeWiresV(Vector3 position, Vector3 size, Color color)`
`rl.drawSphere(centerPos: Vector3, radius: f32, color: Color) void`	`void DrawSphere(Vector3 centerPos, float radius, Color color)`
`rl.drawSphereEx(centerPos: Vector3, radius: f32, rings: i32, slices: i32, color: Color) void`	`void DrawSphereEx(Vector3 centerPos, float radius, int rings, int slices, Color color)`
`rl.drawSphereWires(centerPos: Vector3, radius: f32, rings: i32, slices: i32, color: Color) void`	`void DrawSphereWires(Vector3 centerPos, float radius, int rings, int slices, Color color)`
`rl.drawCylinder(position: Vector3, radiusTop: f32, radiusBottom: f32, height: f32, sides: i32, color: Color) void`	`void DrawCylinder(Vector3 position, float radiusTop, float radiusBottom, float height, int sides, Color color)`
`rl.drawCylinderEx(startPos: Vector3, endPos: Vector3, startRadius: f32, endRadius: f32, sides: i32, color: Color) void`	`void DrawCylinderEx(Vector3 startPos, Vector3 endPos, float startRadius, float endRadius, int sides, Color color)`
`rl.drawCylinderWires(position: Vector3, radiusTop: f32, radiusBottom: f32, height: f32, sides: i32, color: Color) void`	`void DrawCylinderWires(Vector3 position, float radiusTop, float radiusBottom, float height, int sides, Color color)`
`rl.drawCylinderWiresEx(startPos: Vector3, endPos: Vector3, startRadius: f32, endRadius: f32, sides: i32, color: Color) void`	`void DrawCylinderWiresEx(Vector3 startPos, Vector3 endPos, float startRadius, float endRadius, int sides, Color color)`
`rl.drawCapsule(startPos: Vector3, endPos: Vector3, radius: f32, rings: i32, slices: i32, color: Color) void`	`void DrawCapsule(Vector3 startPos, Vector3 endPos, float radius, int rings, int slices, Color color)`
`rl.drawCapsuleWires(startPos: Vector3, endPos: Vector3, radius: f32, rings: i32, slices: i32, color: Color) void`	`void DrawCapsuleWires(Vector3 startPos, Vector3 endPos, float radius, int rings, int slices, Color color)`
`rl.drawPlane(centerPos: Vector3, size: Vector2, color: Color) void`	`void DrawPlane(Vector3 centerPos, Vector2 size, Color color)`
`rl.drawRay(ray: Ray, color: Color) void`	`void DrawRay(Ray ray, Color color)`
`rl.drawGrid(slices: i32, spacing: f32) void`	`void DrawGrid(int slices, float spacing)`
`rl.loadModel(fileName: [:0]const u8) error{LoadFailed}!Model`	`Model LoadModel(const char *fileName)`
`rl.loadModelFromMesh(mesh: Mesh) error{LoadFailed}!Model`	`Model LoadModelFromMesh(Mesh mesh)`
`rl.isModelValid(model: Model) bool`	`bool IsModelValid(Model model)`
`rl.unloadModel(model: Model) void`	`void UnloadModel(Model model)`
`rl.getModelBoundingBox(model: Model) BoundingBox`	`BoundingBox GetModelBoundingBox(Model model)`
`rl.drawModel(model: Model, position: Vector3, scale: f32, tint: Color) void`	`void DrawModel(Model model, Vector3 position, float scale, Color tint)`
`rl.drawModelEx(model: Model, position: Vector3, rotationAxis: Vector3, rotationAngle: f32, scale: Vector3, tint: Color) void`	`void DrawModelEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint)`
`rl.drawModelWires(model: Model, position: Vector3, scale: f32, tint: Color) void`	`void DrawModelWires(Model model, Vector3 position, float scale, Color tint)`
`rl.drawModelWiresEx(model: Model, position: Vector3, rotationAxis: Vector3, rotationAngle: f32, scale: Vector3, tint: Color) void`	`void DrawModelWiresEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint)`
`rl.drawBoundingBox(box: BoundingBox, color: Color) void`	`void DrawBoundingBox(BoundingBox box, Color color)`
`rl.drawBillboard(camera: Camera, texture: Texture2D, position: Vector3, scale: f32, tint: Color) void`	`void DrawBillboard(Camera camera, Texture2D texture, Vector3 position, float scale, Color tint)`
`rl.drawBillboardRec(camera: Camera, texture: Texture2D, rec: Rectangle, position: Vector3, size: Vector2, tint: Color) void`	`void DrawBillboardRec(Camera camera, Texture2D texture, Rectangle rec, Vector3 position, Vector2 size, Color tint)`
`rl.drawBillboardPro(camera: Camera, texture: Texture2D, rec: Rectangle, position: Vector3, up: Vector3, size: Vector2, origin: Vector2, rotation: f32, tint: Color) void`	`void DrawBillboardPro(Camera camera, Texture2D texture, Rectangle rec, Vector3 position, Vector3 up, Vector2 size, Vector2 origin, float rotation, Color tint)`
`rl.uploadMesh(mesh: *Mesh, dynamic: bool) void`	`void UploadMesh(Mesh *mesh, bool dynamic)`
`rl.updateMeshBuffer(mesh: Mesh, index: i32, data: []const u8, offset: i32) void`	`void UpdateMeshBuffer(Mesh mesh, int index, const void *data, int dataSize, int offset)`
`rl.unloadMesh(mesh: Mesh) void`	`void UnloadMesh(Mesh mesh)`
`rl.drawMesh(mesh: Mesh, material: Material, transform: Matrix) void`	`void DrawMesh(Mesh mesh, Material material, Matrix transform)`
`rl.drawMeshInstanced(mesh: Mesh, material: Material, transforms: []const Matrix) void`	`void DrawMeshInstanced(Mesh mesh, Material material, const Matrix *transforms, int instances)`
`rl.getMeshBoundingBox(mesh: Mesh) BoundingBox`	`BoundingBox GetMeshBoundingBox(Mesh mesh)`
`rl.genMeshTangents(mesh: *Mesh) void`	`void GenMeshTangents(Mesh *mesh)`
`rl.exportMesh(mesh: Mesh, fileName: [:0]const u8) bool`	`bool ExportMesh(Mesh mesh, const char *fileName)`
`rl.exportMeshAsCode(mesh: Mesh, fileName: [:0]const u8) bool`	`bool ExportMeshAsCode(Mesh mesh, const char *fileName)`
`rl.genMeshPoly(sides: i32, radius: f32) Mesh`	`Mesh GenMeshPoly(int sides, float radius)`
`rl.genMeshPlane(width: f32, length: f32, resX: i32, resZ: i32) Mesh`	`Mesh GenMeshPlane(float width, float length, int resX, int resZ)`
`rl.genMeshCube(width: f32, height: f32, length: f32) Mesh`	`Mesh GenMeshCube(float width, float height, float length)`
`rl.genMeshSphere(radius: f32, rings: i32, slices: i32) Mesh`	`Mesh GenMeshSphere(float radius, int rings, int slices)`
`rl.genMeshHemiSphere(radius: f32, rings: i32, slices: i32) Mesh`	`Mesh GenMeshHemiSphere(float radius, int rings, int slices)`
`rl.genMeshCylinder(radius: f32, height: f32, slices: i32) Mesh`	`Mesh GenMeshCylinder(float radius, float height, int slices)`
`rl.genMeshCone(radius: f32, height: f32, slices: i32) Mesh`	`Mesh GenMeshCone(float radius, float height, int slices)`
`rl.genMeshTorus(radius: f32, size: f32, radSeg: i32, sides: i32) Mesh`	`Mesh GenMeshTorus(float radius, float size, int radSeg, int sides)`
`rl.genMeshKnot(radius: f32, size: f32, radSeg: i32, sides: i32) Mesh`	`Mesh GenMeshKnot(float radius, float size, int radSeg, int sides)`
`rl.genMeshHeightmap(heightmap: Image, size: Vector3) Mesh`	`Mesh GenMeshHeightmap(Image heightmap, Vector3 size)`
`rl.genMeshCubicmap(cubicmap: Image, cubeSize: Vector3) Mesh`	`Mesh GenMeshCubicmap(Image cubicmap, Vector3 cubeSize)`
`rl.loadMaterials(fileName: [:0]const u8) error{LoadFailed}![]Material`	`Material LoadMaterials(const char fileName, int *materialCount)`
`rl.loadMaterialDefault() Material`	`Material LoadMaterialDefault(void)`
`rl.isMaterialValid(material: Material) bool`	`bool IsMaterialValid(Material material)`
`rl.unloadMaterial(material: Material) void`	`void UnloadMaterial(Material material)`
`rl.setMaterialTexture(material: *Material, mapType: MaterialMapIndex, texture: Texture2D) void`	`void SetMaterialTexture(Material *material, int mapType, Texture2D texture)`
`rl.setModelMeshMaterial(model: *Model, meshId: i32, materialId: i32) void`	`void SetModelMeshMaterial(Model *model, int meshId, int materialId)`
`rl.loadModelAnimations(fileName: [:0]const u8) error{LoadFailed}![]ModelAnimation`	`ModelAnimation LoadModelAnimations(const char fileName, int *animCount)`
`rl.updateModelAnimation(model: Model, anim: ModelAnimation, frame: f32) void`	`void UpdateModelAnimation(Model model, ModelAnimation anim, float frame)`
`rl.updateModelAnimationEx(model: Model, animA: ModelAnimation, frameA: f32, animB: ModelAnimation, frameB: f32, blend: f32) void`	`void UpdateModelAnimationEx(Model model, ModelAnimation animA, float frameA, ModelAnimation animB, float frameB, float blend)`
`rl.unloadModelAnimations(animations: []ModelAnimation) void`	`void UnloadModelAnimations(ModelAnimation *animations, int animCount)`
`rl.isModelAnimationValid(model: Model, anim: ModelAnimation) bool`	`bool IsModelAnimationValid(Model model, ModelAnimation anim)`
`rl.checkCollisionSpheres(center1: Vector3, radius1: f32, center2: Vector3, radius2: f32) bool`	`bool CheckCollisionSpheres(Vector3 center1, float radius1, Vector3 center2, float radius2)`
`rl.checkCollisionBoxes(box1: BoundingBox, box2: BoundingBox) bool`	`bool CheckCollisionBoxes(BoundingBox box1, BoundingBox box2)`
`rl.checkCollisionBoxSphere(box: BoundingBox, center: Vector3, radius: f32) bool`	`bool CheckCollisionBoxSphere(BoundingBox box, Vector3 center, float radius)`
`rl.getRayCollisionSphere(ray: Ray, center: Vector3, radius: f32) RayCollision`	`RayCollision GetRayCollisionSphere(Ray ray, Vector3 center, float radius)`
`rl.getRayCollisionBox(ray: Ray, box: BoundingBox) RayCollision`	`RayCollision GetRayCollisionBox(Ray ray, BoundingBox box)`
`rl.getRayCollisionMesh(ray: Ray, mesh: Mesh, transform: Matrix) RayCollision`	`RayCollision GetRayCollisionMesh(Ray ray, Mesh mesh, Matrix transform)`
`rl.getRayCollisionTriangle(ray: Ray, p1: Vector3, p2: Vector3, p3: Vector3) RayCollision`	`RayCollision GetRayCollisionTriangle(Ray ray, Vector3 p1, Vector3 p2, Vector3 p3)`
`rl.getRayCollisionQuad(ray: Ray, p1: Vector3, p2: Vector3, p3: Vector3, p4: Vector3) RayCollision`	`RayCollision GetRayCollisionQuad(Ray ray, Vector3 p1, Vector3 p2, Vector3 p3, Vector3 p4)`

audio

Zig	C
`rl.initAudioDevice() void`	`void InitAudioDevice(void)`
`rl.closeAudioDevice() void`	`void CloseAudioDevice(void)`
`rl.isAudioDeviceReady() bool`	`bool IsAudioDeviceReady(void)`
`rl.setMasterVolume(volume: f32) void`	`void SetMasterVolume(float volume)`
`rl.getMasterVolume() f32`	`float GetMasterVolume(void)`
`rl.loadWave(fileName: [:0]const u8) error{LoadFailed}!Wave`	`Wave LoadWave(const char *fileName)`
`rl.loadWaveFromMemory(fileType: [:0]const u8, fileData: []const u8) error{LoadFailed}!Wave`	`Wave LoadWaveFromMemory(const char fileType, const unsigned char fileData, int dataSize)`
`rl.isWaveValid(wave: Wave) bool`	`bool IsWaveValid(Wave wave)`
`rl.loadSound(fileName: [:0]const u8) error{LoadFailed}!Sound`	`Sound LoadSound(const char *fileName)`
`rl.loadSoundFromWave(wave: Wave) error{LoadFailed}!Sound`	`Sound LoadSoundFromWave(Wave wave)`
`rl.loadSoundAlias(source: Sound) error{LoadFailed}!Sound`	`Sound LoadSoundAlias(Sound source)`
`rl.isSoundValid(sound: Sound) bool`	`bool IsSoundValid(Sound sound)`
`rl.updateSound(sound: Sound, data: *const anyopaque, frameCount: i32) void`	`void UpdateSound(Sound sound, const void *data, int frameCount)`
`rl.unloadWave(wave: Wave) void`	`void UnloadWave(Wave wave)`
`rl.unloadSound(sound: Sound) void`	`void UnloadSound(Sound sound)`
`rl.unloadSoundAlias(alias: Sound) void`	`void UnloadSoundAlias(Sound alias)`
`rl.exportWave(wave: Wave, fileName: [:0]const u8) bool`	`bool ExportWave(Wave wave, const char *fileName)`
`rl.exportWaveAsCode(wave: Wave, fileName: [:0]const u8) bool`	`bool ExportWaveAsCode(Wave wave, const char *fileName)`
`rl.playSound(sound: Sound) void`	`void PlaySound(Sound sound)`
`rl.stopSound(sound: Sound) void`	`void StopSound(Sound sound)`
`rl.pauseSound(sound: Sound) void`	`void PauseSound(Sound sound)`
`rl.resumeSound(sound: Sound) void`	`void ResumeSound(Sound sound)`
`rl.isSoundPlaying(sound: Sound) bool`	`bool IsSoundPlaying(Sound sound)`
`rl.setSoundVolume(sound: Sound, volume: f32) void`	`void SetSoundVolume(Sound sound, float volume)`
`rl.setSoundPitch(sound: Sound, pitch: f32) void`	`void SetSoundPitch(Sound sound, float pitch)`
`rl.setSoundPan(sound: Sound, pan: f32) void`	`void SetSoundPan(Sound sound, float pan)`
`rl.waveCopy(wave: Wave) Wave`	`Wave WaveCopy(Wave wave)`
`rl.waveCrop(wave: *Wave, initFrame: i32, finalFrame: i32) void`	`void WaveCrop(Wave *wave, int initFrame, int finalFrame)`
`rl.waveFormat(wave: *Wave, sampleRate: i32, sampleSize: i32, channels: i32) void`	`void WaveFormat(Wave *wave, int sampleRate, int sampleSize, int channels)`
`rl.loadWaveSamples(wave: Wave) error{LoadFailed}![]f32`	`float *LoadWaveSamples(Wave wave)`
`rl.unloadWaveSamples(samples: []f32) void`	`void UnloadWaveSamples(float *samples)`
`rl.loadMusicStream(fileName: [:0]const u8) error{LoadFailed}!Music`	`Music LoadMusicStream(const char *fileName)`
`rl.loadMusicStreamFromMemory(fileType: [:0]const u8, data: []const u8) error{LoadFailed}!Music`	`Music LoadMusicStreamFromMemory(const char fileType, const unsigned char data, int dataSize)`
`rl.isMusicValid(music: Music) bool`	`bool IsMusicValid(Music music)`
`rl.unloadMusicStream(music: Music) void`	`void UnloadMusicStream(Music music)`
`rl.playMusicStream(music: Music) void`	`void PlayMusicStream(Music music)`
`rl.isMusicStreamPlaying(music: Music) bool`	`bool IsMusicStreamPlaying(Music music)`
`rl.updateMusicStream(music: Music) void`	`void UpdateMusicStream(Music music)`
`rl.stopMusicStream(music: Music) void`	`void StopMusicStream(Music music)`
`rl.pauseMusicStream(music: Music) void`	`void PauseMusicStream(Music music)`
`rl.resumeMusicStream(music: Music) void`	`void ResumeMusicStream(Music music)`
`rl.seekMusicStream(music: Music, position: f32) void`	`void SeekMusicStream(Music music, float position)`
`rl.setMusicVolume(music: Music, volume: f32) void`	`void SetMusicVolume(Music music, float volume)`
`rl.setMusicPitch(music: Music, pitch: f32) void`	`void SetMusicPitch(Music music, float pitch)`
`rl.setMusicPan(music: Music, pan: f32) void`	`void SetMusicPan(Music music, float pan)`
`rl.getMusicTimeLength(music: Music) f32`	`float GetMusicTimeLength(Music music)`
`rl.getMusicTimePlayed(music: Music) f32`	`float GetMusicTimePlayed(Music music)`
`rl.loadAudioStream(sampleRate: u32, sampleSize: u32, channels: u32) error{LoadFailed}!AudioStream`	`AudioStream LoadAudioStream(unsigned int sampleRate, unsigned int sampleSize, unsigned int channels)`
`rl.isAudioStreamValid(stream: AudioStream) bool`	`bool IsAudioStreamValid(AudioStream stream)`
`rl.unloadAudioStream(stream: AudioStream) void`	`void UnloadAudioStream(AudioStream stream)`
`rl.updateAudioStream(stream: AudioStream, data: *const anyopaque, frameCount: i32) void`	`void UpdateAudioStream(AudioStream stream, const void *data, int frameCount)`
`rl.isAudioStreamProcessed(stream: AudioStream) bool`	`bool IsAudioStreamProcessed(AudioStream stream)`
`rl.playAudioStream(stream: AudioStream) void`	`void PlayAudioStream(AudioStream stream)`
`rl.pauseAudioStream(stream: AudioStream) void`	`void PauseAudioStream(AudioStream stream)`
`rl.resumeAudioStream(stream: AudioStream) void`	`void ResumeAudioStream(AudioStream stream)`
`rl.isAudioStreamPlaying(stream: AudioStream) bool`	`bool IsAudioStreamPlaying(AudioStream stream)`
`rl.stopAudioStream(stream: AudioStream) void`	`void StopAudioStream(AudioStream stream)`
`rl.setAudioStreamVolume(stream: AudioStream, volume: f32) void`	`void SetAudioStreamVolume(AudioStream stream, float volume)`
`rl.setAudioStreamPitch(stream: AudioStream, pitch: f32) void`	`void SetAudioStreamPitch(AudioStream stream, float pitch)`
`rl.setAudioStreamPan(stream: AudioStream, pan: f32) void`	`void SetAudioStreamPan(AudioStream stream, float pan)`
`rl.setAudioStreamBufferSizeDefault(size: i32) void`	`void SetAudioStreamBufferSizeDefault(int size)`
`rl.setAudioStreamCallback(stream: AudioStream, callback: AudioCallback) void`	`void SetAudioStreamCallback(AudioStream stream, AudioCallback callback)`
`rl.attachAudioStreamProcessor(stream: AudioStream, processor: AudioCallback) void`	`void AttachAudioStreamProcessor(AudioStream stream, AudioCallback processor)`
`rl.detachAudioStreamProcessor(stream: AudioStream, processor: AudioCallback) void`	`void DetachAudioStreamProcessor(AudioStream stream, AudioCallback processor)`
`rl.attachAudioMixedProcessor(processor: AudioCallback) void`	`void AttachAudioMixedProcessor(AudioCallback processor)`
`rl.detachAudioMixedProcessor(processor: AudioCallback) void`	`void DetachAudioMixedProcessor(AudioCallback processor)`

math

Zig	C
`rl.math.clamp(value: f32, min: f32, max: f32) f32`	`float Clamp(float value, float min, float max)`
`rl.math.lerp(start: f32, end: f32, amount: f32) f32`	`float Lerp(float start, float end, float amount)`
`rl.math.normalize(value: f32, start: f32, end: f32) f32`	`float Normalize(float value, float start, float end)`
`rl.math.remap(value: f32, inputStart: f32, inputEnd: f32, outputStart: f32, outputEnd: f32) f32`	`float Remap(float value, float inputStart, float inputEnd, float outputStart, float outputEnd)`
`rl.math.wrap(value: f32, min: f32, max: f32) f32`	`float Wrap(float value, float min, float max)`
`rl.math.floatEquals(x: f32, y: f32) i32`	`int FloatEquals(float x, float y)`
`rl.math.vector2Zero() Vector2`	`Vector2 Vector2Zero(void)`
`rl.math.vector2One() Vector2`	`Vector2 Vector2One(void)`
`rl.math.vector2Add(v1: Vector2, v2: Vector2) Vector2`	`Vector2 Vector2Add(Vector2 v1, Vector2 v2)`
`rl.math.vector2AddValue(v: Vector2, add: f32) Vector2`	`Vector2 Vector2AddValue(Vector2 v, float add)`
`rl.math.vector2Subtract(v1: Vector2, v2: Vector2) Vector2`	`Vector2 Vector2Subtract(Vector2 v1, Vector2 v2)`
`rl.math.vector2SubtractValue(v: Vector2, sub: f32) Vector2`	`Vector2 Vector2SubtractValue(Vector2 v, float sub)`
`rl.math.vector2Length(v: Vector2) f32`	`float Vector2Length(Vector2 v)`
`rl.math.vector2LengthSqr(v: Vector2) f32`	`float Vector2LengthSqr(Vector2 v)`
`rl.math.vector2DotProduct(v1: Vector2, v2: Vector2) f32`	`float Vector2DotProduct(Vector2 v1, Vector2 v2)`
`rl.math.vector2CrossProduct(v1: Vector2, v2: Vector2) f32`	`float Vector2CrossProduct(Vector2 v1, Vector2 v2)`
`rl.math.vector2Distance(v1: Vector2, v2: Vector2) f32`	`float Vector2Distance(Vector2 v1, Vector2 v2)`
`rl.math.vector2DistanceSqr(v1: Vector2, v2: Vector2) f32`	`float Vector2DistanceSqr(Vector2 v1, Vector2 v2)`
`rl.math.vector2Angle(v1: Vector2, v2: Vector2) f32`	`float Vector2Angle(Vector2 v1, Vector2 v2)`
`rl.math.vector2LineAngle(start: Vector2, end: Vector2) f32`	`float Vector2LineAngle(Vector2 start, Vector2 end)`
`rl.math.vector2Scale(v: Vector2, scale: f32) Vector2`	`Vector2 Vector2Scale(Vector2 v, float scale)`
`rl.math.vector2Multiply(v1: Vector2, v2: Vector2) Vector2`	`Vector2 Vector2Multiply(Vector2 v1, Vector2 v2)`
`rl.math.vector2Negate(v: Vector2) Vector2`	`Vector2 Vector2Negate(Vector2 v)`
`rl.math.vector2Divide(v1: Vector2, v2: Vector2) Vector2`	`Vector2 Vector2Divide(Vector2 v1, Vector2 v2)`
`rl.math.vector2Normalize(v: Vector2) Vector2`	`Vector2 Vector2Normalize(Vector2 v)`
`rl.math.vector2Transform(v: Vector2, mat: Matrix) Vector2`	`Vector2 Vector2Transform(Vector2 v, Matrix mat)`
`rl.math.vector2Lerp(v1: Vector2, v2: Vector2, amount: f32) Vector2`	`Vector2 Vector2Lerp(Vector2 v1, Vector2 v2, float amount)`
`rl.math.vector2Reflect(v: Vector2, normal: Vector2) Vector2`	`Vector2 Vector2Reflect(Vector2 v, Vector2 normal)`
`rl.math.vector2Min(v1: Vector2, v2: Vector2) Vector2`	`Vector2 Vector2Min(Vector2 v1, Vector2 v2)`
`rl.math.vector2Max(v1: Vector2, v2: Vector2) Vector2`	`Vector2 Vector2Max(Vector2 v1, Vector2 v2)`
`rl.math.vector2Rotate(v: Vector2, angle: f32) Vector2`	`Vector2 Vector2Rotate(Vector2 v, float angle)`
`rl.math.vector2MoveTowards(v: Vector2, target: Vector2, maxDistance: f32) Vector2`	`Vector2 Vector2MoveTowards(Vector2 v, Vector2 target, float maxDistance)`
`rl.math.vector2Invert(v: Vector2) Vector2`	`Vector2 Vector2Invert(Vector2 v)`
`rl.math.vector2Clamp(v: Vector2, min: Vector2, max: Vector2) Vector2`	`Vector2 Vector2Clamp(Vector2 v, Vector2 min, Vector2 max)`
`rl.math.vector2ClampValue(v: Vector2, min: f32, max: f32) Vector2`	`Vector2 Vector2ClampValue(Vector2 v, float min, float max)`
`rl.math.vector2Equals(p: Vector2, q: Vector2) i32`	`int Vector2Equals(Vector2 p, Vector2 q)`
`rl.math.vector2Refract(v: Vector2, n: Vector2, r: f32) Vector2`	`Vector2 Vector2Refract(Vector2 v, Vector2 n, float r)`
`rl.math.vector3Zero() Vector3`	`Vector3 Vector3Zero(void)`
`rl.math.vector3One() Vector3`	`Vector3 Vector3One(void)`
`rl.math.vector3Add(v1: Vector3, v2: Vector3) Vector3`	`Vector3 Vector3Add(Vector3 v1, Vector3 v2)`
`rl.math.vector3AddValue(v: Vector3, add: f32) Vector3`	`Vector3 Vector3AddValue(Vector3 v, float add)`
`rl.math.vector3Subtract(v1: Vector3, v2: Vector3) Vector3`	`Vector3 Vector3Subtract(Vector3 v1, Vector3 v2)`
`rl.math.vector3SubtractValue(v: Vector3, sub: f32) Vector3`	`Vector3 Vector3SubtractValue(Vector3 v, float sub)`
`rl.math.vector3Scale(v: Vector3, scalar: f32) Vector3`	`Vector3 Vector3Scale(Vector3 v, float scalar)`
`rl.math.vector3Multiply(v1: Vector3, v2: Vector3) Vector3`	`Vector3 Vector3Multiply(Vector3 v1, Vector3 v2)`
`rl.math.vector3CrossProduct(v1: Vector3, v2: Vector3) Vector3`	`Vector3 Vector3CrossProduct(Vector3 v1, Vector3 v2)`
`rl.math.vector3Perpendicular(v: Vector3) Vector3`	`Vector3 Vector3Perpendicular(Vector3 v)`
`rl.math.vector3Length(v: Vector3) f32`	`float Vector3Length(const Vector3 v)`
`rl.math.vector3LengthSqr(v: Vector3) f32`	`float Vector3LengthSqr(const Vector3 v)`
`rl.math.vector3DotProduct(v1: Vector3, v2: Vector3) f32`	`float Vector3DotProduct(Vector3 v1, Vector3 v2)`
`rl.math.vector3Distance(v1: Vector3, v2: Vector3) f32`	`float Vector3Distance(Vector3 v1, Vector3 v2)`
`rl.math.vector3DistanceSqr(v1: Vector3, v2: Vector3) f32`	`float Vector3DistanceSqr(Vector3 v1, Vector3 v2)`
`rl.math.vector3Angle(v1: Vector3, v2: Vector3) f32`	`float Vector3Angle(Vector3 v1, Vector3 v2)`
`rl.math.vector3Negate(v: Vector3) Vector3`	`Vector3 Vector3Negate(Vector3 v)`
`rl.math.vector3Divide(v1: Vector3, v2: Vector3) Vector3`	`Vector3 Vector3Divide(Vector3 v1, Vector3 v2)`
`rl.math.vector3Normalize(v: Vector3) Vector3`	`Vector3 Vector3Normalize(Vector3 v)`
`rl.math.vector3Project(v1: Vector3, v2: Vector3) Vector3`	`Vector3 Vector3Project(Vector3 v1, Vector3 v2)`
`rl.math.vector3Reject(v1: Vector3, v2: Vector3) Vector3`	`Vector3 Vector3Reject(Vector3 v1, Vector3 v2)`
`rl.math.vector3OrthoNormalize(v1: Vector3, v2: Vector3) void`	`void Vector3OrthoNormalize(Vector3 v1, Vector3 v2)`
`rl.math.vector3Transform(v: Vector3, mat: Matrix) Vector3`	`Vector3 Vector3Transform(Vector3 v, Matrix mat)`
`rl.math.vector3RotateByQuaternion(v: Vector3, q: Quaternion) Vector3`	`Vector3 Vector3RotateByQuaternion(Vector3 v, Quaternion q)`
`rl.math.vector3RotateByAxisAngle(v: Vector3, axis: Vector3, angle: f32) Vector3`	`Vector3 Vector3RotateByAxisAngle(Vector3 v, Vector3 axis, float angle)`
`rl.math.vector3MoveTowards(v: Vector3, target: Vector3, maxDistance: f32) Vector3`	`Vector3 Vector3MoveTowards(Vector3 v, Vector3 target, float maxDistance)`
`rl.math.vector3Lerp(v1: Vector3, v2: Vector3, amount: f32) Vector3`	`Vector3 Vector3Lerp(Vector3 v1, Vector3 v2, float amount)`
`rl.math.vector3CubicHermite(v1: Vector3, tangent1: Vector3, v2: Vector3, tangent2: Vector3, amount: f32) Vector3`	`Vector3 Vector3CubicHermite(Vector3 v1, Vector3 tangent1, Vector3 v2, Vector3 tangent2, float amount)`
`rl.math.vector3Reflect(v: Vector3, normal: Vector3) Vector3`	`Vector3 Vector3Reflect(Vector3 v, Vector3 normal)`
`rl.math.vector3Min(v1: Vector3, v2: Vector3) Vector3`	`Vector3 Vector3Min(Vector3 v1, Vector3 v2)`
`rl.math.vector3Max(v1: Vector3, v2: Vector3) Vector3`	`Vector3 Vector3Max(Vector3 v1, Vector3 v2)`
`rl.math.vector3Barycenter(p: Vector3, v1: Vector3, v2: Vector3, v3: Vector3) Vector3`	`Vector3 Vector3Barycenter(Vector3 p, Vector3 a, Vector3 b, Vector3 c)`
`rl.math.vector3Unproject(source: Vector3, projection: Matrix, view: Matrix) Vector3`	`Vector3 Vector3Unproject(Vector3 source, Matrix projection, Matrix view)`
`rl.math.vector3ToFloatV(v: Vector3) float3`	`float3 Vector3ToFloatV(Vector3 v)`
`rl.math.vector3Invert(v: Vector3) Vector3`	`Vector3 Vector3Invert(Vector3 v)`
`rl.math.vector3Clamp(v: Vector3, min: Vector3, max: Vector3) Vector3`	`Vector3 Vector3Clamp(Vector3 v, Vector3 min, Vector3 max)`
`rl.math.vector3ClampValue(v: Vector3, min: f32, max: f32) Vector3`	`Vector3 Vector3ClampValue(Vector3 v, float min, float max)`
`rl.math.vector3Equals(p: Vector3, q: Vector3) i32`	`int Vector3Equals(Vector3 p, Vector3 q)`
`rl.math.vector3Refract(v: Vector3, n: Vector3, r: f32) Vector3`	`Vector3 Vector3Refract(Vector3 v, Vector3 n, float r)`
`rl.math.vector4Zero() Vector4`	`Vector4 Vector4Zero(void)`
`rl.math.vector4One() Vector4`	`Vector4 Vector4One(void)`
`rl.math.vector4Add(v1: Vector4, v2: Vector4) Vector4`	`Vector4 Vector4Add(Vector4 v1, Vector4 v2)`
`rl.math.vector4AddValue(v: Vector4, add: f32) Vector4`	`Vector4 Vector4AddValue(Vector4 v, float add)`
`rl.math.vector4Subtract(v1: Vector4, v2: Vector4) Vector4`	`Vector4 Vector4Subtract(Vector4 v1, Vector4 v2)`
`rl.math.vector4SubtractValue(v: Vector4, add: f32) Vector4`	`Vector4 Vector4SubtractValue(Vector4 v, float add)`
`rl.math.vector4Length(v: Vector4) f32`	`float Vector4Length(Vector4 v)`
`rl.math.vector4LengthSqr(v: Vector4) f32`	`float Vector4LengthSqr(Vector4 v)`
`rl.math.vector4DotProduct(v1: Vector4, v2: Vector4) f32`	`float Vector4DotProduct(Vector4 v1, Vector4 v2)`
`rl.math.vector4Distance(v1: Vector4, v2: Vector4) f32`	`float Vector4Distance(Vector4 v1, Vector4 v2)`
`rl.math.vector4DistanceSqr(v1: Vector4, v2: Vector4) f32`	`float Vector4DistanceSqr(Vector4 v1, Vector4 v2)`
`rl.math.vector4Scale(v: Vector4, scale: f32) Vector4`	`Vector4 Vector4Scale(Vector4 v, float scale)`
`rl.math.vector4Multiply(v1: Vector4, v2: Vector4) Vector4`	`Vector4 Vector4Multiply(Vector4 v1, Vector4 v2)`
`rl.math.vector4Negate(v: Vector4) Vector4`	`Vector4 Vector4Negate(Vector4 v)`
`rl.math.vector4Divide(v1: Vector4, v2: Vector4) Vector4`	`Vector4 Vector4Divide(Vector4 v1, Vector4 v2)`
`rl.math.vector4Normalize(v: Vector4) Vector4`	`Vector4 Vector4Normalize(Vector4 v)`
`rl.math.vector4Min(v1: Vector4, v2: Vector4) Vector4`	`Vector4 Vector4Min(Vector4 v1, Vector4 v2)`
`rl.math.vector4Max(v1: Vector4, v2: Vector4) Vector4`	`Vector4 Vector4Max(Vector4 v1, Vector4 v2)`
`rl.math.vector4Lerp(v1: Vector4, v2: Vector4, amount: f32) Vector4`	`Vector4 Vector4Lerp(Vector4 v1, Vector4 v2, float amount)`
`rl.math.vector4MoveTowards(v: Vector4, target: Vector4, maxDistance: f32) Vector4`	`Vector4 Vector4MoveTowards(Vector4 v, Vector4 target, float maxDistance)`
`rl.math.vector4Invert(v: Vector4) Vector4`	`Vector4 Vector4Invert(Vector4 v)`
`rl.math.vector4Equals(p: Vector4, q: Vector4) i32`	`int Vector4Equals(Vector4 p, Vector4 q)`
`rl.math.matrixDeterminant(mat: Matrix) f32`	`float MatrixDeterminant(Matrix mat)`
`rl.math.matrixTrace(mat: Matrix) f32`	`float MatrixTrace(Matrix mat)`
`rl.math.matrixTranspose(mat: Matrix) Matrix`	`Matrix MatrixTranspose(Matrix mat)`
`rl.math.matrixInvert(mat: Matrix) Matrix`	`Matrix MatrixInvert(Matrix mat)`
`rl.math.matrixIdentity() Matrix`	`Matrix MatrixIdentity(void)`
`rl.math.matrixAdd(left: Matrix, right: Matrix) Matrix`	`Matrix MatrixAdd(Matrix left, Matrix right)`
`rl.math.matrixSubtract(left: Matrix, right: Matrix) Matrix`	`Matrix MatrixSubtract(Matrix left, Matrix right)`
`rl.math.matrixMultiply(left: Matrix, right: Matrix) Matrix`	`Matrix MatrixMultiply(Matrix left, Matrix right)`
`rl.math.matrixMultiplyValue(left: Matrix, value: f32) Matrix`	`Matrix MatrixMultiplyValue(Matrix left, float value)`
`rl.math.matrixTranslate(x: f32, y: f32, z: f32) Matrix`	`Matrix MatrixTranslate(float x, float y, float z)`
`rl.math.matrixRotate(axis: Vector3, angle: f32) Matrix`	`Matrix MatrixRotate(Vector3 axis, float angle)`
`rl.math.matrixRotateX(angle: f32) Matrix`	`Matrix MatrixRotateX(float angle)`
`rl.math.matrixRotateY(angle: f32) Matrix`	`Matrix MatrixRotateY(float angle)`
`rl.math.matrixRotateZ(angle: f32) Matrix`	`Matrix MatrixRotateZ(float angle)`
`rl.math.matrixRotateXYZ(angle: Vector3) Matrix`	`Matrix MatrixRotateXYZ(Vector3 angle)`
`rl.math.matrixRotateZYX(angle: Vector3) Matrix`	`Matrix MatrixRotateZYX(Vector3 angle)`
`rl.math.matrixScale(x: f32, y: f32, z: f32) Matrix`	`Matrix MatrixScale(float x, float y, float z)`
`rl.math.matrixFrustum(left: f64, right: f64, bottom: f64, top: f64, nearPlane: f64, farPlane: f64) Matrix`	`Matrix MatrixFrustum(double left, double right, double bottom, double top, double nearPlane, double farPlane)`
`rl.math.matrixPerspective(fovY: f64, aspect: f64, nearPlane: f64, farPlane: f64) Matrix`	`Matrix MatrixPerspective(double fovY, double aspect, double nearPlane, double farPlane)`
`rl.math.matrixOrtho(left: f64, right: f64, bottom: f64, top: f64, nearPlane: f64, farPlane: f64) Matrix`	`Matrix MatrixOrtho(double left, double right, double bottom, double top, double nearPlane, double farPlane)`
`rl.math.matrixLookAt(eye: Vector3, target: Vector3, up: Vector3) Matrix`	`Matrix MatrixLookAt(Vector3 eye, Vector3 target, Vector3 up)`
`rl.math.matrixToFloatV(mat: Matrix) float16`	`float16 MatrixToFloatV(Matrix mat)`
`rl.math.quaternionAdd(q1: Quaternion, q2: Quaternion) Quaternion`	`Quaternion QuaternionAdd(Quaternion q1, Quaternion q2)`
`rl.math.quaternionAddValue(q: Quaternion, add: f32) Quaternion`	`Quaternion QuaternionAddValue(Quaternion q, float add)`
`rl.math.quaternionSubtract(q1: Quaternion, q2: Quaternion) Quaternion`	`Quaternion QuaternionSubtract(Quaternion q1, Quaternion q2)`
`rl.math.quaternionSubtractValue(q: Quaternion, sub: f32) Quaternion`	`Quaternion QuaternionSubtractValue(Quaternion q, float sub)`
`rl.math.quaternionIdentity() Quaternion`	`Quaternion QuaternionIdentity(void)`
`rl.math.quaternionLength(q: Quaternion) f32`	`float QuaternionLength(Quaternion q)`
`rl.math.quaternionNormalize(q: Quaternion) Quaternion`	`Quaternion QuaternionNormalize(Quaternion q)`
`rl.math.quaternionInvert(q: Quaternion) Quaternion`	`Quaternion QuaternionInvert(Quaternion q)`
`rl.math.quaternionMultiply(q1: Quaternion, q2: Quaternion) Quaternion`	`Quaternion QuaternionMultiply(Quaternion q1, Quaternion q2)`
`rl.math.quaternionScale(q: Quaternion, mul: f32) Quaternion`	`Quaternion QuaternionScale(Quaternion q, float mul)`
`rl.math.quaternionDivide(q1: Quaternion, q2: Quaternion) Quaternion`	`Quaternion QuaternionDivide(Quaternion q1, Quaternion q2)`
`rl.math.quaternionLerp(q1: Quaternion, q2: Quaternion, amount: f32) Quaternion`	`Quaternion QuaternionLerp(Quaternion q1, Quaternion q2, float amount)`
`rl.math.quaternionNlerp(q1: Quaternion, q2: Quaternion, amount: f32) Quaternion`	`Quaternion QuaternionNlerp(Quaternion q1, Quaternion q2, float amount)`
`rl.math.quaternionSlerp(q1: Quaternion, q2: Quaternion, amount: f32) Quaternion`	`Quaternion QuaternionSlerp(Quaternion q1, Quaternion q2, float amount)`
`rl.math.quaternionCubicHermiteSpline(q1: Quaternion, outTangent1: Quaternion, q2: Quaternion, inTangent2: Quaternion, t: f32) Quaternion`	`Quaternion QuaternionCubicHermiteSpline(Quaternion q1, Quaternion outTangent1, Quaternion q2, Quaternion inTangent2, float t)`
`rl.math.quaternionFromVector3ToVector3(from: Vector3, to: Vector3) Quaternion`	`Quaternion QuaternionFromVector3ToVector3(Vector3 from, Vector3 to)`
`rl.math.quaternionFromMatrix(mat: Matrix) Quaternion`	`Quaternion QuaternionFromMatrix(Matrix mat)`
`rl.math.quaternionToMatrix(q: Quaternion) Matrix`	`Matrix QuaternionToMatrix(Quaternion q)`
`rl.math.quaternionFromAxisAngle(axis: Vector3, angle: f32) Quaternion`	`Quaternion QuaternionFromAxisAngle(Vector3 axis, float angle)`
`rl.math.quaternionToAxisAngle(q: Quaternion, outAxis: Vector3, outAngle: f32) void`	`void QuaternionToAxisAngle(Quaternion q, Vector3 outAxis, float outAngle)`
`rl.math.quaternionFromEuler(pitch: f32, yaw: f32, roll: f32) Quaternion`	`Quaternion QuaternionFromEuler(float pitch, float yaw, float roll)`
`rl.math.quaternionToEuler(q: Quaternion) Vector3`	`Vector3 QuaternionToEuler(Quaternion q)`
`rl.math.quaternionTransform(q: Quaternion, mat: Matrix) Quaternion`	`Quaternion QuaternionTransform(Quaternion q, Matrix mat)`
`rl.math.quaternionEquals(p: Quaternion, q: Quaternion) i32`	`int QuaternionEquals(Quaternion p, Quaternion q)`
`rl.math.matrixCompose(translation: Vector3, rotation: Quaternion, scale: Vector3) Matrix`	`Matrix MatrixCompose(Vector3 translation, Quaternion rotation, Vector3 scale)`
`rl.math.matrixDecompose(mat: Matrix, translation: Vector3, rotation: Quaternion, scale: *Vector3) void`	`void MatrixDecompose(Matrix mat, Vector3 translation, Quaternion rotation, Vector3 *scale)`

gl

Zig	C
`rl.gl.matrixMode(mode: i32) void`	`void rlMatrixMode(int mode)`
`rl.gl.pushMatrix() void`	`void rlPushMatrix(void)`
`rl.gl.popMatrix() void`	`void rlPopMatrix(void)`
`rl.gl.loadIdentity() void`	`void rlLoadIdentity(void)`
`rl.gl.translatef(x: f32, y: f32, z: f32) void`	`void rlTranslatef(float x, float y, float z)`
`rl.gl.rotatef(angle: f32, x: f32, y: f32, z: f32) void`	`void rlRotatef(float angle, float x, float y, float z)`
`rl.gl.scalef(x: f32, y: f32, z: f32) void`	`void rlScalef(float x, float y, float z)`
`rl.gl.multMatrixf(matf: *const [16]f32) void`	`void rlMultMatrixf(const float *matf)`
`rl.gl.frustum(left: f64, right: f64, bottom: f64, top: f64, znear: f64, zfar: f64) void`	`void rlFrustum(double left, double right, double bottom, double top, double znear, double zfar)`
`rl.gl.ortho(left: f64, right: f64, bottom: f64, top: f64, znear: f64, zfar: f64) void`	`void rlOrtho(double left, double right, double bottom, double top, double znear, double zfar)`
`rl.gl.viewport(x: i32, y: i32, width: i32, height: i32) void`	`void rlViewport(int x, int y, int width, int height)`
`rl.gl.setClipPlanes(nearPlane: f64, farPlane: f64) void`	`void rlSetClipPlanes(double nearPlane, double farPlane)`
`rl.gl.getCullDistanceNear() f64`	`double rlGetCullDistanceNear(void)`
`rl.gl.getCullDistanceFar() f64`	`double rlGetCullDistanceFar(void)`
`rl.gl.begin(mode: i32) void`	`void rlBegin(int mode)`
`rl.gl.end() void`	`void rlEnd(void)`
`rl.gl.vertex2i(x: i32, y: i32) void`	`void rlVertex2i(int x, int y)`
`rl.gl.vertex2f(x: f32, y: f32) void`	`void rlVertex2f(float x, float y)`
`rl.gl.vertex3f(x: f32, y: f32, z: f32) void`	`void rlVertex3f(float x, float y, float z)`
`rl.gl.texCoord2f(x: f32, y: f32) void`	`void rlTexCoord2f(float x, float y)`
`rl.gl.normal3f(x: f32, y: f32, z: f32) void`	`void rlNormal3f(float x, float y, float z)`
`rl.gl.color4ub(r: u8, g: u8, b: u8, a: u8) void`	`void rlColor4ub(unsigned char r, unsigned char g, unsigned char b, unsigned char a)`
`rl.gl.color3f(x: f32, y: f32, z: f32) void`	`void rlColor3f(float x, float y, float z)`
`rl.gl.color4f(x: f32, y: f32, z: f32, w: f32) void`	`void rlColor4f(float x, float y, float z, float w)`
`rl.gl.enableVertexArray(vaoId: u32) bool`	`bool rlEnableVertexArray(unsigned int vaoId)`
`rl.gl.disableVertexArray() void`	`void rlDisableVertexArray(void)`
`rl.gl.enableVertexBuffer(id: u32) void`	`void rlEnableVertexBuffer(unsigned int id)`
`rl.gl.disableVertexBuffer() void`	`void rlDisableVertexBuffer(void)`
`rl.gl.enableVertexBufferElement(id: u32) void`	`void rlEnableVertexBufferElement(unsigned int id)`
`rl.gl.disableVertexBufferElement() void`	`void rlDisableVertexBufferElement(void)`
`rl.gl.enableVertexAttribute(index: u32) void`	`void rlEnableVertexAttribute(unsigned int index)`
`rl.gl.disableVertexAttribute(index: u32) void`	`void rlDisableVertexAttribute(unsigned int index)`
`rl.gl.enableStatePointer(vertexAttribType: i32, buffer: ?*anyopaque) void`	`void rlEnableStatePointer(int vertexAttribType, void *buffer)`
`rl.gl.disableStatePointer(vertexAttribType: i32) void`	`void rlDisableStatePointer(int vertexAttribType)`
`rl.gl.activeTextureSlot(slot: i32) void`	`void rlActiveTextureSlot(int slot)`
`rl.gl.enableTexture(id: u32) void`	`void rlEnableTexture(unsigned int id)`
`rl.gl.disableTexture() void`	`void rlDisableTexture(void)`
`rl.gl.enableTextureCubemap(id: u32) void`	`void rlEnableTextureCubemap(unsigned int id)`
`rl.gl.disableTextureCubemap() void`	`void rlDisableTextureCubemap(void)`
`rl.gl.textureParameters(id: u32, param: i32, value: i32) void`	`void rlTextureParameters(unsigned int id, int param, int value)`
`rl.gl.cubemapParameters(id: u32, param: i32, value: i32) void`	`void rlCubemapParameters(unsigned int id, int param, int value)`
`rl.gl.enableShader(id: u32) void`	`void rlEnableShader(unsigned int id)`
`rl.gl.disableShader() void`	`void rlDisableShader(void)`
`rl.gl.enableFramebuffer(id: u32) void`	`void rlEnableFramebuffer(unsigned int id)`
`rl.gl.disableFramebuffer() void`	`void rlDisableFramebuffer(void)`
`rl.gl.getActiveFramebuffer() u32`	`unsigned int rlGetActiveFramebuffer(void)`
`rl.gl.activeDrawBuffers(count: i32) void`	`void rlActiveDrawBuffers(int count)`
`rl.gl.blitFramebuffer(srcX: i32, srcY: i32, srcWidth: i32, srcHeight: i32, dstX: i32, dstY: i32, dstWidth: i32, dstHeight: i32, bufferMask: i32) void`	`void rlBlitFramebuffer(int srcX, int srcY, int srcWidth, int srcHeight, int dstX, int dstY, int dstWidth, int dstHeight, int bufferMask)`
`rl.gl.bindFramebuffer(target: u32, framebuffer: u32) void`	`void rlBindFramebuffer(unsigned int target, unsigned int framebuffer)`
`rl.gl.enableColorBlend() void`	`void rlEnableColorBlend(void)`
`rl.gl.disableColorBlend() void`	`void rlDisableColorBlend(void)`
`rl.gl.enableDepthTest() void`	`void rlEnableDepthTest(void)`
`rl.gl.disableDepthTest() void`	`void rlDisableDepthTest(void)`
`rl.gl.enableDepthMask() void`	`void rlEnableDepthMask(void)`
`rl.gl.disableDepthMask() void`	`void rlDisableDepthMask(void)`
`rl.gl.enableBackfaceCulling() void`	`void rlEnableBackfaceCulling(void)`
`rl.gl.disableBackfaceCulling() void`	`void rlDisableBackfaceCulling(void)`
`rl.gl.colorMask(r: bool, g: bool, b: bool, a: bool) void`	`void rlColorMask(bool r, bool g, bool b, bool a)`
`rl.gl.setCullFace(mode: i32) void`	`void rlSetCullFace(int mode)`
`rl.gl.enableScissorTest() void`	`void rlEnableScissorTest(void)`
`rl.gl.disableScissorTest() void`	`void rlDisableScissorTest(void)`
`rl.gl.scissor(x: i32, y: i32, width: i32, height: i32) void`	`void rlScissor(int x, int y, int width, int height)`
`rl.gl.enablePointMode() void`	`void rlEnablePointMode(void)`
`rl.gl.disablePointMode() void`	`void rlDisablePointMode(void)`
`rl.gl.setPointSize(size: f32) void`	`void rlSetPointSize(float size)`
`rl.gl.getPointSize() f32`	`float rlGetPointSize(void)`
`rl.gl.enableWireMode() void`	`void rlEnableWireMode(void)`
`rl.gl.disableWireMode() void`	`void rlDisableWireMode(void)`
`rl.gl.setLineWidth(width: f32) void`	`void rlSetLineWidth(float width)`
`rl.gl.getLineWidth() f32`	`float rlGetLineWidth(void)`
`rl.gl.enableSmoothLines() void`	`void rlEnableSmoothLines(void)`
`rl.gl.disableSmoothLines() void`	`void rlDisableSmoothLines(void)`
`rl.gl.enableStereoRender() void`	`void rlEnableStereoRender(void)`
`rl.gl.disableStereoRender() void`	`void rlDisableStereoRender(void)`
`rl.gl.isStereoRenderEnabled() bool`	`bool rlIsStereoRenderEnabled(void)`
`rl.gl.clearColor(r: u8, g: u8, b: u8, a: u8) void`	`void rlClearColor(unsigned char r, unsigned char g, unsigned char b, unsigned char a)`
`rl.gl.clearScreenBuffers() void`	`void rlClearScreenBuffers(void)`
`rl.gl.checkErrors() void`	`void rlCheckErrors(void)`
`rl.gl.setBlendMode(mode: i32) void`	`void rlSetBlendMode(int mode)`
`rl.gl.setBlendFactors(glSrcFactor: i32, glDstFactor: i32, glEquation: i32) void`	`void rlSetBlendFactors(int glSrcFactor, int glDstFactor, int glEquation)`
`rl.gl.setBlendFactorsSeparate(glSrcRGB: i32, glDstRGB: i32, glSrcAlpha: i32, glDstAlpha: i32, glEqRGB: i32, glEqAlpha: i32) void`	`void rlSetBlendFactorsSeparate(int glSrcRGB, int glDstRGB, int glSrcAlpha, int glDstAlpha, int glEqRGB, int glEqAlpha)`
`rl.gl.init(width: i32, height: i32) void`	`void rlglInit(int width, int height)`
`rl.gl.close() void`	`void rlglClose(void)`
`rl.gl.loadExtensions(loader: ?*anyopaque) void`	`void rlLoadExtensions(void *loader)`
`rl.gl.getProcAddress(procName: [:0]const u8) ?*anyopaque`	`void rlGetProcAddress(const char procName)`
`rl.gl.getVersion() i32`	`int rlGetVersion(void)`
`rl.gl.setFramebufferWidth(width: i32) void`	`void rlSetFramebufferWidth(int width)`
`rl.gl.getFramebufferWidth() i32`	`int rlGetFramebufferWidth(void)`
`rl.gl.setFramebufferHeight(height: i32) void`	`void rlSetFramebufferHeight(int height)`
`rl.gl.getFramebufferHeight() i32`	`int rlGetFramebufferHeight(void)`
`rl.gl.getTextureIdDefault() u32`	`unsigned int rlGetTextureIdDefault(void)`
`rl.gl.getShaderIdDefault() u32`	`unsigned int rlGetShaderIdDefault(void)`
`rl.gl.getShaderLocsDefault() [*]i32`	`int *rlGetShaderLocsDefault(void)`
`rl.gl.loadRenderBatch(numBuffers: i32, bufferElements: i32) RenderBatch`	`rlRenderBatch rlLoadRenderBatch(int numBuffers, int bufferElements)`
`rl.gl.unloadRenderBatch(batch: RenderBatch) void`	`void rlUnloadRenderBatch(rlRenderBatch batch)`
`rl.gl.drawRenderBatch(batch: *RenderBatch) void`	`void rlDrawRenderBatch(rlRenderBatch *batch)`
`rl.gl.setRenderBatchActive(batch: ?*RenderBatch) void`	`void rlSetRenderBatchActive(rlRenderBatch *batch)`
`rl.gl.drawRenderBatchActive() void`	`void rlDrawRenderBatchActive(void)`
`rl.gl.checkRenderBatchLimit(vCount: i32) bool`	`bool rlCheckRenderBatchLimit(int vCount)`
`rl.gl.setTexture(id: u32) void`	`void rlSetTexture(unsigned int id)`
`rl.gl.loadVertexArray() u32`	`unsigned int rlLoadVertexArray(void)`
`rl.gl.loadVertexBuffer(buffer: []const u8, dynamic: bool) u32`	`unsigned int rlLoadVertexBuffer(const void *buffer, int size, bool dynamic)`
`rl.gl.loadVertexBufferElement(buffer: []const u8, dynamic: bool) u32`	`unsigned int rlLoadVertexBufferElement(const void *buffer, int size, bool dynamic)`
`rl.gl.updateVertexBuffer(bufferId: u32, data: []const u8, offset: i32) void`	`void rlUpdateVertexBuffer(unsigned int bufferId, const void *data, int dataSize, int offset)`
`rl.gl.updateVertexBufferElements(id: u32, data: []const u8, offset: i32) void`	`void rlUpdateVertexBufferElements(unsigned int id, const void *data, int dataSize, int offset)`
`rl.gl.unloadVertexArray(vaoId: u32) void`	`void rlUnloadVertexArray(unsigned int vaoId)`
`rl.gl.unloadVertexBuffer(vboId: u32) void`	`void rlUnloadVertexBuffer(unsigned int vboId)`
`rl.gl.setVertexAttribute(index: u32, compSize: i32, @"type": i32, normalized: bool, stride: i32, offset: i32) void`	`void rlSetVertexAttribute(unsigned int index, int compSize, int type, bool normalized, int stride, int offset)`
`rl.gl.setVertexAttributeDivisor(index: u32, divisor: i32) void`	`void rlSetVertexAttributeDivisor(unsigned int index, int divisor)`
`rl.gl.setVertexAttributeDefault(locIndex: i32, value: ?*const anyopaque, attribType: i32, count: i32) void`	`void rlSetVertexAttributeDefault(int locIndex, const void *value, int attribType, int count)`
`rl.gl.drawVertexArray(offset: i32, count: i32) void`	`void rlDrawVertexArray(int offset, int count)`
`rl.gl.drawVertexArrayElements(offset: i32, count: i32, buffer: ?*const anyopaque) void`	`void rlDrawVertexArrayElements(int offset, int count, const void *buffer)`
`rl.gl.drawVertexArrayInstanced(offset: i32, count: i32, instances: i32) void`	`void rlDrawVertexArrayInstanced(int offset, int count, int instances)`
`rl.gl.drawVertexArrayElementsInstanced(offset: i32, count: i32, buffer: ?*const anyopaque, instances: i32) void`	`void rlDrawVertexArrayElementsInstanced(int offset, int count, const void *buffer, int instances)`
`rl.gl.loadTexture(data: ?*const anyopaque, width: i32, height: i32, format: i32, mipmapCount: i32) u32`	`unsigned int rlLoadTexture(const void *data, int width, int height, int format, int mipmapCount)`
`rl.gl.loadTextureDepth(width: i32, height: i32, useRenderBuffer: bool) u32`	`unsigned int rlLoadTextureDepth(int width, int height, bool useRenderBuffer)`
`rl.gl.loadTextureCubemap(data: ?*const anyopaque, size: i32, format: i32, mipmapCount: i32) u32`	`unsigned int rlLoadTextureCubemap(const void *data, int size, int format, int mipmapCount)`
`rl.gl.updateTexture(id: u32, offsetX: i32, offsetY: i32, width: i32, height: i32, format: i32, data: ?*const anyopaque) void`	`void rlUpdateTexture(unsigned int id, int offsetX, int offsetY, int width, int height, int format, const void *data)`
`rl.gl.getGlTextureFormats(format: i32, glInternalFormat: c_uint, glFormat: c_uint, glType: *c_uint) void`	`void rlGetGlTextureFormats(int format, unsigned int glInternalFormat, unsigned int glFormat, unsigned int *glType)`
`rl.gl.getPixelFormatName(format: u32) [:0]const u8`	`const char *rlGetPixelFormatName(unsigned int format)`
`rl.gl.unloadTexture(id: u32) void`	`void rlUnloadTexture(unsigned int id)`
`rl.gl.genTextureMipmaps(id: u32, width: i32, height: i32, format: i32, mipmaps: *c_int) void`	`void rlGenTextureMipmaps(unsigned int id, int width, int height, int format, int *mipmaps)`
`rl.gl.readTexturePixels(id: u32, width: i32, height: i32, format: i32) ?*anyopaque`	`void *rlReadTexturePixels(unsigned int id, int width, int height, int format)`
`rl.gl.readScreenPixels(width: i32, height: i32) ?[]u8`	`unsigned char *rlReadScreenPixels(int width, int height)`
`rl.gl.loadFramebuffer() u32`	`unsigned int rlLoadFramebuffer(void)`
`rl.gl.framebufferAttach(id: u32, texId: u32, attachType: i32, texType: i32, mipLevel: i32) void`	`void rlFramebufferAttach(unsigned int id, unsigned int texId, int attachType, int texType, int mipLevel)`
`rl.gl.framebufferComplete(id: u32) bool`	`bool rlFramebufferComplete(unsigned int id)`
`rl.gl.unloadFramebuffer(id: u32) void`	`void rlUnloadFramebuffer(unsigned int id)`
`rl.gl.copyFramebuffer(x: i32, y: i32, width: i32, height: i32, format: i32, pixels: ?*anyopaque) void`	`void rlCopyFramebuffer(int x, int y, int width, int height, int format, void *pixels)`
`rl.gl.resizeFramebuffer(width: i32, height: i32) void`	`void rlResizeFramebuffer(int width, int height)`
`rl.gl.loadShader(code: [:0]const u8, @"type": i32) u32`	`unsigned int rlLoadShader(const char *code, int type)`
`rl.gl.loadShaderProgram(vsCode: [:0]const u8, fsCode: [:0]const u8) u32`	`unsigned int rlLoadShaderProgram(const char vsCode, const char fsCode)`
`rl.gl.loadShaderProgramEx(vsId: u32, fsId: u32) u32`	`unsigned int rlLoadShaderProgramEx(unsigned int vsId, unsigned int fsId)`
`rl.gl.loadShaderProgramCompute(csId: u32) u32`	`unsigned int rlLoadShaderProgramCompute(unsigned int csId)`
`rl.gl.unloadShader(id: u32) void`	`void rlUnloadShader(unsigned int id)`
`rl.gl.unloadShaderProgram(id: u32) void`	`void rlUnloadShaderProgram(unsigned int id)`
`rl.gl.getLocationUniform(id: u32, uniformName: [:0]const u8) i32`	`int rlGetLocationUniform(unsigned int id, const char *uniformName)`
`rl.gl.getLocationAttrib(id: u32, attribName: [:0]const u8) i32`	`int rlGetLocationAttrib(unsigned int id, const char *attribName)`
`rl.gl.setUniform(locIndex: i32, value: ?*const anyopaque, uniformType: i32, count: i32) void`	`void rlSetUniform(int locIndex, const void *value, int uniformType, int count)`
`rl.gl.setUniformMatrix(locIndex: i32, mat: Matrix) void`	`void rlSetUniformMatrix(int locIndex, Matrix mat)`
`rl.gl.setUniformMatrices(locIndex: i32, mat: []const Matrix) void`	`void rlSetUniformMatrices(int locIndex, const Matrix *mat, int count)`
`rl.gl.setUniformSampler(locIndex: i32, textureId: u32) void`	`void rlSetUniformSampler(int locIndex, unsigned int textureId)`
`rl.gl.setShader(id: u32, locs: [*]i32) void`	`void rlSetShader(unsigned int id, int *locs)`
`rl.gl.computeShaderDispatch(groupX: u32, groupY: u32, groupZ: u32) void`	`void rlComputeShaderDispatch(unsigned int groupX, unsigned int groupY, unsigned int groupZ)`
`rl.gl.loadShaderBuffer(size: u32, data: ?*const anyopaque, usageHint: i32) u32`	`unsigned int rlLoadShaderBuffer(unsigned int size, const void *data, int usageHint)`
`rl.gl.unloadShaderBuffer(ssboId: u32) void`	`void rlUnloadShaderBuffer(unsigned int ssboId)`
`rl.gl.updateShaderBuffer(id: u32, data: []const u8, offset: u32) void`	`void rlUpdateShaderBuffer(unsigned int id, const void *data, unsigned int dataSize, unsigned int offset)`
`rl.gl.bindShaderBuffer(id: u32, index: u32) void`	`void rlBindShaderBuffer(unsigned int id, unsigned int index)`
`rl.gl.readShaderBuffer(id: u32, dest: ?*anyopaque, count: u32, offset: u32) void`	`void rlReadShaderBuffer(unsigned int id, void *dest, unsigned int count, unsigned int offset)`
`rl.gl.copyShaderBuffer(destId: u32, srcId: u32, destOffset: u32, srcOffset: u32, count: u32) void`	`void rlCopyShaderBuffer(unsigned int destId, unsigned int srcId, unsigned int destOffset, unsigned int srcOffset, unsigned int count)`
`rl.gl.getShaderBufferSize(id: u32) u32`	`unsigned int rlGetShaderBufferSize(unsigned int id)`
`rl.gl.bindImageTexture(id: u32, index: u32, format: i32, readonly: bool) void`	`void rlBindImageTexture(unsigned int id, unsigned int index, int format, bool readonly)`
`rl.gl.getMatrixModelview() Matrix`	`Matrix rlGetMatrixModelview(void)`
`rl.gl.getMatrixProjection() Matrix`	`Matrix rlGetMatrixProjection(void)`
`rl.gl.getMatrixTransform() Matrix`	`Matrix rlGetMatrixTransform(void)`
`rl.gl.getMatrixProjectionStereo(eye: i32) Matrix`	`Matrix rlGetMatrixProjectionStereo(int eye)`
`rl.gl.getMatrixViewOffsetStereo(eye: i32) Matrix`	`Matrix rlGetMatrixViewOffsetStereo(int eye)`
`rl.gl.setMatrixProjection(proj: Matrix) void`	`void rlSetMatrixProjection(Matrix proj)`
`rl.gl.setMatrixModelview(view: Matrix) void`	`void rlSetMatrixModelview(Matrix view)`
`rl.gl.setMatrixProjectionStereo(right: Matrix, left: Matrix) void`	`void rlSetMatrixProjectionStereo(Matrix right, Matrix left)`
`rl.gl.setMatrixViewOffsetStereo(right: Matrix, left: Matrix) void`	`void rlSetMatrixViewOffsetStereo(Matrix right, Matrix left)`
`rl.gl.loadDrawCube() void`	`void rlLoadDrawCube(void)`
`rl.gl.loadDrawQuad() void`	`void rlLoadDrawQuad(void)`

raygui

Zig	C
`gui.enable() void`	`void GuiEnable(void)`
`gui.disable() void`	`void GuiDisable(void)`
`gui.lock() void`	`void GuiLock(void)`
`gui.unlock() void`	`void GuiUnlock(void)`
`gui.isLocked() bool`	`bool GuiIsLocked(void)`
`gui.setAlpha(alpha: f32) void`	`void GuiSetAlpha(float alpha)`
`gui.setState(state: State) void`	`void GuiSetState(int state)`
`gui.getState() State`	`int GuiGetState(void)`
`gui.setFont(font: Font) void`	`void GuiSetFont(Font font)`
`gui.getFont() Font`	`Font GuiGetFont(void)`
`gui.setStyle(control: Control, property: anytype, value: anytype) void`	`void GuiSetStyle(int control, int property, int value)`
`gui.getStyle(control: Control, property: anytype) i32`	`int GuiGetStyle(int control, int property)`
`gui.loadStyle(fileName: ?[:0]const u8) void`	`void GuiLoadStyle(const char *fileName)`
`gui.loadStyleFromMemory(fileData: []const u8) void`	`void GuiLoadStyleFromMemory(const unsigned char *fileData, int dataSize)`
`gui.loadStyleDefault() void`	`void GuiLoadStyleDefault(void)`
`gui.enableTooltip() void`	`void GuiEnableTooltip(void)`
`gui.disableTooltip() void`	`void GuiDisableTooltip(void)`
`gui.setTooltip(tooltip: ?[:0]const u8) void`	`void GuiSetTooltip(const char *tooltip)`
`gui.iconText(iconId: IconName, text: ?[:0]const u8) [:0]const u8`	`const char GuiIconText(int iconId, const char text)`
`gui.setIconScale(scale: i32) void`	`void GuiSetIconScale(int scale)`
`gui.getIcons() [*]u32`	`unsigned int *GuiGetIcons(void)`
`gui.loadIcons(fileName: ?[:0]const u8, loadIconsName: bool) ?[][:0]u8`	`char *GuiLoadIcons(const char fileName, bool loadIconsName)`
`gui.loadIconsFromMemory(fileData: []const u8, loadIconsName: bool) ?[][:0]u8`	`char *GuiLoadIconsFromMemory(const unsigned char fileData, int dataSize, bool loadIconsName)`
`gui.drawIcon(iconId: IconName, posX: i32, posY: i32, pixelSize: i32, color: Color) void`	`void GuiDrawIcon(int iconId, int posX, int posY, int pixelSize, Color color)`
`gui.getTextWidth(text: ?[:0]const u8) i32`	`int GuiGetTextWidth(const char *text)`
`gui.windowBox(bounds: Rectangle, title: ?[:0]const u8) i32`	`int GuiWindowBox(Rectangle bounds, const char *title)`
`gui.groupBox(bounds: Rectangle, text: ?[:0]const u8) i32`	`int GuiGroupBox(Rectangle bounds, const char *text)`
`gui.line(bounds: Rectangle, text: ?[:0]const u8) i32`	`int GuiLine(Rectangle bounds, const char *text)`
`gui.panel(bounds: Rectangle, text: ?[:0]const u8) i32`	`int GuiPanel(Rectangle bounds, const char *text)`
`gui.scrollPanel(bounds: Rectangle, text: ?[:0]const u8, content: Rectangle, scroll: Vector2, view: Rectangle) i32`	`int GuiScrollPanel(Rectangle bounds, const char text, Rectangle content, Vector2 scroll, Rectangle *view)`
`gui.label(bounds: Rectangle, text: ?[:0]const u8) i32`	`int GuiLabel(Rectangle bounds, const char *text)`
`gui.button(bounds: Rectangle, text: ?[:0]const u8) i32`	`int GuiButton(Rectangle bounds, const char *text)`
`gui.labelButton(bounds: Rectangle, text: ?[:0]const u8) i32`	`int GuiLabelButton(Rectangle bounds, const char *text)`
`gui.toggle(bounds: Rectangle, text: ?[:0]const u8, active: *bool) i32`	`int GuiToggle(Rectangle bounds, const char text, bool active)`
`gui.toggleGroup(bounds: Rectangle, text: ?[:0]const u8, active: *i32) i32`	`int GuiToggleGroup(Rectangle bounds, const char text, int active)`
`gui.toggleSlider(bounds: Rectangle, text: ?[:0]const u8, active: *i32) i32`	`int GuiToggleSlider(Rectangle bounds, const char text, int active)`
`gui.checkBox(bounds: Rectangle, text: ?[:0]const u8, checked: *bool) i32`	`int GuiCheckBox(Rectangle bounds, const char text, bool checked)`
`gui.comboBox(bounds: Rectangle, text: ?[:0]const u8, active: *i32) i32`	`int GuiComboBox(Rectangle bounds, const char text, int active)`
`gui.dropdownBox(bounds: Rectangle, text: ?[:0]const u8, active: *i32, editMode: bool) i32`	`int GuiDropdownBox(Rectangle bounds, const char text, int active, bool editMode)`
`gui.spinner(bounds: Rectangle, text: ?[:0]const u8, value: *i32, minValue: i32, maxValue: i32, editMode: bool) i32`	`int GuiSpinner(Rectangle bounds, const char text, int value, int minValue, int maxValue, bool editMode)`
`gui.valueBox(bounds: Rectangle, text: ?[:0]const u8, value: *i32, minValue: i32, maxValue: i32, editMode: bool) i32`	`int GuiValueBox(Rectangle bounds, const char text, int value, int minValue, int maxValue, bool editMode)`
`gui.valueBoxFloat(bounds: Rectangle, text: ?[:0]const u8, textValue: []u8, value: f32, editMode: bool) i32`	`int GuiValueBoxFloat(Rectangle bounds, const char text, char textValue, float *value, bool editMode)`
`gui.textBox(bounds: Rectangle, text: ?[]u8, editMode: bool) i32`	`int GuiTextBox(Rectangle bounds, char *text, int textSize, bool editMode)`
`gui.slider(bounds: Rectangle, textLeft: ?[:0]const u8, textRight: ?[:0]const u8, value: *f32, minValue: f32, maxValue: f32) i32`	`int GuiSlider(Rectangle bounds, const char textLeft, const char textRight, float *value, float minValue, float maxValue)`
`gui.sliderBar(bounds: Rectangle, textLeft: ?[:0]const u8, textRight: ?[:0]const u8, value: *f32, minValue: f32, maxValue: f32) i32`	`int GuiSliderBar(Rectangle bounds, const char textLeft, const char textRight, float *value, float minValue, float maxValue)`
`gui.progressBar(bounds: Rectangle, textLeft: ?[:0]const u8, textRight: ?[:0]const u8, value: *f32, minValue: f32, maxValue: f32) i32`	`int GuiProgressBar(Rectangle bounds, const char textLeft, const char textRight, float *value, float minValue, float maxValue)`
`gui.statusBar(bounds: Rectangle, text: ?[:0]const u8) i32`	`int GuiStatusBar(Rectangle bounds, const char *text)`
`gui.dummyRec(bounds: Rectangle, text: ?[:0]const u8) i32`	`int GuiDummyRec(Rectangle bounds, const char *text)`
`gui.grid(bounds: Rectangle, text: ?[:0]const u8, spacing: f32, subdivs: i32, mouseCell: *Vector2) i32`	`int GuiGrid(Rectangle bounds, const char text, float spacing, int subdivs, Vector2 mouseCell)`
`gui.listView(bounds: Rectangle, text: ?[:0]const u8, scrollIndex: i32, active: i32) i32`	`int GuiListView(Rectangle bounds, const char text, int scrollIndex, int *active)`
`gui.listViewEx(bounds: Rectangle, text: []const [:0]const u8, scrollIndex: i32, active: i32, focus: i32) i32`	`int GuiListViewEx(Rectangle bounds, char *text, int count, int scrollIndex, int active, int focus)`
`gui.tabBar(bounds: Rectangle, text: ?[:0]const u8, hscroll: i32, active: i32) i32`	`int GuiTabBar(Rectangle bounds, const char text, int hscroll, int *active)`
`gui.tabBarEx(bounds: Rectangle, text: []const [:0]const u8, hscroll: i32, active: i32, focus: i32) i32`	`int GuiTabBarEx(Rectangle bounds, char *text, int count, int hscroll, int active, int focus)`
`gui.messageBox(bounds: Rectangle, title: ?[:0]const u8, message: ?[:0]const u8, btnText: ?[:0]const u8, btnActive: *i32) i32`	`int GuiMessageBox(Rectangle bounds, const char title, const char message, const char btnText, int btnActive)`
`gui.textInputBox(bounds: Rectangle, title: ?[:0]const u8, message: ?[:0]const u8, text: ?[]u8, btnText: ?[:0]const u8, btnActive: i32, secretViewActive: bool) i32`	`int GuiTextInputBox(Rectangle bounds, const char title, const char message, char text, int textSize, const char btnText, int btnActive, bool secretViewActive)`
`gui.colorPicker(bounds: Rectangle, text: ?[:0]const u8, color: *Color) i32`	`int GuiColorPicker(Rectangle bounds, const char text, Color color)`
`gui.colorPanel(bounds: Rectangle, text: ?[:0]const u8, color: *Color) i32`	`int GuiColorPanel(Rectangle bounds, const char text, Color color)`
`gui.colorBarAlpha(bounds: Rectangle, text: ?[:0]const u8, alpha: *f32) i32`	`int GuiColorBarAlpha(Rectangle bounds, const char text, float alpha)`
`gui.colorBarHue(bounds: Rectangle, text: ?[:0]const u8, value: *f32) i32`	`int GuiColorBarHue(Rectangle bounds, const char text, float value)`
`gui.colorPickerHSV(bounds: Rectangle, text: ?[:0]const u8, colorHsv: *Vector3) i32`	`int GuiColorPickerHSV(Rectangle bounds, const char text, Vector3 colorHsv)`
`gui.colorPanelHSV(bounds: Rectangle, text: ?[:0]const u8, colorHsv: *Vector3) i32`	`int GuiColorPanelHSV(Rectangle bounds, const char text, Vector3 colorHsv)`