nub-lang/example/src/raylib.nub

module "raylib"

// export let PI = 3.14159265358979323846

// export let LIGHTGRAY  = struct Color { r = 200, g = 200, b = 200, a = 255 }
// export let GRAY       = struct Color { r = 130, g = 130, b = 130, a = 255 }
// export let DARKGRAY   = struct Color { r = 80, g = 80, b = 80, a = 255 }
// export let YELLOW     = struct Color { r = 253, g = 249, b = 0, a = 255 }
// export let GOLD       = struct Color { r = 255, g = 203, b = 0, a = 255 }
// export let ORANGE     = struct Color { r = 255, g = 161, b = 0, a = 255 }
// export let PINK       = struct Color { r = 255, g = 109, b = 194, a = 255 }
// export let RED        = struct Color { r = 230, g = 41, b = 55, a = 255 }
// export let MAROON     = struct Color { r = 190, g = 33, b = 55, a = 255 }
// export let GREEN      = struct Color { r = 0, g = 228, b = 48, a = 255 }
// export let LIME       = struct Color { r = 0, g = 158, b = 47, a = 255 }
// export let DARKGREEN  = struct Color { r = 0, g = 117, b = 44, a = 255 }
// export let SKYBLUE    = struct Color { r = 102, g = 191, b = 255, a = 255 }
// export let BLUE       = struct Color { r = 0, g = 121, b = 241, a = 255 }
// export let DARKBLUE   = struct Color { r = 0, g = 82, b = 172, a = 255 }
// export let PURPLE     = struct Color { r = 200, g = 122, b = 255, a = 255 }
// export let VIOLET     = struct Color { r = 135, g = 60, b = 190, a = 255 }
// export let DARKPURPLE = struct Color { r = 112, g = 31, b = 126, a = 255 }
// export let BEIGE      = struct Color { r = 211, g = 176, b = 131, a = 255 }
// export let BROWN      = struct Color { r = 127, g = 106, b = 79, a = 255 }
// export let DARKBROWN  = struct Color { r = 76, g = 63, b = 47, a = 255 }

// export let WHITE      = struct Color { r = 255, g = 255, b = 255, a = 255 }
// export let BLACK      = struct Color { r = 0, g = 0, b = 0, a = 255 }
// export let BLANK      = struct Color { r = 0, g = 0, b = 0, a = 0 }
// export let MAGENTA    = struct Color { r = 255, g = 0, b = 255, a = 255 }
// export let RAYWHITE   = struct Color { r = 245, g = 245, b = 245, a = 255 }

export struct Vector2
{
    x: f32
    y: f32
}

export struct Vector3
{
    x: f32
    y: f32
    z: f32
}

export struct Vector4
{
    x: f32
    y: f32
    z: f32
    w: f32
}

export struct Quaternion
{
    x: f32
    y: f32
    z: f32
    w: f32
}

export struct Matrix
{
    m0: f32
    m1: f32
    m2: f32
    m3: f32
    m4: f32
    m5: f32
    m6: f32
    m7: f32
    m8: f32
    m9: f32
    m10: f32
    m11: f32
    m12: f32
    m13: f32
    m14: f32
    m15: f32
}

export struct Color
{
    r: u8
    g: u8
    b: u8
    a: u8
}

export struct Rectangle
{
    x: f32
    y: f32
    width: f32
    height: f32
}

export struct Image
{
    data: ^void
    width: i32
    height: i32
    mipmaps: i32
    format: i32
}

export struct Texture
{
    id: u32
    width: i32
    height: i32
    mipmaps: i32
    format: i32
}

export struct Texture2D
{
    id: u32
    width: i32
    height: i32
    mipmaps: i32
    format: i32
}

export struct TextureCubemap
{
    id: u32
    width: i32
    height: i32
    mipmaps: i32
    format: i32
}

export struct RenderTexture
{
    id: u32
    texture: Texture
    depth: Texture
}

export struct RenderTexture2D
{
    id: u32
    texture: Texture
    depth: Texture
}

export struct NPatchInfo
{
    source: Rectangle
    left: i32
    top: i32
    right: i32
    bottom: i32
    layout: i32
}

export struct GlyphInfo
{
    value: i32
    offsetX: i32
    offsetY: i32
    advanceX: i32
    image: Image
}

export struct Font
{
    baseSize: i32
    glyphCount: i32
    glyphPadding: i32
    texture: Texture2D
    recs: ^Rectangle
    glyphs: ^GlyphInfo
}

export struct Camera3D
{
    position: Vector3
    target: Vector3
    up: Vector3
    fovy: f32
    projection: i32
}

export struct Camera
{
    position: Vector3
    target: Vector3
    up: Vector3
    fovy: f32
    projection: i32
}

export struct Camera2D
{
    offset: Vector2
    target: Vector2
    rotation: f32
    zoom: f32
}

export struct Mesh
{
    vertexCount: i32
    triangleCount: i32

    vertices: ^f32
    texcoords: ^f32
    texcoords2: ^f32
    normals: ^f32
    tangents: ^f32
    colors: ^u8
    indices: ^u16

    animVertices: ^f32
    animNormals: ^f32
    boneIds: ^u8
    boneWeights:  ^f32
    boneMatrices: ^Matrix
    boneCount: i32

    vaoId: u32
    vboId: ^u32
}

export struct Shader
{
    id: u32
    locs: ^i32
}

export struct MaterialMap
{
    texture: Texture2D
    color: Color
    value: f32
}

// export struct Material
// {
//     shader: Shader
//     maps: ^MaterialMap
//     params: [4]float
// }

export struct Transform
{
    translation: Vector3
    rotation: Quaternion
    scale: Vector3
}

// export struct BoneInfo
// {
//     name: [32]u8
//     parent: i32
// }

// export struct Model
// {
//     transform: Matrix

//     meshCount: i32
//     materialCount: i32
//     meshes: ^Mesh
//     materials: ^Material
//     meshMaterial: ^int

//     boneCount: i32
//     bones: ^BoneInfo
//     bindPose: ^Transform
// }

// export struct ModelAnimation
// {
//     boneCount: i32
//     frameCount: i32
//     bones: ^BoneInfo
//     framePoses: ^^Transform
//     name: [32]u8
// }

export struct Ray
{
    position: Vector3
    direction: Vector3
}

export struct RayCollision
{
    hit: bool
    distance: f32
    point: Vector3
    normal: Vector3
}

export struct BoundingBox
{
    min: Vector3
    max: Vector3
}

// export struct Wave
// {
//     frameCount: u32;
//     sampleRate: u32;
//     sampleSize: u32;
//     channels: u32;
//     data: ^void;
// }

// // Opaque structs declaration
// // NOTE: Actual structs are defined internally in raudio module
// typedef struct rAudioBuffer rAudioBuffer;
// typedef struct rAudioProcessor rAudioProcessor;

// // AudioStream, custom audio stream
// typedef struct AudioStream {
//     rAudioBuffer *buffer;       // Pointer to internal data used by the audio system
//     rAudioProcessor *processor; // Pointer to internal data processor, useful for audio effects

//     unsigned int sampleRate;    // Frequency (samples per second)
//     unsigned int sampleSize;    // Bit depth (bits per sample): 8, 16, 32 (24 not supported)
//     unsigned int channels;      // Number of channels (1-mono, 2-stereo, ...)
// } AudioStream;

// // Sound
// typedef struct Sound {
//     AudioStream stream;         // Audio stream
//     unsigned int frameCount;    // Total number of frames (considering channels)
// } Sound;

// // Music, audio stream, anything longer than ~10 seconds should be streamed
// typedef struct Music {
//     AudioStream stream;         // Audio stream
//     unsigned int frameCount;    // Total number of frames (considering channels)
//     bool looping;               // Music looping enable

//     int ctxType;                // Type of music context (audio filetype)
//     void *ctxData;              // Audio context data, depends on type
// } Music;

// // VrDeviceInfo, Head-Mounted-Display device parameters
// typedef struct VrDeviceInfo {
//     int hResolution;                // Horizontal resolution in pixels
//     int vResolution;                // Vertical resolution in pixels
//     float hScreenSize;              // Horizontal size in meters
//     float vScreenSize;              // Vertical size in meters
//     float eyeToScreenDistance;      // Distance between eye and display in meters
//     float lensSeparationDistance;   // Lens separation distance in meters
//     float interpupillaryDistance;   // IPD (distance between pupils) in meters
//     float lensDistortionValues[4];  // Lens distortion constant parameters
//     float chromaAbCorrection[4];    // Chromatic aberration correction parameters
// } VrDeviceInfo;

// // VrStereoConfig, VR stereo rendering configuration for simulator
// typedef struct VrStereoConfig {
//     Matrix projection[2];           // VR projection matrices (per eye)
//     Matrix viewOffset[2];           // VR view offset matrices (per eye)
//     float leftLensCenter[2];        // VR left lens center
//     float rightLensCenter[2];       // VR right lens center
//     float leftScreenCenter[2];      // VR left screen center
//     float rightScreenCenter[2];     // VR right screen center
//     float scale[2];                 // VR distortion scale
//     float scaleIn[2];               // VR distortion scale in
// } VrStereoConfig;

// // File path list
// typedef struct FilePathList {
//     unsigned int capacity;          // Filepaths max entries
//     unsigned int count;             // Filepaths entries count
//     char **paths;                   // Filepaths entries
// } FilePathList;

// // Automation event
// typedef struct AutomationEvent {
//     unsigned int frame;             // Event frame
//     unsigned int type;              // Event type (AutomationEventType)
//     int params[4];                  // Event parameters (if required)
// } AutomationEvent;

// // Automation event list
// typedef struct AutomationEventList {
//     unsigned int capacity;          // Events max entries (MAX_AUTOMATION_EVENTS)
//     unsigned int count;             // Events entries count
//     AutomationEvent *events;        // Events entries
// } AutomationEventList;

// export enum ConfigFlags
// {
//     VSYNC_HINT = 0x00000040
//     FULLSCREEN_MODE = 0x00000002
//     WINDOW_RESIZABLE = 0x00000004
//     WINDOW_UNDECORATED = 0x00000008
//     WINDOW_HIDDEN = 0x00000080
//     WINDOW_MINIMIZED = 0x00000200
//     WINDOW_MAXIMIZED = 0x00000400
//     WINDOW_UNFOCUSED = 0x00000800
//     WINDOW_TOPMOST = 0x00001000
//     WINDOW_ALWAYS_RUN = 0x00000100
//     WINDOW_TRANSPARENT = 0x00000010
//     WINDOW_HIGHDPI = 0x00002000
//     WINDOW_MOUSE_PASSTHROUGH = 0x00004000
//     BORDERLESS_WINDOWED_MODE = 0x00008000
//     MSAA_4X_HINT = 0x00000020
//     INTERLACED_HINT = 0x00010000
// }


// export enum TraceLogLevel
// {
//     LOG_ALL = 0
//     LOG_TRACE
//     LOG_DEBUG
//     LOG_INFO
//     LOG_WARNING
//     LOG_ERROR
//     LOG_FATAL
//     LOG_NONE
// }

// export enum KeyboardKey
// {
//     NULL            = 0
//     APOSTROPHE      = 39
//     COMMA           = 44
//     MINUS           = 45
//     PERIOD          = 46
//     SLASH           = 47
//     ZERO            = 48
//     ONE             = 49
//     TWO             = 50
//     THREE           = 51
//     FOUR            = 52
//     FIVE            = 53
//     SIX             = 54
//     SEVEN           = 55
//     EIGHT           = 56
//     NINE            = 57
//     SEMICOLON       = 59
//     EQUAL           = 61
//     A               = 65
//     B               = 66
//     C               = 67
//     D               = 68
//     E               = 69
//     F               = 70
//     G               = 71
//     H               = 72
//     I               = 73
//     J               = 74
//     K               = 75
//     L               = 76
//     M               = 77
//     N               = 78
//     O               = 79
//     P               = 80
//     Q               = 81
//     R               = 82
//     S               = 83
//     T               = 84
//     U               = 85
//     V               = 86
//     W               = 87
//     X               = 88
//     Y               = 89
//     Z               = 90
//     LEFT_BRACKET    = 91
//     BACKSLASH       = 92
//     RIGHT_BRACKET   = 93
//     GRAVE           = 96
//     SPACE           = 32
//     ESCAPE          = 256
//     ENTER           = 257
//     TAB             = 258
//     BACKSPACE       = 259
//     INSERT          = 260
//     DELETE          = 261
//     RIGHT           = 262
//     LEFT            = 263
//     DOWN            = 264
//     UP              = 265
//     PAGE_UP         = 266
//     PAGE_DOWN       = 267
//     HOME            = 268
//     END             = 269
//     CAPS_LOCK       = 280
//     SCROLL_LOCK     = 281
//     NUM_LOCK        = 282
//     PRINT_SCREEN    = 283
//     PAUSE           = 284
//     F1              = 290
//     F2              = 291
//     F3              = 292
//     F4              = 293
//     F5              = 294
//     F6              = 295
//     F7              = 296
//     F8              = 297
//     F9              = 298
//     F10             = 299
//     F11             = 300
//     F12             = 301
//     LEFT_SHIFT      = 340
//     LEFT_CONTROL    = 341
//     LEFT_ALT        = 342
//     LEFT_SUPER      = 343
//     RIGHT_SHIFT     = 344
//     RIGHT_CONTROL   = 345
//     RIGHT_ALT       = 346
//     RIGHT_SUPER     = 347
//     KB_MENU         = 348
//     KP_0            = 320
//     KP_1            = 321
//     KP_2            = 322
//     KP_3            = 323
//     KP_4            = 324
//     KP_5            = 325
//     KP_6            = 326
//     KP_7            = 327
//     KP_8            = 328
//     KP_9            = 329
//     KP_DECIMAL      = 330
//     KP_DIVIDE       = 331
//     KP_MULTIPLY     = 332
//     KP_SUBTRACT     = 333
//     KP_ADD          = 334
//     KP_ENTER        = 335
//     KP_EQUAL        = 336
//     BACK            = 4
//     MENU            = 5
//     VOLUME_UP       = 24
//     VOLUME_DOWN     = 25
// }

// export enum MouseButton
// {
//     LEFT    = 0
//     RIGHT   = 1
//     MIDDLE  = 2
//     SIDE    = 3
//     EXTRA   = 4
//     FORWARD = 5
//     BACK    = 6
// }

// export enum MouseCursor
// {
//     DEFAULT       = 0
//     ARROW         = 1
//     IBEAM         = 2
//     CROSSHAIR     = 3
//     POINTING_HAND = 4
//     RESIZE_EW     = 5
//     RESIZE_NS     = 6
//     RESIZE_NWSE   = 7
//     RESIZE_NESW   = 8
//     RESIZE_ALL    = 9
//     NOT_ALLOWED   = 10
// }

// export enum GamepadButton
// {
//     UNKNOWN = 0
//     LEFT_FACE_UP
//     LEFT_FACE_RIGHT
//     LEFT_FACE_DOWN
//     LEFT_FACE_LEFT
//     RIGHT_FACE_UP
//     RIGHT_FACE_RIGHT
//     RIGHT_FACE_DOWN
//     RIGHT_FACE_LEFT
//     LEFT_TRIGGER_1
//     LEFT_TRIGGER_2
//     RIGHT_TRIGGER_1
//     RIGHT_TRIGGER_2
//     MIDDLE_LEFT
//     MIDDLE
//     MIDDLE_RIGHT
//     LEFT_THUMB
//     RIGHT_THUMB
// }

// export enum GamepadAxis
// {
//     LEFT_X        = 0
//     LEFT_Y        = 1
//     RIGHT_X       = 2
//     RIGHT_Y       = 3
//     LEFT_TRIGGER  = 4
//     RIGHT_TRIGGER = 5
// }

// export enum MaterialMapIndex
// {
//     ALBEDO = 0
//     METALNESS
//     NORMAL
//     ROUGHNESS
//     OCCLUSION
//     EMISSION
//     HEIGHT
//     CUBEMAP
//     IRRADIANCE
//     PREFILTER
//     BRDF
// }

// export enum ShaderLocationIndex
// {
//     VERTEX_POSITION = 0
//     VERTEX_TEXCOORD01
//     VERTEX_TEXCOORD02
//     VERTEX_NORMAL
//     VERTEX_TANGENT
//     VERTEX_COLOR
//     MATRIX_MVP
//     MATRIX_VIEW
//     MATRIX_PROJECTION
//     MATRIX_MODEL
//     MATRIX_NORMAL
//     VECTOR_VIEW
//     COLOR_DIFFUSE
//     COLOR_SPECULAR
//     COLOR_AMBIENT
//     MAP_ALBEDO
//     MAP_METALNESS
//     MAP_NORMAL
//     MAP_ROUGHNESS
//     MAP_OCCLUSION
//     MAP_EMISSION
//     MAP_HEIGHT
//     MAP_CUBEMAP
//     MAP_IRRADIANCE
//     MAP_PREFILTER
//     MAP_BRDF
//     VERTEX_BONEIDS
//     VERTEX_BONEWEIGHTS
//     BONE_MATRICES
// }

// export enum ShaderUniformDataType {
//     FLOAT = 0
//     VEC2
//     VEC3
//     VEC4
//     INT
//     IVEC2
//     IVEC3
//     IVEC4
//     SAMPLER2D
// }

// export enum ShaderAttributeDataType {
//     FLOAT = 0
//     VEC2
//     VEC3
//     VEC4
// }

// export enum PixelFormat
// {
//     UNCOMPRESSED_GRAYSCALE = 1
//     UNCOMPRESSED_GRAY_ALPHA
//     UNCOMPRESSED_R5G6B5
//     UNCOMPRESSED_R8G8B8
//     UNCOMPRESSED_R5G5B5A1
//     UNCOMPRESSED_R4G4B4A4
//     UNCOMPRESSED_R8G8B8A8
//     UNCOMPRESSED_R32
//     UNCOMPRESSED_R32G32B32
//     UNCOMPRESSED_R32G32B32A32
//     UNCOMPRESSED_R16
//     UNCOMPRESSED_R16G16B16
//     UNCOMPRESSED_R16G16B16A16
//     COMPRESSED_DXT1_RGB
//     COMPRESSED_DXT1_RGBA
//     COMPRESSED_DXT3_RGBA
//     COMPRESSED_DXT5_RGBA
//     COMPRESSED_ETC1_RGB
//     COMPRESSED_ETC2_RGB
//     COMPRESSED_ETC2_EAC_RGBA
//     COMPRESSED_PVRT_RGB
//     COMPRESSED_PVRT_RGBA
//     COMPRESSED_ASTC_4x4_RGBA
//     COMPRESSED_ASTC_8x8_RGBA
// }

// export enum TextureFilter
// {
//     POINT = 0
//     BILINEAR
//     TRILINEAR
//     ANISOTROPIC_4X
//     ANISOTROPIC_8X
//     ANISOTROPIC_16X
// }

// export enum TextureWrap
// {
//     REPEAT = 0
//     CLAMP
//     MIRROR_REPEAT
//     MIRROR_CLAMP
// }

// export enum CubemapLayout
// {
//     AUTO_DETECT = 0
//     LINE_VERTICAL
//     LINE_HORIZONTAL
//     CROSS_THREE_BY_FOUR
//     CROSS_FOUR_BY_THREE
// }

// export enum FontType
// {
//     FONT_DEFAULT = 0
//     FONT_BITMAP
//     FONT_SDF
// }

// export enum BlendMode
// {
//     BLEND_ALPHA = 0,
//     BLEND_ADDITIVE,
//     BLEND_MULTIPLIED,
//     BLEND_ADD_COLORS,
//     BLEND_SUBTRACT_COLORS,
//     BLEND_ALPHA_PREMULTIPLY,
//     BLEND_CUSTOM,
//     BLEND_CUSTOM_SEPARATE
// }

// export enum Gesture
// {
//     GESTURE_NONE        = 0
//     GESTURE_TAP         = 1
//     GESTURE_DOUBLETAP   = 2
//     GESTURE_HOLD        = 4
//     GESTURE_DRAG        = 8
//     GESTURE_SWIPE_RIGHT = 16
//     GESTURE_SWIPE_LEFT  = 32
//     GESTURE_SWIPE_UP    = 64
//     GESTURE_SWIPE_DOWN  = 128
//     GESTURE_PINCH_IN    = 256
//     GESTURE_PINCH_OUT   = 512
// }

// export enum CameraMode
// {
//     CAMERA_CUSTOM = 0
//     CAMERA_FREE
//     CAMERA_ORBITAL
//     CAMERA_FIRST_PERSON
//     CAMERA_THIRD_PERSON
// }

// export enum CameraProjection
// {
//     CAMERA_PERSPECTIVE = 0
//     CAMERA_ORTHOGRAPHIC
// }

// export enum NPatchLayout
// {
//     NPATCH_NINE_PATCH = 0
//     NPATCH_THREE_PATCH_VERTICAL
//     NPATCH_THREE_PATCH_HORIZONTAL
// }

// // Callbacks to hook some internal functions
// // WARNING: These callbacks are intended for advanced users
// typedef void (*TraceLogCallback)(int logLevel, const char *text, va_list args);  // Logging: Redirect trace log messages
// typedef unsigned char *(*LoadFileDataCallback)(const char *fileName, int *dataSize);    // FileIO: Load binary data
// typedef bool (*SaveFileDataCallback)(const char *fileName, void *data, int dataSize);   // FileIO: Save binary data
// typedef char *(*LoadFileTextCallback)(const char *fileName);            // FileIO: Load text data
// typedef bool (*SaveFileTextCallback)(const char *fileName, char *text); // FileIO: Save text data

export extern "InitWindow" func InitWindow(width: i32, height: i32, title: cstring)
export extern "CloseWindow" func CloseWindow()
export extern "WindowShouldClose" func WindowShouldClose(): bool
export extern "IsWindowReady" func IsWindowReady(): bool
export extern "IsWindowFullscreen" func IsWindowFullscreen(): bool
export extern "IsWindowHidden" func IsWindowHidden(): bool
export extern "IsWindowMinimized" func IsWindowMinimized(): bool
export extern "IsWindowMaximized" func IsWindowMaximized(): bool
export extern "IsWindowFocused" func IsWindowFocused(): bool
export extern "IsWindowResized" func IsWindowResized(): bool
export extern "IsWindowState" func IsWindowState(flag: u32): bool
export extern "SetWindowState" func SetWindowState(flags: u32)
export extern "ClearWindowState" func ClearWindowState(flags: u32)
export extern "ToggleFullscreen" func ToggleFullscreen()
export extern "ToggleBorderlessWindowed" func ToggleBorderlessWindowed()
export extern "MaximizeWindow" func MaximizeWindow()
export extern "MinimizeWindow" func MinimizeWindow()
export extern "RestoreWindow" func RestoreWindow()
export extern "SetWindowIcon" func SetWindowIcon(image: Image)
export extern "SetWindowIcons" func SetWindowIcons(images: ^Image, count: i32)
export extern "SetWindowTitle" func SetWindowTitle(title: cstring)
export extern "SetWindowPosition" func SetWindowPosition(x: i32, y: i32)
export extern "SetWindowMonitor" func SetWindowMonitor(monitor: i32)
export extern "SetWindowMinSize" func SetWindowMinSize(width: i32, height: i32)
export extern "SetWindowMaxSize" func SetWindowMaxSize(width: i32, height: i32)
export extern "SetWindowSize" func SetWindowSize(width: i32, height: i32)
export extern "SetWindowOpacity" func SetWindowOpacity(opacity: f32)
export extern "SetWindowFocused" func SetWindowFocused()
export extern "*GetWindowHandle" func GetWindowHandle(): ^void
export extern "GetScreenWidth" func GetScreenWidth(): i32
export extern "GetScreenHeight" func GetScreenHeight(): i32
export extern "GetRenderWidth" func GetRenderWidth(): i32
export extern "GetRenderHeight" func GetRenderHeight(): i32
export extern "GetMonitorCount" func GetMonitorCount(): i32
export extern "GetCurrentMonitor" func GetCurrentMonitor(): i32
export extern "GetMonitorPosition" func GetMonitorPosition(monitor: i32): Vector2
export extern "GetMonitorWidth" func GetMonitorWidth(monitor: i32): i32
export extern "GetMonitorHeight" func GetMonitorHeight(monitor: i32): i32
export extern "GetMonitorPhysicalWidth" func GetMonitorPhysicalWidth(monitor: i32): i32
export extern "GetMonitorPhysicalHeight" func GetMonitorPhysicalHeight(monitor: i32): i32
export extern "GetMonitorRefreshRate" func GetMonitorRefreshRate(monitor: i32): i32
export extern "GetWindowPosition" func GetWindowPosition(): Vector2
export extern "GetWindowScaleDPI" func GetWindowScaleDPI(): Vector2
export extern "GetMonitorName" func GetMonitorName(monitor: i32): cstring
export extern "SetClipboardText" func SetClipboardText(text: cstring)
export extern "GetClipboardText" func GetClipboardText(): cstring
export extern "GetClipboardImage" func GetClipboardImage(): Image
export extern "EnableEventWaiting" func EnableEventWaiting()
export extern "DisableEventWaiting" func DisableEventWaiting()

export extern "ShowCursor" func ShowCursor()
export extern "HideCursor" func HideCursor()
export extern "IsCursorHidden" func IsCursorHidden(): bool
export extern "EnableCursor" func EnableCursor()
export extern "DisableCursor" func DisableCursor()
export extern "IsCursorOnScreen" func IsCursorOnScreen(): bool

export extern "ClearBackground" func ClearBackground(color: Color)
export extern "BeginDrawing" func BeginDrawing()
export extern "EndDrawing" func EndDrawing()
export extern "BeginMode2D" func BeginMode2D(camera: Camera2D)
export extern "EndMode2D" func EndMode2D()
export extern "BeginMode3D" func BeginMode3D(camera: Camera3D)
export extern "EndMode3D" func EndMode3D()
export extern "BeginTextureMode" func BeginTextureMode(target: RenderTexture2D)
export extern "EndTextureMode" func EndTextureMode()
export extern "BeginShaderMode" func BeginShaderMode(shader: Shader)
export extern "EndShaderMode" func EndShaderMode()
export extern "BeginBlendMode" func BeginBlendMode(mode: i32)
export extern "EndBlendMode" func EndBlendMode()
export extern "BeginScissorMode" func BeginScissorMode(x: i32, y: i32, width: i32, height: i32)
export extern "EndScissorMode" func EndScissorMode()
// export extern "BeginVrStereoMode" func BeginVrStereoMode(config: VrStereoConfig)
// export extern "EndVrStereoMode" func EndVrStereoMode()

// export extern "LoadVrStereoConfig" func LoadVrStereoConfig(device: VrDeviceInfo): VrStereoConfig
// export extern "UnloadVrStereoConfig" func UnloadVrStereoConfig(config: VrStereoConfig)

export extern "LoadShader" func LoadShader(vsFileName: cstring, fsFileName: cstring): Shader
export extern "LoadShaderFromMemory" func LoadShaderFromMemory(vsCode: cstring, fsCode: cstring): Shader
export extern "IsShaderValid" func IsShaderValid(shader: Shader): bool
export extern "GetShaderLocation" func GetShaderLocation(shader: Shader, uniformName: cstring): i32
export extern "GetShaderLocationAttrib" func GetShaderLocationAttrib(shader: Shader, attribName: cstring): i32
export extern "SetShaderValue" func SetShaderValue(shader: Shader, locIndex: i32, value: ^void, uniformType: i32)
export extern "SetShaderValueV" func SetShaderValueV(shader: Shader, locIndex: i32, value: ^void, uniformType: i32, count: i32)
export extern "SetShaderValueMatrix" func SetShaderValueMatrix(shader: Shader, locIndex: i32, mat: Matrix)
export extern "SetShaderValueTexture" func SetShaderValueTexture(shader: Shader, locIndex: i32, texture: Texture2D)
export extern "UnloadShader" func UnloadShader(shader: Shader)

export extern "GetScreenToWorldRay" func GetScreenToWorldRay(position: Vector2, camera: Camera): Ray
export extern "GetScreenToWorldRayEx" func GetScreenToWorldRayEx(position: Vector2, camera: Camera, width: i32, height: i32): Ray
export extern "GetWorldToScreen" func GetWorldToScreen(position: Vector3, camera: Camera): Vector2
export extern "GetWorldToScreenEx" func GetWorldToScreenEx(position: Vector3, camera: Camera, width: i32, height: i32): Vector2
export extern "GetWorldToScreen2D" func GetWorldToScreen2D(position: Vector2, camera: Camera2D): Vector2
export extern "GetScreenToWorld2D" func GetScreenToWorld2D(position: Vector2, camera: Camera2D): Vector2
export extern "GetCameraMatrix" func GetCameraMatrix(camera: Camera): Matrix
export extern "GetCameraMatrix2D" func GetCameraMatrix2D(camera: Camera2D): Matrix

export extern "SetTargetFPS" func SetTargetFPS(fps: i32)
export extern "GetFrameTime" func GetFrameTime(): f32
export extern "GetTime" func GetTime(): f64
export extern "GetFPS" func GetFPS(): i32

export extern "SwapScreenBuffer" func SwapScreenBuffer()
export extern "PollInputEvents" func PollInputEvents()
export extern "WaitTime" func WaitTime(seconds: f64)

export extern "SetRandomSeed" func SetRandomSeed(seed: u32)
export extern "GetRandomValue" func GetRandomValue(min: i32, max: i32): i32
export extern "LoadRandomSequence" func LoadRandomSequence(count: u32, min: i32, max: i32): ^i32
export extern "UnloadRandomSequence" func UnloadRandomSequence(sequence: ^i32)

export extern "TakeScreenshot" func TakeScreenshot(fileName: cstring)
export extern "SetConfigFlags" func SetConfigFlags(flags: u32)
export extern "OpenURL" func OpenURL(url: cstring)

// export extern "TraceLog" func TraceLog(logLevel: i32, text: cstring, ...)
export extern "SetTraceLogLevel" func SetTraceLogLevel(logLevel: i32)
export extern "MemAlloc" func MemAlloc(size: u32): ^void
export extern "MemRealloc" func MemRealloc(ptr: ^void, size: u32): ^void
export extern "MemFree" func MemFree(ptr: ^void)

// export extern "SetTraceLogCallback" func SetTraceLogCallback(callback: TraceLogCallback)
// export extern "SetLoadFileDataCallback" func SetLoadFileDataCallback(callback: LoadFileDataCallback)
// export extern "SetSaveFileDataCallback" func SetSaveFileDataCallback(callback: SaveFileDataCallback)
// export extern "SetLoadFileTextCallback" func SetLoadFileTextCallback(callback: LoadFileTextCallback)
// export extern "SetSaveFileTextCallback" func SetSaveFileTextCallback(callback: SaveFileTextCallback)

export extern "LoadFileData" func LoadFileData(fileName: cstring, dataSize: ^i32): ^u8
export extern "UnloadFileData" func UnloadFileData(data: ^u8)
export extern "SaveFileData" func SaveFileData(fileName: cstring, data: ^void, dataSize: i32): bool
export extern "ExportDataAsCode" func ExportDataAsCode(data: ^u8, dataSize: i32, fileName: cstring): bool
export extern "LoadFileText" func LoadFileText(fileName: cstring): cstring
export extern "UnloadFileText" func UnloadFileText(text: cstring)
export extern "SaveFileText" func SaveFileText(fileName: cstring, text: cstring): bool

export extern "FileExists" func FileExists(fileName: cstring): bool
export extern "DirectoryExists" func DirectoryExists(dirPath: cstring): bool
export extern "IsFileExtension" func IsFileExtension(fileName: cstring, ext: cstring): bool
export extern "GetFileLength" func GetFileLength(fileName: cstring): i32
export extern "GetFileExtension" func GetFileExtension(fileName: cstring): cstring
export extern "GetFileName" func GetFileName(filePath: cstring): cstring
export extern "GetFileNameWithoutExt" func GetFileNameWithoutExt(filePath: cstring): cstring
export extern "GetDirectoryPath" func GetDirectoryPath(filePath: cstring): cstring
export extern "GetPrevDirectoryPath" func GetPrevDirectoryPath(dirPath: cstring): cstring
export extern "GetWorkingDirectory" func GetWorkingDirectory(): cstring
export extern "GetApplicationDirectory" func GetApplicationDirectory(): cstring
export extern "MakeDirectory" func MakeDirectory(dirPath: cstring): i32
export extern "ChangeDirectory" func ChangeDirectory(dir: cstring): bool
export extern "IsPathFile" func IsPathFile(path: cstring): bool
export extern "IsFileNameValid" func IsFileNameValid(fileName: cstring): bool
// export extern "LoadDirectoryFiles" func LoadDirectoryFiles(dirPath: cstring): FilePathList
// export extern "LoadDirectoryFilesEx" func LoadDirectoryFilesEx(basePath: cstring, filter: cstring, scanSubdirs: bool): FilePathList
// export extern "UnloadDirectoryFiles" func UnloadDirectoryFiles(files: FilePathList)
export extern "IsFileDropped" func IsFileDropped(): bool
// export extern "LoadDroppedFiles" func LoadDroppedFiles(): FilePathList
// export extern "UnloadDroppedFiles" func UnloadDroppedFiles(files: FilePathList)
export extern "GetFileModTime" func GetFileModTime(fileName: cstring): i64

export extern "CompressData" func CompressData(data: ^u8, dataSize: i32, compDataSize: ^i32): ^u8
export extern "DecompressData" func DecompressData(compData: ^u8, compDataSize: i32, dataSize: ^i32): ^u8
export extern "EncodeDataBase64" func EncodeDataBase64(data: ^u8, dataSize: i32, outputSize: ^i32): ^u8
export extern "DecodeDataBase64" func DecodeDataBase64(data: ^u8, outputSize: ^i32): ^u8
export extern "ComputeCRC32" func ComputeCRC32(data: ^u8, dataSize: i32): u32
export extern "ComputeMD5" func ComputeMD5(data: ^u8, dataSize: i32): ^u32
export extern "ComputeSHA1" func ComputeSHA1(data: ^u8, dataSize: i32): ^u32

// export extern "LoadAutomationEventList" func LoadAutomationEventList(fileName: cstring): AutomationEventList
// export extern "UnloadAutomationEventList" func UnloadAutomationEventList(list: AutomationEventList)
// export extern "ExportAutomationEventList" func ExportAutomationEventList(list: AutomationEventList, fileName: cstring): bool
// export extern "SetAutomationEventList" func SetAutomationEventList(list: ^AutomationEventList)
export extern "SetAutomationEventBaseFrame" func SetAutomationEventBaseFrame(frame: i32)
export extern "StartAutomationEventRecording" func StartAutomationEventRecording()
export extern "StopAutomationEventRecording" func StopAutomationEventRecording()
// export extern "PlayAutomationEvent" func PlayAutomationEvent(event: AutomationEvent)

export extern "IsKeyPressed" func IsKeyPressed(key: i32): bool
export extern "IsKeyPressedRepeat" func IsKeyPressedRepeat(key: i32): bool
export extern "IsKeyDown" func IsKeyDown(key: i32): bool
export extern "IsKeyReleased" func IsKeyReleased(key: i32): bool
export extern "IsKeyUp" func IsKeyUp(key: i32): bool
export extern "GetKeyPressed" func GetKeyPressed(): i32
export extern "GetCharPressed" func GetCharPressed(): i32
export extern "SetExitKey" func SetExitKey(key: i32)

export extern "IsGamepadAvailable" func IsGamepadAvailable(gamepad: i32): bool
export extern "GetGamepadName" func GetGamepadName(gamepad: i32): cstring
export extern "IsGamepadButtonPressed" func IsGamepadButtonPressed(gamepad: i32, button: i32): bool
export extern "IsGamepadButtonDown" func IsGamepadButtonDown(gamepad: i32, button: i32): bool
export extern "IsGamepadButtonReleased" func IsGamepadButtonReleased(gamepad: i32, button: i32): bool
export extern "IsGamepadButtonUp" func IsGamepadButtonUp(gamepad: i32, button: i32): bool
export extern "GetGamepadButtonPressed" func GetGamepadButtonPressed(): i32
export extern "GetGamepadAxisCount" func GetGamepadAxisCount(gamepad: i32): i32
export extern "GetGamepadAxisMovement" func GetGamepadAxisMovement(gamepad: i32, axis: i32): f32
export extern "SetGamepadMappings" func SetGamepadMappings(mappings: ^u8): i32
export extern "SetGamepadVibration" func SetGamepadVibration(gamepad: i32, leftMotor: f32, rightMotor: f32, duration: f32)

export extern "IsMouseButtonPressed" func IsMouseButtonPressed(button: i32): bool
export extern "IsMouseButtonDown" func IsMouseButtonDown(button: i32): bool
export extern "IsMouseButtonReleased" func IsMouseButtonReleased(button: i32): bool
export extern "IsMouseButtonUp" func IsMouseButtonUp(button: i32): bool
export extern "GetMouseX" func GetMouseX(): i32
export extern "GetMouseY" func GetMouseY(): i32
export extern "GetMousePosition" func GetMousePosition(): Vector2
export extern "GetMouseDelta" func GetMouseDelta(): Vector2
export extern "SetMousePosition" func SetMousePosition(x: i32, y: i32)
export extern "SetMouseOffset" func SetMouseOffset(offsetX: i32, offsetY: i32)
export extern "SetMouseScale" func SetMouseScale(scaleX: f32, scaleY: f32)
export extern "GetMouseWheelMove" func GetMouseWheelMove(): f32
export extern "GetMouseWheelMoveV" func GetMouseWheelMoveV(): Vector2
export extern "SetMouseCursor" func SetMouseCursor(cursor: i32)

export extern "GetTouchX" func GetTouchX(): i32
export extern "GetTouchY" func GetTouchY(): i32
export extern "GetTouchPosition" func GetTouchPosition(index: i32): Vector2
export extern "GetTouchPointId" func GetTouchPointId(index: i32): i32
export extern "GetTouchPointCount" func GetTouchPointCount(): i32

export extern "SetGesturesEnabled" func SetGesturesEnabled(flags: u32)
export extern "IsGestureDetected" func IsGestureDetected(gesture: u32): bool
export extern "GetGestureDetected" func GetGestureDetected(): i32
export extern "GetGestureHoldDuration" func GetGestureHoldDuration(): f32
export extern "GetGestureDragVector" func GetGestureDragVector(): Vector2
export extern "GetGestureDragAngle" func GetGestureDragAngle(): f32
export extern "GetGesturePinchVector" func GetGesturePinchVector(): Vector2
export extern "GetGesturePinchAngle" func GetGesturePinchAngle(): f32

export extern "UpdateCamera" func UpdateCamera(camera: ^Camera, mode: i32)
export extern "UpdateCameraPro" func UpdateCameraPro(camera: ^Camera, movement: Vector3, rotation: Vector3, zoom: f32)

export extern "SetShapesTexture" func SetShapesTexture(texture: Texture2D, source: Rectangle)
export extern "GetShapesTexture" func GetShapesTexture(): Texture2D
export extern "GetShapesTextureRectangle" func GetShapesTextureRectangle(): Rectangle

export extern "DrawPixel" func DrawPixel(posX: i32, posY: i32, color: Color)
export extern "DrawPixelV" func DrawPixelV(position: Vector2, color: Color)
export extern "DrawLine" func DrawLine(startPosX: i32, startPosY: i32, endPosX: i32, endPosY: i32, color: Color)
export extern "DrawLineV" func DrawLineV(startPos: Vector2, endPos: Vector2, color: Color)
export extern "DrawLineEx" func DrawLineEx(startPos: Vector2, endPos: Vector2, thick: f32, color: Color)
export extern "DrawLineStrip" func DrawLineStrip(points: ^Vector2, pointCount: i32, color: Color)
export extern "DrawLineBezier" func DrawLineBezier(startPos: Vector2, endPos: Vector2, thick: f32, color: Color)
export extern "DrawCircle" func DrawCircle(centerX: i32, centerY: i32, radius: f32, color: Color)
export extern "DrawCircleSector" func DrawCircleSector(center: Vector2, radius: f32, startAngle: f32, endAngle: f32, segments: i32, color: Color)
export extern "DrawCircleSectorLines" func DrawCircleSectorLines(center: Vector2, radius: f32, startAngle: f32, endAngle: f32, segments: i32, color: Color)
export extern "DrawCircleGradient" func DrawCircleGradient(centerX: i32, centerY: i32, radius: f32, inner: Color, outer: Color)
export extern "DrawCircleV" func DrawCircleV(center: Vector2, radius: f32, color: Color)
export extern "DrawCircleLines" func DrawCircleLines(centerX: i32, centerY: i32, radius: f32, color: Color)
export extern "DrawCircleLinesV" func DrawCircleLinesV(center: Vector2, radius: f32, color: Color)
export extern "DrawEllipse" func DrawEllipse(centerX: i32, centerY: i32, radiusH: f32, radiusV: f32, color: Color)
export extern "DrawEllipseLines" func DrawEllipseLines(centerX: i32, centerY: i32, radiusH: f32, radiusV: f32, color: Color)
export extern "DrawRing" func DrawRing(center: Vector2, innerRadius: f32, outerRadius: f32, startAngle: f32, endAngle: f32, segments: i32, color: Color)
export extern "DrawRingLines" func DrawRingLines(center: Vector2, innerRadius: f32, outerRadius: f32, startAngle: f32, endAngle: f32, segments: i32, color: Color)
export extern "DrawRectangle" func DrawRectangle(posX: i32, posY: i32, width: i32, height: i32, color: Color)
export extern "DrawRectangleV" func DrawRectangleV(position: Vector2, size: Vector2, color: Color)
export extern "DrawRectangleRec" func DrawRectangleRec(rec: Rectangle, color: Color)
export extern "DrawRectanglePro" func DrawRectanglePro(rec: Rectangle, origin: Vector2, rotation: f32, color: Color)
export extern "DrawRectangleGradientV" func DrawRectangleGradientV(posX: i32, posY: i32, width: i32, height: i32, top: Color, bottom: Color)
export extern "DrawRectangleGradientH" func DrawRectangleGradientH(posX: i32, posY: i32, width: i32, height: i32, left: Color, right: Color)
export extern "DrawRectangleGradientEx" func DrawRectangleGradientEx(rec: Rectangle, topLeft: Color, bottomLeft: Color, topRight: Color, bottomRight: Color)
export extern "DrawRectangleLines" func DrawRectangleLines(posX: i32, posY: i32, width: i32, height: i32, color: Color)
export extern "DrawRectangleLinesEx" func DrawRectangleLinesEx(rec: Rectangle, lineThick: f32, color: Color)
export extern "DrawRectangleRounded" func DrawRectangleRounded(rec: Rectangle, roundness: f32, segments: i32, color: Color)
export extern "DrawRectangleRoundedLines" func DrawRectangleRoundedLines(rec: Rectangle, roundness: f32, segments: i32, color: Color)
export extern "DrawRectangleRoundedLinesEx" func DrawRectangleRoundedLinesEx(rec: Rectangle, roundness: f32, segments: i32, lineThick: f32, color: Color)
export extern "DrawTriangle" func DrawTriangle(v1: Vector2, v2: Vector2, v3: Vector2, color: Color)
export extern "DrawTriangleLines" func DrawTriangleLines(v1: Vector2, v2: Vector2, v3: Vector2, color: Color)
export extern "DrawTriangleFan" func DrawTriangleFan(points: ^Vector2, pointCount: i32, color: Color)
export extern "DrawTriangleStrip" func DrawTriangleStrip(points: ^Vector2, pointCount: i32, color: Color)
export extern "DrawPoly" func DrawPoly(center: Vector2, sides: i32, radius: f32, rotation: f32, color: Color)
export extern "DrawPolyLines" func DrawPolyLines(center: Vector2, sides: i32, radius: f32, rotation: f32, color: Color)
export extern "DrawPolyLinesEx" func DrawPolyLinesEx(center: Vector2, sides: i32, radius: f32, rotation: f32, lineThick: f32, color: Color)

export extern "DrawSplineLinear" func DrawSplineLinear(points: ^Vector2, pointCount: i32, thick: f32, color: Color)
export extern "DrawSplineBasis" func DrawSplineBasis(points: ^Vector2, pointCount: i32, thick: f32, color: Color)
export extern "DrawSplineCatmullRom" func DrawSplineCatmullRom(points: ^Vector2, pointCount: i32, thick: f32, color: Color)
export extern "DrawSplineBezierQuadratic" func DrawSplineBezierQuadratic(points: ^Vector2, pointCount: i32, thick: f32, color: Color)
export extern "DrawSplineBezierCubic" func DrawSplineBezierCubic(points: ^Vector2, pointCount: i32, thick: f32, color: Color)
export extern "DrawSplineSegmentLinear" func DrawSplineSegmentLinear(p1: Vector2, p2: Vector2, thick: f32, color: Color)
export extern "DrawSplineSegmentBasis" func DrawSplineSegmentBasis(p1: Vector2, p2: Vector2, p3: Vector2, p4: Vector2, thick: f32, color: Color)
export extern "DrawSplineSegmentCatmullRom" func DrawSplineSegmentCatmullRom(p1: Vector2, p2: Vector2, p3: Vector2, p4: Vector2, thick: f32, color: Color)
export extern "DrawSplineSegmentBezierQuadratic" func DrawSplineSegmentBezierQuadratic(p1: Vector2, c2: Vector2, p3: Vector2, thick: f32, color: Color)
export extern "DrawSplineSegmentBezierCubic" func DrawSplineSegmentBezierCubic(p1: Vector2, c2: Vector2, c3: Vector2, p4: Vector2, thick: f32, color: Color)

export extern "GetSplinePointLinear" func GetSplinePointLinear(startPos: Vector2, endPos: Vector2, t: f32): Vector2
export extern "GetSplinePointBasis" func GetSplinePointBasis(p1: Vector2, p2: Vector2, p3: Vector2, p4: Vector2, t: f32): Vector2
export extern "GetSplinePointCatmullRom" func GetSplinePointCatmullRom(p1: Vector2, p2: Vector2, p3: Vector2, p4: Vector2, t: f32): Vector2
export extern "GetSplinePointBezierQuad" func GetSplinePointBezierQuad(p1: Vector2, c2: Vector2, p3: Vector2, t: f32): Vector2
export extern "GetSplinePointBezierCubic" func GetSplinePointBezierCubic(p1: Vector2, c2: Vector2, c3: Vector2, p4: Vector2, t: f32): Vector2

export extern "CheckCollisionRecs" func CheckCollisionRecs(rec1: Rectangle, rec2: Rectangle): bool
export extern "CheckCollisionCircles" func CheckCollisionCircles(center1: Vector2, radius1: f32, center2: Vector2, radius2: f32): bool
export extern "CheckCollisionCircleRec" func CheckCollisionCircleRec(center: Vector2, radius: f32, rec: Rectangle): bool
export extern "CheckCollisionCircleLine" func CheckCollisionCircleLine(center: Vector2, radius: f32, p1: Vector2, p2: Vector2): bool
export extern "CheckCollisionPointRec" func CheckCollisionPointRec(point: Vector2, rec: Rectangle): bool
export extern "CheckCollisionPointCircle" func CheckCollisionPointCircle(point: Vector2, center: Vector2, radius: f32): bool
export extern "CheckCollisionPointTriangle" func CheckCollisionPointTriangle(point: Vector2, p1: Vector2, p2: Vector2, p3: Vector2): bool
export extern "CheckCollisionPointLine" func CheckCollisionPointLine(point: Vector2, p1: Vector2, p2: Vector2, threshold: i32): bool
export extern "CheckCollisionPointPoly" func CheckCollisionPointPoly(point: Vector2, points: ^Vector2, pointCount: i32): bool
export extern "CheckCollisionLines" func CheckCollisionLines(startPos1: Vector2, endPos1: Vector2, startPos2: Vector2, endPos2: Vector2, collisionPoint: ^Vector2): bool
export extern "GetCollisionRec" func GetCollisionRec(rec1: Rectangle, rec2: Rectangle): Rectangle

export extern "LoadImage" func LoadImage(fileName: cstring): Image
export extern "LoadImageRaw" func LoadImageRaw(fileName: cstring, width: i32, height: i32, format: i32, headerSize: i32): Image
export extern "LoadImageAnim" func LoadImageAnim(fileName: cstring, frames: ^i32): Image
export extern "LoadImageAnimFromMemory" func LoadImageAnimFromMemory(fileType: cstring, fileData: ^u8, dataSize: i32, frames: ^i32): Image
export extern "LoadImageFromMemory" func LoadImageFromMemory(fileType: cstring, fileData: ^u8, dataSize: i32): Image
export extern "LoadImageFromTexture" func LoadImageFromTexture(texture: Texture2D): Image
export extern "LoadImageFromScreen" func LoadImageFromScreen(): Image
export extern "IsImageValid" func IsImageValid(image: Image): bool
export extern "UnloadImage" func UnloadImage(image: Image)
export extern "ExportImage" func ExportImage(image: Image, fileName: cstring): bool
export extern "ExportImageToMemory" func ExportImageToMemory(image: Image, fileType: cstring, fileSize: ^i32): ^u8
export extern "ExportImageAsCode" func ExportImageAsCode(image: Image, fileName: cstring): bool

export extern "GenImageColor" func GenImageColor(width: i32, height: i32, color: Color): Image
export extern "GenImageGradientLinear" func GenImageGradientLinear(width: i32, height: i32, direction: i32, start: Color, end: Color): Image
export extern "GenImageGradientRadial" func GenImageGradientRadial(width: i32, height: i32, density: f32, inner: Color, outer: Color): Image
export extern "GenImageGradientSquare" func GenImageGradientSquare(width: i32, height: i32, density: f32, inner: Color, outer: Color): Image
export extern "GenImageChecked" func GenImageChecked(width: i32, height: i32, checksX: i32, checksY: i32, col1: Color, col2: Color): Image
export extern "GenImageWhiteNoise" func GenImageWhiteNoise(width: i32, height: i32, factor: f32): Image
export extern "GenImagePerlinNoise" func GenImagePerlinNoise(width: i32, height: i32, offsetX: i32, offsetY: i32, scale: f32): Image
export extern "GenImageCellular" func GenImageCellular(width: i32, height: i32, tileSize: i32): Image
export extern "GenImageText" func GenImageText(width: i32, height: i32, text: cstring): Image

export extern "ImageCopy" func ImageCopy(image: Image): Image
export extern "ImageFromImage" func ImageFromImage(image: Image, rec: Rectangle): Image
export extern "ImageFromChannel" func ImageFromChannel(image: Image, selectedChannel: i32): Image
export extern "ImageText" func ImageText(text: cstring, fontSize: i32, color: Color): Image
export extern "ImageTextEx" func ImageTextEx(font: Font, text: cstring, fontSize: f32, spacing: f32, tint: Color): Image
export extern "ImageFormat" func ImageFormat(image: ^Image, newFormat: i32)
export extern "ImageToPOT" func ImageToPOT(image: ^Image, fill: Color)
export extern "ImageCrop" func ImageCrop(image: ^Image, crop: Rectangle)
export extern "ImageAlphaCrop" func ImageAlphaCrop(image: ^Image, threshold: f32)
export extern "ImageAlphaClear" func ImageAlphaClear(image: ^Image, color: Color, threshold: f32)
export extern "ImageAlphaMask" func ImageAlphaMask(image: ^Image, alphaMask: Image)
export extern "ImageAlphaPremultiply" func ImageAlphaPremultiply(image: ^Image)
export extern "ImageBlurGaussian" func ImageBlurGaussian(image: ^Image, blurSize: i32)
export extern "ImageKernelConvolution" func ImageKernelConvolution(image: ^Image, kernel: ^f32, kernelSize: i32)
export extern "ImageResize" func ImageResize(image: ^Image, newWidth: i32, newHeight: i32)
export extern "ImageResizeNN" func ImageResizeNN(image: ^Image, newWidth: i32, newHeight: i32)
export extern "ImageResizeCanvas" func ImageResizeCanvas(image: ^Image, newWidth: i32, newHeight: i32, offsetX: i32, offsetY: i32, fill: Color)
export extern "ImageMipmaps" func ImageMipmaps(image: ^Image)
export extern "ImageDither" func ImageDither(image: ^Image, rBpp: i32, gBpp: i32, bBpp: i32, aBpp: i32)
export extern "ImageFlipVertical" func ImageFlipVertical(image: ^Image)
export extern "ImageFlipHorizontal" func ImageFlipHorizontal(image: ^Image)
export extern "ImageRotate" func ImageRotate(image: ^Image, degrees: i32)
export extern "ImageRotateCW" func ImageRotateCW(image: ^Image)
export extern "ImageRotateCCW" func ImageRotateCCW(image: ^Image)
export extern "ImageColorTint" func ImageColorTint(image: ^Image, color: Color)
export extern "ImageColorInvert" func ImageColorInvert(image: ^Image)
export extern "ImageColorGrayscale" func ImageColorGrayscale(image: ^Image)
export extern "ImageColorContrast" func ImageColorContrast(image: ^Image, contrast: f32)
export extern "ImageColorBrightness" func ImageColorBrightness(image: ^Image, brightness: i32)
export extern "ImageColorReplace" func ImageColorReplace(image: ^Image, color: Color, replace: Color)
export extern "LoadImageColors" func LoadImageColors(image: Image): ^Color
export extern "LoadImagePalette" func LoadImagePalette(image: Image, maxPaletteSize: i32, colorCount: ^i32): ^Color
export extern "UnloadImageColors" func UnloadImageColors(colors: ^Color)
export extern "UnloadImagePalette" func UnloadImagePalette(colors: ^Color)
export extern "GetImageAlphaBorder" func GetImageAlphaBorder(image: Image, threshold: f32): Rectangle
export extern "GetImageColor" func GetImageColor(image: Image, x: i32, y: i32): Color

export extern "ImageClearBackground" func ImageClearBackground(dst: ^Image, color: Color)
export extern "ImageDrawPixel" func ImageDrawPixel(dst: ^Image, posX: i32, posY: i32, color: Color)
export extern "ImageDrawPixelV" func ImageDrawPixelV(dst: ^Image, position: Vector2, color: Color)
export extern "ImageDrawLine" func ImageDrawLine(dst: ^Image, startPosX: i32, startPosY: i32, endPosX: i32, endPosY: i32, color: Color)
export extern "ImageDrawLineV" func ImageDrawLineV(dst: ^Image, start: Vector2, end: Vector2, color: Color)
export extern "ImageDrawLineEx" func ImageDrawLineEx(dst: ^Image, start: Vector2, end: Vector2, thick: i32, color: Color)
export extern "ImageDrawCircle" func ImageDrawCircle(dst: ^Image, centerX: i32, centerY: i32, radius: i32, color: Color)
export extern "ImageDrawCircleV" func ImageDrawCircleV(dst: ^Image, center: Vector2, radius: i32, color: Color)
export extern "ImageDrawCircleLines" func ImageDrawCircleLines(dst: ^Image, centerX: i32, centerY: i32, radius: i32, color: Color)
export extern "ImageDrawCircleLinesV" func ImageDrawCircleLinesV(dst: ^Image, center: Vector2, radius: i32, color: Color)
export extern "ImageDrawRectangle" func ImageDrawRectangle(dst: ^Image, posX: i32, posY: i32, width: i32, height: i32, color: Color)
export extern "ImageDrawRectangleV" func ImageDrawRectangleV(dst: ^Image, position: Vector2, size: Vector2, color: Color)
export extern "ImageDrawRectangleRec" func ImageDrawRectangleRec(dst: ^Image, rec: Rectangle, color: Color)
export extern "ImageDrawRectangleLines" func ImageDrawRectangleLines(dst: ^Image, rec: Rectangle, thick: i32, color: Color)
export extern "ImageDrawTriangle" func ImageDrawTriangle(dst: ^Image, v1: Vector2, v2: Vector2, v3: Vector2, color: Color)
export extern "ImageDrawTriangleEx" func ImageDrawTriangleEx(dst: ^Image, v1: Vector2, v2: Vector2, v3: Vector2, c1: Color, c2: Color, c3: Color)
export extern "ImageDrawTriangleLines" func ImageDrawTriangleLines(dst: ^Image, v1: Vector2, v2: Vector2, v3: Vector2, color: Color)
export extern "ImageDrawTriangleFan" func ImageDrawTriangleFan(dst: ^Image, points: ^Vector2, pointCount: i32, color: Color)
export extern "ImageDrawTriangleStrip" func ImageDrawTriangleStrip(dst: ^Image, points: ^Vector2, pointCount: i32, color: Color)
export extern "ImageDraw" func ImageDraw(dst: ^Image, src: Image, srcRec: Rectangle, dstRec: Rectangle, tint: Color)
export extern "ImageDrawText" func ImageDrawText(dst: ^Image, text: cstring, posX: i32, posY: i32, fontSize: i32, color: Color)
export extern "ImageDrawTextEx" func ImageDrawTextEx(dst: ^Image, font: Font, text: cstring, position: Vector2, fontSize: f32, spacing: f32, tint: Color)

export extern "LoadTexture" func LoadTexture(fileName: cstring): Texture2D
export extern "LoadTextureFromImage" func LoadTextureFromImage(image: Image): Texture2D
export extern "LoadTextureCubemap" func LoadTextureCubemap(image: Image, layout: i32): TextureCubemap
export extern "LoadRenderTexture" func LoadRenderTexture(width: i32, height: i32): RenderTexture2D
export extern "IsTextureValid" func IsTextureValid(texture: Texture2D): bool
export extern "UnloadTexture" func UnloadTexture(texture: Texture2D)
export extern "IsRenderTextureValid" func IsRenderTextureValid(target: RenderTexture2D): bool
export extern "UnloadRenderTexture" func UnloadRenderTexture(target: RenderTexture2D)
export extern "UpdateTexture" func UpdateTexture(texture: Texture2D, pixels: ^void)
export extern "UpdateTextureRec" func UpdateTextureRec(texture: Texture2D, rec: Rectangle, pixels: ^void)

export extern "GenTextureMipmaps" func GenTextureMipmaps(texture: ^Texture2D)
export extern "SetTextureFilter" func SetTextureFilter(texture: Texture2D, filter: i32)
export extern "SetTextureWrap" func SetTextureWrap(texture: Texture2D, wrap: i32)

export extern "DrawTexture" func DrawTexture(texture: Texture2D, posX: i32, posY: i32, tint: Color)
export extern "DrawTextureV" func DrawTextureV(texture: Texture2D, position: Vector2, tint: Color)
export extern "DrawTextureEx" func DrawTextureEx(texture: Texture2D, position: Vector2, rotation: f32, scale: f32, tint: Color)
export extern "DrawTextureRec" func DrawTextureRec(texture: Texture2D, source: Rectangle, position: Vector2, tint: Color)
export extern "DrawTexturePro" func DrawTexturePro(texture: Texture2D, source: Rectangle, dest: Rectangle, origin: Vector2, rotation: f32, tint: Color)
export extern "DrawTextureNPatch" func DrawTextureNPatch(texture: Texture2D, nPatchInfo: NPatchInfo, dest: Rectangle, origin: Vector2, rotation: f32, tint: Color)

export extern "ColorIsEqual" func ColorIsEqual(col1: Color, col2: Color): bool
export extern "Fade" func Fade(color: Color, alpha: f32): Color
export extern "ColorToInt" func ColorToInt(color: Color): i32
export extern "ColorNormalize" func ColorNormalize(color: Color): Vector4
export extern "ColorFromNormalized" func ColorFromNormalized(normalized: Vector4): Color
export extern "ColorToHSV" func ColorToHSV(color: Color): Vector3
export extern "ColorFromHSV" func ColorFromHSV(hue: f32, saturation: f32, value: f32): Color
export extern "ColorTint" func ColorTint(color: Color, tint: Color): Color
export extern "ColorBrightness" func ColorBrightness(color: Color, factor: f32): Color
export extern "ColorContrast" func ColorContrast(color: Color, contrast: f32): Color
export extern "ColorAlpha" func ColorAlpha(color: Color, alpha: f32): Color
export extern "ColorAlphaBlend" func ColorAlphaBlend(dst: Color, src: Color, tint: Color): Color
export extern "ColorLerp" func ColorLerp(color1: Color, color2: Color, factor: f32): Color
export extern "GetColor" func GetColor(hexValue: u32): Color
export extern "GetPixelColor" func GetPixelColor(srcPtr: ^void, format: i32): Color
export extern "SetPixelColor" func SetPixelColor(dstPtr: ^void, color: Color, format: i32)
export extern "GetPixelDataSize" func GetPixelDataSize(width: i32, height: i32, format: i32): i32

// //------------------------------------------------------------------------------------
// // Font Loading and Text Drawing Functions (Module: text)
// //------------------------------------------------------------------------------------

// // Font loading/unloading functions
// RLAPI Font GetFontDefault(void);                                                            // Get the default Font
// RLAPI Font LoadFont(const char *fileName);                                                  // Load font from file into GPU memory (VRAM)
// RLAPI Font LoadFontEx(const char *fileName, int fontSize, int *codepoints, int codepointCount); // Load font from file with extended parameters, use NULL for codepoints and 0 for codepointCount to load the default character set, font size is provided in pixels height
// RLAPI Font LoadFontFromImage(Image image, Color key, int firstChar);                        // Load font from Image (XNA style)
// RLAPI Font LoadFontFromMemory(const char *fileType, const unsigned char *fileData, int dataSize, int fontSize, int *codepoints, int codepointCount); // Load font from memory buffer, fileType refers to extension: i.e. '.ttf'
// RLAPI bool IsFontValid(Font font);                                                          // Check if a font is valid (font data loaded, WARNING: GPU texture not checked)
// RLAPI GlyphInfo *LoadFontData(const unsigned char *fileData, int dataSize, int fontSize, int *codepoints, int codepointCount, int type); // Load font data for further use
// RLAPI Image GenImageFontAtlas(const GlyphInfo *glyphs, Rectangle **glyphRecs, int glyphCount, int fontSize, int padding, int packMethod); // Generate image font atlas using chars info
// RLAPI void UnloadFontData(GlyphInfo *glyphs, int glyphCount);                               // Unload font chars info data (RAM)
// RLAPI void UnloadFont(Font font);                                                           // Unload font from GPU memory (VRAM)
// RLAPI bool ExportFontAsCode(Font font, const char *fileName);                               // Export font as code file, returns true on success

// // Text drawing functions
// RLAPI void DrawFPS(int posX, int posY);                                                     // Draw current FPS
// RLAPI void DrawText(const char *text, int posX, int posY, int fontSize, Color color);       // Draw text (using default font)
// RLAPI void DrawTextEx(Font font, const char *text, Vector2 position, float fontSize, float spacing, Color tint); // Draw text using font and additional parameters
// RLAPI void DrawTextPro(Font font, const char *text, Vector2 position, Vector2 origin, float rotation, float fontSize, float spacing, Color tint); // Draw text using Font and pro parameters (rotation)
// RLAPI void DrawTextCodepoint(Font font, int codepoint, Vector2 position, float fontSize, Color tint); // Draw one character (codepoint)
// RLAPI void DrawTextCodepoints(Font font, const int *codepoints, int codepointCount, Vector2 position, float fontSize, float spacing, Color tint); // Draw multiple character (codepoint)

// // Text font info functions
// RLAPI void SetTextLineSpacing(int spacing);                                                 // Set vertical line spacing when drawing with line-breaks
// RLAPI int MeasureText(const char *text, int fontSize);                                      // Measure string width for default font
// RLAPI Vector2 MeasureTextEx(Font font, const char *text, float fontSize, float spacing);    // Measure string size for Font
// RLAPI int GetGlyphIndex(Font font, int codepoint);                                          // Get glyph index position in font for a codepoint (unicode character), fallback to '?' if not found
// RLAPI GlyphInfo GetGlyphInfo(Font font, int codepoint);                                     // Get glyph font info data for a codepoint (unicode character), fallback to '?' if not found
// RLAPI Rectangle GetGlyphAtlasRec(Font font, int codepoint);                                 // Get glyph rectangle in font atlas for a codepoint (unicode character), fallback to '?' if not found

// // Text codepoints management functions (unicode characters)
// RLAPI char *LoadUTF8(const int *codepoints, int length);                // Load UTF-8 text encoded from codepoints array
// RLAPI void UnloadUTF8(char *text);                                      // Unload UTF-8 text encoded from codepoints array
// RLAPI int *LoadCodepoints(const char *text, int *count);                // Load all codepoints from a UTF-8 text string, codepoints count returned by parameter
// RLAPI void UnloadCodepoints(int *codepoints);                           // Unload codepoints data from memory
// RLAPI int GetCodepointCount(const char *text);                          // Get total number of codepoints in a UTF-8 encoded string
// RLAPI int GetCodepoint(const char *text, int *codepointSize);           // Get next codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure
// RLAPI int GetCodepointNext(const char *text, int *codepointSize);       // Get next codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure
// RLAPI int GetCodepointPrevious(const char *text, int *codepointSize);   // Get previous codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure
// RLAPI const char *CodepointToUTF8(int codepoint, int *utf8Size);        // Encode one codepoint into UTF-8 byte array (array length returned as parameter)

// // Text strings management functions (no UTF-8 strings, only byte chars)
// // NOTE: Some strings allocate memory internally for returned strings, just be careful!
// RLAPI int TextCopy(char *dst, const char *src);                                             // Copy one string to another, returns bytes copied
// RLAPI bool TextIsEqual(const char *text1, const char *text2);                               // Check if two text string are equal
// RLAPI unsigned int TextLength(const char *text);                                            // Get text length, checks for '\0' ending
// RLAPI const char *TextFormat(const char *text, ...);                                        // Text formatting with variables (sprintf() style)
// RLAPI const char *TextSubtext(const char *text, int position, int length);                  // Get a piece of a text string
// RLAPI char *TextReplace(const char *text, const char *replace, const char *by);             // Replace text string (WARNING: memory must be freed!)
// RLAPI char *TextInsert(const char *text, const char *insert, int position);                 // Insert text in a position (WARNING: memory must be freed!)
// RLAPI const char *TextJoin(const char **textList, int count, const char *delimiter);        // Join text strings with delimiter
// RLAPI const char **TextSplit(const char *text, char delimiter, int *count);                 // Split text into multiple strings
// RLAPI void TextAppend(char *text, const char *append, int *position);                       // Append text at specific position and move cursor!
// RLAPI int TextFindIndex(const char *text, const char *find);                                // Find first text occurrence within a string
// RLAPI const char *TextToUpper(const char *text);                      // Get upper case version of provided string
// RLAPI const char *TextToLower(const char *text);                      // Get lower case version of provided string
// RLAPI const char *TextToPascal(const char *text);                     // Get Pascal case notation version of provided string
// RLAPI const char *TextToSnake(const char *text);                      // Get Snake case notation version of provided string
// RLAPI const char *TextToCamel(const char *text);                      // Get Camel case notation version of provided string

// RLAPI int TextToInteger(const char *text);                            // Get integer value from text (negative values not supported)
// RLAPI float TextToFloat(const char *text);                            // Get float value from text (negative values not supported)

// //------------------------------------------------------------------------------------
// // Basic 3d Shapes Drawing Functions (Module: models)
// //------------------------------------------------------------------------------------

// // Basic geometric 3D shapes drawing functions
// RLAPI void DrawLine3D(Vector3 startPos, Vector3 endPos, Color color);                                    // Draw a line in 3D world space
// RLAPI void DrawPoint3D(Vector3 position, Color color);                                                   // Draw a point in 3D space, actually a small line
// RLAPI void DrawCircle3D(Vector3 center, float radius, Vector3 rotationAxis, float rotationAngle, Color color); // Draw a circle in 3D world space
// RLAPI void DrawTriangle3D(Vector3 v1, Vector3 v2, Vector3 v3, Color color);                              // Draw a color-filled triangle (vertex in counter-clockwise order!)
// RLAPI void DrawTriangleStrip3D(const Vector3 *points, int pointCount, Color color);                      // Draw a triangle strip defined by points
// RLAPI void DrawCube(Vector3 position, float width, float height, float length, Color color);             // Draw cube
// RLAPI void DrawCubeV(Vector3 position, Vector3 size, Color color);                                       // Draw cube (Vector version)
// RLAPI void DrawCubeWires(Vector3 position, float width, float height, float length, Color color);        // Draw cube wires
// RLAPI void DrawCubeWiresV(Vector3 position, Vector3 size, Color color);                                  // Draw cube wires (Vector version)
// RLAPI void DrawSphere(Vector3 centerPos, float radius, Color color);                                     // Draw sphere
// RLAPI void DrawSphereEx(Vector3 centerPos, float radius, int rings, int slices, Color color);            // Draw sphere with extended parameters
// RLAPI void DrawSphereWires(Vector3 centerPos, float radius, int rings, int slices, Color color);         // Draw sphere wires
// RLAPI void DrawCylinder(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color); // Draw a cylinder/cone
// RLAPI void DrawCylinderEx(Vector3 startPos, Vector3 endPos, float startRadius, float endRadius, int sides, Color color); // Draw a cylinder with base at startPos and top at endPos
// RLAPI void DrawCylinderWires(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color); // Draw a cylinder/cone wires
// RLAPI void DrawCylinderWiresEx(Vector3 startPos, Vector3 endPos, float startRadius, float endRadius, int sides, Color color); // Draw a cylinder wires with base at startPos and top at endPos
// RLAPI void DrawCapsule(Vector3 startPos, Vector3 endPos, float radius, int slices, int rings, Color color); // Draw a capsule with the center of its sphere caps at startPos and endPos
// RLAPI void DrawCapsuleWires(Vector3 startPos, Vector3 endPos, float radius, int slices, int rings, Color color); // Draw capsule wireframe with the center of its sphere caps at startPos and endPos
// RLAPI void DrawPlane(Vector3 centerPos, Vector2 size, Color color);                                      // Draw a plane XZ
// RLAPI void DrawRay(Ray ray, Color color);                                                                // Draw a ray line
// RLAPI void DrawGrid(int slices, float spacing);                                                          // Draw a grid (centered at (0, 0, 0))

// //------------------------------------------------------------------------------------
// // Model 3d Loading and Drawing Functions (Module: models)
// //------------------------------------------------------------------------------------

// // Model management functions
// RLAPI Model LoadModel(const char *fileName);                                                // Load model from files (meshes and materials)
// RLAPI Model LoadModelFromMesh(Mesh mesh);                                                   // Load model from generated mesh (default material)
// RLAPI bool IsModelValid(Model model);                                                       // Check if a model is valid (loaded in GPU, VAO/VBOs)
// RLAPI void UnloadModel(Model model);                                                        // Unload model (including meshes) from memory (RAM and/or VRAM)
// RLAPI BoundingBox GetModelBoundingBox(Model model);                                         // Compute model bounding box limits (considers all meshes)

// // Model drawing functions
// RLAPI void DrawModel(Model model, Vector3 position, float scale, Color tint);               // Draw a model (with texture if set)
// RLAPI void DrawModelEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint); // Draw a model with extended parameters
// RLAPI void DrawModelWires(Model model, Vector3 position, float scale, Color tint);          // Draw a model wires (with texture if set)
// RLAPI void DrawModelWiresEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint); // Draw a model wires (with texture if set) with extended parameters
// RLAPI void DrawModelPoints(Model model, Vector3 position, float scale, Color tint); // Draw a model as points
// RLAPI void DrawModelPointsEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint); // Draw a model as points with extended parameters
// RLAPI void DrawBoundingBox(BoundingBox box, Color color);                                   // Draw bounding box (wires)
// RLAPI void DrawBillboard(Camera camera, Texture2D texture, Vector3 position, float scale, Color tint);   // Draw a billboard texture
// RLAPI void DrawBillboardRec(Camera camera, Texture2D texture, Rectangle source, Vector3 position, Vector2 size, Color tint); // Draw a billboard texture defined by source
// RLAPI void DrawBillboardPro(Camera camera, Texture2D texture, Rectangle source, Vector3 position, Vector3 up, Vector2 size, Vector2 origin, float rotation, Color tint); // Draw a billboard texture defined by source and rotation

// // Mesh management functions
// RLAPI void UploadMesh(Mesh *mesh, bool dynamic);                                            // Upload mesh vertex data in GPU and provide VAO/VBO ids
// RLAPI void UpdateMeshBuffer(Mesh mesh, int index, const void *data, int dataSize, int offset); // Update mesh vertex data in GPU for a specific buffer index
// RLAPI void UnloadMesh(Mesh mesh);                                                           // Unload mesh data from CPU and GPU
// RLAPI void DrawMesh(Mesh mesh, Material material, Matrix transform);                        // Draw a 3d mesh with material and transform
// RLAPI void DrawMeshInstanced(Mesh mesh, Material material, const Matrix *transforms, int instances); // Draw multiple mesh instances with material and different transforms
// RLAPI BoundingBox GetMeshBoundingBox(Mesh mesh);                                            // Compute mesh bounding box limits
// RLAPI void GenMeshTangents(Mesh *mesh);                                                     // Compute mesh tangents
// RLAPI bool ExportMesh(Mesh mesh, const char *fileName);                                     // Export mesh data to file, returns true on success
// RLAPI bool ExportMeshAsCode(Mesh mesh, const char *fileName);                               // Export mesh as code file (.h) defining multiple arrays of vertex attributes

// // Mesh generation functions
// RLAPI Mesh GenMeshPoly(int sides, float radius);                                            // Generate polygonal mesh
// RLAPI Mesh GenMeshPlane(float width, float length, int resX, int resZ);                     // Generate plane mesh (with subdivisions)
// RLAPI Mesh GenMeshCube(float width, float height, float length);                            // Generate cuboid mesh
// RLAPI Mesh GenMeshSphere(float radius, int rings, int slices);                              // Generate sphere mesh (standard sphere)
// RLAPI Mesh GenMeshHemiSphere(float radius, int rings, int slices);                          // Generate half-sphere mesh (no bottom cap)
// RLAPI Mesh GenMeshCylinder(float radius, float height, int slices);                         // Generate cylinder mesh
// RLAPI Mesh GenMeshCone(float radius, float height, int slices);                             // Generate cone/pyramid mesh
// RLAPI Mesh GenMeshTorus(float radius, float size, int radSeg, int sides);                   // Generate torus mesh
// RLAPI Mesh GenMeshKnot(float radius, float size, int radSeg, int sides);                    // Generate trefoil knot mesh
// RLAPI Mesh GenMeshHeightmap(Image heightmap, Vector3 size);                                 // Generate heightmap mesh from image data
// RLAPI Mesh GenMeshCubicmap(Image cubicmap, Vector3 cubeSize);                               // Generate cubes-based map mesh from image data

// // Material loading/unloading functions
// RLAPI Material *LoadMaterials(const char *fileName, int *materialCount);                    // Load materials from model file
// RLAPI Material LoadMaterialDefault(void);                                                   // Load default material (Supports: DIFFUSE, SPECULAR, NORMAL maps)
// RLAPI bool IsMaterialValid(Material material);                                              // Check if a material is valid (shader assigned, map textures loaded in GPU)
// RLAPI void UnloadMaterial(Material material);                                               // Unload material from GPU memory (VRAM)
// RLAPI void SetMaterialTexture(Material *material, int mapType, Texture2D texture);          // Set texture for a material map type (MATERIAL_MAP_DIFFUSE, MATERIAL_MAP_SPECULAR...)
// RLAPI void SetModelMeshMaterial(Model *model, int meshId, int materialId);                  // Set material for a mesh

// // Model animations loading/unloading functions
// RLAPI ModelAnimation *LoadModelAnimations(const char *fileName, int *animCount);            // Load model animations from file
// RLAPI void UpdateModelAnimation(Model model, ModelAnimation anim, int frame);               // Update model animation pose (CPU)
// RLAPI void UpdateModelAnimationBones(Model model, ModelAnimation anim, int frame);          // Update model animation mesh bone matrices (GPU skinning)
// RLAPI void UnloadModelAnimation(ModelAnimation anim);                                       // Unload animation data
// RLAPI void UnloadModelAnimations(ModelAnimation *animations, int animCount);                // Unload animation array data
// RLAPI bool IsModelAnimationValid(Model model, ModelAnimation anim);                         // Check model animation skeleton match

// // Collision detection functions
// RLAPI bool CheckCollisionSpheres(Vector3 center1, float radius1, Vector3 center2, float radius2);   // Check collision between two spheres
// RLAPI bool CheckCollisionBoxes(BoundingBox box1, BoundingBox box2);                                 // Check collision between two bounding boxes
// RLAPI bool CheckCollisionBoxSphere(BoundingBox box, Vector3 center, float radius);                  // Check collision between box and sphere
// RLAPI RayCollision GetRayCollisionSphere(Ray ray, Vector3 center, float radius);                    // Get collision info between ray and sphere
// RLAPI RayCollision GetRayCollisionBox(Ray ray, BoundingBox box);                                    // Get collision info between ray and box
// RLAPI RayCollision GetRayCollisionMesh(Ray ray, Mesh mesh, Matrix transform);                       // Get collision info between ray and mesh
// RLAPI RayCollision GetRayCollisionTriangle(Ray ray, Vector3 p1, Vector3 p2, Vector3 p3);            // Get collision info between ray and triangle
// RLAPI RayCollision GetRayCollisionQuad(Ray ray, Vector3 p1, Vector3 p2, Vector3 p3, Vector3 p4);    // Get collision info between ray and quad

// //------------------------------------------------------------------------------------
// // Audio Loading and Playing Functions (Module: audio)
// //------------------------------------------------------------------------------------
// typedef void (*AudioCallback)(void *bufferData, unsigned int frames);

// // Audio device management functions
// RLAPI void InitAudioDevice(void);                                     // Initialize audio device and context
// RLAPI void CloseAudioDevice(void);                                    // Close the audio device and context
// RLAPI bool IsAudioDeviceReady(void);                                  // Check if audio device has been initialized successfully
// RLAPI void SetMasterVolume(float volume);                             // Set master volume (listener)
// RLAPI float GetMasterVolume(void);                                    // Get master volume (listener)

// // Wave/Sound loading/unloading functions
// RLAPI Wave LoadWave(const char *fileName);                            // Load wave data from file
// RLAPI Wave LoadWaveFromMemory(const char *fileType, const unsigned char *fileData, int dataSize); // Load wave from memory buffer, fileType refers to extension: i.e. '.wav'
// RLAPI bool IsWaveValid(Wave wave);                                    // Checks if wave data is valid (data loaded and parameters)
// RLAPI Sound LoadSound(const char *fileName);                          // Load sound from file
// RLAPI Sound LoadSoundFromWave(Wave wave);                             // Load sound from wave data
// RLAPI Sound LoadSoundAlias(Sound source);                             // Create a new sound that shares the same sample data as the source sound, does not own the sound data
// RLAPI bool IsSoundValid(Sound sound);                                 // Checks if a sound is valid (data loaded and buffers initialized)
// RLAPI void UpdateSound(Sound sound, const void *data, int sampleCount); // Update sound buffer with new data
// RLAPI void UnloadWave(Wave wave);                                     // Unload wave data
// RLAPI void UnloadSound(Sound sound);                                  // Unload sound
// RLAPI void UnloadSoundAlias(Sound alias);                             // Unload a sound alias (does not deallocate sample data)
// RLAPI bool ExportWave(Wave wave, const char *fileName);               // Export wave data to file, returns true on success
// RLAPI bool ExportWaveAsCode(Wave wave, const char *fileName);         // Export wave sample data to code (.h), returns true on success

// // Wave/Sound management functions
// RLAPI void PlaySound(Sound sound);                                    // Play a sound
// RLAPI void StopSound(Sound sound);                                    // Stop playing a sound
// RLAPI void PauseSound(Sound sound);                                   // Pause a sound
// RLAPI void ResumeSound(Sound sound);                                  // Resume a paused sound
// RLAPI bool IsSoundPlaying(Sound sound);                               // Check if a sound is currently playing
// RLAPI void SetSoundVolume(Sound sound, float volume);                 // Set volume for a sound (1.0 is max level)
// RLAPI void SetSoundPitch(Sound sound, float pitch);                   // Set pitch for a sound (1.0 is base level)
// RLAPI void SetSoundPan(Sound sound, float pan);                       // Set pan for a sound (0.5 is center)
// RLAPI Wave WaveCopy(Wave wave);                                       // Copy a wave to a new wave
// RLAPI void WaveCrop(Wave *wave, int initFrame, int finalFrame);       // Crop a wave to defined frames range
// RLAPI void WaveFormat(Wave *wave, int sampleRate, int sampleSize, int channels); // Convert wave data to desired format
// RLAPI float *LoadWaveSamples(Wave wave);                              // Load samples data from wave as a 32bit float data array
// RLAPI void UnloadWaveSamples(float *samples);                         // Unload samples data loaded with LoadWaveSamples()

// // Music management functions
// RLAPI Music LoadMusicStream(const char *fileName);                    // Load music stream from file
// RLAPI Music LoadMusicStreamFromMemory(const char *fileType, const unsigned char *data, int dataSize); // Load music stream from data
// RLAPI bool IsMusicValid(Music music);                                 // Checks if a music stream is valid (context and buffers initialized)
// RLAPI void UnloadMusicStream(Music music);                            // Unload music stream
// RLAPI void PlayMusicStream(Music music);                              // Start music playing
// RLAPI bool IsMusicStreamPlaying(Music music);                         // Check if music is playing
// RLAPI void UpdateMusicStream(Music music);                            // Updates buffers for music streaming
// RLAPI void StopMusicStream(Music music);                              // Stop music playing
// RLAPI void PauseMusicStream(Music music);                             // Pause music playing
// RLAPI void ResumeMusicStream(Music music);                            // Resume playing paused music
// RLAPI void SeekMusicStream(Music music, float position);              // Seek music to a position (in seconds)
// RLAPI void SetMusicVolume(Music music, float volume);                 // Set volume for music (1.0 is max level)
// RLAPI void SetMusicPitch(Music music, float pitch);                   // Set pitch for a music (1.0 is base level)
// RLAPI void SetMusicPan(Music music, float pan);                       // Set pan for a music (0.5 is center)
// RLAPI float GetMusicTimeLength(Music music);                          // Get music time length (in seconds)
// RLAPI float GetMusicTimePlayed(Music music);                          // Get current music time played (in seconds)

// // AudioStream management functions
// RLAPI AudioStream LoadAudioStream(unsigned int sampleRate, unsigned int sampleSize, unsigned int channels); // Load audio stream (to stream raw audio pcm data)
// RLAPI bool IsAudioStreamValid(AudioStream stream);                    // Checks if an audio stream is valid (buffers initialized)
// RLAPI void UnloadAudioStream(AudioStream stream);                     // Unload audio stream and free memory
// RLAPI void UpdateAudioStream(AudioStream stream, const void *data, int frameCount); // Update audio stream buffers with data
// RLAPI bool IsAudioStreamProcessed(AudioStream stream);                // Check if any audio stream buffers requires refill
// RLAPI void PlayAudioStream(AudioStream stream);                       // Play audio stream
// RLAPI void PauseAudioStream(AudioStream stream);                      // Pause audio stream
// RLAPI void ResumeAudioStream(AudioStream stream);                     // Resume audio stream
// RLAPI bool IsAudioStreamPlaying(AudioStream stream);                  // Check if audio stream is playing
// RLAPI void StopAudioStream(AudioStream stream);                       // Stop audio stream
// RLAPI void SetAudioStreamVolume(AudioStream stream, float volume);    // Set volume for audio stream (1.0 is max level)
// RLAPI void SetAudioStreamPitch(AudioStream stream, float pitch);      // Set pitch for audio stream (1.0 is base level)
// RLAPI void SetAudioStreamPan(AudioStream stream, float pan);          // Set pan for audio stream (0.5 is centered)
// RLAPI void SetAudioStreamBufferSizeDefault(int size);                 // Default size for new audio streams
// RLAPI void SetAudioStreamCallback(AudioStream stream, AudioCallback callback); // Audio thread callback to request new data

// RLAPI void AttachAudioStreamProcessor(AudioStream stream, AudioCallback processor); // Attach audio stream processor to stream, receives the samples as 'float'
// RLAPI void DetachAudioStreamProcessor(AudioStream stream, AudioCallback processor); // Detach audio stream processor from stream

// RLAPI void AttachAudioMixedProcessor(AudioCallback processor); // Attach audio stream processor to the entire audio pipeline, receives the samples as 'float'
// RLAPI void DetachAudioMixedProcessor(AudioCallback processor); // Detach audio stream processor from the entire audio pipeline