[..] Module – raylib

Module raylib provides bindings for the raylib C library (v5.5). Supported platforms: Windows, Mac, Linux

#import "jc/ext/raylib";

BEIGE :: Color.{ 211, 176, 131, 255 };   // Beige

BLACK :: Color.{ 0, 0, 0, 255 };         // Black

BLANK :: Color.{ 0, 0, 0, 0 };           // Blank (Transparent)

BLUE :: Color.{ 0, 121, 241, 255 };     // Blue

BROWN :: Color.{ 127, 106, 79, 255 };    // Brown

Camera :: Camera3D;

DARKBLUE :: Color.{ 0, 82, 172, 255 };      // Dark Blue

DARKBROWN :: Color.{ 76, 63, 47, 255 };      // Dark Brown

DARKGRAY :: Color.{ 80, 80, 80, 255 };      // Dark Gray

DARKGREEN :: Color.{ 0, 117, 44, 255 };      // Dark Green

DARKPURPLE :: Color.{ 112, 31, 126, 255 };    // Dark Purple

DEG2RAD :: PI/180.0;

EPSILON :: 0.000001;

GOLD :: Color.{ 255, 203, 0, 255 };     // Gold

GREEN :: Color.{ 0, 228, 48, 255 };      // Green

GetMouseRay :: GetScreenToWorldRay;

LIME :: Color.{ 0, 158, 47, 255 };      // Lime

MAGENTA :: Color.{ 255, 0, 255, 255 };     // Magenta

MAROON :: Color.{ 190, 33, 55, 255 };     // Maroon

ORANGE :: Color.{ 255, 161, 0, 255 };     // Orange

PI :: 3.14159265358979323846;

PINK :: Color.{ 255, 109, 194, 255 };   // Pink

PURPLE :: Color.{ 200, 122, 255, 255 };   // Purple

Quaternion :: Vector4;

RAD2DEG :: 180.0/PI;

RAYLIB_VERSION :: "5.5";

RAYLIB_VERSION_MAJOR :: 5;

RAYLIB_VERSION_MINOR :: 5;

RAYLIB_VERSION_PATCH :: 0;

RAYWHITE :: Color.{ 245, 245, 245, 255 };   // My own White (raylib logo)

RED :: Color.{ 230, 41, 55, 255 };     // Red

RenderTexture2D :: RenderTexture;

SKYBLUE :: Color.{ 102, 191, 255, 255 };   // Sky Blue

STATIC :: true;

Texture2D :: Texture;

TextureCubemap :: Texture;

TraceLogCallback :: *void /* function type contained C va_list argument */;

VIOLET :: Color.{ 135, 60, 190, 255 };    // Violet

WHITE :: Color.{ 255, 255, 255, 255 };   // White

YELLOW :: Color.{ 253, 249, 0, 255 };     // Yellow

AttachAudioMixedProcessor :: (processor: AudioCallback)

AttachAudioStreamProcessor :: (stream: AudioStream, processor: AudioCallback)

BeginBlendMode :: (mode: s32)

BeginDrawing :: ()

BeginMode2D :: (camera: Camera2D)

BeginMode3D :: (camera: Camera3D)

BeginScissorMode :: (x: s32, y: s32, width: s32, height: s32)

BeginShaderMode :: (shader: Shader)

BeginTextureMode :: (target: RenderTexture2D)

BeginVrStereoMode :: (config: VrStereoConfig)

ChangeDirectory :: (dir: *u8) -> bool

CheckCollisionBoxSphere :: (box: BoundingBox, center: Vector3, radius: float) -> bool

CheckCollisionBoxes :: (box1: BoundingBox, box2: BoundingBox) -> bool

CheckCollisionCircleLine :: (center: Vector2, radius: float, p1: Vector2, p2: Vector2) -> bool

CheckCollisionCircleRec :: (center: Vector2, radius: float, rec: Rectangle) -> bool

CheckCollisionCircles :: (center1: Vector2, radius1: float, center2: Vector2, radius2: float) -> bool

CheckCollisionLines :: (startPos1: Vector2, endPos1: Vector2, startPos2: Vector2, endPos2: Vector2, collisionPoint: *Vector2) -> bool

CheckCollisionPointCircle :: (point: Vector2, center: Vector2, radius: float) -> bool

CheckCollisionPointLine :: (point: Vector2, p1: Vector2, p2: Vector2, threshold: s32) -> bool

CheckCollisionPointPoly :: (point: Vector2, points: *Vector2, pointCount: s32) -> bool

CheckCollisionPointRec :: (point: Vector2, rec: Rectangle) -> bool

CheckCollisionPointTriangle :: (point: Vector2, p1: Vector2, p2: Vector2, p3: Vector2) -> bool

CheckCollisionRecs :: (rec1: Rectangle, rec2: Rectangle) -> bool

CheckCollisionSpheres :: (center1: Vector3, radius1: float, center2: Vector3, radius2: float) -> bool

Clamp :: (value: float, min: float, max: float) -> float

ClearBackground :: (color: Color)

ClearWindowState :: (flags: ConfigFlags)

CloseAudioDevice :: ()

CloseWindow :: ()

CodepointToUTF8 :: (codepoint: s32, utf8Size: *s32) -> *u8

ColorAlpha :: (color: Color, alpha: float) -> Color

ColorAlphaBlend :: (dst: Color, src: Color, tint: Color) -> Color

ColorBrightness :: (color: Color, factor: float) -> Color

ColorContrast :: (color: Color, contrast: float) -> Color

ColorFromHSV :: (hue: float, saturation: float, value: float) -> Color

ColorFromNormalized :: (normalized: Vector4) -> Color

ColorIsEqual :: (col1: Color, col2: Color) -> bool

ColorLerp :: (color1: Color, color2: Color, factor: float) -> Color

ColorNormalize :: (color: Color) -> Vector4

ColorTint :: (color: Color, tint: Color) -> Color

ColorToHSV :: (color: Color) -> Vector3

ColorToInt :: (color: Color) -> s32

CompressData :: (data: *u8, dataSize: s32, compDataSize: *s32) -> *u8

ComputeCRC32 :: (data: *u8, dataSize: s32) -> u32

ComputeMD5 :: (data: *u8, dataSize: s32) -> *u32

ComputeSHA1 :: (data: *u8, dataSize: s32) -> *u32

DecodeDataBase64 :: (data: *u8, outputSize: *s32) -> *u8

DecompressData :: (compData: *u8, compDataSize: s32, dataSize: *s32) -> *u8

DetachAudioMixedProcessor :: (processor: AudioCallback)

DetachAudioStreamProcessor :: (stream: AudioStream, processor: AudioCallback)

DirectoryExists :: (dirPath: *u8) -> bool

DisableCursor :: ()

DisableEventWaiting :: ()

DrawBillboard :: (camera: Camera, texture: Texture2D, position: Vector3, scale: float, tint: Color)

DrawBillboardPro :: (camera: Camera, texture: Texture2D, source: Rectangle, position: Vector3, up: Vector3, size: Vector2, origin: Vector2, rotation: float, tint: Color)

DrawBillboardRec :: (camera: Camera, texture: Texture2D, source: Rectangle, position: Vector3, size: Vector2, tint: Color)

DrawBoundingBox :: (box: BoundingBox, color: Color)

DrawCapsule :: (startPos: Vector3, endPos: Vector3, radius: float, slices: s32, rings: s32, color: Color)

DrawCapsuleWires :: (startPos: Vector3, endPos: Vector3, radius: float, slices: s32, rings: s32, color: Color)

DrawCircle :: (centerX: s32, centerY: s32, radius: float, color: Color)

DrawCircle3D :: (center: Vector3, radius: float, rotationAxis: Vector3, rotationAngle: float, color: Color)

DrawCircleGradient :: (centerX: s32, centerY: s32, radius: float, inner: Color, outer: Color)

DrawCircleLines :: (centerX: s32, centerY: s32, radius: float, color: Color)

DrawCircleLinesV :: (center: Vector2, radius: float, color: Color)

DrawCircleSector :: (center: Vector2, radius: float, startAngle: float, endAngle: float, segments: s32, color: Color)

DrawCircleSectorLines :: (center: Vector2, radius: float, startAngle: float, endAngle: float, segments: s32, color: Color)

DrawCircleV :: (center: Vector2, radius: float, color: Color)

DrawCube :: (position: Vector3, width: float, height: float, length: float, color: Color)

DrawCubeV :: (position: Vector3, size: Vector3, color: Color)

DrawCubeWires :: (position: Vector3, width: float, height: float, length: float, color: Color)

DrawCubeWiresV :: (position: Vector3, size: Vector3, color: Color)

DrawCylinder :: (position: Vector3, radiusTop: float, radiusBottom: float, height: float, slices: s32, color: Color)

DrawCylinderEx :: (startPos: Vector3, endPos: Vector3, startRadius: float, endRadius: float, sides: s32, color: Color)

DrawCylinderWires :: (position: Vector3, radiusTop: float, radiusBottom: float, height: float, slices: s32, color: Color)

DrawCylinderWiresEx :: (startPos: Vector3, endPos: Vector3, startRadius: float, endRadius: float, sides: s32, color: Color)

DrawEllipse :: (centerX: s32, centerY: s32, radiusH: float, radiusV: float, color: Color)

DrawEllipseLines :: (centerX: s32, centerY: s32, radiusH: float, radiusV: float, color: Color)

DrawFPS :: (posX: s32, posY: s32)

DrawGrid :: (slices: s32, spacing: float)

DrawLine :: (startPosX: s32, startPosY: s32, endPosX: s32, endPosY: s32, color: Color)

DrawLine3D :: (startPos: Vector3, endPos: Vector3, color: Color)

DrawLineBezier :: (startPos: Vector2, endPos: Vector2, thick: float, color: Color)

DrawLineEx :: (startPos: Vector2, endPos: Vector2, thick: float, color: Color)

DrawLineStrip :: (points: *Vector2, pointCount: s32, color: Color)

DrawLineV :: (startPos: Vector2, endPos: Vector2, color: Color)

DrawMesh :: (mesh: Mesh, material: Material, transform: Matrix)

DrawMeshInstanced :: (mesh: Mesh, material: Material, transforms: *Matrix, instances: s32)

DrawModel :: (model: Model, position: Vector3, scale: float, tint: Color)

DrawModelEx :: (model: Model, position: Vector3, rotationAxis: Vector3, rotationAngle: float, scale: Vector3, tint: Color)

DrawModelPoints :: (model: Model, position: Vector3, scale: float, tint: Color)

DrawModelPointsEx :: (model: Model, position: Vector3, rotationAxis: Vector3, rotationAngle: float, scale: Vector3, tint: Color)

DrawModelWires :: (model: Model, position: Vector3, scale: float, tint: Color)

DrawModelWiresEx :: (model: Model, position: Vector3, rotationAxis: Vector3, rotationAngle: float, scale: Vector3, tint: Color)

DrawPixel :: (posX: s32, posY: s32, color: Color)

DrawPixelV :: (position: Vector2, color: Color)

DrawPlane :: (centerPos: Vector3, size: Vector2, color: Color)

DrawPoint3D :: (position: Vector3, color: Color)

DrawPoly :: (center: Vector2, sides: s32, radius: float, rotation: float, color: Color)

DrawPolyLines :: (center: Vector2, sides: s32, radius: float, rotation: float, color: Color)

DrawPolyLinesEx :: (center: Vector2, sides: s32, radius: float, rotation: float, lineThick: float, color: Color)

DrawRay :: (ray: Ray, color: Color)

DrawRectangle :: (posX: s32, posY: s32, width: s32, height: s32, color: Color)

DrawRectangleGradientEx :: (rec: Rectangle, topLeft: Color, bottomLeft: Color, topRight: Color, bottomRight: Color)

DrawRectangleGradientH :: (posX: s32, posY: s32, width: s32, height: s32, left: Color, right: Color)

DrawRectangleGradientV :: (posX: s32, posY: s32, width: s32, height: s32, top: Color, bottom: Color)

DrawRectangleLines :: (posX: s32, posY: s32, width: s32, height: s32, color: Color)

DrawRectangleLinesEx :: (rec: Rectangle, lineThick: float, color: Color)

DrawRectanglePro :: (rec: Rectangle, origin: Vector2, rotation: float, color: Color)

DrawRectangleRec :: (rec: Rectangle, color: Color)

DrawRectangleRounded :: (rec: Rectangle, roundness: float, segments: s32, color: Color)

DrawRectangleRoundedLines :: (rec: Rectangle, roundness: float, segments: s32, color: Color)

DrawRectangleRoundedLinesEx :: (rec: Rectangle, roundness: float, segments: s32, lineThick: float, color: Color)

DrawRectangleV :: (position: Vector2, size: Vector2, color: Color)

DrawRing :: (center: Vector2, innerRadius: float, outerRadius: float, startAngle: float, endAngle: float, segments: s32, color: Color)

DrawRingLines :: (center: Vector2, innerRadius: float, outerRadius: float, startAngle: float, endAngle: float, segments: s32, color: Color)

DrawSphere :: (centerPos: Vector3, radius: float, color: Color)

DrawSphereEx :: (centerPos: Vector3, radius: float, rings: s32, slices: s32, color: Color)

DrawSphereWires :: (centerPos: Vector3, radius: float, rings: s32, slices: s32, color: Color)

DrawSplineBasis :: (points: *Vector2, pointCount: s32, thick: float, color: Color)

DrawSplineBezierCubic :: (points: *Vector2, pointCount: s32, thick: float, color: Color)

DrawSplineBezierQuadratic :: (points: *Vector2, pointCount: s32, thick: float, color: Color)

DrawSplineCatmullRom :: (points: *Vector2, pointCount: s32, thick: float, color: Color)

DrawSplineLinear :: (points: *Vector2, pointCount: s32, thick: float, color: Color)

DrawSplineSegmentBasis :: (p1: Vector2, p2: Vector2, p3: Vector2, p4: Vector2, thick: float, color: Color)

DrawSplineSegmentBezierCubic :: (p1: Vector2, c2: Vector2, c3: Vector2, p4: Vector2, thick: float, color: Color)

DrawSplineSegmentBezierQuadratic :: (p1: Vector2, c2: Vector2, p3: Vector2, thick: float, color: Color)

DrawSplineSegmentCatmullRom :: (p1: Vector2, p2: Vector2, p3: Vector2, p4: Vector2, thick: float, color: Color)

DrawSplineSegmentLinear :: (p1: Vector2, p2: Vector2, thick: float, color: Color)

DrawText :: (text: *u8, posX: s32, posY: s32, fontSize: s32, color: Color)

DrawTextCodepoint :: (font: Font, codepoint: s32, position: Vector2, fontSize: float, tint: Color)

DrawTextCodepoints :: (font: Font, codepoints: *s32, codepointCount: s32, position: Vector2, fontSize: float, spacing: float, tint: Color)

DrawTextEx :: (font: Font, text: *u8, position: Vector2, fontSize: float, spacing: float, tint: Color)

DrawTextPro :: (font: Font, text: *u8, position: Vector2, origin: Vector2, rotation: float, fontSize: float, spacing: float, tint: Color)

DrawTexture :: (texture: Texture2D, posX: s32, posY: s32, tint: Color)

DrawTextureEx :: (texture: Texture2D, position: Vector2, rotation: float, scale: float, tint: Color)

DrawTextureNPatch :: (texture: Texture2D, nPatchInfo: NPatchInfo, dest: Rectangle, origin: Vector2, rotation: float, tint: Color)

DrawTexturePro :: (texture: Texture2D, source: Rectangle, dest: Rectangle, origin: Vector2, rotation: float, tint: Color)

DrawTextureRec :: (texture: Texture2D, source: Rectangle, position: Vector2, tint: Color)

DrawTextureV :: (texture: Texture2D, position: Vector2, tint: Color)

DrawTriangle :: (v1: Vector2, v2: Vector2, v3: Vector2, color: Color)

DrawTriangle3D :: (v1: Vector3, v2: Vector3, v3: Vector3, color: Color)

DrawTriangleFan :: (points: *Vector2, pointCount: s32, color: Color)

DrawTriangleLines :: (v1: Vector2, v2: Vector2, v3: Vector2, color: Color)

DrawTriangleStrip :: (points: *Vector2, pointCount: s32, color: Color)

DrawTriangleStrip3D :: (points: *Vector3, pointCount: s32, color: Color)

EnableCursor :: ()

EnableEventWaiting :: ()

EncodeDataBase64 :: (data: *u8, dataSize: s32, outputSize: *s32) -> *u8

EndBlendMode :: ()

EndDrawing :: ()

EndMode2D :: ()

EndMode3D :: ()

EndScissorMode :: ()

EndShaderMode :: ()

EndTextureMode :: ()

EndVrStereoMode :: ()

ExportAutomationEventList :: (list: AutomationEventList, fileName: *u8) -> bool

ExportDataAsCode :: (data: *u8, dataSize: s32, fileName: *u8) -> bool

ExportFontAsCode :: (font: Font, fileName: *u8) -> bool

ExportImage :: (image: Image, fileName: *u8) -> bool

ExportImageAsCode :: (image: Image, fileName: *u8) -> bool

ExportImageToMemory :: (image: Image, fileType: *u8, fileSize: *s32) -> *u8

ExportMesh :: (mesh: Mesh, fileName: *u8) -> bool

ExportMeshAsCode :: (mesh: Mesh, fileName: *u8) -> bool

ExportWave :: (wave: Wave, fileName: *u8) -> bool

ExportWaveAsCode :: (wave: Wave, fileName: *u8) -> bool

Fade :: (color: Color, alpha: float) -> Color

FileExists :: (fileName: *u8) -> bool

FloatEquals :: (x: float, y: float) -> s32

GenImageCellular :: (width: s32, height: s32, tileSize: s32) -> Image

GenImageChecked :: (width: s32, height: s32, checksX: s32, checksY: s32, col1: Color, col2: Color) -> Image

GenImageColor :: (width: s32, height: s32, color: Color) -> Image

GenImageFontAtlas :: (glyphs: *GlyphInfo, glyphRecs: **Rectangle, glyphCount: s32, fontSize: s32, padding: s32, packMethod: s32) -> Image

GenImageGradientLinear :: (width: s32, height: s32, direction: s32, start: Color, end: Color) -> Image

GenImageGradientRadial :: (width: s32, height: s32, density: float, inner: Color, outer: Color) -> Image

GenImageGradientSquare :: (width: s32, height: s32, density: float, inner: Color, outer: Color) -> Image

GenImagePerlinNoise :: (width: s32, height: s32, offsetX: s32, offsetY: s32, scale: float) -> Image

GenImageText :: (width: s32, height: s32, text: *u8) -> Image

GenImageWhiteNoise :: (width: s32, height: s32, factor: float) -> Image

GenMeshCone :: (radius: float, height: float, slices: s32) -> Mesh

GenMeshCube :: (width: float, height: float, length: float) -> Mesh

GenMeshCubicmap :: (cubicmap: Image, cubeSize: Vector3) -> Mesh

GenMeshCylinder :: (radius: float, height: float, slices: s32) -> Mesh

GenMeshHeightmap :: (heightmap: Image, size: Vector3) -> Mesh

GenMeshHemiSphere :: (radius: float, rings: s32, slices: s32) -> Mesh

GenMeshKnot :: (radius: float, size: float, radSeg: s32, sides: s32) -> Mesh

GenMeshPlane :: (width: float, length: float, resX: s32, resZ: s32) -> Mesh

GenMeshPoly :: (sides: s32, radius: float) -> Mesh

GenMeshSphere :: (radius: float, rings: s32, slices: s32) -> Mesh

GenMeshTangents :: (mesh: *Mesh)

GenMeshTorus :: (radius: float, size: float, radSeg: s32, sides: s32) -> Mesh

GenTextureMipmaps :: (texture: *Texture2D)

GetApplicationDirectory :: () -> *u8

GetCameraMatrix :: (camera: Camera) -> Matrix

GetCameraMatrix2D :: (camera: Camera2D) -> Matrix

GetCharPressed :: () -> s32

GetClipboardImage :: () -> Image

GetClipboardText :: () -> *u8

GetCodepoint :: (text: *u8, codepointSize: *s32) -> s32

GetCodepointCount :: (text: *u8) -> s32

GetCodepointNext :: (text: *u8, codepointSize: *s32) -> s32

GetCodepointPrevious :: (text: *u8, codepointSize: *s32) -> s32

GetCollisionRec :: (rec1: Rectangle, rec2: Rectangle) -> Rectangle

GetColor :: (hexValue: u32) -> Color

GetCurrentMonitor :: () -> s32

GetDirectoryPath :: (filePath: *u8) -> *u8

GetFPS :: () -> s32

GetFileExtension :: (fileName: *u8) -> *u8

GetFileLength :: (fileName: *u8) -> s32

GetFileModTime :: (fileName: *u8) -> s64

GetFileName :: (filePath: *u8) -> *u8

GetFileNameWithoutExt :: (filePath: *u8) -> *u8

GetFontDefault :: () -> Font

GetFrameTime :: () -> float

GetGamepadAxisCount :: (gamepad: s32) -> s32

GetGamepadAxisMovement :: (gamepad: s32, axis: GamepadAxis) -> float

GetGamepadButtonPressed :: () -> s32

GetGamepadName :: (gamepad: s32) -> *u8

GetGestureDetected :: () -> Gesture

GetGestureDragAngle :: () -> float

GetGestureDragVector :: () -> Vector2

GetGestureHoldDuration :: () -> float

GetGesturePinchAngle :: () -> float

GetGesturePinchVector :: () -> Vector2

GetGlyphAtlasRec :: (font: Font, codepoint: s32) -> Rectangle

GetGlyphIndex :: (font: Font, codepoint: s32) -> s32

GetGlyphInfo :: (font: Font, codepoint: s32) -> GlyphInfo

GetImageAlphaBorder :: (image: Image, threshold: float) -> Rectangle

GetImageColor :: (image: Image, x: s32, y: s32) -> Color

GetKeyPressed :: () -> s32

GetMasterVolume :: () -> float

GetMeshBoundingBox :: (mesh: Mesh) -> BoundingBox

GetModelBoundingBox :: (model: Model) -> BoundingBox

GetMonitorCount :: () -> s32

GetMonitorHeight :: (monitor: s32) -> s32

GetMonitorName :: (monitor: s32) -> *u8

GetMonitorPhysicalHeight :: (monitor: s32) -> s32

GetMonitorPhysicalWidth :: (monitor: s32) -> s32

GetMonitorPosition :: (monitor: s32) -> Vector2

GetMonitorRefreshRate :: (monitor: s32) -> s32

GetMonitorWidth :: (monitor: s32) -> s32

GetMouseDelta :: () -> Vector2

GetMousePosition :: () -> Vector2

GetMouseWheelMove :: () -> float

GetMouseWheelMoveV :: () -> Vector2

GetMouseX :: () -> s32

GetMouseY :: () -> s32

GetMusicTimeLength :: (music: Music) -> float

GetMusicTimePlayed :: (music: Music) -> float

GetPixelColor :: (srcPtr: *void, format: PixelFormat) -> Color

GetPixelDataSize :: (width: s32, height: s32, format: PixelFormat) -> s32

GetPrevDirectoryPath :: (dirPath: *u8) -> *u8

GetRandomValue :: (min: s32, max: s32) -> s32

GetRayCollisionBox :: (ray: Ray, box: BoundingBox) -> RayCollision

GetRayCollisionMesh :: (ray: Ray, mesh: Mesh, transform: Matrix) -> RayCollision

GetRayCollisionQuad :: (ray: Ray, p1: Vector3, p2: Vector3, p3: Vector3, p4: Vector3) -> RayCollision

GetRayCollisionSphere :: (ray: Ray, center: Vector3, radius: float) -> RayCollision

GetRayCollisionTriangle :: (ray: Ray, p1: Vector3, p2: Vector3, p3: Vector3) -> RayCollision

GetRenderHeight :: () -> s32

GetRenderWidth :: () -> s32

GetScreenHeight :: () -> s32

GetScreenToWorld2D :: (position: Vector2, camera: Camera2D) -> Vector2

GetScreenToWorldRay :: (position: Vector2, camera: Camera) -> Ray

GetScreenToWorldRayEx :: (position: Vector2, camera: Camera, width: s32, height: s32) -> Ray

GetScreenWidth :: () -> s32

GetShaderLocation :: (shader: Shader, uniformName: *u8) -> s32

GetShaderLocationAttrib :: (shader: Shader, attribName: *u8) -> s32

GetShapesTexture :: () -> Texture2D

GetShapesTextureRectangle :: () -> Rectangle

GetSplinePointBasis :: (p1: Vector2, p2: Vector2, p3: Vector2, p4: Vector2, t: float) -> Vector2

GetSplinePointBezierCubic :: (p1: Vector2, c2: Vector2, c3: Vector2, p4: Vector2, t: float) -> Vector2

GetSplinePointBezierQuad :: (p1: Vector2, c2: Vector2, p3: Vector2, t: float) -> Vector2

GetSplinePointCatmullRom :: (p1: Vector2, p2: Vector2, p3: Vector2, p4: Vector2, t: float) -> Vector2

GetSplinePointLinear :: (startPos: Vector2, endPos: Vector2, t: float) -> Vector2

GetTime :: () -> float64

GetTouchPointCount :: () -> s32

GetTouchPointId :: (index: s32) -> s32

GetTouchPosition :: (index: s32) -> Vector2

GetTouchX :: () -> s32

GetTouchY :: () -> s32

GetWindowHandle :: () -> *void

GetWindowPosition :: () -> Vector2

GetWindowScaleDPI :: () -> Vector2

GetWorkingDirectory :: () -> *u8

GetWorldToScreen :: (position: Vector3, camera: Camera) -> Vector2

GetWorldToScreen2D :: (position: Vector2, camera: Camera2D) -> Vector2

GetWorldToScreenEx :: (position: Vector3, camera: Camera, width: s32, height: s32) -> Vector2

HideCursor :: ()

ImageAlphaClear :: (image: *Image, color: Color, threshold: float)

ImageAlphaCrop :: (image: *Image, threshold: float)

ImageAlphaMask :: (image: *Image, alphaMask: Image)

ImageAlphaPremultiply :: (image: *Image)

ImageBlurGaussian :: (image: *Image, blurSize: s32)

ImageClearBackground :: (dst: *Image, color: Color)

ImageColorBrightness :: (image: *Image, brightness: s32)

ImageColorContrast :: (image: *Image, contrast: float)

ImageColorGrayscale :: (image: *Image)

ImageColorInvert :: (image: *Image)

ImageColorReplace :: (image: *Image, color: Color, replace: Color)

ImageColorTint :: (image: *Image, color: Color)

ImageCopy :: (image: Image) -> Image

ImageCrop :: (image: *Image, crop: Rectangle)

ImageDither :: (image: *Image, rBpp: s32, gBpp: s32, bBpp: s32, aBpp: s32)

ImageDraw :: (dst: *Image, src: Image, srcRec: Rectangle, dstRec: Rectangle, tint: Color)

ImageDrawCircle :: (dst: *Image, centerX: s32, centerY: s32, radius: s32, color: Color)

ImageDrawCircleLines :: (dst: *Image, centerX: s32, centerY: s32, radius: s32, color: Color)

ImageDrawCircleLinesV :: (dst: *Image, center: Vector2, radius: s32, color: Color)

ImageDrawCircleV :: (dst: *Image, center: Vector2, radius: s32, color: Color)

ImageDrawLine :: (dst: *Image, startPosX: s32, startPosY: s32, endPosX: s32, endPosY: s32, color: Color)

ImageDrawLineEx :: (dst: *Image, start: Vector2, end: Vector2, thick: s32, color: Color)

ImageDrawLineV :: (dst: *Image, start: Vector2, end: Vector2, color: Color)

ImageDrawPixel :: (dst: *Image, posX: s32, posY: s32, color: Color)

ImageDrawPixelV :: (dst: *Image, position: Vector2, color: Color)

ImageDrawRectangle :: (dst: *Image, posX: s32, posY: s32, width: s32, height: s32, color: Color)

ImageDrawRectangleLines :: (dst: *Image, rec: Rectangle, thick: s32, color: Color)

ImageDrawRectangleRec :: (dst: *Image, rec: Rectangle, color: Color)

ImageDrawRectangleV :: (dst: *Image, position: Vector2, size: Vector2, color: Color)

ImageDrawText :: (dst: *Image, text: *u8, posX: s32, posY: s32, fontSize: s32, color: Color)

ImageDrawTextEx :: (dst: *Image, font: Font, text: *u8, position: Vector2, fontSize: float, spacing: float, tint: Color)

ImageDrawTriangle :: (dst: *Image, v1: Vector2, v2: Vector2, v3: Vector2, color: Color)

ImageDrawTriangleEx :: (dst: *Image, v1: Vector2, v2: Vector2, v3: Vector2, c1: Color, c2: Color, c3: Color)

ImageDrawTriangleFan :: (dst: *Image, points: *Vector2, pointCount: s32, color: Color)

ImageDrawTriangleLines :: (dst: *Image, v1: Vector2, v2: Vector2, v3: Vector2, color: Color)

ImageDrawTriangleStrip :: (dst: *Image, points: *Vector2, pointCount: s32, color: Color)

ImageFlipHorizontal :: (image: *Image)

ImageFlipVertical :: (image: *Image)

ImageFormat :: (image: *Image, newFormat: PixelFormat)

ImageFromChannel :: (image: Image, selectedChannel: s32) -> Image

ImageFromImage :: (image: Image, rec: Rectangle) -> Image

ImageKernelConvolution :: (image: *Image, kernel: *float, kernelSize: s32)

ImageMipmaps :: (image: *Image)

ImageResize :: (image: *Image, newWidth: s32, newHeight: s32)

ImageResizeCanvas :: (image: *Image, newWidth: s32, newHeight: s32, offsetX: s32, offsetY: s32, fill: Color)

ImageResizeNN :: (image: *Image, newWidth: s32, newHeight: s32)

ImageRotate :: (image: *Image, degrees: s32)

ImageRotateCCW :: (image: *Image)

ImageRotateCW :: (image: *Image)

ImageText :: (text: *u8, fontSize: s32, color: Color) -> Image

ImageTextEx :: (font: Font, text: *u8, fontSize: float, spacing: float, tint: Color) -> Image

ImageToPOT :: (image: *Image, fill: Color)

InitAudioDevice :: ()

InitWindow :: (width: s32, height: s32, title: *u8)

IsAudioDeviceReady :: () -> bool

IsAudioStreamPlaying :: (stream: AudioStream) -> bool

IsAudioStreamProcessed :: (stream: AudioStream) -> bool

IsAudioStreamValid :: (stream: AudioStream) -> bool

IsCursorHidden :: () -> bool

IsCursorOnScreen :: () -> bool

IsFileDropped :: () -> bool

IsFileExtension :: (fileName: *u8, ext: *u8) -> bool

IsFileNameValid :: (fileName: *u8) -> bool

IsFontValid :: (font: Font) -> bool

IsGamepadAvailable :: (gamepad: s32) -> bool

IsGamepadButtonDown :: (gamepad: s32, button: GamepadButton) -> bool

IsGamepadButtonPressed :: (gamepad: s32, button: GamepadButton) -> bool

IsGamepadButtonReleased :: (gamepad: s32, button: GamepadButton) -> bool

IsGamepadButtonUp :: (gamepad: s32, button: GamepadButton) -> bool

IsGestureDetected :: (gesture: Gesture) -> bool

IsImageValid :: (image: Image) -> bool

IsKeyDown :: (key: KeyboardKey) -> bool

IsKeyPressed :: (key: KeyboardKey) -> bool

IsKeyPressedRepeat :: (key: KeyboardKey) -> bool

IsKeyReleased :: (key: KeyboardKey) -> bool

IsKeyUp :: (key: KeyboardKey) -> bool

IsMaterialValid :: (material: Material) -> bool

IsModelAnimationValid :: (model: Model, anim: ModelAnimation) -> bool

IsModelValid :: (model: Model) -> bool

IsMouseButtonDown :: (button: MouseButton) -> bool

IsMouseButtonPressed :: (button: MouseButton) -> bool

IsMouseButtonReleased :: (button: MouseButton) -> bool

IsMouseButtonUp :: (button: MouseButton) -> bool

IsMusicStreamPlaying :: (music: Music) -> bool

IsMusicValid :: (music: Music) -> bool

IsPathFile :: (path: *u8) -> bool

IsRenderTextureValid :: (target: RenderTexture2D) -> bool

IsShaderValid :: (shader: Shader) -> bool

IsSoundPlaying :: (sound: Sound) -> bool

IsSoundValid :: (sound: Sound) -> bool

IsTextureValid :: (texture: Texture2D) -> bool

IsWaveValid :: (wave: Wave) -> bool

IsWindowFocused :: () -> bool

IsWindowFullscreen :: () -> bool

IsWindowHidden :: () -> bool

IsWindowMaximized :: () -> bool

IsWindowMinimized :: () -> bool

IsWindowReady :: () -> bool

IsWindowResized :: () -> bool

IsWindowState :: (flag: u32) -> bool

Lerp :: (start: float, end: float, amount: float) -> float

LoadAudioStream :: (sampleRate: u32, sampleSize: u32, channels: u32) -> AudioStream

LoadAutomationEventList :: (fileName: *u8) -> AutomationEventList

LoadCodepoints :: (text: *u8, count: *s32) -> *s32

LoadDirectoryFiles :: (dirPath: *u8) -> FilePathList

LoadDirectoryFilesEx :: (basePath: *u8, filter: *u8, scanSubdirs: bool) -> FilePathList

LoadDroppedFiles :: () -> FilePathList

LoadFileData :: (fileName: *u8, dataSize: *s32) -> *u8

LoadFileText :: (fileName: *u8) -> *u8

LoadFont :: (fileName: *u8) -> Font

LoadFontData :: (fileData: *u8, dataSize: s32, fontSize: s32, codepoints: *s32, codepointCount: s32, type: s32) -> *GlyphInfo

LoadFontEx :: (fileName: *u8, fontSize: s32, codepoints: *s32, codepointCount: s32) -> Font

LoadFontFromImage :: (image: Image, key: Color, firstChar: s32) -> Font

LoadFontFromMemory :: (fileType: *u8, fileData: *u8, dataSize: s32, fontSize: s32, codepoints: *s32, codepointCount: s32) -> Font

LoadImage :: (fileName: *u8) -> Image

LoadImageAnim :: (fileName: *u8, frames: *s32) -> Image

LoadImageAnimFromMemory :: (fileType: *u8, fileData: *u8, dataSize: s32, frames: *s32) -> Image

LoadImageColors :: (image: Image) -> *Color

LoadImageFromMemory :: (fileType: *u8, fileData: *u8, dataSize: s32) -> Image

LoadImageFromScreen :: () -> Image

LoadImageFromTexture :: (texture: Texture2D) -> Image

LoadImagePalette :: (image: Image, maxPaletteSize: s32, colorCount: *s32) -> *Color

LoadImageRaw :: (fileName: *u8, width: s32, height: s32, format: PixelFormat, headerSize: s32) -> Image

LoadMaterialDefault :: () -> Material

LoadMaterials :: (fileName: *u8, materialCount: *s32) -> *Material

LoadModel :: (fileName: *u8) -> Model

LoadModelAnimations :: (fileName: *u8, animCount: *s32) -> *ModelAnimation

LoadModelFromMesh :: (mesh: Mesh) -> Model

LoadMusicStream :: (fileName: *u8) -> Music

LoadMusicStreamFromMemory :: (fileType: *u8, data: *u8, dataSize: s32) -> Music

LoadRandomSequence :: (count: u32, min: s32, max: s32) -> *s32

LoadRenderTexture :: (width: s32, height: s32) -> RenderTexture2D

LoadShader :: (vsFileName: *u8, fsFileName: *u8) -> Shader

LoadShaderFromMemory :: (vsCode: *u8, fsCode: *u8) -> Shader

LoadSound :: (fileName: *u8) -> Sound

LoadSoundAlias :: (source: Sound) -> Sound

LoadSoundFromWave :: (wave: Wave) -> Sound

LoadTexture :: (fileName: *u8) -> Texture2D

LoadTextureCubemap :: (image: Image, layout: CubemapLayout) -> TextureCubemap

LoadTextureFromImage :: (image: Image) -> Texture2D

LoadUTF8 :: (codepoints: *s32, length: s32) -> *u8

LoadVrStereoConfig :: (device: VrDeviceInfo) -> VrStereoConfig

LoadWave :: (fileName: *u8) -> Wave

LoadWaveFromMemory :: (fileType: *u8, fileData: *u8, dataSize: s32) -> Wave

LoadWaveSamples :: (wave: Wave) -> *float

MakeDirectory :: (dirPath: *u8) -> s32

MatrixAdd :: (left: Matrix, right: Matrix) -> Matrix

MatrixDecompose :: (mat: Matrix, translation: *Vector3, rotation: *Quaternion, scale: *Vector3)

MatrixDeterminant :: (mat: Matrix) -> float

MatrixFrustum :: (left: float64, right: float64, bottom: float64, top: float64, nearPlane: float64, farPlane: float64) -> Matrix

MatrixIdentity :: () -> Matrix

MatrixInvert :: (mat: Matrix) -> Matrix

MatrixLookAt :: (eye: Vector3, target: Vector3, up: Vector3) -> Matrix

MatrixMultiply :: (left: Matrix, right: Matrix) -> Matrix

MatrixOrtho :: (left: float64, right: float64, bottom: float64, top: float64, nearPlane: float64, farPlane: float64) -> Matrix

MatrixPerspective :: (fovY: float64, aspect: float64, nearPlane: float64, farPlane: float64) -> Matrix

MatrixRotate :: (axis: Vector3, angle: float) -> Matrix

MatrixRotateX :: (angle: float) -> Matrix

MatrixRotateXYZ :: (angle: Vector3) -> Matrix

MatrixRotateY :: (angle: float) -> Matrix

MatrixRotateZ :: (angle: float) -> Matrix

MatrixRotateZYX :: (angle: Vector3) -> Matrix

MatrixScale :: (x: float, y: float, z: float) -> Matrix

MatrixSubtract :: (left: Matrix, right: Matrix) -> Matrix

MatrixToFloatV :: (mat: Matrix) -> float16

MatrixTrace :: (mat: Matrix) -> float

MatrixTranslate :: (x: float, y: float, z: float) -> Matrix

MatrixTranspose :: (mat: Matrix) -> Matrix

MaximizeWindow :: ()

MeasureText :: (text: *u8, fontSize: s32) -> s32

MeasureTextEx :: (font: Font, text: *u8, fontSize: float, spacing: float) -> Vector2

MemAlloc :: (size: u32) -> *void

MemFree :: (ptr: *void)

MemRealloc :: (ptr: *void, size: u32) -> *void

MinimizeWindow :: ()

Normalize :: (value: float, start: float, end: float) -> float

OpenURL :: (url: *u8)

PauseAudioStream :: (stream: AudioStream)

PauseMusicStream :: (music: Music)

PauseSound :: (sound: Sound)

PlayAudioStream :: (stream: AudioStream)

PlayAutomationEvent :: (event: AutomationEvent)

PlayMusicStream :: (music: Music)

PlaySound :: (sound: Sound)

PollInputEvents :: ()

QuaternionAdd :: (q1: Quaternion, q2: Quaternion) -> Quaternion

QuaternionAddValue :: (q: Quaternion, add: float) -> Quaternion

QuaternionCubicHermiteSpline :: (q1: Quaternion, outTangent1: Quaternion, q2: Quaternion, inTangent2: Quaternion, t: float) -> Quaternion

QuaternionDivide :: (q1: Quaternion, q2: Quaternion) -> Quaternion

QuaternionEquals :: (p: Quaternion, q: Quaternion) -> s32

QuaternionFromAxisAngle :: (axis: Vector3, angle: float) -> Quaternion

QuaternionFromEuler :: (pitch: float, yaw: float, roll: float) -> Quaternion

QuaternionFromMatrix :: (mat: Matrix) -> Quaternion

QuaternionFromVector3ToVector3 :: (from: Vector3, to: Vector3) -> Quaternion

QuaternionIdentity :: () -> Quaternion

QuaternionInvert :: (q: Quaternion) -> Quaternion

QuaternionLength :: (q: Quaternion) -> float

QuaternionLerp :: (q1: Quaternion, q2: Quaternion, amount: float) -> Quaternion

QuaternionMultiply :: (q1: Quaternion, q2: Quaternion) -> Quaternion

QuaternionNlerp :: (q1: Quaternion, q2: Quaternion, amount: float) -> Quaternion

QuaternionNormalize :: (q: Quaternion) -> Quaternion

QuaternionScale :: (q: Quaternion, mul: float) -> Quaternion

QuaternionSlerp :: (q1: Quaternion, q2: Quaternion, amount: float) -> Quaternion

QuaternionSubtract :: (q1: Quaternion, q2: Quaternion) -> Quaternion

QuaternionSubtractValue :: (q: Quaternion, sub: float) -> Quaternion

QuaternionToAxisAngle :: (q: Quaternion, outAxis: *Vector3, outAngle: *float)

QuaternionToEuler :: (q: Quaternion) -> Vector3

QuaternionToMatrix :: (q: Quaternion) -> Matrix

QuaternionTransform :: (q: Quaternion, mat: Matrix) -> Quaternion

Remap :: (value: float, inputStart: float, inputEnd: float, outputStart: float, outputEnd: float) -> float

RestoreWindow :: ()

ResumeAudioStream :: (stream: AudioStream)

ResumeMusicStream :: (music: Music)

ResumeSound :: (sound: Sound)

SaveFileData :: (fileName: *u8, data: *void, dataSize: s32) -> bool

SaveFileText :: (fileName: *u8, text: *u8) -> bool

SeekMusicStream :: (music: Music, position: float)

SetAudioStreamBufferSizeDefault :: (size: s32)

SetAudioStreamCallback :: (stream: AudioStream, callback: AudioCallback)

SetAudioStreamPan :: (stream: AudioStream, pan: float)

SetAudioStreamPitch :: (stream: AudioStream, pitch: float)

SetAudioStreamVolume :: (stream: AudioStream, volume: float)

SetAutomationEventBaseFrame :: (frame: s32)

SetAutomationEventList :: (list: *AutomationEventList)

SetClipboardText :: (text: *u8)

SetConfigFlags :: (flags: ConfigFlags)

SetExitKey :: (key: KeyboardKey)

SetGamepadMappings :: (mappings: *u8) -> s32

SetGamepadVibration :: (gamepad: s32, leftMotor: float, rightMotor: float, duration: float)

SetGesturesEnabled :: (flags: Gesture)

SetLoadFileDataCallback :: (callback: LoadFileDataCallback)

SetLoadFileTextCallback :: (callback: LoadFileTextCallback)

SetMasterVolume :: (volume: float)

SetMaterialTexture :: (material: *Material, mapType: MaterialMapIndex, texture: Texture2D)

SetModelMeshMaterial :: (model: *Model, meshId: s32, materialId: s32)

SetMouseCursor :: (cursor: s32)

SetMouseOffset :: (offsetX: s32, offsetY: s32)

SetMousePosition :: (x: s32, y: s32)

SetMouseScale :: (scaleX: float, scaleY: float)

SetMusicPan :: (music: Music, pan: float)

SetMusicPitch :: (music: Music, pitch: float)

SetMusicVolume :: (music: Music, volume: float)

SetPixelColor :: (dstPtr: *void, color: Color, format: PixelFormat)

SetRandomSeed :: (seed: u32)

SetSaveFileDataCallback :: (callback: SaveFileDataCallback)

SetSaveFileTextCallback :: (callback: SaveFileTextCallback)

SetShaderValue :: (shader: Shader, locIndex: s32, value: *void, uniformType: s32)

SetShaderValueMatrix :: (shader: Shader, locIndex: s32, mat: Matrix)

SetShaderValueTexture :: (shader: Shader, locIndex: s32, texture: Texture2D)

SetShaderValueV :: (shader: Shader, locIndex: s32, value: *void, uniformType: s32, count: s32)

SetShapesTexture :: (texture: Texture2D, source: Rectangle)

SetSoundPan :: (sound: Sound, pan: float)

SetSoundPitch :: (sound: Sound, pitch: float)

SetSoundVolume :: (sound: Sound, volume: float)

SetTargetFPS :: (fps: s32)

SetTextLineSpacing :: (spacing: s32)

SetTextureFilter :: (texture: Texture2D, filter: TextureFilter)

SetTextureWrap :: (texture: Texture2D, wrap: TextureWrap)

SetTraceLogCallback :: (callback: TraceLogCallback)

SetTraceLogLevel :: (logLevel: s32)

SetWindowFocused :: ()

SetWindowIcon :: (image: Image)

SetWindowIcons :: (images: *Image, count: s32)

SetWindowMaxSize :: (width: s32, height: s32)

SetWindowMinSize :: (width: s32, height: s32)

SetWindowMonitor :: (monitor: s32)

SetWindowOpacity :: (opacity: float)

SetWindowPosition :: (x: s32, y: s32)

SetWindowSize :: (width: s32, height: s32)

SetWindowState :: (flags: ConfigFlags)

SetWindowTitle :: (title: *u8)

ShowCursor :: ()

StartAutomationEventRecording :: ()

StopAudioStream :: (stream: AudioStream)

StopAutomationEventRecording :: ()

StopMusicStream :: (music: Music)

StopSound :: (sound: Sound)

SwapScreenBuffer :: ()

TakeScreenshot :: (fileName: *u8)

TextAppend :: (text: *u8, append: *u8, position: *s32)

TextCopy :: (dst: *u8, src: *u8) -> s32

TextFindIndex :: (text: *u8, find: *u8) -> s32

TextFormat :: (text: string, __args: ..Any) -> *u8

TextFormat_CFormat :: (text: *u8, __args: ..Any) -> *u8

TextInsert :: (text: *u8, insert: *u8, position: s32) -> *u8

TextIsEqual :: (text1: *u8, text2: *u8) -> bool

TextJoin :: (textList: **u8, count: s32, delimiter: *u8) -> *u8

TextLength :: (text: *u8) -> u32

TextReplace :: (text: *u8, replace: *u8, by: *u8) -> *u8

TextSplit :: (text: *u8, delimiter: u8, count: *s32) -> **u8

TextSubtext :: (text: *u8, position: s32, length: s32) -> *u8

TextToCamel :: (text: *u8) -> *u8

TextToFloat :: (text: *u8) -> float

TextToInteger :: (text: *u8) -> s32

TextToLower :: (text: *u8) -> *u8

TextToPascal :: (text: *u8) -> *u8

TextToSnake :: (text: *u8) -> *u8

TextToUpper :: (text: *u8) -> *u8

ToggleBorderlessWindowed :: ()

ToggleFullscreen :: ()

TraceLog :: (logLevel: s32, text: string, __args: ..Any)

TraceLog_CFormat :: (logLevel: s32, text: *u8, __args: ..Any)

UnloadAudioStream :: (stream: AudioStream)

UnloadAutomationEventList :: (list: AutomationEventList)

UnloadCodepoints :: (codepoints: *s32)

UnloadDirectoryFiles :: (files: FilePathList)

UnloadDroppedFiles :: (files: FilePathList)

UnloadFileData :: (data: *u8)

UnloadFileText :: (text: *u8)

UnloadFont :: (font: Font)

UnloadFontData :: (glyphs: *GlyphInfo, glyphCount: s32)

UnloadImage :: (image: Image)

UnloadImageColors :: (colors: *Color)

UnloadImagePalette :: (colors: *Color)

UnloadMaterial :: (material: Material)

UnloadMesh :: (mesh: Mesh)

UnloadModel :: (model: Model)

UnloadModelAnimation :: (anim: ModelAnimation)

UnloadModelAnimations :: (animations: *ModelAnimation, animCount: s32)

UnloadMusicStream :: (music: Music)

UnloadRandomSequence :: (sequence: *s32)

UnloadRenderTexture :: (target: RenderTexture2D)

UnloadShader :: (shader: Shader)

UnloadSound :: (sound: Sound)

UnloadSoundAlias :: (alias: Sound)

UnloadTexture :: (texture: Texture2D)

UnloadUTF8 :: (text: *u8)

UnloadVrStereoConfig :: (config: VrStereoConfig)

UnloadWave :: (wave: Wave)

UnloadWaveSamples :: (samples: *float)

UpdateAudioStream :: (stream: AudioStream, data: *void, frameCount: s32)

UpdateCamera :: (camera: *Camera, mode: CameraMode)

UpdateCameraPro :: (camera: *Camera, movement: Vector3, rotation: Vector3, zoom: float)

UpdateMeshBuffer :: (mesh: Mesh, index: s32, data: *void, dataSize: s32, offset: s32)

UpdateModelAnimation :: (model: Model, anim: ModelAnimation, frame: s32)

UpdateModelAnimationBones :: (model: Model, anim: ModelAnimation, frame: s32)

UpdateMusicStream :: (music: Music)

UpdateSound :: (sound: Sound, data: *void, sampleCount: s32)

UpdateTexture :: (texture: Texture2D, pixels: *void)

UpdateTextureRec :: (texture: Texture2D, rec: Rectangle, pixels: *void)

UploadMesh :: (mesh: *Mesh, dynamic: bool)

Vector2Add :: (v1: Vector2, v2: Vector2) -> Vector2

Vector2AddValue :: (v: Vector2, add: float) -> Vector2

Vector2Angle :: (v1: Vector2, v2: Vector2) -> float

Vector2Clamp :: (v: Vector2, min: Vector2, max: Vector2) -> Vector2

Vector2ClampValue :: (v: Vector2, min: float, max: float) -> Vector2

Vector2Distance :: (v1: Vector2, v2: Vector2) -> float

Vector2DistanceSqr :: (v1: Vector2, v2: Vector2) -> float

Vector2Divide :: (v1: Vector2, v2: Vector2) -> Vector2

Vector2DotProduct :: (v1: Vector2, v2: Vector2) -> float

Vector2Equals :: (p: Vector2, q: Vector2) -> s32

Vector2Invert :: (v: Vector2) -> Vector2

Vector2Length :: (v: Vector2) -> float

Vector2LengthSqr :: (v: Vector2) -> float

Vector2Lerp :: (v1: Vector2, v2: Vector2, amount: float) -> Vector2

Vector2LineAngle :: (start: Vector2, end: Vector2) -> float

Vector2Max :: (v1: Vector2, v2: Vector2) -> Vector2

Vector2Min :: (v1: Vector2, v2: Vector2) -> Vector2

Vector2MoveTowards :: (v: Vector2, target: Vector2, maxDistance: float) -> Vector2

Vector2Multiply :: (v1: Vector2, v2: Vector2) -> Vector2

Vector2Negate :: (v: Vector2) -> Vector2

Vector2Normalize :: (v: Vector2) -> Vector2

Vector2One :: () -> Vector2

Vector2Reflect :: (v: Vector2, normal: Vector2) -> Vector2

Vector2Refract :: (v: Vector2, n: Vector2, r: float) -> Vector2

Vector2Rotate :: (v: Vector2, angle: float) -> Vector2

Vector2Scale :: (v: Vector2, scale: float) -> Vector2

Vector2Subtract :: (v1: Vector2, v2: Vector2) -> Vector2

Vector2SubtractValue :: (v: Vector2, sub: float) -> Vector2

Vector2Transform :: (v: Vector2, mat: Matrix) -> Vector2

Vector2Zero :: () -> Vector2

Vector3Add :: (v1: Vector3, v2: Vector3) -> Vector3

Vector3AddValue :: (v: Vector3, add: float) -> Vector3

Vector3Angle :: (v1: Vector3, v2: Vector3) -> float

Vector3Barycenter :: (p: Vector3, a: Vector3, b: Vector3, c: Vector3) -> Vector3

Vector3Clamp :: (v: Vector3, min: Vector3, max: Vector3) -> Vector3

Vector3ClampValue :: (v: Vector3, min: float, max: float) -> Vector3

Vector3CrossProduct :: (v1: Vector3, v2: Vector3) -> Vector3

Vector3CubicHermite :: (v1: Vector3, tangent1: Vector3, v2: Vector3, tangent2: Vector3, amount: float) -> Vector3

Vector3Distance :: (v1: Vector3, v2: Vector3) -> float

Vector3DistanceSqr :: (v1: Vector3, v2: Vector3) -> float

Vector3Divide :: (v1: Vector3, v2: Vector3) -> Vector3

Vector3DotProduct :: (v1: Vector3, v2: Vector3) -> float

Vector3Equals :: (p: Vector3, q: Vector3) -> s32

Vector3Invert :: (v: Vector3) -> Vector3

Vector3Length :: (v: Vector3) -> float

Vector3LengthSqr :: (v: Vector3) -> float

Vector3Lerp :: (v1: Vector3, v2: Vector3, amount: float) -> Vector3

Vector3Max :: (v1: Vector3, v2: Vector3) -> Vector3

Vector3Min :: (v1: Vector3, v2: Vector3) -> Vector3

Vector3MoveTowards :: (v: Vector3, target: Vector3, maxDistance: float) -> Vector3

Vector3Multiply :: (v1: Vector3, v2: Vector3) -> Vector3

Vector3Negate :: (v: Vector3) -> Vector3

Vector3Normalize :: (v: Vector3) -> Vector3

Vector3One :: () -> Vector3

Vector3OrthoNormalize :: (v1: *Vector3, v2: *Vector3)

Vector3Perpendicular :: (v: Vector3) -> Vector3

Vector3Project :: (v1: Vector3, v2: Vector3) -> Vector3

Vector3Reflect :: (v: Vector3, normal: Vector3) -> Vector3

Vector3Refract :: (v: Vector3, n: Vector3, r: float) -> Vector3

Vector3Reject :: (v1: Vector3, v2: Vector3) -> Vector3

Vector3RotateByAxisAngle :: (v: Vector3, axis: Vector3, angle: float) -> Vector3

Vector3RotateByQuaternion :: (v: Vector3, q: Quaternion) -> Vector3

Vector3Scale :: (v: Vector3, scalar: float) -> Vector3

Vector3Subtract :: (v1: Vector3, v2: Vector3) -> Vector3

Vector3SubtractValue :: (v: Vector3, sub: float) -> Vector3

Vector3ToFloatV :: (v: Vector3) -> float3

Vector3Transform :: (v: Vector3, mat: Matrix) -> Vector3

Vector3Unproject :: (source: Vector3, projection: Matrix, view: Matrix) -> Vector3

Vector3Zero :: () -> Vector3

Vector4Add :: (v1: Vector4, v2: Vector4) -> Vector4

Vector4AddValue :: (v: Vector4, add: float) -> Vector4

Vector4Distance :: (v1: Vector4, v2: Vector4) -> float

Vector4DistanceSqr :: (v1: Vector4, v2: Vector4) -> float

Vector4Divide :: (v1: Vector4, v2: Vector4) -> Vector4

Vector4DotProduct :: (v1: Vector4, v2: Vector4) -> float

Vector4Equals :: (p: Vector4, q: Vector4) -> s32

Vector4Invert :: (v: Vector4) -> Vector4

Vector4Length :: (v: Vector4) -> float

Vector4LengthSqr :: (v: Vector4) -> float

Vector4Lerp :: (v1: Vector4, v2: Vector4, amount: float) -> Vector4

Vector4Max :: (v1: Vector4, v2: Vector4) -> Vector4

Vector4Min :: (v1: Vector4, v2: Vector4) -> Vector4

Vector4MoveTowards :: (v: Vector4, target: Vector4, maxDistance: float) -> Vector4

Vector4Multiply :: (v1: Vector4, v2: Vector4) -> Vector4

Vector4Negate :: (v: Vector4) -> Vector4

Vector4Normalize :: (v: Vector4) -> Vector4

Vector4One :: () -> Vector4

Vector4Scale :: (v: Vector4, scale: float) -> Vector4

Vector4Subtract :: (v1: Vector4, v2: Vector4) -> Vector4

Vector4SubtractValue :: (v: Vector4, add: float) -> Vector4

Vector4Zero :: () -> Vector4

WaitTime :: (seconds: float64)

WaveCopy :: (wave: Wave) -> Wave

WaveCrop :: (wave: *Wave, initFrame: s32, finalFrame: s32)

WaveFormat :: (wave: *Wave, sampleRate: s32, sampleSize: s32, channels: s32)

WindowShouldClose :: () -> bool

Wrap :: (value: float, min: float, max: float) -> float

AudioCallback :: #type (bufferData: *void, frames: u32) -> void #c_call;

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

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

AutomationEvent :: struct {
    frame:  u32; // Event frame
    type:   u32; // Event type (AutomationEventType)
    params: [4] s32; // Event parameters (if required)
}

AutomationEventList :: struct {
    capacity: u32; // Events max entries (MAX_AUTOMATION_EVENTS)
    count:    u32; // Events entries count
    events:   *AutomationEvent; // Events entries
}

BlendMode :: enum u32 {
    ALPHA             :: 0;
    ADDITIVE          :: 1;
    MULTIPLIED        :: 2;
    ADD_COLORS        :: 3;
    SUBTRACT_COLORS   :: 4;
    ALPHA_PREMULTIPLY :: 5;
    CUSTOM            :: 6;
    CUSTOM_SEPARATE   :: 7;

    BLEND_ALPHA             :: ALPHA;
    BLEND_ADDITIVE          :: ADDITIVE;
    BLEND_MULTIPLIED        :: MULTIPLIED;
    BLEND_ADD_COLORS        :: ADD_COLORS;
    BLEND_SUBTRACT_COLORS   :: SUBTRACT_COLORS;
    BLEND_ALPHA_PREMULTIPLY :: ALPHA_PREMULTIPLY;
    BLEND_CUSTOM            :: CUSTOM;
    BLEND_CUSTOM_SEPARATE   :: CUSTOM_SEPARATE;
}

BoneInfo :: struct {
    name:   [32] u8; // Bone name
    parent: s32; // Bone parent
}

BoundingBox :: struct {
    min: Vector3; // Minimum vertex box-corner
    max: Vector3; // Maximum vertex box-corner
}

Camera2D :: struct {
    offset:   Vector2; // Camera offset (displacement from target)
    target:   Vector2; // Camera target (rotation and zoom origin)
    rotation: float; // Camera rotation in degrees
    zoom:     float; // Camera zoom (scaling), should be 1.0f by default
}

Camera3D :: struct {
    position:   Vector3; // Camera position
    target:     Vector3; // Camera target it looks-at
    up:         Vector3; // Camera up vector (rotation over its axis)
    fovy:       float; // Camera field-of-view aperture in Y (degrees) in perspective, used as near plane width in orthographic
    projection: s32; // Camera projection: CAMERA_PERSPECTIVE or CAMERA_ORTHOGRAPHIC
}

CameraMode :: enum u32 {
    CUSTOM       :: 0;
    FREE         :: 1;
    ORBITAL      :: 2;
    FIRST_PERSON :: 3;
    THIRD_PERSON :: 4;

    CAMERA_CUSTOM       :: CUSTOM;
    CAMERA_FREE         :: FREE;
    CAMERA_ORBITAL      :: ORBITAL;
    CAMERA_FIRST_PERSON :: FIRST_PERSON;
    CAMERA_THIRD_PERSON :: THIRD_PERSON;
}

CameraProjection :: enum u32 {
    PERSPECTIVE  :: 0;
    ORTHOGRAPHIC :: 1;

    CAMERA_PERSPECTIVE  :: PERSPECTIVE;
    CAMERA_ORTHOGRAPHIC :: ORTHOGRAPHIC;
}

Color :: struct {
    r: u8; // Color red value
    g: u8; // Color green value
    b: u8; // Color blue value
    a: u8; // Color alpha value
}

ConfigFlags :: enum u32 {
    VSYNC_HINT               :: 64;
    FULLSCREEN_MODE          :: 2;
    WINDOW_RESIZABLE         :: 4;
    WINDOW_UNDECORATED       :: 8;
    WINDOW_HIDDEN            :: 128;
    WINDOW_MINIMIZED         :: 512;
    WINDOW_MAXIMIZED         :: 1024;
    WINDOW_UNFOCUSED         :: 2048;
    WINDOW_TOPMOST           :: 4096;
    WINDOW_ALWAYS_RUN        :: 256;
    WINDOW_TRANSPARENT       :: 16;
    WINDOW_HIGHDPI           :: 8192;
    WINDOW_MOUSE_PASSTHROUGH :: 16384;
    BORDERLESS_WINDOWED_MODE :: 32768;
    MSAA_4X_HINT             :: 32;
    INTERLACED_HINT          :: 65536;

    FLAG_VSYNC_HINT               :: VSYNC_HINT;
    FLAG_FULLSCREEN_MODE          :: FULLSCREEN_MODE;
    FLAG_WINDOW_RESIZABLE         :: WINDOW_RESIZABLE;
    FLAG_WINDOW_UNDECORATED       :: WINDOW_UNDECORATED;
    FLAG_WINDOW_HIDDEN            :: WINDOW_HIDDEN;
    FLAG_WINDOW_MINIMIZED         :: WINDOW_MINIMIZED;
    FLAG_WINDOW_MAXIMIZED         :: WINDOW_MAXIMIZED;
    FLAG_WINDOW_UNFOCUSED         :: WINDOW_UNFOCUSED;
    FLAG_WINDOW_TOPMOST           :: WINDOW_TOPMOST;
    FLAG_WINDOW_ALWAYS_RUN        :: WINDOW_ALWAYS_RUN;
    FLAG_WINDOW_TRANSPARENT       :: WINDOW_TRANSPARENT;
    FLAG_WINDOW_HIGHDPI           :: WINDOW_HIGHDPI;
    FLAG_WINDOW_MOUSE_PASSTHROUGH :: WINDOW_MOUSE_PASSTHROUGH;
    FLAG_BORDERLESS_WINDOWED_MODE :: BORDERLESS_WINDOWED_MODE;
    FLAG_MSAA_4X_HINT             :: MSAA_4X_HINT;
    FLAG_INTERLACED_HINT          :: INTERLACED_HINT;
}

CubemapLayout :: enum u32 {
    AUTO_DETECT         :: 0;
    LINE_VERTICAL       :: 1;
    LINE_HORIZONTAL     :: 2;
    CROSS_THREE_BY_FOUR :: 3;
    CROSS_FOUR_BY_THREE :: 4;

    CUBEMAP_LAYOUT_AUTO_DETECT         :: AUTO_DETECT;
    CUBEMAP_LAYOUT_LINE_VERTICAL       :: LINE_VERTICAL;
    CUBEMAP_LAYOUT_LINE_HORIZONTAL     :: LINE_HORIZONTAL;
    CUBEMAP_LAYOUT_CROSS_THREE_BY_FOUR :: CROSS_THREE_BY_FOUR;
    CUBEMAP_LAYOUT_CROSS_FOUR_BY_THREE :: CROSS_FOUR_BY_THREE;
}

FilePathList :: struct {
    capacity: u32; // Filepaths max entries
    count:    u32; // Filepaths entries count
    paths:    **u8; // Filepaths entries
}

Font :: struct {
    baseSize:     s32; // Base size (default chars height)
    glyphCount:   s32; // Number of glyph characters
    glyphPadding: s32; // Padding around the glyph characters
    texture:      Texture2D; // Texture atlas containing the glyphs
    recs:         *Rectangle; // Rectangles in texture for the glyphs
    glyphs:       *GlyphInfo; // Glyphs info data
}

FontType :: enum u32 {
    DEFAULT :: 0;
    BITMAP  :: 1;
    SDF     :: 2;

    FONT_DEFAULT :: DEFAULT;
    FONT_BITMAP  :: BITMAP;
    FONT_SDF     :: SDF;
}

GamepadAxis :: enum u32 {
    LEFT_X        :: 0;
    LEFT_Y        :: 1;
    RIGHT_X       :: 2;
    RIGHT_Y       :: 3;
    LEFT_TRIGGER  :: 4;
    RIGHT_TRIGGER :: 5;

    GAMEPAD_AXIS_LEFT_X        :: LEFT_X;
    GAMEPAD_AXIS_LEFT_Y        :: LEFT_Y;
    GAMEPAD_AXIS_RIGHT_X       :: RIGHT_X;
    GAMEPAD_AXIS_RIGHT_Y       :: RIGHT_Y;
    GAMEPAD_AXIS_LEFT_TRIGGER  :: LEFT_TRIGGER;
    GAMEPAD_AXIS_RIGHT_TRIGGER :: RIGHT_TRIGGER;
}

GamepadButton :: enum u32 {
    UNKNOWN          :: 0;
    LEFT_FACE_UP     :: 1;
    LEFT_FACE_RIGHT  :: 2;
    LEFT_FACE_DOWN   :: 3;
    LEFT_FACE_LEFT   :: 4;
    RIGHT_FACE_UP    :: 5;
    RIGHT_FACE_RIGHT :: 6;
    RIGHT_FACE_DOWN  :: 7;
    RIGHT_FACE_LEFT  :: 8;
    LEFT_TRIGGER_1   :: 9;
    LEFT_TRIGGER_2   :: 10;
    RIGHT_TRIGGER_1  :: 11;
    RIGHT_TRIGGER_2  :: 12;
    MIDDLE_LEFT      :: 13;
    MIDDLE           :: 14;
    MIDDLE_RIGHT     :: 15;
    LEFT_THUMB       :: 16;
    RIGHT_THUMB      :: 17;

    GAMEPAD_BUTTON_UNKNOWN          :: UNKNOWN;
    GAMEPAD_BUTTON_LEFT_FACE_UP     :: LEFT_FACE_UP;
    GAMEPAD_BUTTON_LEFT_FACE_RIGHT  :: LEFT_FACE_RIGHT;
    GAMEPAD_BUTTON_LEFT_FACE_DOWN   :: LEFT_FACE_DOWN;
    GAMEPAD_BUTTON_LEFT_FACE_LEFT   :: LEFT_FACE_LEFT;
    GAMEPAD_BUTTON_RIGHT_FACE_UP    :: RIGHT_FACE_UP;
    GAMEPAD_BUTTON_RIGHT_FACE_RIGHT :: RIGHT_FACE_RIGHT;
    GAMEPAD_BUTTON_RIGHT_FACE_DOWN  :: RIGHT_FACE_DOWN;
    GAMEPAD_BUTTON_RIGHT_FACE_LEFT  :: RIGHT_FACE_LEFT;
    GAMEPAD_BUTTON_LEFT_TRIGGER_1   :: LEFT_TRIGGER_1;
    GAMEPAD_BUTTON_LEFT_TRIGGER_2   :: LEFT_TRIGGER_2;
    GAMEPAD_BUTTON_RIGHT_TRIGGER_1  :: RIGHT_TRIGGER_1;
    GAMEPAD_BUTTON_RIGHT_TRIGGER_2  :: RIGHT_TRIGGER_2;
    GAMEPAD_BUTTON_MIDDLE_LEFT      :: MIDDLE_LEFT;
    GAMEPAD_BUTTON_MIDDLE           :: MIDDLE;
    GAMEPAD_BUTTON_MIDDLE_RIGHT     :: MIDDLE_RIGHT;
    GAMEPAD_BUTTON_LEFT_THUMB       :: LEFT_THUMB;
    GAMEPAD_BUTTON_RIGHT_THUMB      :: RIGHT_THUMB;
}

Gesture :: enum u32 {
    NONE        :: 0;
    TAP         :: 1;
    DOUBLETAP   :: 2;
    HOLD        :: 4;
    DRAG        :: 8;
    SWIPE_RIGHT :: 16;
    SWIPE_LEFT  :: 32;
    SWIPE_UP    :: 64;
    SWIPE_DOWN  :: 128;
    PINCH_IN    :: 256;
    PINCH_OUT   :: 512;

    GESTURE_NONE        :: NONE;
    GESTURE_TAP         :: TAP;
    GESTURE_DOUBLETAP   :: DOUBLETAP;
    GESTURE_HOLD        :: HOLD;
    GESTURE_DRAG        :: DRAG;
    GESTURE_SWIPE_RIGHT :: SWIPE_RIGHT;
    GESTURE_SWIPE_LEFT  :: SWIPE_LEFT;
    GESTURE_SWIPE_UP    :: SWIPE_UP;
    GESTURE_SWIPE_DOWN  :: SWIPE_DOWN;
    GESTURE_PINCH_IN    :: PINCH_IN;
    GESTURE_PINCH_OUT   :: PINCH_OUT;
}

GlyphInfo :: struct {
    value:    s32; // Character value (Unicode)
    offsetX:  s32; // Character offset X when drawing
    offsetY:  s32; // Character offset Y when drawing
    advanceX: s32; // Character advance position X
    image:    Image; // Character image data
}

Image :: struct {
    data:    *void; // Image raw data
    width:   s32; // Image base width
    height:  s32; // Image base height
    mipmaps: s32; // Mipmap levels, 1 by default
    format:  s32; // Data format (PixelFormat type)
}

KeyboardKey :: enum u32 {
    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;

    KEY_NULL          :: NULL;

    KEY_APOSTROPHE    :: APOSTROPHE;
    KEY_COMMA         :: COMMA;
    KEY_MINUS         :: MINUS;
    KEY_PERIOD        :: PERIOD;
    KEY_SLASH         :: SLASH;
    KEY_ZERO          :: ZERO;
    KEY_ONE           :: ONE;
    KEY_TWO           :: TWO;
    KEY_THREE         :: THREE;
    KEY_FOUR          :: FOUR;
    KEY_FIVE          :: FIVE;
    KEY_SIX           :: SIX;
    KEY_SEVEN         :: SEVEN;
    KEY_EIGHT         :: EIGHT;
    KEY_NINE          :: NINE;
    KEY_SEMICOLON     :: SEMICOLON;
    KEY_EQUAL         :: EQUAL;
    KEY_A             :: A;
    KEY_B             :: B;
    KEY_C             :: C;
    KEY_D             :: D;
    KEY_E             :: E;
    KEY_F             :: F;
    KEY_G             :: G;
    KEY_H             :: H;
    KEY_I             :: I;
    KEY_J             :: J;
    KEY_K             :: K;
    KEY_L             :: L;
    KEY_M             :: M;
    KEY_N             :: N;
    KEY_O             :: O;
    KEY_P             :: P;
    KEY_Q             :: Q;
    KEY_R             :: R;
    KEY_S             :: S;
    KEY_T             :: T;
    KEY_U             :: U;
    KEY_V             :: V;
    KEY_W             :: W;
    KEY_X             :: X;
    KEY_Y             :: Y;
    KEY_Z             :: Z;
    KEY_LEFT_BRACKET  :: LEFT_BRACKET;
    KEY_BACKSLASH     :: BACKSLASH;
    KEY_RIGHT_BRACKET :: RIGHT_BRACKET;
    KEY_GRAVE         :: GRAVE;

    KEY_SPACE         :: SPACE;
    KEY_ESCAPE        :: ESCAPE;
    KEY_ENTER         :: ENTER;
    KEY_TAB           :: TAB;
    KEY_BACKSPACE     :: BACKSPACE;
    KEY_INSERT        :: INSERT;
    KEY_DELETE        :: DELETE;
    KEY_RIGHT         :: RIGHT;
    KEY_LEFT          :: LEFT;
    KEY_DOWN          :: DOWN;
    KEY_UP            :: UP;
    KEY_PAGE_UP       :: PAGE_UP;
    KEY_PAGE_DOWN     :: PAGE_DOWN;
    KEY_HOME          :: HOME;
    KEY_END           :: END;
    KEY_CAPS_LOCK     :: CAPS_LOCK;
    KEY_SCROLL_LOCK   :: SCROLL_LOCK;
    KEY_NUM_LOCK      :: NUM_LOCK;
    KEY_PRINT_SCREEN  :: PRINT_SCREEN;
    KEY_PAUSE         :: PAUSE;
    KEY_F1            :: F1;
    KEY_F2            :: F2;
    KEY_F3            :: F3;
    KEY_F4            :: F4;
    KEY_F5            :: F5;
    KEY_F6            :: F6;
    KEY_F7            :: F7;
    KEY_F8            :: F8;
    KEY_F9            :: F9;
    KEY_F10           :: F10;
    KEY_F11           :: F11;
    KEY_F12           :: F12;
    KEY_LEFT_SHIFT    :: LEFT_SHIFT;
    KEY_LEFT_CONTROL  :: LEFT_CONTROL;
    KEY_LEFT_ALT      :: LEFT_ALT;
    KEY_LEFT_SUPER    :: LEFT_SUPER;
    KEY_RIGHT_SHIFT   :: RIGHT_SHIFT;
    KEY_RIGHT_CONTROL :: RIGHT_CONTROL;
    KEY_RIGHT_ALT     :: RIGHT_ALT;
    KEY_RIGHT_SUPER   :: RIGHT_SUPER;
    KEY_KB_MENU       :: KB_MENU;

    KEY_KP_0          :: KP_0;
    KEY_KP_1          :: KP_1;
    KEY_KP_2          :: KP_2;
    KEY_KP_3          :: KP_3;
    KEY_KP_4          :: KP_4;
    KEY_KP_5          :: KP_5;
    KEY_KP_6          :: KP_6;
    KEY_KP_7          :: KP_7;
    KEY_KP_8          :: KP_8;
    KEY_KP_9          :: KP_9;
    KEY_KP_DECIMAL    :: KP_DECIMAL;
    KEY_KP_DIVIDE     :: KP_DIVIDE;
    KEY_KP_MULTIPLY   :: KP_MULTIPLY;
    KEY_KP_SUBTRACT   :: KP_SUBTRACT;
    KEY_KP_ADD        :: KP_ADD;
    KEY_KP_ENTER      :: KP_ENTER;
    KEY_KP_EQUAL      :: KP_EQUAL;

    KEY_BACK          :: BACK;
    KEY_MENU          :: MENU;
    KEY_VOLUME_UP     :: VOLUME_UP;
    KEY_VOLUME_DOWN   :: VOLUME_DOWN;
}

LoadFileDataCallback :: #type (fileName: *u8, dataSize: *s32) -> *u8 #c_call;

LoadFileTextCallback :: #type (fileName: *u8) -> *u8 #c_call;

Material :: struct {
    shader: Shader; // Material shader
    maps:   *MaterialMap; // Material maps array (MAX_MATERIAL_MAPS)
    params: [4] float; // Material generic parameters (if required)
}

MaterialMap :: struct {
    texture: Texture2D; // Material map texture
    color:   Color; // Material map color
    value:   float; // Material map value
}

MaterialMapIndex :: enum u32 {
    ALBEDO     :: 0;
    METALNESS  :: 1;
    NORMAL     :: 2;
    ROUGHNESS  :: 3;
    OCCLUSION  :: 4;
    EMISSION   :: 5;
    HEIGHT     :: 6;
    CUBEMAP    :: 7;
    IRRADIANCE :: 8;
    PREFILTER  :: 9;
    BRDF       :: 10;

    MATERIAL_MAP_ALBEDO     :: ALBEDO;
    MATERIAL_MAP_METALNESS  :: METALNESS;
    MATERIAL_MAP_NORMAL     :: NORMAL;
    MATERIAL_MAP_ROUGHNESS  :: ROUGHNESS;
    MATERIAL_MAP_OCCLUSION  :: OCCLUSION;
    MATERIAL_MAP_EMISSION   :: EMISSION;
    MATERIAL_MAP_HEIGHT     :: HEIGHT;
    MATERIAL_MAP_CUBEMAP    :: CUBEMAP;
    MATERIAL_MAP_IRRADIANCE :: IRRADIANCE;
    MATERIAL_MAP_PREFILTER  :: PREFILTER;
    MATERIAL_MAP_BRDF       :: BRDF;
}

Matrix :: struct {
    m0:  float; // Matrix first row (4 components)
    m4:  float; // Matrix first row (4 components)
    m8:  float; // Matrix first row (4 components)
    m12: float; // Matrix first row (4 components)
    m1:  float; // Matrix second row (4 components)
    m5:  float; // Matrix second row (4 components)
    m9:  float; // Matrix second row (4 components)
    m13: float; // Matrix second row (4 components)
    m2:  float; // Matrix third row (4 components)
    m6:  float; // Matrix third row (4 components)
    m10: float; // Matrix third row (4 components)
    m14: float; // Matrix third row (4 components)
    m3:  float; // Matrix fourth row (4 components)
    m7:  float; // Matrix fourth row (4 components)
    m11: float; // Matrix fourth row (4 components)
    m15: float; // Matrix fourth row (4 components)
}

Mesh :: struct {
    vertexCount:   s32; // Number of vertices stored in arrays
    triangleCount: s32; // Number of triangles stored (indexed or not)

    vertices:      *float; // Vertex position (XYZ - 3 components per vertex) (shader-location = 0)
    texcoords:     *float; // Vertex texture coordinates (UV - 2 components per vertex) (shader-location = 1)
    texcoords2:    *float; // Vertex texture second coordinates (UV - 2 components per vertex) (shader-location = 5)
    normals:       *float; // Vertex normals (XYZ - 3 components per vertex) (shader-location = 2)
    tangents:      *float; // Vertex tangents (XYZW - 4 components per vertex) (shader-location = 4)
    colors:        *u8; // Vertex colors (RGBA - 4 components per vertex) (shader-location = 3)
    indices:       *u16; // Vertex indices (in case vertex data comes indexed)

    animVertices:  *float; // Animated vertex positions (after bones transformations)
    animNormals:   *float; // Animated normals (after bones transformations)
    boneIds:       *u8; // Vertex bone ids, max 255 bone ids, up to 4 bones influence by vertex (skinning) (shader-location = 6)
    boneWeights:   *float; // Vertex bone weight, up to 4 bones influence by vertex (skinning) (shader-location = 7)
    boneMatrices:  *Matrix; // Bones animated transformation matrices
    boneCount:     s32; // Number of bones

    vaoId:         u32; // OpenGL Vertex Array Object id
    vboId:         *u32; // OpenGL Vertex Buffer Objects id (default vertex data)
}

Model :: struct {
    transform:     Matrix; // Local transform matrix

    meshCount:     s32; // Number of meshes
    materialCount: s32; // Number of materials
    meshes:        *Mesh; // Meshes array
    materials:     *Material; // Materials array
    meshMaterial:  *s32; // Mesh material number

    boneCount:     s32; // Number of bones
    bones:         *BoneInfo; // Bones information (skeleton)
    bindPose:      *Transform; // Bones base transformation (pose)
}

ModelAnimation :: struct {
    boneCount:  s32; // Number of bones
    frameCount: s32; // Number of animation frames
    bones:      *BoneInfo; // Bones information (skeleton)
    framePoses: **Transform; // Poses array by frame
    name:       [32] u8; // Animation name
}

MouseButton :: enum u32 {
    LEFT    :: 0;
    RIGHT   :: 1;
    MIDDLE  :: 2;
    SIDE    :: 3;
    EXTRA   :: 4;
    FORWARD :: 5;
    BACK    :: 6;

    MOUSE_BUTTON_LEFT    :: LEFT;
    MOUSE_BUTTON_RIGHT   :: RIGHT;
    MOUSE_BUTTON_MIDDLE  :: MIDDLE;
    MOUSE_BUTTON_SIDE    :: SIDE;
    MOUSE_BUTTON_EXTRA   :: EXTRA;
    MOUSE_BUTTON_FORWARD :: FORWARD;
    MOUSE_BUTTON_BACK    :: BACK;
}

MouseCursor :: enum u32 {
    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;

    MOUSE_CURSOR_DEFAULT       :: DEFAULT;
    MOUSE_CURSOR_ARROW         :: ARROW;
    MOUSE_CURSOR_IBEAM         :: IBEAM;
    MOUSE_CURSOR_CROSSHAIR     :: CROSSHAIR;
    MOUSE_CURSOR_POINTING_HAND :: POINTING_HAND;
    MOUSE_CURSOR_RESIZE_EW     :: RESIZE_EW;
    MOUSE_CURSOR_RESIZE_NS     :: RESIZE_NS;
    MOUSE_CURSOR_RESIZE_NWSE   :: RESIZE_NWSE;
    MOUSE_CURSOR_RESIZE_NESW   :: RESIZE_NESW;
    MOUSE_CURSOR_RESIZE_ALL    :: RESIZE_ALL;
    MOUSE_CURSOR_NOT_ALLOWED   :: NOT_ALLOWED;
}

Music :: struct {
    stream:     AudioStream; // Audio stream
    frameCount: u32; // Total number of frames (considering channels)
    looping:    bool; // Music looping enable

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

NPatchInfo :: struct {
    source: Rectangle; // Texture source rectangle
    left:   s32; // Left border offset
    top:    s32; // Top border offset
    right:  s32; // Right border offset
    bottom: s32; // Bottom border offset
    layout: s32; // Layout of the n-patch: 3x3, 1x3 or 3x1
}

NPatchLayout :: enum u32 {
    NINE_PATCH             :: 0;
    THREE_PATCH_VERTICAL   :: 1;
    THREE_PATCH_HORIZONTAL :: 2;

    NPATCH_NINE_PATCH             :: NINE_PATCH;
    NPATCH_THREE_PATCH_VERTICAL   :: THREE_PATCH_VERTICAL;
    NPATCH_THREE_PATCH_HORIZONTAL :: THREE_PATCH_HORIZONTAL;
}

PixelFormat :: enum u32 {
    UNCOMPRESSED_GRAYSCALE    :: 1;
    UNCOMPRESSED_GRAY_ALPHA   :: 2;
    UNCOMPRESSED_R5G6B5       :: 3;
    UNCOMPRESSED_R8G8B8       :: 4;
    UNCOMPRESSED_R5G5B5A1     :: 5;
    UNCOMPRESSED_R4G4B4A4     :: 6;
    UNCOMPRESSED_R8G8B8A8     :: 7;
    UNCOMPRESSED_R32          :: 8;
    UNCOMPRESSED_R32G32B32    :: 9;
    UNCOMPRESSED_R32G32B32A32 :: 10;
    UNCOMPRESSED_R16          :: 11;
    UNCOMPRESSED_R16G16B16    :: 12;
    UNCOMPRESSED_R16G16B16A16 :: 13;
    COMPRESSED_DXT1_RGB       :: 14;
    COMPRESSED_DXT1_RGBA      :: 15;
    COMPRESSED_DXT3_RGBA      :: 16;
    COMPRESSED_DXT5_RGBA      :: 17;
    COMPRESSED_ETC1_RGB       :: 18;
    COMPRESSED_ETC2_RGB       :: 19;
    COMPRESSED_ETC2_EAC_RGBA  :: 20;
    COMPRESSED_PVRT_RGB       :: 21;
    COMPRESSED_PVRT_RGBA      :: 22;
    COMPRESSED_ASTC_4x4_RGBA  :: 23;
    COMPRESSED_ASTC_8x8_RGBA  :: 24;

    PIXELFORMAT_UNCOMPRESSED_GRAYSCALE    :: UNCOMPRESSED_GRAYSCALE;
    PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA   :: UNCOMPRESSED_GRAY_ALPHA;
    PIXELFORMAT_UNCOMPRESSED_R5G6B5       :: UNCOMPRESSED_R5G6B5;
    PIXELFORMAT_UNCOMPRESSED_R8G8B8       :: UNCOMPRESSED_R8G8B8;
    PIXELFORMAT_UNCOMPRESSED_R5G5B5A1     :: UNCOMPRESSED_R5G5B5A1;
    PIXELFORMAT_UNCOMPRESSED_R4G4B4A4     :: UNCOMPRESSED_R4G4B4A4;
    PIXELFORMAT_UNCOMPRESSED_R8G8B8A8     :: UNCOMPRESSED_R8G8B8A8;
    PIXELFORMAT_UNCOMPRESSED_R32          :: UNCOMPRESSED_R32;
    PIXELFORMAT_UNCOMPRESSED_R32G32B32    :: UNCOMPRESSED_R32G32B32;
    PIXELFORMAT_UNCOMPRESSED_R32G32B32A32 :: UNCOMPRESSED_R32G32B32A32;
    PIXELFORMAT_UNCOMPRESSED_R16          :: UNCOMPRESSED_R16;
    PIXELFORMAT_UNCOMPRESSED_R16G16B16    :: UNCOMPRESSED_R16G16B16;
    PIXELFORMAT_UNCOMPRESSED_R16G16B16A16 :: UNCOMPRESSED_R16G16B16A16;
    PIXELFORMAT_COMPRESSED_DXT1_RGB       :: COMPRESSED_DXT1_RGB;
    PIXELFORMAT_COMPRESSED_DXT1_RGBA      :: COMPRESSED_DXT1_RGBA;
    PIXELFORMAT_COMPRESSED_DXT3_RGBA      :: COMPRESSED_DXT3_RGBA;
    PIXELFORMAT_COMPRESSED_DXT5_RGBA      :: COMPRESSED_DXT5_RGBA;
    PIXELFORMAT_COMPRESSED_ETC1_RGB       :: COMPRESSED_ETC1_RGB;
    PIXELFORMAT_COMPRESSED_ETC2_RGB       :: COMPRESSED_ETC2_RGB;
    PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA  :: COMPRESSED_ETC2_EAC_RGBA;
    PIXELFORMAT_COMPRESSED_PVRT_RGB       :: COMPRESSED_PVRT_RGB;
    PIXELFORMAT_COMPRESSED_PVRT_RGBA      :: COMPRESSED_PVRT_RGBA;
    PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA  :: COMPRESSED_ASTC_4x4_RGBA;
    PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA  :: COMPRESSED_ASTC_8x8_RGBA;
}

Ray :: struct {
    position:  Vector3; // Ray position (origin)
    direction: Vector3; // Ray direction (normalized)
}

RayCollision :: struct {
    hit:      bool; // Did the ray hit something?
    distance: float; // Distance to the nearest hit
    point:    Vector3; // Point of the nearest hit
    normal:   Vector3; // Surface normal of hit
}

Rectangle :: struct {
    x:      float; // Rectangle top-left corner position x
    y:      float; // Rectangle top-left corner position y
    width:  float; // Rectangle width
    height: float; // Rectangle height
}

RenderTexture :: struct {
    id:      u32; // OpenGL framebuffer object id
    texture: Texture; // Color buffer attachment texture
    depth:   Texture; // Depth buffer attachment texture
}

SaveFileDataCallback :: #type (fileName: *u8, data: *void, dataSize: s32) -> bool #c_call;

SaveFileTextCallback :: #type (fileName: *u8, text: *u8) -> bool #c_call;

Shader :: struct {
    id:   u32; // Shader program id
    locs: *s32; // Shader locations array (RL_MAX_SHADER_LOCATIONS)
}

ShaderAttributeDataType :: enum u32 {
    FLOAT :: 0;
    VEC2  :: 1;
    VEC3  :: 2;
    VEC4  :: 3;

    SHADER_ATTRIB_FLOAT :: FLOAT;
    SHADER_ATTRIB_VEC2  :: VEC2;
    SHADER_ATTRIB_VEC3  :: VEC3;
    SHADER_ATTRIB_VEC4  :: VEC4;
}

ShaderLocationIndex :: enum u32 {
    VERTEX_POSITION    :: 0;
    VERTEX_TEXCOORD01  :: 1;
    VERTEX_TEXCOORD02  :: 2;
    VERTEX_NORMAL      :: 3;
    VERTEX_TANGENT     :: 4;
    VERTEX_COLOR       :: 5;
    MATRIX_MVP         :: 6;
    MATRIX_VIEW        :: 7;
    MATRIX_PROJECTION  :: 8;
    MATRIX_MODEL       :: 9;
    MATRIX_NORMAL      :: 10;
    VECTOR_VIEW        :: 11;
    COLOR_DIFFUSE      :: 12;
    COLOR_SPECULAR     :: 13;
    COLOR_AMBIENT      :: 14;
    MAP_ALBEDO         :: 15;
    MAP_METALNESS      :: 16;
    MAP_NORMAL         :: 17;
    MAP_ROUGHNESS      :: 18;
    MAP_OCCLUSION      :: 19;
    MAP_EMISSION       :: 20;
    MAP_HEIGHT         :: 21;
    MAP_CUBEMAP        :: 22;
    MAP_IRRADIANCE     :: 23;
    MAP_PREFILTER      :: 24;
    MAP_BRDF           :: 25;
    VERTEX_BONEIDS     :: 26;
    VERTEX_BONEWEIGHTS :: 27;
    BONE_MATRICES      :: 28;

    SHADER_LOC_VERTEX_POSITION    :: VERTEX_POSITION;
    SHADER_LOC_VERTEX_TEXCOORD01  :: VERTEX_TEXCOORD01;
    SHADER_LOC_VERTEX_TEXCOORD02  :: VERTEX_TEXCOORD02;
    SHADER_LOC_VERTEX_NORMAL      :: VERTEX_NORMAL;
    SHADER_LOC_VERTEX_TANGENT     :: VERTEX_TANGENT;
    SHADER_LOC_VERTEX_COLOR       :: VERTEX_COLOR;
    SHADER_LOC_MATRIX_MVP         :: MATRIX_MVP;
    SHADER_LOC_MATRIX_VIEW        :: MATRIX_VIEW;
    SHADER_LOC_MATRIX_PROJECTION  :: MATRIX_PROJECTION;
    SHADER_LOC_MATRIX_MODEL       :: MATRIX_MODEL;
    SHADER_LOC_MATRIX_NORMAL      :: MATRIX_NORMAL;
    SHADER_LOC_VECTOR_VIEW        :: VECTOR_VIEW;
    SHADER_LOC_COLOR_DIFFUSE      :: COLOR_DIFFUSE;
    SHADER_LOC_COLOR_SPECULAR     :: COLOR_SPECULAR;
    SHADER_LOC_COLOR_AMBIENT      :: COLOR_AMBIENT;
    SHADER_LOC_MAP_ALBEDO         :: MAP_ALBEDO;
    SHADER_LOC_MAP_METALNESS      :: MAP_METALNESS;
    SHADER_LOC_MAP_NORMAL         :: MAP_NORMAL;
    SHADER_LOC_MAP_ROUGHNESS      :: MAP_ROUGHNESS;
    SHADER_LOC_MAP_OCCLUSION      :: MAP_OCCLUSION;
    SHADER_LOC_MAP_EMISSION       :: MAP_EMISSION;
    SHADER_LOC_MAP_HEIGHT         :: MAP_HEIGHT;
    SHADER_LOC_MAP_CUBEMAP        :: MAP_CUBEMAP;
    SHADER_LOC_MAP_IRRADIANCE     :: MAP_IRRADIANCE;
    SHADER_LOC_MAP_PREFILTER      :: MAP_PREFILTER;
    SHADER_LOC_MAP_BRDF           :: MAP_BRDF;
    SHADER_LOC_VERTEX_BONEIDS     :: VERTEX_BONEIDS;
    SHADER_LOC_VERTEX_BONEWEIGHTS :: VERTEX_BONEWEIGHTS;
    SHADER_LOC_BONE_MATRICES      :: BONE_MATRICES;
}

ShaderUniformDataType :: enum u32 {
    FLOAT     :: 0;
    VEC2      :: 1;
    VEC3      :: 2;
    VEC4      :: 3;
    INT       :: 4;
    IVEC2     :: 5;
    IVEC3     :: 6;
    IVEC4     :: 7;
    SAMPLER2D :: 8;

    SHADER_UNIFORM_FLOAT     :: FLOAT;
    SHADER_UNIFORM_VEC2      :: VEC2;
    SHADER_UNIFORM_VEC3      :: VEC3;
    SHADER_UNIFORM_VEC4      :: VEC4;
    SHADER_UNIFORM_INT       :: INT;
    SHADER_UNIFORM_IVEC2     :: IVEC2;
    SHADER_UNIFORM_IVEC3     :: IVEC3;
    SHADER_UNIFORM_IVEC4     :: IVEC4;
    SHADER_UNIFORM_SAMPLER2D :: SAMPLER2D;
}

Sound :: struct {
    stream:     AudioStream; // Audio stream
    frameCount: u32; // Total number of frames (considering channels)
}

Texture :: struct {
    id:      u32; // OpenGL texture id
    width:   s32; // Texture base width
    height:  s32; // Texture base height
    mipmaps: s32; // Mipmap levels, 1 by default
    format:  s32; // Data format (PixelFormat type)
}

TextureFilter :: enum u32 {
    POINT           :: 0;
    BILINEAR        :: 1;
    TRILINEAR       :: 2;
    ANISOTROPIC_4X  :: 3;
    ANISOTROPIC_8X  :: 4;
    ANISOTROPIC_16X :: 5;

    TEXTURE_FILTER_POINT           :: POINT;
    TEXTURE_FILTER_BILINEAR        :: BILINEAR;
    TEXTURE_FILTER_TRILINEAR       :: TRILINEAR;
    TEXTURE_FILTER_ANISOTROPIC_4X  :: ANISOTROPIC_4X;
    TEXTURE_FILTER_ANISOTROPIC_8X  :: ANISOTROPIC_8X;
    TEXTURE_FILTER_ANISOTROPIC_16X :: ANISOTROPIC_16X;
}

TextureWrap :: enum u32 {
    REPEAT        :: 0;
    CLAMP         :: 1;
    MIRROR_REPEAT :: 2;
    MIRROR_CLAMP  :: 3;

    TEXTURE_WRAP_REPEAT        :: REPEAT;
    TEXTURE_WRAP_CLAMP         :: CLAMP;
    TEXTURE_WRAP_MIRROR_REPEAT :: MIRROR_REPEAT;
    TEXTURE_WRAP_MIRROR_CLAMP  :: MIRROR_CLAMP;
}

TraceLogLevel :: enum u32 {
    ALL     :: 0;
    TRACE   :: 1;
    DEBUG   :: 2;
    INFO    :: 3;
    WARNING :: 4;
    ERROR   :: 5;
    FATAL   :: 6;
    NONE    :: 7;

    LOG_ALL     :: ALL;
    LOG_TRACE   :: TRACE;
    LOG_DEBUG   :: DEBUG;
    LOG_INFO    :: INFO;
    LOG_WARNING :: WARNING;
    LOG_ERROR   :: ERROR;
    LOG_FATAL   :: FATAL;
    LOG_NONE    :: NONE;
}

Transform :: struct {
    translation: Vector3; // Translation
    rotation:    Quaternion; // Rotation
    scale:       Vector3; // Scale
}

Vector2 :: struct {
    x: float; // Vector x component
    y: float; // Vector y component
}

Vector3 :: struct {
    x: float; // Vector x component
    y: float; // Vector y component
    z: float; // Vector z component
}

Vector4 :: struct {
    x: float; // Vector x component
    y: float; // Vector y component
    z: float; // Vector z component
    w: float; // Vector w component
}

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

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

Wave :: struct {
    frameCount: u32; // Total number of frames (considering channels)
    sampleRate: u32; // Frequency (samples per second)
    sampleSize: u32; // Bit depth (bits per sample): 8, 16, 32 (24 not supported)
    channels:   u32; // Number of channels (1-mono, 2-stereo, ...)
    data:       *void; // Buffer data pointer
}

float16 :: struct {
    v: [16] float;
}

float3 :: struct {
    v: [3] float;
}

rAudioBuffer :: struct {}

rAudioProcessor :: struct {}