Bindings for [[ raylib v5.5 ; https://www.raylib.com ]]. ********************************************************************************************* * * raylib v5.5 - A simple and easy-to-use library to enjoy videogames programming (www.raylib.com) * * FEATURES: * - NO external dependencies, all required libraries included with raylib * - Multiplatform: Windows, Linux, FreeBSD, OpenBSD, NetBSD, DragonFly, * MacOS, Haiku, Android, Raspberry Pi, DRM native, HTML5. * - Written in plain C code (C99) in PascalCase/camelCase notation * - Hardware accelerated with OpenGL (1.1, 2.1, 3.3, 4.3, ES2, ES3 - choose at compile) * - Unique OpenGL abstraction layer (usable as standalone module): [rlgl] * - Multiple Fonts formats supported (TTF, OTF, FNT, BDF, Sprite fonts) * - Outstanding texture formats support, including compressed formats (DXT, ETC, ASTC) * - Full 3d support for 3d Shapes, Models, Billboards, Heightmaps and more! * - Flexible Materials system, supporting classic maps and PBR maps * - Animated 3D models supported (skeletal bones animation) (IQM, M3D, GLTF) * - Shaders support, including Model shaders and Postprocessing shaders * - Powerful math module for Vector, Matrix and Quaternion operations: [raymath] * - Audio loading and playing with streaming support (WAV, OGG, MP3, FLAC, QOA, XM, MOD) * - VR stereo rendering with configurable HMD device parameters * - Bindings to multiple programming languages available! * * NOTES: * - One default Font is loaded on InitWindow()->LoadFontDefault() [core, text] * - One default Texture2D is loaded on rlglInit(), 1x1 white pixel R8G8B8A8 [rlgl] (OpenGL 3.3 or ES2) * - One default Shader is loaded on rlglInit()->rlLoadShaderDefault() [rlgl] (OpenGL 3.3 or ES2) * - One default RenderBatch is loaded on rlglInit()->rlLoadRenderBatch() [rlgl] (OpenGL 3.3 or ES2) * * DEPENDENCIES (included): * [rcore][GLFW] rglfw (Camilla Löwy - github.com/glfw/glfw) for window/context management and input * [rcore][RGFW] rgfw (ColleagueRiley - github.com/ColleagueRiley/RGFW) for window/context management and input * [rlgl] glad/glad_gles2 (David Herberth - github.com/Dav1dde/glad) for OpenGL 3.3 extensions loading * [raudio] miniaudio (David Reid - github.com/mackron/miniaudio) for audio device/context management * * OPTIONAL DEPENDENCIES (included): * [rcore] msf_gif (Miles Fogle) for GIF recording * [rcore] sinfl (Micha Mettke) for DEFLATE decompression algorithm * [rcore] sdefl (Micha Mettke) for DEFLATE compression algorithm * [rcore] rprand (Ramon Snatamaria) for pseudo-random numbers generation * [rtextures] qoi (Dominic Szablewski - https://phoboslab.org) for QOI image manage * [rtextures] stb_image (Sean Barret) for images loading (BMP, TGA, PNG, JPEG, HDR...) * [rtextures] stb_image_write (Sean Barret) for image writing (BMP, TGA, PNG, JPG) * [rtextures] stb_image_resize2 (Sean Barret) for image resizing algorithms * [rtextures] stb_perlin (Sean Barret) for Perlin Noise image generation * [rtext] stb_truetype (Sean Barret) for ttf fonts loading * [rtext] stb_rect_pack (Sean Barret) for rectangles packing * [rmodels] par_shapes (Philip Rideout) for parametric 3d shapes generation * [rmodels] tinyobj_loader_c (Syoyo Fujita) for models loading (OBJ, MTL) * [rmodels] cgltf (Johannes Kuhlmann) for models loading (glTF) * [rmodels] m3d (bzt) for models loading (M3D, https://bztsrc.gitlab.io/model3d) * [rmodels] vox_loader (Johann Nadalutti) for models loading (VOX) * [raudio] dr_wav (David Reid) for WAV audio file loading * [raudio] dr_flac (David Reid) for FLAC audio file loading * [raudio] dr_mp3 (David Reid) for MP3 audio file loading * [raudio] stb_vorbis (Sean Barret) for OGG audio loading * [raudio] jar_xm (Joshua Reisenauer) for XM audio module loading * [raudio] jar_mod (Joshua Reisenauer) for MOD audio module loading * [raudio] qoa (Dominic Szablewski - https://phoboslab.org) for QOA audio manage * * * LICENSE: zlib/libpng * * raylib is licensed under an unmodified zlib/libpng license, which is an OSI-certified, * BSD-like license that allows static linking with closed source software: * * Copyright (c) 2013-2024 Ramon Santamaria (@raysan5) * * This software is provided "as-is", without any express or implied warranty. In no event * will the authors be held liable for any damages arising from the use of this software. * * Permission is granted to anyone to use this software for any purpose, including commercial * applications, and to alter it and redistribute it freely, subject to the following restrictions: * * 1. The origin of this software must not be misrepresented; you must not claim that you * wrote the original software. If you use this software in a product, an acknowledgment * in the product documentation would be appreciated but is not required. * * 2. Altered source versions must be plainly marked as such, and must not be misrepresented * as being the original software. * * 3. This notice may not be removed or altered from any source distribution. * *********************************************************************************************

Collection Info

View Source
Collection
vendor
Path
raylib
Entries
949
Constants 49
Jump to Constants
BEIGE BLACK BLANK BLUE BROWN CAMERA_MOUSE_MOVE_SENSITIVITY CAMERA_MOVE_SPEED CAMERA_ORBITAL_SPEED CAMERA_PAN_SPEED CAMERA_ROTATION_SPEED DARKBLUE DARKBROWN DARKGRAY DARKGREEN DARKPURPLE DEG2RAD +33 more
Types 86
Jump to Types
AudioCallback AudioStream AutomationEvent AutomationEventList BlendMode BoneInfo BoundingBox Camera Camera2D Camera3D CameraMode CameraProjection Color ConfigFlag ConfigFlags CubemapLayout +70 more
Procedures 805
Jump to Procedures
AttachAudioMixedProcessor AttachAudioStreamProcessor BeginBlendMode BeginDrawing BeginMode2D BeginMode3D BeginScissorMode BeginShaderMode BeginTextureMode BeginVrStereoMode CameraMoveForward CameraMoveRight CameraMoveToTarget CameraMoveUp CameraPitch CameraRoll +789 more
Procedure Groups 1
Jump to Procedure Groups
MemFree
Variables 1
Jump to Variables
version

Source Files

Constants

49

CAMERA_MOUSE_MOVE_SENSITIVITY #

Source 
CAMERA_MOUSE_MOVE_SENSITIVITY :: 0.003

Camera mouse movement sensitivity

CAMERA_MOVE_SPEED #

Source 
CAMERA_MOVE_SPEED :: 5.4

Camera speed values

CAMERA_ORBITAL_SPEED #

Source 
CAMERA_ORBITAL_SPEED :: 0.5

Camera orbital speed in CAMERA_ORBITAL mode

DARKPURPLE #

Source 
DARKPURPLE :: Color{112, 31, 126, 255}

Dark Purple

LIGHTGRAY #

Source 
LIGHTGRAY :: Color{200, 200, 200, 255}

Some Basic Colors NOTE: Custom raylib color palette for amazing visuals on WHITE background

MAX_MATERIAL_MAPS #

Source 
MAX_MATERIAL_MAPS :: #config(RAYLIB_MAX_MATERIAL_MAPS, 12)

MAX_TEXT_BUFFER_LENGTH #

Source 
MAX_TEXT_BUFFER_LENGTH :: #config(RAYLIB_MAX_TEXT_BUFFER_LENGTH, 1024)

MAX_TEXTFORMAT_BUFFERS #

Source 
MAX_TEXTFORMAT_BUFFERS :: #config(RAYLIB_MAX_TEXTFORMAT_BUFFERS, 4)

RAYGUI_SHARED #

Source 
RAYGUI_SHARED :: #config(RAYGUI_SHARED, false)

RAYGUI_WASM_LIB #

Source 
RAYGUI_WASM_LIB :: #config(RAYGUI_WASM_LIB, "wasm/libraygui.a")

RAYLIB_SHARED #

Source 
RAYLIB_SHARED :: #config(RAYLIB_SHARED, false)

RAYLIB_WASM_LIB #

Source 
RAYLIB_WASM_LIB :: #config(RAYLIB_WASM_LIB, "wasm/libraylib.a")

RAYWHITE #

Source 
RAYWHITE :: Color{245, 245, 245, 255}

My own White (raylib logo)

Config Values

7

MAX_MATERIAL_MAPS #

Source 
MAX_MATERIAL_MAPS :: #config(RAYLIB_MAX_MATERIAL_MAPS, 12)

MAX_TEXT_BUFFER_LENGTH #

Source 
MAX_TEXT_BUFFER_LENGTH :: #config(RAYLIB_MAX_TEXT_BUFFER_LENGTH, 1024)

MAX_TEXTFORMAT_BUFFERS #

Source 
MAX_TEXTFORMAT_BUFFERS :: #config(RAYLIB_MAX_TEXTFORMAT_BUFFERS, 4)

RAYGUI_SHARED #

Source 
RAYGUI_SHARED :: #config(RAYGUI_SHARED, false)

RAYGUI_WASM_LIB #

Source 
RAYGUI_WASM_LIB :: #config(RAYGUI_WASM_LIB, "wasm/libraygui.a")

RAYLIB_SHARED #

Source 
RAYLIB_SHARED :: #config(RAYLIB_SHARED, false)

RAYLIB_WASM_LIB #

Source 
RAYLIB_WASM_LIB :: #config(RAYLIB_WASM_LIB, "wasm/libraylib.a")

Types

86

AudioStream #

Source 
AudioStream :: AudioStream

Audio stream type NOTE: Actual structs are defined internally in raudio module

Color #

Source 
Color :: distinct Color

Color, 4 components, R8G8B8A8 (32bit) Note: In Raylib this is a struct. But here we use a fixed array, so that .rgba swizzling etc work.

ConfigFlag #

Source 
ConfigFlag :: ConfigFlag

---------------------------------------------------------------------------------- Enumerators Definition ---------------------------------------------------------------------------------- System/Window config flags NOTE: Every bit registers one state (use it with bit masks) By default all flags are set to 0

Gesture #

Source 
Gesture :: Gesture

Gestures NOTE: It could be used as flags to enable only some gestures

GuiControlProperty #

Source 
GuiControlProperty :: GuiControlProperty

Gui base properties for every control NOTE: RAYGUI_MAX_PROPS_BASE properties (by default 16 properties)

GuiIconName #

Source 
GuiIconName :: GuiIconName

---------------------------------------------------------------------------------- Icons enumeration ----------------------------------------------------------------------------------

Image #

Source 
Image :: Image

Image type, bpp always RGBA (32bit) NOTE: Data stored in CPU memory (RAM)

KeyboardKey #

Source 
KeyboardKey :: KeyboardKey

Keyboard keys (US keyboard layout) NOTE: Use GetKeyPressed() to allow redefining required keys for alternative layouts

Matrix #

Source 
Matrix :: matrix[4, 4]f32

Matrix type (right handed, stored row major)

Mesh #

Source 
Mesh :: Mesh

Vertex data defining a mesh NOTE: Data stored in CPU memory (and GPU)

Music #

Source 
Music :: Music

Music stream type (audio file streaming from memory) NOTE: Anything longer than ~10 seconds should be streamed

TextureFilter #

Source 
TextureFilter :: TextureFilter

Texture parameters: filter mode NOTE 1: Filtering considers mipmaps if available in the texture NOTE 2: Filter is accordingly set for minification and magnification

TraceLogCallback #

Source 
TraceLogCallback :: TraceLogCallback

Callbacks to hook some internal functions WARNING: This callbacks are intended for advanced users

Procedures

805

AttachAudioMixedProcessor #

Source 
AttachAudioMixedProcessor :: proc "c" (processor: AudioCallback) ---

Attach audio stream processor to the entire audio pipeline, receives the samples as 'float'

AttachAudioStreamProcessor #

Source 
AttachAudioStreamProcessor :: proc "c" (stream: AudioStream, processor: AudioCallback) ---

Attach audio stream processor to stream, receives the samples as 'float'

BeginBlendMode #

Source 
BeginBlendMode :: proc "c" (mode: BlendMode) ---

Begin blending mode (alpha, additive, multiplied)

BeginDrawing #

Source 
BeginDrawing :: proc "c" () ---

Setup canvas (framebuffer) to start drawing

BeginMode2D #

Source 
BeginMode2D :: proc "c" (camera: Camera2D) ---

Initialize 2D mode with custom camera (2D)

BeginMode3D #

Source 
BeginMode3D :: proc "c" (camera: Camera3D) ---

Initializes 3D mode with custom camera (3D)

BeginScissorMode #

Source 
BeginScissorMode :: proc "c" (x, y, width, height: i32) ---

Begin scissor mode (define screen area for following drawing)

BeginShaderMode #

Source 
BeginShaderMode :: proc "c" (shader: Shader) ---

Begin custom shader drawing

CameraMoveForward #

Source 
CameraMoveForward :: proc "c" (camera: ^Camera3D, distance: f32, moveInWorldPlane: bool) ---

move the camera in its forward direction

CameraMoveRight #

Source 
CameraMoveRight :: proc "c" (camera: ^Camera3D, distance: f32, moveInWorldPlane: bool) ---

move camera in it's current right direction

CameraMoveToTarget #

Source 
CameraMoveToTarget :: proc "c" (camera: ^Camera3D, delta: f32) ---

moves the camera position closer/farther to/from the camera target

CameraPitch #

Source 
CameraPitch :: proc "c" (camera: ^Camera3D, angle: f32, lockView: bool, rotateAroundTarget: bool, rotateUp: bool) ---

rotates the camera around its right vector (up and down)

CameraRoll #

Source 
CameraRoll :: proc "c" (camera: ^Camera3D, angle: f32) ---

rotates the camera around its forward vector (left and right)

CameraYaw #

Source 
CameraYaw :: proc "c" (camera: ^Camera3D, angle: f32, rotateAroundTarget: bool) ---

rotates the camera around its up vector (left and right)

ChangeDirectory #

Source 
ChangeDirectory :: proc "c" (dir: cstring) -> bool ---

Change working directory, return true on success

CheckCollisionCircleLine #

Source 
CheckCollisionCircleLine :: proc "c" (center: [2]f32, radius: f32, p1, p2: [2]f32) -> bool ---

Check if circle collides with a line created betweeen two points [p1] and [p2]

CheckCollisionCircleRec #

Source 
CheckCollisionCircleRec :: proc "c" (center: [2]f32, radius: f32, rec: Rectangle) -> bool ---

Check collision between circle and rectangle

CheckCollisionCircles #

Source 
CheckCollisionCircles :: proc "c" (center1: [2]f32, radius1: f32, center2: [2]f32, radius2: f32) -> bool ---

Check collision between two circles

CheckCollisionLines #

Source 
CheckCollisionLines :: proc "c" (startPos1, endPos1, startPos2, endPos2: [2]f32, collisionPoint: [^][2]f32) -> bool ---

Check the collision between two lines defined by two points each, returns collision point by reference

CheckCollisionPointCircle #

Source 
CheckCollisionPointCircle :: proc "c" (point, center: [2]f32, radius: f32) -> bool ---

Check if point is inside circle

CheckCollisionPointLine #

Source 
CheckCollisionPointLine :: proc "c" (point: [2]f32, p1, p2: [2]f32, threshold: i32) -> bool ---

Check if point belongs to line created between two points [p1] and [p2] with defined margin in pixels [threshold]

CheckCollisionPointPoly #

Source 
CheckCollisionPointPoly :: proc "c" (point: [2]f32, points: [^][2]f32, pointCount: i32) -> bool ---

Check if point is within a polygon described by array of vertices

CheckCollisionPointTriangle #

Source 
CheckCollisionPointTriangle :: proc "c" (point: [2]f32, p1, p2, p3: [2]f32) -> bool ---

Check if point is inside a triangle

CheckCollisionRecs #

Source 
CheckCollisionRecs :: proc "c" (rec1, rec2: Rectangle) -> bool ---

Basic shapes collision detection functions

CheckCollisionSpheres #

Source 
CheckCollisionSpheres :: proc "c" (center1: [3]f32, radius1: f32, center2: [3]f32, radius2: f32) -> bool ---

Check collision between two spheres

ClearBackground #

Source 
ClearBackground :: proc "c" (color: Color) ---

Set background color (framebuffer clear color)

CloseAudioDevice #

Source 
CloseAudioDevice :: proc "c" () ---

Close the audio device and context

CloseWindow #

Source 
CloseWindow :: proc "c" () ---

Close window and unload OpenGL context

CodepointToUTF8 #

Source 
CodepointToUTF8 :: proc "c" (codepoint: rune, utf8Size: ^i32) -> cstring ---

Encode one codepoint into UTF-8 byte array (array length returned as parameter)

ColorAlpha #

Source 
ColorAlpha :: proc "c" (color: Color, alpha: f32) -> Color ---

Get color with alpha applied, alpha goes from 0.0f to 1.0f

ColorAlphaBlend #

Source 
ColorAlphaBlend :: proc "c" (dst, src, tint: Color) -> Color ---

Get src alpha-blended into dst color with tint

ColorBrightness #

Source 
ColorBrightness :: proc "c" (color: Color, factor: f32) -> Color ---

Get color with brightness correction, brightness factor goes from -1.0f to 1.0f

ColorContrast #

Source 
ColorContrast :: proc "c" (color: Color, contrast: f32) -> Color ---

Get color with contrast correction, contrast values between -1.0f and 1.0f

ColorFromHSV #

Source 
ColorFromHSV :: proc "c" (hue, saturation, value: f32) -> Color ---

Get a Color from HSV values, hue [0..360], saturation/value [0..1]

ColorFromNormalized #

Source 
ColorFromNormalized :: proc "c" (normalized: [4]f32) -> Color ---

Get Color from normalized values [0..1]

ColorIsEqual #

Source 
@(deprecated="Prefer col1 == col2")
ColorIsEqual :: proc "c" (col1, col2: Color) ---

Check if two colors are equal

ColorLerp #

Source 
ColorLerp :: proc "c" (color1, color2: Color, factor: f32) -> Color ---

Get color lerp interpolation between two colors, factor [0.0f..1.0f]

ColorNormalize #

Source 
ColorNormalize :: proc "c" (color: Color) -> [4]f32 ---

Get Color normalized as float [0..1]

ColorToHSV #

Source 
ColorToHSV :: proc "c" (color: Color) -> [3]f32 ---

Get HSV values for a Color, hue [0..360], saturation/value [0..1]

ColorToInt #

Source 
ColorToInt :: proc "c" (color: Color) -> u32 ---

Get hexadecimal value for a Color (0xRRGGBBAA)

CompressData #

Source 
CompressData :: proc "c" (data: rawptr, dataSize: i32, compDataSize: ^i32) -> [^]u8 ---

Compress data (DEFLATE algorithm), memory must be MemFree()

ComputeMD5 #

Source 
ComputeMD5 :: proc "c" (data: rawptr, dataSize: i32) -> [^]u32 ---

Compute MD5 hash code, returns static int[4] (16 bytes)

ComputeSHA1 #

Source 
ComputeSHA1 :: proc "c" (data: rawptr, dataSize: i32) -> [^]u32 ---

Compute SHA1 hash code, returns static int[5] (20 bytes)

DecodeDataBase64 #

Source 
DecodeDataBase64 :: proc "c" (data: rawptr, outputSize: ^i32) -> [^]u8 ---

Decode Base64 string data, memory must be MemFree()

DecompressData #

Source 
DecompressData :: proc "c" (compData: rawptr, compDataSize: i32, dataSize: ^i32) -> [^]u8 ---

Decompress data (DEFLATE algorithm), memory must be MemFree()

DetachAudioMixedProcessor #

Source 
DetachAudioMixedProcessor :: proc "c" (processor: AudioCallback) ---

Detach audio stream processor from the entire audio pipeline

DisableCursor #

Source 
DisableCursor :: proc "c" () ---

Disables cursor (lock cursor)

DisableEventWaiting #

Source 
DisableEventWaiting :: proc "c" () ---

Disable waiting for events on EndDrawing(), automatic events polling

DrawCapsule #

Source 
DrawCapsule :: proc "c" (
	startPos, endPos: [3]f32, 
	radius:           f32, 
	slices, rings:    i32, 
	color:            Color, 
) ---

Draw a capsule with the center of its sphere caps at startPos and endPos

DrawCapsuleWires #

Source 
DrawCapsuleWires :: proc "c" (
	startPos, endPos: [3]f32, 
	radius:           f32, 
	slices, rings:    i32, 
	color:            Color, 
) ---

Draw capsule wireframe with the center of its sphere caps at startPos and endPos

DrawCircle #

Source 
DrawCircle :: proc "c" (centerX, centerY: i32, radius: f32, color: Color) ---

Draw a color-filled circle

DrawCircle3D #

Source 
DrawCircle3D :: proc "c" (center: [3]f32, radius: f32, rotationAxis: [3]f32, rotationAngle: f32, color: Color) ---

Draw a circle in 3D world space

DrawCircleGradient #

Source 
DrawCircleGradient :: proc "c" (centerX, centerY: i32, radius: f32, inner, outer: Color) ---

Draw a gradient-filled circle

DrawCircleLines #

Source 
DrawCircleLines :: proc "c" (centerX, centerY: i32, radius: f32, color: Color) ---

Draw circle outline

DrawCircleLinesV #

Source 
DrawCircleLinesV :: proc "c" (center: [2]f32, radius: f32, color: Color) ---

Draw circle outline (Vector version)

DrawCircleSector #

Source 
DrawCircleSector :: proc "c" (
	center:               [2]f32, 
	radius:               f32, 
	startAngle, endAngle: f32, 
	segments:             i32, 
	color:                Color, 
) ---

Draw a piece of a circle

DrawCircleSectorLines #

Source 
DrawCircleSectorLines :: proc "c" (
	center:               [2]f32, 
	radius:               f32, 
	startAngle, endAngle: f32, 
	segments:             i32, 
	color:                Color, 
) ---

Draw circle sector outline

DrawCircleV #

Source 
DrawCircleV :: proc "c" (center: [2]f32, radius: f32, color: Color) ---

Draw a color-filled circle (Vector version)

DrawCubeV #

Source 
DrawCubeV :: proc "c" (position, size: [3]f32, color: Color) ---

Draw cube (Vector version)

DrawCubeWires #

Source 
DrawCubeWires :: proc "c" (position: [3]f32, width, height, length: f32, color: Color) ---

Draw cube wires

DrawCubeWiresV #

Source 
DrawCubeWiresV :: proc "c" (position, size: [3]f32, color: Color) ---

Draw cube wires (Vector version)

DrawCylinder #

Source 
DrawCylinder :: proc "c" (
	position:                [3]f32, 
	radiusTop, radiusBottom: f32, 
	height:                  f32, 
	slices:                  i32, 
	color:                   Color, 
) ---

Draw a cylinder/cone

DrawCylinderEx #

Source 
DrawCylinderEx :: proc "c" (
	startPos, endPos:       [3]f32, 
	startRadius, endRadius: f32, 
	sides:                  i32, 
	color:                  Color, 
) ---

Draw a cylinder with base at startPos and top at endPos

DrawCylinderWires #

Source 
DrawCylinderWires :: proc "c" (
	position:                [3]f32, 
	radiusTop, radiusBottom: f32, 
	height:                  f32, 
	slices:                  i32, 
	color:                   Color, 
) ---

Draw a cylinder/cone wires

DrawCylinderWiresEx #

Source 
DrawCylinderWiresEx :: proc "c" (
	startPos, endPos:       [3]f32, 
	startRadius, endRadius: f32, 
	sides:                  i32, 
	color:                  Color, 
) ---

Draw a cylinder wires with base at startPos and top at endPos

DrawEllipseLines #

Source 
DrawEllipseLines :: proc "c" (centerX, centerY: i32, radiusH, radiusV: f32, color: Color) ---

Draw ellipse outline

DrawGrid #

Source 
DrawGrid :: proc "c" (slices: i32, spacing: f32) ---

Draw a grid (centered at (0, 0, 0))

DrawLine #

Source 
DrawLine :: proc "c" (startPosX, startPosY, endPosX, endPosY: i32, color: Color) ---

Draw a line

DrawLine3D #

Source 
DrawLine3D :: proc "c" (startPos, endPos: [3]f32, color: Color) ---

Draw a line in 3D world space

DrawLineBezier #

Source 
DrawLineBezier :: proc "c" (startPos, endPos: [2]f32, thick: f32, color: Color) ---

Draw line segment cubic-bezier in-out interpolation

DrawLineEx #

Source 
DrawLineEx :: proc "c" (startPos, endPos: [2]f32, thick: f32, color: Color) ---

Draw a line (using triangles/quads)

DrawLineStrip #

Source 
DrawLineStrip :: proc "c" (points: [^][2]f32, pointCount: i32, color: Color) ---

Draw lines sequence (using gl lines)

DrawLineV #

Source 
DrawLineV :: proc "c" (startPos, endPos: [2]f32, color: Color) ---

Draw a line (using gl lines)

DrawMesh #

Source 
DrawMesh :: proc "c" (mesh: Mesh, material: Material, transform: matrix[4, 4]f32) ---

Draw a 3d mesh with material and transform

DrawMeshInstanced #

Source 
DrawMeshInstanced :: proc "c" (mesh: Mesh, material: Material, transforms: [^]matrix[4, 4]f32, instances: i32) ---

Draw multiple mesh instances with material and different transforms

DrawModelEx #

Source 
DrawModelEx :: proc "c" (
	model:         Model, 
	position:      [3]f32, 
	rotationAxis:  [3]f32, 
	rotationAngle: f32, 
	scale:         [3]f32, 
	tint:          Color, 
) ---

Draw a model with extended parameters

DrawModelPointsEx #

Source 
DrawModelPointsEx :: proc "c" (
	model:         Model, 
	position:      [3]f32, 
	rotationAxis:  [3]f32, 
	rotationAngle: f32, 
	scale:         [3]f32, 
	tint:          Color, 
) ---

Draw a model as points with extended parameters

DrawModelWires #

Source 
DrawModelWires :: proc "c" (model: Model, position: [3]f32, scale: f32, tint: Color) ---

Draw a model wires (with texture if set)

DrawModelWiresEx #

Source 
DrawModelWiresEx :: proc "c" (
	model:         Model, 
	position:      [3]f32, 
	rotationAxis:  [3]f32, 
	rotationAngle: f32, 
	scale:         [3]f32, 
	tint:          Color, 
) ---

Draw a model wires (with texture if set) with extended parameters

DrawPixel #

Source 
DrawPixel :: proc "c" (posX, posY: i32, color: Color) ---

Draw a pixel using geometry [Can be slow, use with care]

DrawPixelV #

Source 
DrawPixelV :: proc "c" (position: [2]f32, color: Color) ---

Draw a pixel using geometry (Vector version) [Can be slow, use with care]

DrawPoint3D #

Source 
DrawPoint3D :: proc "c" (position: [3]f32, color: Color) ---

Draw a point in 3D space, actually a small line

DrawPolyLines #

Source 
DrawPolyLines :: proc "c" (center: [2]f32, sides: i32, radius: f32, rotation: f32, color: Color) ---

Draw a polygon outline of n sides

DrawPolyLinesEx #

Source 
DrawPolyLinesEx :: proc "c" (
	center:    [2]f32, 
	sides:     i32, 
	radius:    f32, 
	rotation:  f32, 
	lineThick: f32, 
	color:     Color, 
) ---

Draw a polygon outline of n sides with extended parameters

DrawRectangle #

Source 
DrawRectangle :: proc "c" (posX, posY: i32, width, height: i32, color: Color) ---

Draw a color-filled rectangle

DrawRectangleGradientEx #

Source 
DrawRectangleGradientEx :: proc "c" (rec: Rectangle, topLeft, bottomLeft, topRight, bottomRight: Color) ---

Draw a gradient-filled rectangle with custom vertex colors

DrawRectangleGradientH #

Source 
DrawRectangleGradientH :: proc "c" (
	posX, posY:    i32, 
	width, height: i32, 
	left, right:   Color, 
) ---

Draw a horizontal-gradient-filled rectangle

DrawRectangleGradientV #

Source 
DrawRectangleGradientV :: proc "c" (
	posX, posY:    i32, 
	width, height: i32, 
	top, bottom:   Color, 
) ---

Draw a vertical-gradient-filled rectangle

DrawRectangleLines #

Source 
DrawRectangleLines :: proc "c" (posX, posY: i32, width, height: i32, color: Color) ---

Draw rectangle outline

DrawRectangleLinesEx #

Source 
DrawRectangleLinesEx :: proc "c" (rec: Rectangle, lineThick: f32, color: Color) ---

Draw rectangle outline with extended parameters

DrawRectanglePro #

Source 
DrawRectanglePro :: proc "c" (rec: Rectangle, origin: [2]f32, rotation: f32, color: Color) ---

Draw a color-filled rectangle with pro parameters

DrawRectangleRoundedLines #

Source 
DrawRectangleRoundedLines :: proc "c" (rec: Rectangle, roundness: f32, segments: i32, color: Color) ---

Draw rectangle lines with rounded edges

DrawRectangleRoundedLinesEx #

Source 
DrawRectangleRoundedLinesEx :: proc "c" (rec: Rectangle, roundness: f32, segments: i32, lineThick: f32, color: Color) ---

Draw rectangle with rounded edges outline

DrawRectangleV #

Source 
DrawRectangleV :: proc "c" (position: [2]f32, size: [2]f32, color: Color) ---

Draw a color-filled rectangle (Vector version)

DrawRing #

Source 
DrawRing :: proc "c" (
	center:                   [2]f32, 
	innerRadius, outerRadius: f32, 
	startAngle, endAngle:     f32, 
	segments:                 i32, 
	color:                    Color, 
) ---

Draw ring

DrawRingLines #

Source 
DrawRingLines :: proc "c" (
	center:                   [2]f32, 
	innerRadius, outerRadius: f32, 
	startAngle, endAngle:     f32, 
	segments:                 i32, 
	color:                    Color, 
) ---

Draw ring outline

DrawSphereEx #

Source 
DrawSphereEx :: proc "c" (centerPos: [3]f32, radius: f32, rings, slices: i32, color: Color) ---

Draw sphere with extended parameters

DrawSphereWires #

Source 
DrawSphereWires :: proc "c" (centerPos: [3]f32, radius: f32, rings, slices: i32, color: Color) ---

Draw sphere wires

DrawSplineBasis #

Source 
DrawSplineBasis :: proc "c" (points: [^][2]f32, pointCount: i32, thick: f32, color: Color) ---

Draw spline: B-Spline, minimum 4 points

DrawSplineBezierCubic #

Source 
DrawSplineBezierCubic :: proc "c" (points: [^][2]f32, pointCount: i32, thick: f32, color: Color) ---

Draw spline: Cubic Bezier, minimum 4 points (2 control points): [p1, c2, c3, p4, c5, c6...]

DrawSplineBezierQuadratic #

Source 
DrawSplineBezierQuadratic :: proc "c" (points: [^][2]f32, pointCount: i32, thick: f32, color: Color) ---

Draw spline: Quadratic Bezier, minimum 3 points (1 control point): [p1, c2, p3, c4...]

DrawSplineCatmullRom #

Source 
DrawSplineCatmullRom :: proc "c" (points: [^][2]f32, pointCount: i32, thick: f32, color: Color) ---

Draw spline: Catmull-Rom, minimum 4 points

DrawSplineLinear #

Source 
DrawSplineLinear :: proc "c" (points: [^][2]f32, pointCount: i32, thick: f32, color: Color) ---

Splines drawing functions

DrawSplineSegmentBasis #

Source 
DrawSplineSegmentBasis :: proc "c" (
	p1, p2, p3, p4: [2]f32, 
	thick:          f32, 
	color:          Color, 
) ---

Draw spline segment: B-Spline, 4 points

DrawSplineSegmentBezierCubic #

Source 
DrawSplineSegmentBezierCubic :: proc "c" (
	p1, c2, c3, p4: [2]f32, 
	thick:          f32, 
	color:          Color, 
) ---

Draw spline segment: Cubic Bezier, 2 points, 2 control points

DrawSplineSegmentBezierQuadratic #

Source 
DrawSplineSegmentBezierQuadratic :: proc "c" (p1, c2, p3: [2]f32, thick: f32, color: Color) ---

Draw spline segment: Quadratic Bezier, 2 points, 1 control point

DrawSplineSegmentCatmullRom #

Source 
DrawSplineSegmentCatmullRom :: proc "c" (
	p1, p2, p3, p4: [2]f32, 
	thick:          f32, 
	color:          Color, 
) ---

Draw spline segment: Catmull-Rom, 4 points

DrawSplineSegmentLinear #

Source 
DrawSplineSegmentLinear :: proc "c" (p1, p2: [2]f32, thick: f32, color: Color) ---

Draw spline segment: Linear, 2 points

DrawTextCodepoint #

Source 
DrawTextCodepoint :: proc "c" (font: Font, codepoint: rune, position: [2]f32, fontSize: f32, tint: Color) ---

Draw one character (codepoint)

DrawTextCodepoints #

Source 
DrawTextCodepoints :: proc "c" (
	font:           Font, 
	codepoints:     [^]rune, 
	codepointCount: i32, 
	position:       [2]f32, 
	fontSize:       f32, 
	spacing:        f32, 
	tint:           Color, 
) ---

Draw multiple character (codepoint)

DrawTextPro #

Source 
DrawTextPro :: proc "c" (
	font:             Font, 
	text:             cstring, 
	position, origin: [2]f32, 
	rotation:         f32, 
	fontSize:         f32, 
	spacing:          f32, 
	tint:             Color, 
) ---

Draw text using Font and pro parameters (rotation)

DrawTexturePro #

Source 
DrawTexturePro :: proc "c" (
	texture:      Texture, 
	source, dest: Rectangle, 
	origin:       [2]f32, 
	rotation:     f32, 
	tint:         Color, 
) ---

Draw a part of a texture defined by a rectangle with 'pro' parameters

DrawTextureV #

Source 
DrawTextureV :: proc "c" (texture: Texture, position: [2]f32, tint: Color) ---

Draw a Texture2D with position defined as Vector2

DrawTriangle #

Source 
DrawTriangle :: proc "c" (v1, v2, v3: [2]f32, color: Color) ---

Draw a color-filled triangle (vertex in counter-clockwise order!)

DrawTriangle3D #

Source 
DrawTriangle3D :: proc "c" (v1, v2, v3: [3]f32, color: Color) ---

Draw a color-filled triangle (vertex in counter-clockwise order!)

DrawTriangleFan #

Source 
DrawTriangleFan :: proc "c" (points: [^][2]f32, pointCount: i32, color: Color) ---

Draw a triangle fan defined by points (first vertex is the center)

DrawTriangleLines #

Source 
DrawTriangleLines :: proc "c" (v1, v2, v3: [2]f32, color: Color) ---

Draw triangle outline (vertex in counter-clockwise order!)

DrawTriangleStrip #

Source 
DrawTriangleStrip :: proc "c" (points: [^][2]f32, pointCount: i32, color: Color) ---

Draw a triangle strip defined by points

DrawTriangleStrip3D #

Source 
DrawTriangleStrip3D :: proc "c" (points: [^][3]f32, pointCount: i32, color: Color) ---

Draw a triangle strip defined by points

EaseElasticIn #

Source 
EaseElasticIn :: proc(t, b, c, d: f32) -> f32 {…}

Elastic Easing functions

EnableCursor #

Source 
EnableCursor :: proc "c" () ---

Enables cursor (unlock cursor)

EnableEventWaiting #

Source 
EnableEventWaiting :: proc "c" () ---

Enable waiting for events on EndDrawing(), no automatic event polling

EncodeDataBase64 #

Source 
EncodeDataBase64 :: proc "c" (data: rawptr, dataSize: i32, outputSize: ^i32) -> [^]u8 ---

Encode data to Base64 string, memory must be MemFree()

EndBlendMode #

Source 
EndBlendMode :: proc "c" () ---

End blending mode (reset to default: alpha blending)

EndDrawing #

Source 
EndDrawing :: proc "c" () ---

End canvas drawing and swap buffers (double buffering)

EndMode2D #

Source 
EndMode2D :: proc "c" () ---

Ends 2D mode with custom camera

EndMode3D #

Source 
EndMode3D :: proc "c" () ---

Ends 3D mode and returns to default 2D orthographic mode

EndScissorMode #

Source 
EndScissorMode :: proc "c" () ---

End scissor mode

EndShaderMode #

Source 
EndShaderMode :: proc "c" () ---

End custom shader drawing (use default shader)

EndTextureMode #

Source 
EndTextureMode :: proc "c" () ---

Ends drawing to render texture

EndVrStereoMode #

Source 
EndVrStereoMode :: proc "c" () ---

End stereo rendering (requires VR simulator)

ExportFontAsCode #

Source 
ExportFontAsCode :: proc "c" (font: Font, fileName: cstring) -> bool ---

Export font as code file, returns true on success

ExportImageAsCode #

Source 
ExportImageAsCode :: proc "c" (image: Image, fileName: cstring) -> bool ---

Export image as code file defining an array of bytes, returns true on success

ExportMeshAsCode #

Source 
ExportMeshAsCode :: proc "c" (mesh: Mesh, fileName: cstring) -> bool ---

Export mesh as code file (.h) defining multiple arrays of vertex attributes

ExportWaveAsCode #

Source 
ExportWaveAsCode :: proc "c" (wave: Wave, fileName: cstring) -> bool ---

Export wave sample data to code (.h), returns true on success

FloatEquals #

Source 
@(require_results)
FloatEquals :: proc "c" (x, y: f32) -> bool {…}

Check whether two given floats are almost equal

GenImageCellular #

Source 
GenImageCellular :: proc "c" (width, height: i32, tileSize: i32) -> Image ---

Generate image: cellular algorithm, bigger tileSize means bigger cells

GenImageChecked #

Source 
GenImageChecked :: proc "c" (
	width, height:    i32, 
	checksX, checksY: i32, 
	col1, col2:       Color, 
) -> Image ---

Generate image: checked

GenImageGradientLinear #

Source 
GenImageGradientLinear :: proc "c" (width, height, direction: i32, start, end: Color) -> Image ---

Generate image: linear gradient, direction in degrees [0..360], 0=Vertical gradient

GenImageGradientRadial #

Source 
GenImageGradientRadial :: proc "c" (width, height: i32, density: f32, inner, outer: Color) -> Image ---

Generate image: radial gradient

GenImageGradientSquare #

Source 
GenImageGradientSquare :: proc "c" (width, height: i32, density: f32, inner, outer: Color) -> Image ---

Generate image: square gradient

GenImagePerlinNoise #

Source 
GenImagePerlinNoise :: proc "c" (width, height: i32, offsetX, offsetY: i32, scale: f32) -> Image ---

Generate image: perlin noise

GenImageWhiteNoise #

Source 
GenImageWhiteNoise :: proc "c" (width, height: i32, factor: f32) -> Image ---

Generate image: white noise

GenMeshCube #

Source 
GenMeshCube :: proc "c" (width, height, length: f32) -> Mesh ---

Generate cuboid mesh

GenMeshCubicmap #

Source 
GenMeshCubicmap :: proc "c" (cubicmap: Image, cubeSize: [3]f32) -> Mesh ---

Generate cubes-based map mesh from image data

GenMeshCylinder #

Source 
GenMeshCylinder :: proc "c" (radius, height: f32, slices: i32) -> Mesh ---

Generate cylinder mesh

GenMeshHeightmap #

Source 
GenMeshHeightmap :: proc "c" (heightmap: Image, size: [3]f32) -> Mesh ---

Generate heightmap mesh from image data

GenMeshHemiSphere #

Source 
GenMeshHemiSphere :: proc "c" (radius: f32, rings, slices: i32) -> Mesh ---

Generate half-sphere mesh (no bottom cap)

GenMeshKnot #

Source 
GenMeshKnot :: proc "c" (radius, size: f32, radSeg, sides: i32) -> Mesh ---

Generate trefoil knot mesh

GenMeshPlane #

Source 
GenMeshPlane :: proc "c" (width, length: f32, resX, resZ: i32) -> Mesh ---

Generate plane mesh (with subdivisions)

GenMeshSphere #

Source 
GenMeshSphere :: proc "c" (radius: f32, rings, slices: i32) -> Mesh ---

Generate sphere mesh (standard sphere)

GenMeshTangents #

Source 
GenMeshTangents :: proc "c" (mesh: ^Mesh) ---

Compute mesh tangents

GenTextureMipmaps #

Source 
GenTextureMipmaps :: proc "c" (texture: ^Texture) ---

Generate GPU mipmaps for a texture

GetApplicationDirectory #

Source 
GetApplicationDirectory :: proc "c" () -> cstring ---

Get the directory of the running application (uses static string)

GetCameraForward #

Source 
GetCameraForward :: proc "c" (camera: ^Camera3D) -> [3]f32 ---

returns the camera's forward vector (normalized)

GetCameraMatrix #

Source 
GetCameraMatrix :: proc "c" (camera: Camera3D) -> matrix[4, 4]f32 ---

Get camera transform matrix (view matrix)

GetCameraMatrix2D #

Source 
GetCameraMatrix2D :: proc "c" (camera: Camera2D) -> matrix[4, 4]f32 ---

Get camera 2d transform matrix

GetCameraProjectionMatrix #

Source 
GetCameraProjectionMatrix :: proc "c" (camera: ^Camera3D, aspect: f32) -> matrix[4, 4]f32 ---

returns the camera projection matrix

GetCameraRight #

Source 
GetCameraRight :: proc "c" (camera: ^Camera3D) -> [3]f32 ---

returns the camera's right vector (normalized)

GetCameraUp #

Source 
GetCameraUp :: proc "c" (camera: ^Camera3D) -> [3]f32 ---

returns the camera's up vector (normalized) - might not be perpendicular to forward vector

GetCameraViewMatrix #

Source 
GetCameraViewMatrix :: proc "c" (camera: ^Camera3D) -> matrix[4, 4]f32 ---

returns the camera view matrix

GetCharPressed #

Source 
GetCharPressed :: proc "c" () -> rune ---

Get char pressed (unicode), call it multiple times for chars queued

GetClipboardImage #

Source 
GetClipboardImage :: proc "c" () -> Image ---

Get clipboard image content

GetCodepoint #

Source 
GetCodepoint :: proc "c" (text: cstring, codepointSize: ^i32) -> rune ---

Get next codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure

GetCodepointCount #

Source 
GetCodepointCount :: proc "c" (text: cstring) -> i32 ---

Get total number of codepoints in a UTF-8 encoded string

GetCodepointNext #

Source 
GetCodepointNext :: proc "c" (text: cstring, codepointSize: ^i32) -> rune ---

Get next codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure

GetCodepointPrevious #

Source 
GetCodepointPrevious :: proc "c" (text: cstring, codepointSize: ^i32) -> rune ---

Get previous codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure

GetColor #

Source 
GetColor :: proc "c" (hexValue: u32) -> Color ---

Get Color structure from hexadecimal value

GetCurrentMonitor #

Source 
GetCurrentMonitor :: proc "c" () -> i32 ---

Get current monitor where window is placed

GetDirectoryPath #

Source 
GetDirectoryPath :: proc "c" (filePath: cstring) -> cstring ---

Get full path for a given fileName with path (uses static string)

GetFileExtension #

Source 
GetFileExtension :: proc "c" (fileName: cstring) -> cstring ---

Get pointer to extension for a filename string (includes dot: '.png')

GetFileLength #

Source 
GetFileLength :: proc "c" (fileName: cstring) -> i32 ---

Get file length in bytes (NOTE: GetFileSize() conflicts with windows.h)

GetFileModTime #

Source 
GetFileModTime :: proc "c" (fileName: cstring) -> i32 ---

Get file modification time (last write time)

GetFileNameWithoutExt #

Source 
GetFileNameWithoutExt :: proc "c" (filePath: cstring) -> cstring ---

Get filename string without extension (uses static string)

GetFrameTime #

Source 
GetFrameTime :: proc "c" () -> f32 ---

Returns time in seconds for last frame drawn (delta time)

GetGamepadAxisCount #

Source 
GetGamepadAxisCount :: proc "c" (gamepad: i32) -> i32 ---

Get gamepad axis count for a gamepad

GetGamepadAxisMovement #

Source 
GetGamepadAxisMovement :: proc "c" (gamepad: i32, axis: GamepadAxis) -> f32 ---

Get axis movement value for a gamepad axis

GetGestureDragAngle #

Source 
GetGestureDragAngle :: proc "c" () -> f32 ---

Get gesture drag angle

GetGestureDragVector #

Source 
GetGestureDragVector :: proc "c" () -> [2]f32 ---

Get gesture drag vector

GetGestureHoldDuration #

Source 
GetGestureHoldDuration :: proc "c" () -> f32 ---

Get gesture hold time in seconds

GetGesturePinchAngle #

Source 
GetGesturePinchAngle :: proc "c" () -> f32 ---

Get gesture pinch angle

GetGesturePinchVector #

Source 
GetGesturePinchVector :: proc "c" () -> [2]f32 ---

Get gesture pinch delta

GetGlyphAtlasRec #

Source 
GetGlyphAtlasRec :: proc "c" (font: Font, codepoint: rune) -> Rectangle ---

Get glyph rectangle in font atlas for a codepoint (unicode character), fallback to '?' if not found

GetGlyphIndex #

Source 
GetGlyphIndex :: proc "c" (font: Font, codepoint: rune) -> i32 ---

Get glyph index position in font for a codepoint (unicode character), fallback to '?' if not found

GetGlyphInfo #

Source 
GetGlyphInfo :: proc "c" (font: Font, codepoint: rune) -> GlyphInfo ---

Get glyph font info data for a codepoint (unicode character), fallback to '?' if not found

GetKeyPressed #

Source 
GetKeyPressed :: proc "c" () -> KeyboardKey ---

Get key pressed (keycode), call it multiple times for keys queued

GetMasterVolume #

Source 
GetMasterVolume :: proc "c" () -> f32 ---

Get master volume (listener)

GetModelBoundingBox #

Source 
GetModelBoundingBox :: proc "c" (model: Model) -> BoundingBox ---

Compute model bounding box limits (considers all meshes)

GetMonitorCount #

Source 
GetMonitorCount :: proc "c" () -> i32 ---

Get number of connected monitors

GetMonitorHeight #

Source 
GetMonitorHeight :: proc "c" (monitor: i32) -> i32 ---

Get specified monitor height (current video mode used by monitor)

GetMonitorName #

Source 
GetMonitorName :: proc "c" (monitor: i32) -> cstring ---

Get the human-readable, UTF-8 encoded name of the specified monitor

GetMonitorPhysicalHeight #

Source 
GetMonitorPhysicalHeight :: proc "c" (monitor: i32) -> i32 ---

Get specified monitor physical height in millimetres

GetMonitorPhysicalWidth #

Source 
GetMonitorPhysicalWidth :: proc "c" (monitor: i32) -> i32 ---

Get specified monitor physical width in millimetres

GetMonitorPosition #

Source 
GetMonitorPosition :: proc "c" (monitor: i32) -> [2]f32 ---

Get specified monitor position

GetMonitorRefreshRate #

Source 
GetMonitorRefreshRate :: proc "c" (monitor: i32) -> i32 ---

Get specified monitor refresh rate

GetMonitorWidth #

Source 
GetMonitorWidth :: proc "c" (monitor: i32) -> i32 ---

Get specified monitor width (current video mode used by monitor)

GetMouseDelta #

Source 
GetMouseDelta :: proc "c" () -> [2]f32 ---

Returns mouse delta XY

GetMousePosition #

Source 
GetMousePosition :: proc "c" () -> [2]f32 ---

Returns mouse position XY

GetMouseWheelMove #

Source 
GetMouseWheelMove :: proc "c" () -> f32 ---

Returns mouse wheel movement Y

GetMouseWheelMoveV #

Source 
GetMouseWheelMoveV :: proc "c" () -> [2]f32 ---

Get mouse wheel movement for both X and Y

GetMusicTimeLength #

Source 
GetMusicTimeLength :: proc "c" (music: Music) -> f32 ---

Get music time length (in seconds)

GetMusicTimePlayed #

Source 
GetMusicTimePlayed :: proc "c" (music: Music) -> f32 ---

Get current music time played (in seconds)

GetPixelDataSize #

Source 
GetPixelDataSize :: proc "c" (width, height: i32, format: PixelFormat) -> i32 ---

Get pixel data size in bytes for certain format

GetPrevDirectoryPath #

Source 
GetPrevDirectoryPath :: proc "c" (dirPath: cstring) -> cstring ---

Get previous directory path for a given path (uses static string)

GetRandomValue #

Source 
GetRandomValue :: proc "c" (min, max: i32) -> i32 ---

Get a random value between min and max (both included)

GetRayCollisionTriangle #

Source 
GetRayCollisionTriangle :: proc "c" (ray: Ray, p1, p2, p3: [3]f32) -> RayCollision ---

Get collision info between ray and triangle

GetRenderHeight #

Source 
GetRenderHeight :: proc "c" () -> i32 ---

Get current render height (it considers HiDPI)

GetRenderWidth #

Source 
GetRenderWidth :: proc "c" () -> i32 ---

Get current render width (it considers HiDPI)

GetScreenHeight #

Source 
GetScreenHeight :: proc "c" () -> i32 ---

Get current screen height

GetScreenToWorld2D #

Source 
GetScreenToWorld2D :: proc "c" (position: [2]f32, camera: Camera2D) -> [2]f32 ---

Get the world space position for a 2d camera screen space position

GetScreenToWorldRay #

Source 
GetScreenToWorldRay :: proc "c" (position: [2]f32, camera: Camera3D) -> Ray ---

Get a ray trace from screen position (i.e mouse)

GetScreenToWorldRayEx #

Source 
GetScreenToWorldRayEx :: proc "c" (position: [2]f32, camera: Camera3D, width: i32, height: i32) -> Ray ---

Get a ray trace from screen position (i.e mouse) in a viewport

GetScreenWidth #

Source 
GetScreenWidth :: proc "c" () -> i32 ---

Get current screen width

GetShapesTexture #

Source 
GetShapesTexture :: proc "c" () -> Texture ---

Get texture that is used for shapes drawing

GetShapesTextureRectangle #

Source 
GetShapesTextureRectangle :: proc "c" () -> Rectangle ---

Get texture source rectangle that is used for shapes drawing

GetSplinePointBasis #

Source 
GetSplinePointBasis :: proc "c" (p1, p2, p3, p4: [2]f32, t: f32) -> [2]f32 ---

Get (evaluate) spline point: B-Spline

GetSplinePointBezierCubic #

Source 
GetSplinePointBezierCubic :: proc "c" (p1, c2, c3, p4: [2]f32, t: f32) -> [2]f32 ---

Get (evaluate) spline point: Cubic Bezier

GetSplinePointBezierQuad #

Source 
GetSplinePointBezierQuad :: proc "c" (p1, c2, p3: [2]f32, t: f32) -> [2]f32 ---

Get (evaluate) spline point: Quadratic Bezier

GetSplinePointCatmullRom #

Source 
GetSplinePointCatmullRom :: proc "c" (p1, p2, p3, p4: [2]f32, t: f32) -> [2]f32 ---

Get (evaluate) spline point: Catmull-Rom

GetSplinePointLinear #

Source 
GetSplinePointLinear :: proc "c" (startPos, endPos: [2]f32, t: f32) -> [2]f32 ---

Spline segment point evaluation functions, for a given t [0.0f .. 1.0f]

GetTime #

Source 
GetTime :: proc "c" () -> f64 ---

Returns elapsed time in seconds since InitWindow()

GetTouchPointCount #

Source 
GetTouchPointCount :: proc "c" () -> i32 ---

Get number of touch points

GetTouchPointId #

Source 
GetTouchPointId :: proc "c" (index: i32) -> i32 ---

Get touch point identifier for given index

GetTouchPosition #

Source 
GetTouchPosition :: proc "c" (index: i32) -> [2]f32 ---

Returns touch position XY for a touch point index (relative to screen size)

GetTouchX #

Source 
GetTouchX :: proc "c" () -> i32 ---

Returns touch position X for touch point 0 (relative to screen size)

GetTouchY #

Source 
GetTouchY :: proc "c" () -> i32 ---

Returns touch position Y for touch point 0 (relative to screen size)

GetWindowPosition #

Source 
GetWindowPosition :: proc "c" () -> [2]f32 ---

Get window position XY on monitor

GetWindowScaleDPI #

Source 
GetWindowScaleDPI :: proc "c" () -> [2]f32 ---

Get window scale DPI factor

GetWorkingDirectory #

Source 
GetWorkingDirectory :: proc "c" () -> cstring ---

Get current working directory (uses static string)

GetWorldToScreen #

Source 
GetWorldToScreen :: proc "c" (position: [3]f32, camera: Camera3D) -> [2]f32 ---

Get the screen space position for a 3d world space position

GetWorldToScreen2D #

Source 
GetWorldToScreen2D :: proc "c" (position: [2]f32, camera: Camera2D) -> [2]f32 ---

Get the screen space position for a 2d camera world space position

GetWorldToScreenEx #

Source 
GetWorldToScreenEx :: proc "c" (position: [3]f32, camera: Camera3D, width: i32, height: i32) -> [2]f32 ---

Get size position for a 3d world space position

GuiColorPanelHSV #

Source 
GuiColorPanelHSV :: proc "c" (bounds: Rectangle, text: cstring, colorHsv: ^[3]f32) -> i32 ---

Color Panel control that returns HSV color value, used by GuiColorPickerHSV()

GuiColorPickerHSV #

Source 
GuiColorPickerHSV :: proc "c" (bounds: Rectangle, text: cstring, colorHsv: ^[3]f32) -> i32 ---

Color Picker control that avoids conversion to RGB on each call (multiple color controls)

GuiDisable #

Source 
GuiDisable :: proc "c" () ---

Disable gui controls (global state)

GuiDisableTooltip #

Source 
GuiDisableTooltip :: proc "c" () ---

Disable gui tooltips (global state)

GuiEnable #

Source 
GuiEnable :: proc "c" () ---

Enable gui controls (global state)

GuiEnableTooltip #

Source 
GuiEnableTooltip :: proc "c" () ---

Enable gui tooltips (global state)

GuiGetFont #

Source 
GuiGetFont :: proc "c" () -> Font ---

Get gui custom font (global state)

GuiGetIcons #

Source 
GuiGetIcons :: proc "c" () -> [^]u32 ---

Get raygui icons data pointer

GuiGetState #

Source 
GuiGetState :: proc "c" () -> i32 ---

Get gui state (global state)

GuiIsLocked #

Source 
GuiIsLocked :: proc "c" () -> bool ---

Check if gui is locked (global state)

GuiLoadIcons #

Source 
GuiLoadIcons :: proc "c" (fileName: cstring, loadIconsName: bool) -> [^]cstring ---

Load raygui icons file (.rgi) into internal icons data

GuiLoadStyle #

Source 
GuiLoadStyle :: proc "c" (fileName: cstring) ---

Load style file over global style variable (.rgs)

GuiLoadStyleDefault #

Source 
GuiLoadStyleDefault :: proc "c" () ---

Load style default over global style

GuiLock #

Source 
GuiLock :: proc "c" () ---

Lock gui controls (global state)

GuiSetAlpha #

Source 
GuiSetAlpha :: proc "c" (alpha: f32) ---

Set gui controls alpha (global state), alpha goes from 0.0f to 1.0f

GuiSetFont #

Source 
GuiSetFont :: proc "c" (font: Font) ---

Set gui custom font (global state)

GuiSetIconScale #

Source 
GuiSetIconScale :: proc "c" (scale: i32) ---

Set default icon drawing size

GuiSetState #

Source 
GuiSetState :: proc "c" (state: i32) ---

Set gui state (global state)

GuiUnlock #

Source 
GuiUnlock :: proc "c" () ---

Unlock gui controls (global state)

ImageAlphaClear #

Source 
ImageAlphaClear :: proc "c" (image: ^Image, color: Color, threshold: f32) ---

Clear alpha channel to desired color

ImageAlphaCrop #

Source 
ImageAlphaCrop :: proc "c" (image: ^Image, threshold: f32) ---

Crop image depending on alpha value

ImageAlphaPremultiply #

Source 
ImageAlphaPremultiply :: proc "c" (image: ^Image) ---

Premultiply alpha channel

ImageBlurGaussian #

Source 
ImageBlurGaussian :: proc "c" (image: ^Image, blurSize: i32) ---

Apply Gaussian blur using a box blur approximation

ImageClearBackground #

Source 
ImageClearBackground :: proc "c" (dst: ^Image, color: Color) ---

Clear image background with given color

ImageColorBrightness #

Source 
ImageColorBrightness :: proc "c" (image: ^Image, brightness: i32) ---

Modify image color: brightness (-255 to 255)

ImageColorContrast #

Source 
ImageColorContrast :: proc "c" (image: ^Image, contrast: f32) ---

Modify image color: contrast (-100 to 100)

ImageColorGrayscale #

Source 
ImageColorGrayscale :: proc "c" (image: ^Image) ---

Modify image color: grayscale

ImageColorInvert #

Source 
ImageColorInvert :: proc "c" (image: ^Image) ---

Modify image color: invert

ImageColorReplace #

Source 
ImageColorReplace :: proc "c" (image: ^Image, color, replace: Color) ---

Modify image color: replace color

ImageCopy #

Source 
ImageCopy :: proc "c" (image: Image) -> Image ---

Create an image duplicate (useful for transformations)

ImageDither #

Source 
ImageDither :: proc "c" (image: ^Image, rBpp, gBpp, bBpp, aBpp: i32) ---

Dither image data to 16bpp or lower (Floyd-Steinberg dithering)

ImageDrawCircle #

Source 
ImageDrawCircle :: proc "c" (dst: ^Image, centerX, centerY: i32, radius: i32, color: Color) ---

Draw a filled circle within an image

ImageDrawCircleLines #

Source 
ImageDrawCircleLines :: proc "c" (dst: ^Image, centerX, centerY: i32, radius: i32, color: Color) ---

Draw circle outline within an image

ImageDrawCircleLinesV #

Source 
ImageDrawCircleLinesV :: proc "c" (dst: ^Image, center: [2]f32, radius: i32, color: Color) ---

Draw circle outline within an image (Vector version)

ImageDrawCircleV #

Source 
ImageDrawCircleV :: proc "c" (dst: ^Image, center: [2]f32, radius: i32, color: Color) ---

Draw a filled circle within an image (Vector version)

ImageDrawLine #

Source 
ImageDrawLine :: proc "c" (
	dst:                                    ^Image, 
	startPosX, startPosY, endPosX, endPosY: i32, 
	color:                                  Color, 
) ---

Draw line within an image

ImageDrawLineEx #

Source 
ImageDrawLineEx :: proc "c" (dst: ^Image, start, end: [2]f32, thick: i32, color: Color) ---

Draw a line defining thickness within an image

ImageDrawLineV #

Source 
ImageDrawLineV :: proc "c" (dst: ^Image, start, end: [2]f32, color: Color) ---

Draw line within an image (Vector version)

ImageDrawPixelV #

Source 
ImageDrawPixelV :: proc "c" (dst: ^Image, position: [2]f32, color: Color) ---

Draw pixel within an image (Vector version)

ImageDrawRectangle #

Source 
ImageDrawRectangle :: proc "c" (
	dst:           ^Image, 
	posX, posY:    i32, 
	width, height: i32, 
	color:         Color, 
) ---

Draw rectangle within an image

ImageDrawRectangleV #

Source 
ImageDrawRectangleV :: proc "c" (dst: ^Image, position, size: [2]f32, color: Color) ---

Draw rectangle within an image (Vector version)

ImageDrawText #

Source 
ImageDrawText :: proc "c" (
	dst:        ^Image, 
	text:       cstring, 
	posX, posY: i32, 
	fontSize:   i32, 
	color:      Color, 
) ---

Draw text (using default font) within an image (destination)

ImageDrawTextEx #

Source 
ImageDrawTextEx :: proc "c" (
	dst:      ^Image, 
	font:     Font, 
	text:     cstring, 
	position: [2]f32, 
	fontSize: f32, 
	spacing:  f32, 
	tint:     Color, 
) ---

Draw text (custom sprite font) within an image (destination)

ImageDrawTriangle #

Source 
ImageDrawTriangle :: proc "c" (dst: ^Image, v1, v2, v3: [2]f32, color: Color) ---

Draw triangle within an image

ImageDrawTriangleEx #

Source 
ImageDrawTriangleEx :: proc "c" (
	dst:        ^Image, 
	v1, v2, v3: [2]f32, 
	c1, c2, c3: Color, 
) ---

Draw triangle with interpolated colors within an image

ImageDrawTriangleFan #

Source 
ImageDrawTriangleFan :: proc "c" (dst: ^Image, points: [^][2]f32, pointCount: i32, color: Color) ---

Draw a triangle fan defined by points within an image (first vertex is the center)

ImageDrawTriangleLines #

Source 
ImageDrawTriangleLines :: proc "c" (dst: ^Image, v1, v2, v3: [2]f32, color: Color) ---

Draw triangle outline within an image

ImageDrawTriangleStrip #

Source 
ImageDrawTriangleStrip :: proc "c" (dst: ^Image, points: [^][2]f32, pointCount: i32, color: Color) ---

Draw a triangle strip defined by points within an image

ImageFlipHorizontal #

Source 
ImageFlipHorizontal :: proc "c" (image: ^Image) ---

Flip image horizontally

ImageFlipVertical #

Source 
ImageFlipVertical :: proc "c" (image: ^Image) ---

Flip image vertically

ImageFromChannel #

Source 
ImageFromChannel :: proc "c" (image: Image, selectedChannel: i32) -> Image ---

Create an image from a selected channel of another image (GRAYSCALE)

ImageKernelConvolution #

Source 
ImageKernelConvolution :: proc "c" (image: ^Image, kernel: [^]f32, kernelSize: i32) ---

Apply custom square convolution kernel to image

ImageMipmaps #

Source 
ImageMipmaps :: proc "c" (image: ^Image) ---

Compute all mipmap levels for a provided image

ImageResize #

Source 
ImageResize :: proc "c" (image: ^Image, newWidth, newHeight: i32) ---

Resize image (Bicubic scaling algorithm)

ImageResizeCanvas #

Source 
ImageResizeCanvas :: proc "c" (
	image:               ^Image, 
	newWidth, newHeight: i32, 
	offsetX, offsetY:    i32, 
	fill:                Color, 
) ---

Resize canvas and fill with color

ImageResizeNN #

Source 
ImageResizeNN :: proc "c" (image: ^Image, newWidth, newHeight: i32) ---

Resize image (Nearest-Neighbor scaling algorithm)

ImageRotate #

Source 
ImageRotate :: proc "c" (image: ^Image, degrees: i32) ---

Rotate image by input angle in degrees( -359 to 359)

ImageRotateCCW #

Source 
ImageRotateCCW :: proc "c" (image: ^Image) ---

Rotate image counter-clockwise 90deg

ImageRotateCW #

Source 
ImageRotateCW :: proc "c" (image: ^Image) ---

Rotate image clockwise 90deg

InitAudioDevice #

Source 
InitAudioDevice :: proc "c" () ---

Initialize audio device and context

InitWindow #

Source 
InitWindow :: proc "c" (width, height: i32, title: cstring) ---

Initialize window and OpenGL context

IsAudioDeviceReady #

Source 
IsAudioDeviceReady :: proc "c" () -> bool ---

Check if audio device has been initialized successfully

IsAudioStreamProcessed #

Source 
IsAudioStreamProcessed :: proc "c" (stream: AudioStream) -> bool ---

Check if any audio stream buffers requires refill

IsAudioStreamReady #

Source 
IsAudioStreamReady :: proc "c" (stream: AudioStream) -> bool ---

Checks if an audio stream is valid (buffers initialized)

IsAudioStreamValid #

Source 
IsAudioStreamValid :: proc "c" (stream: AudioStream) -> bool ---

Checks if an audio stream is valid (buffers initialized)

IsCursorHidden #

Source 
IsCursorHidden :: proc "c" () -> bool ---

Check if cursor is not visible

IsCursorOnScreen #

Source 
IsCursorOnScreen :: proc "c" () -> bool ---

Check if cursor is on the current screen.

IsFileDropped #

Source 
IsFileDropped :: proc "c" () -> bool ---

Check if a file has been dropped into window

IsFileExtension #

Source 
IsFileExtension :: proc "c" (fileName, ext: cstring) -> bool ---

Check file extension (including point: .png, .wav)

IsFileNameValid #

Source 
IsFileNameValid :: proc "c" (fileName: cstring) -> bool ---

Check if fileName is valid for the platform/OS

IsFontReady #

Source 
IsFontReady :: proc "c" (font: Font) -> bool ---

Check if a font is valid (font data loaded, WARNING: GPU texture not checked)

IsFontValid #

Source 
IsFontValid :: proc "c" (font: Font) -> bool ---

Check if a font is valid (font data loaded, WARNING: GPU texture not checked)

IsGamepadAvailable #

Source 
IsGamepadAvailable :: proc "c" (gamepad: i32) -> bool ---

Check if a gamepad is available

IsGestureDetected #

Source 
IsGestureDetected :: proc "c" (gesture: Gesture) -> bool {…}

Check if a gesture have been detected

IsMaterialReady #

Source 
IsMaterialReady :: proc "c" (material: Material) -> bool ---

Check if a material is valid (shader assigned, map textures loaded in GPU)

IsMaterialValid #

Source 
IsMaterialValid :: proc "c" (material: Material) -> bool ---

Check if a material is valid (shader assigned, map textures loaded in GPU)

IsModelReady #

Source 
IsModelReady :: proc "c" (model: Model) -> bool ---

Check if a model is valid (loaded in GPU, VAO/VBOs)

IsModelValid #

Source 
IsModelValid :: proc "c" (model: Model) -> bool ---

Check if a model is valid (loaded in GPU, VAO/VBOs)

IsMouseButtonReleased #

Source 
IsMouseButtonReleased :: proc "c" (button: MouseButton) -> bool ---

Detect if a mouse button has been released once

IsMusicReady #

Source 
IsMusicReady :: proc "c" (music: Music) -> bool ---

Checks if a music stream is valid (context and buffers initialized)

IsMusicStreamPlaying #

Source 
IsMusicStreamPlaying :: proc "c" (music: Music) -> bool ---

Check if music is playing

IsMusicValid #

Source 
IsMusicValid :: proc "c" (music: Music) -> bool ---

Checks if a music stream is valid (context and buffers initialized)

IsShaderReady #

Source 
IsShaderReady :: proc "c" (shader: Shader) -> bool ---

Check if a shader is valid (loaded on GPU)

IsShaderValid #

Source 
IsShaderValid :: proc "c" (shader: Shader) -> bool ---

Check if a shader is valid (loaded on GPU)

IsSoundPlaying #

Source 
IsSoundPlaying :: proc "c" (sound: Sound) -> bool ---

Check if a sound is currently playing

IsSoundReady #

Source 
IsSoundReady :: proc "c" (sound: Sound) -> bool ---

Checks if a sound is valid (data loaded and buffers initialized)

IsSoundValid #

Source 
IsSoundValid :: proc "c" (sound: Sound) -> bool ---

Checks if a sound is valid (data loaded and buffers initialized)

IsWaveReady #

Source 
IsWaveReady :: proc "c" (wave: Wave) -> bool ---

Checks if wave data is // Checks if wave data is valid (data loaded and parameters)

IsWaveValid #

Source 
IsWaveValid :: proc "c" (wave: Wave) -> bool ---

Checks if wave data is // Checks if wave data is valid (data loaded and parameters)

IsWindowFocused #

Source 
IsWindowFocused :: proc "c" () -> bool ---

Check if window is currently focused

IsWindowFullscreen #

Source 
IsWindowFullscreen :: proc "c" () -> bool ---

Check if window is currently fullscreen

IsWindowHidden #

Source 
IsWindowHidden :: proc "c" () -> bool ---

Check if window is currently hidden

IsWindowMaximized #

Source 
IsWindowMaximized :: proc "c" () -> bool ---

Check if window is currently maximized

IsWindowMinimized #

Source 
IsWindowMinimized :: proc "c" () -> bool ---

Check if window is currently minimized

IsWindowReady #

Source 
IsWindowReady :: proc "c" () -> bool ---

Check if window has been initialized successfully

IsWindowResized #

Source 
IsWindowResized :: proc "c" () -> bool ---

Check if window has been resized last frame

Lerp #

Source 
@(require_results)
Lerp :: proc "c" (start, end: f32, amount: f32) -> f32 {…}

Calculate linear interpolation between two floats

LoadAudioStream #

Source 
LoadAudioStream :: proc "c" (sampleRate, sampleSize: u32, channels: u32) -> AudioStream ---

Load audio stream (to stream raw audio pcm data)

LoadAutomationEventList #

Source 
LoadAutomationEventList :: proc "c" (fileName: cstring) -> AutomationEventList ---

Load automation events list from file, NULL for empty list, capacity = MAX_AUTOMATION_EVENTS

LoadCodepoints #

Source 
LoadCodepoints :: proc "c" (text: cstring, count: ^i32) -> [^]rune ---

Load all codepoints from a UTF-8 text string, codepoints count returned by parameter

LoadDirectoryFilesEx #

Source 
LoadDirectoryFilesEx :: proc "c" (basePath: cstring, filter: cstring, scanSubdirs: bool) -> FilePathList ---

Load directory filepaths with extension filtering and recursive directory scan. Use 'DIR' in the filter string to include directories in the result

LoadFileData #

Source 
LoadFileData :: proc "c" (fileName: cstring, dataSize: ^i32) -> [^]u8 ---

Load file data as byte array (read)

LoadFileText #

Source 
LoadFileText :: proc "c" (fileName: cstring) -> [^]u8 ---

Load text data from file (read), returns a '\0' terminated string

LoadFontEx #

Source 
LoadFontEx :: proc "c" (fileName: cstring, fontSize: i32, codepoints: [^]rune, codepointCount: i32) -> Font ---

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

LoadFontFromMemory #

Source 
LoadFontFromMemory :: proc "c" (
	fileType:       cstring, 
	fileData:       rawptr, 
	dataSize:       i32, 
	fontSize:       i32, 
	codepoints:     [^]rune, 
	codepointCount: i32, 
) -> Font ---

Load font from memory buffer, fileType refers to extension: i.e. '.ttf'

LoadImageAnim #

Source 
LoadImageAnim :: proc "c" (fileName: cstring, frames: ^i32) -> Image ---

Load image sequence from file (frames appended to image.data)

LoadImageColors #

Source 
LoadImageColors :: proc "c" (image: Image) -> [^]Color ---

Load color data from image as a Color array (RGBA - 32bit)

LoadImageFromMemory #

Source 
LoadImageFromMemory :: proc "c" (fileType: cstring, fileData: rawptr, dataSize: i32) -> Image ---

Load image from memory buffer, fileType refers to extension: i.e. '.png'

LoadImageFromScreen #

Source 
LoadImageFromScreen :: proc "c" () -> Image ---

Load image from screen buffer and (screenshot)

LoadImagePalette #

Source 
LoadImagePalette :: proc "c" (image: Image, maxPaletteSize: i32, colorCount: ^i32) -> [^]Color ---

Load colors palette from image as a Color array (RGBA - 32bit)

LoadMaterialDefault #

Source 
LoadMaterialDefault :: proc "c" () -> Material ---

Load default material (Supports: DIFFUSE, SPECULAR, NORMAL maps)

LoadModelFromMesh #

Source 
LoadModelFromMesh :: proc "c" (mesh: Mesh) -> Model ---

Load model from generated mesh (default material)

LoadRandomSequence #

Source 
LoadRandomSequence :: proc "c" (count: u32, min, max: i32) -> [^]i32 ---

Load random values sequence, no values repeated

LoadShader #

Source 
LoadShader :: proc "c" (vsFileName, fsFileName: cstring) -> Shader ---

Load shader from files and bind default locations

LoadShaderFromMemory #

Source 
LoadShaderFromMemory :: proc "c" (vsCode, fsCode: cstring) -> Shader ---

Load shader from code strings and bind default locations

LoadSoundAlias #

Source 
LoadSoundAlias :: proc "c" (source: Sound) -> Sound ---

Create a new sound that shares the same sample data as the source sound, does not own the sound data

LoadUTF8 #

Source 
LoadUTF8 :: proc "c" (codepoints: [^]rune, length: i32) -> [^]u8 ---

Load UTF-8 text encoded from codepoints array

LoadWaveFromMemory #

Source 
LoadWaveFromMemory :: proc "c" (fileType: cstring, fileData: rawptr, dataSize: i32) -> Wave ---

Load wave from memory buffer, fileType refers to extension: i.e. '.wav'

LoadWaveSamples #

Source 
LoadWaveSamples :: proc "c" (wave: Wave) -> [^]f32 ---

Load samples data from wave as a 32bit float data array

MakeDirectory #

Source 
MakeDirectory :: proc "c" (dirPath: cstring) -> i32 ---

Create directories (including full path requested), returns 0 on success

MatrixAdd #

Source 
@(require_results)
@(deprecated="Prefer left + right")
MatrixAdd :: proc "c" (left, right: matrix[4, 4]f32) -> matrix[4, 4]f32 {…}

Add two matrices

MatrixDeterminant #

Source 
@(require_results)
MatrixDeterminant :: proc "c" (mat: matrix[4, 4]f32) -> f32 {…}

Compute matrix determinant

MatrixIdentity #

Source 
@(require_results)
@(deprecated="Prefer Matrix(1)")
MatrixIdentity :: proc "c" () -> matrix[4, 4]f32 {…}

Get identity matrix

MatrixInvert #

Source 
@(require_results)
MatrixInvert :: proc "c" (mat: matrix[4, 4]f32) -> matrix[4, 4]f32 {…}

Invert provided matrix

MatrixLookAt #

Source 
@(require_results)
MatrixLookAt :: proc "c" (eye, target, up: [3]f32) -> matrix[4, 4]f32 {…}

Get camera look-at matrix (view matrix)

MatrixMultiply #

Source 
@(require_results)
@(deprecated="Prefer left * right")
MatrixMultiply :: proc "c" (left, right: matrix[4, 4]f32) -> matrix[4, 4]f32 {…}

Get two matrix multiplication NOTE: When multiplying matrices... the order matters!

MatrixOrtho #

Source 
@(require_results)
MatrixOrtho :: proc "c" (
	left, right, bottom, top, near, far: f32, 
) -> matrix[4, 4]f32 {…}

Get orthographic projection matrix

MatrixPerspective #

Source 
@(require_results)
MatrixPerspective :: proc "c" (fovY, aspect, nearPlane, farPlane: f32) -> matrix[4, 4]f32 {…}

Get perspective projection matrix NOTE: Fovy angle must be provided in radians

MatrixRotate #

Source 
@(require_results)
MatrixRotate :: proc "c" (axis: [3]f32, angle: f32) -> matrix[4, 4]f32 {…}

Create rotation matrix from axis and angle NOTE: Angle should be provided in radians

MatrixRotateX #

Source 
@(require_results)
MatrixRotateX :: proc "c" (angle: f32) -> matrix[4, 4]f32 {…}

Get x-rotation matrix NOTE: Angle must be provided in radians

MatrixRotateXYZ #

Source 
@(require_results)
MatrixRotateXYZ :: proc "c" (angle: [3]f32) -> matrix[4, 4]f32 {…}

Get xyz-rotation matrix NOTE: Angle must be provided in radians

MatrixRotateY #

Source 
@(require_results)
MatrixRotateY :: proc "c" (angle: f32) -> matrix[4, 4]f32 {…}

Get y-rotation matrix NOTE: Angle must be provided in radians

MatrixRotateZ #

Source 
@(require_results)
MatrixRotateZ :: proc "c" (angle: f32) -> matrix[4, 4]f32 {…}

Get z-rotation matrix NOTE: Angle must be provided in radians

MatrixRotateZYX #

Source 
@(require_results)
MatrixRotateZYX :: proc "c" (angle: [3]f32) -> matrix[4, 4]f32 {…}

Get zyx-rotation matrix NOTE: Angle must be provided in radians

MatrixScale #

Source 
@(require_results)
MatrixScale :: proc "c" (x, y, z: f32) -> matrix[4, 4]f32 {…}

Get scaling matrix

MatrixSubtract #

Source 
@(require_results)
@(deprecated="Prefer left - right")
MatrixSubtract :: proc "c" (left, right: matrix[4, 4]f32) -> matrix[4, 4]f32 {…}

Subtract two matrices (left - right)

MatrixToFloatV #

Source 
@(require_results)
MatrixToFloatV :: proc "c" (mat: matrix[4, 4]f32) -> [16]f32 {…}

Get float array of matrix data

MatrixTrace #

Source 
@(require_results)
MatrixTrace :: proc "c" (mat: matrix[4, 4]f32) -> f32 {…}

Get the trace of the matrix (sum of the values along the diagonal)

MatrixTranslate #

Source 
@(require_results)
MatrixTranslate :: proc "c" (x, y, z: f32) -> matrix[4, 4]f32 {…}

Get translation matrix

MatrixTranspose #

Source 
@(require_results)
MatrixTranspose :: proc "c" (mat: matrix[4, 4]f32) -> matrix[4, 4]f32 {…}

Transposes provided matrix

MaximizeWindow #

Source 
MaximizeWindow :: proc "c" () ---

Set window state: maximized, if resizable

MinimizeWindow #

Source 
MinimizeWindow :: proc "c" () ---

Set window state: minimized, if resizable

Normalize #

Source 
@(require_results)
Normalize :: proc "c" (value: f32, start, end: f32) -> f32 {…}

Normalize input value within input range

OpenURL #

Source 
OpenURL :: proc "c" (url: cstring) ---

Open URL with default system browser (if available)

PollInputEvents #

Source 
PollInputEvents :: proc "c" () ---

Register all input events

QuaternionEquals #

Source 
@(require_results)
QuaternionEquals :: proc "c" (p, q: quaternion128) -> bool {…}

Check whether two given quaternions are almost equal

QuaternionFromAxisAngle #

Source 
@(require_results)
QuaternionFromAxisAngle :: proc "c" (axis: [3]f32, angle: f32) -> quaternion128 {…}

Get rotation quaternion for an angle and axis NOTE: Angle must be provided in radians

QuaternionFromEuler #

Source 
@(require_results)
QuaternionFromEuler :: proc "c" (pitch, yaw, roll: f32) -> quaternion128 {…}

Get the quaternion equivalent to Euler angles NOTE: Rotation order is ZYX

QuaternionFromMatrix #

Source 
@(require_results)
QuaternionFromMatrix :: proc "c" (mat: matrix[4, 4]f32) -> quaternion128 {…}

Get a quaternion for a given rotation matrix

QuaternionFromVector3ToVector3 #

Source 
@(require_results)
QuaternionFromVector3ToVector3 :: proc "c" (from, to: [3]f32) -> quaternion128 {…}

Calculate quaternion based on the rotation from one vector to another

QuaternionIdentity #

Source 
@(require_results)
@(deprecated="Prefer Quaternion(1)")
QuaternionIdentity :: proc "c" () -> quaternion128 {…}

Get identity quaternion

QuaternionLength #

Source 
@(require_results)
@(deprecated="Prefer abs(q)")
QuaternionLength :: proc "c" (q: quaternion128) -> f32 {…}

Computes the length of a quaternion

QuaternionToAxisAngle #

Source 
@(require_results)
QuaternionToAxisAngle :: proc "c" (q: quaternion128) -> (outAxis: [3]f32, outAngle: f32) {…}

Get the rotation angle and axis for a given quaternion

QuaternionToEuler #

Source 
@(require_results)
QuaternionToEuler :: proc "c" (q: quaternion128) -> [3]f32 {…}

Get the Euler angles equivalent to quaternion (roll, pitch, yaw) NOTE: Angles are returned in a Vector3 struct in radians

QuaternionToMatrix #

Source 
@(require_results)
QuaternionToMatrix :: proc "c" (q: quaternion128) -> matrix[4, 4]f32 {…}

Get a matrix for a given quaternion

Remap #

Source 
@(require_results)
Remap :: proc "c" (value: f32, inputStart, inputEnd: f32, outputStart, outputEnd: f32) -> f32 {…}

Remap input value within input range to output range

RestoreWindow #

Source 
RestoreWindow :: proc "c" () ---

Set window state: not minimized/maximized

ResumeMusicStream #

Source 
ResumeMusicStream :: proc "c" (music: Music) ---

Resume playing paused music

SaveFileData #

Source 
SaveFileData :: proc "c" (fileName: cstring, data: rawptr, dataSize: i32) -> bool ---

Save data to file from byte array (write), returns true on success

SaveFileText #

Source 
SaveFileText :: proc "c" (fileName: cstring, text: [^]u8) -> bool ---

Save text data to file (write), string must be '\0' terminated, returns true on success

SeekMusicStream #

Source 
SeekMusicStream :: proc "c" (music: Music, position: f32) ---

Seek music to a position (in seconds)

SetAudioStreamBufferSizeDefault #

Source 
SetAudioStreamBufferSizeDefault :: proc "c" (size: i32) ---

Default size for new audio streams

SetAudioStreamPitch #

Source 
SetAudioStreamPitch :: proc "c" (stream: AudioStream, pitch: f32) ---

Set pitch for audio stream (1.0 is base level)

SetAudioStreamVolume #

Source 
SetAudioStreamVolume :: proc "c" (stream: AudioStream, volume: f32) ---

Set volume for audio stream (1.0 is max level)

SetAutomationEventBaseFrame #

Source 
SetAutomationEventBaseFrame :: proc "c" (frame: i32) ---

Set automation event internal base frame to start recording

SetConfigFlags #

Source 
SetConfigFlags :: proc "c" (flags: ConfigFlags) ---

Setup init configuration flags (view FLAGS). NOTE: This function is expected to be called before window creation

SetGamepadMappings #

Source 
SetGamepadMappings :: proc "c" (mappings: cstring) -> i32 ---

Set internal gamepad mappings (SDL_GameControllerDB)

SetGamepadVibration #

Source 
SetGamepadVibration :: proc "c" (gamepad: i32, leftMotor: f32, rightMotor: f32, duration: f32) ---

Set gamepad vibration for both motors (duration in seconds)

SetGesturesEnabled #

Source 
SetGesturesEnabled :: proc "c" (flags: Gestures) ---

Enable a set of gestures using flags

SetMasterVolume #

Source 
SetMasterVolume :: proc "c" (volume: f32) ---

Set master volume (listener)

SetModelMeshMaterial #

Source 
SetModelMeshMaterial :: proc "c" (model: ^Model, meshId: i32, materialId: i32) ---

Set material for a mesh

SetMouseOffset #

Source 
SetMouseOffset :: proc "c" (offsetX, offsetY: i32) ---

Set mouse offset

SetMousePosition #

Source 
SetMousePosition :: proc "c" (x, y: i32) ---

Set mouse position XY

SetMouseScale #

Source 
SetMouseScale :: proc "c" (scaleX, scaleY: f32) ---

Set mouse scaling

SetMusicPan #

Source 
SetMusicPan :: proc "c" (music: Music, pan: f32) ---

Set pan for a music (0.5 is center)

SetMusicPitch #

Source 
SetMusicPitch :: proc "c" (music: Music, pitch: f32) ---

Set pitch for a music (1.0 is base level)

SetMusicVolume #

Source 
SetMusicVolume :: proc "c" (music: Music, volume: f32) ---

Set volume for music (1.0 is max level)

SetRandomSeed #

Source 
SetRandomSeed :: proc "c" (seed: u32) ---

Set the seed for the random number generator

SetShaderValueMatrix #

Source 
SetShaderValueMatrix :: proc "c" (shader: Shader, #any_int locIndex: i32, mat: matrix[4, 4]f32) ---

Set shader uniform value (matrix 4x4)

SetShaderValueTexture #

Source 
SetShaderValueTexture :: proc "c" (shader: Shader, #any_int locIndex: i32, texture: Texture) ---

Set shader uniform value for texture (sampler2d)

SetShapesTexture #

Source 
SetShapesTexture :: proc "c" (texture: Texture, source: Rectangle) ---

Set texture and rectangle to be used on shapes drawing

SetSoundPan #

Source 
SetSoundPan :: proc "c" (sound: Sound, pan: f32) ---

Set pan for a sound (0.5 is center)

SetSoundPitch #

Source 
SetSoundPitch :: proc "c" (sound: Sound, pitch: f32) ---

Set pitch for a sound (1.0 is base level)

SetSoundVolume #

Source 
SetSoundVolume :: proc "c" (sound: Sound, volume: f32) ---

Set volume for a sound (1.0 is max level)

SetTargetFPS #

Source 
SetTargetFPS :: proc "c" (fps: i32) ---

Set target FPS (maximum)

SetTextLineSpacing #

Source 
SetTextLineSpacing :: proc "c" (spacing: i32) ---

Set vertical line spacing when drawing with line-breaks

SetWindowFocused #

Source 
SetWindowFocused :: proc "c" () ---

Set window focused

SetWindowIcon #

Source 
SetWindowIcon :: proc "c" (image: Image) ---

Set icon for window (single image, RGBA 32bit,)

SetWindowIcons #

Source 
SetWindowIcons :: proc "c" (images: [^]Image, count: i32) ---

Set icon for window (multiple images, RGBA 32bit,)

SetWindowMaxSize #

Source 
SetWindowMaxSize :: proc "c" (width, height: i32) ---

Set window maximum dimensions (for WINDOW_RESIZABLE)

SetWindowMinSize #

Source 
SetWindowMinSize :: proc "c" (width, height: i32) ---

Set window minimum dimensions (for WINDOW_RESIZABLE)

SetWindowMonitor #

Source 
SetWindowMonitor :: proc "c" (monitor: i32) ---

Set monitor for the current window

SetWindowOpacity #

Source 
SetWindowOpacity :: proc "c" (opacity: f32) ---

Set window opacity [0.0f..1.0f]

SetWindowPosition #

Source 
SetWindowPosition :: proc "c" (x, y: i32) ---

Set window position on screen

SetWindowSize #

Source 
SetWindowSize :: proc "c" (width, height: i32) ---

Set window dimensions

StartAutomationEventRecording #

Source 
StartAutomationEventRecording :: proc "c" () ---

Start recording automation events (AutomationEventList must be set)

StopAutomationEventRecording #

Source 
StopAutomationEventRecording :: proc "c" () ---

Stop recording automation events

SwapScreenBuffer #

Source 
SwapScreenBuffer :: proc "c" () ---

Swap back buffer with front buffer (screen drawing)

TextAppend #

Source 
TextAppend :: proc "c" (text: [^]u8, append: cstring, position: ^i32) ---

Append text at specific position and move cursor!

TextFindIndex #

Source 
TextFindIndex :: proc "c" (text, find: cstring) -> i32 ---

Find first text occurrence within a string

TextFormatAlloc #

Source 
TextFormatAlloc :: proc(text: cstring, args: ..any) -> cstring {…}

Text formatting with variables (sprintf style) and allocates (must be freed with 'MemFree')

TextInsert #

Source 
TextInsert :: proc "c" (text, insert: cstring, position: i32) -> [^]u8 ---

Insert text in a position (WARNING: memory must be freed!)

TextReplace #

Source 
TextReplace :: proc "c" (text: [^]u8, replace, by: cstring) -> [^]u8 ---

Replace text string (WARNING: memory must be freed!)

TextToFloat #

Source 
TextToFloat :: proc "c" (text: cstring) -> f32 ---

Get float value from text (negative values not supported)

TextToInteger #

Source 
TextToInteger :: proc "c" (text: cstring) -> i32 ---

Get integer value from text (negative values not supported)

ToggleBorderlessWindowed #

Source 
ToggleBorderlessWindowed :: proc "c" () ---

Toggle window state: borderless windowed

ToggleFullscreen #

Source 
ToggleFullscreen :: proc "c" () ---

Toggle window state: fullscreen/windowed

TraceLog #

Source 
TraceLog :: proc "c" (logLevel: TraceLogLevel, text: cstring, args: ..any) ---

NOTE: Following functions implemented in module [utils] ------------------------------------------------------------------

UnloadCodepoints #

Source 
UnloadCodepoints :: proc "c" (codepoints: [^]rune) ---

Unload codepoints data from memory

UnloadFileData #

Source 
UnloadFileData :: proc "c" (data: [^]u8) ---

Unload file data allocated by LoadFileData()

UnloadFileText #

Source 
UnloadFileText :: proc "c" (text: [^]u8) ---

Unload file text data allocated by LoadFileText()

UnloadFont #

Source 
UnloadFont :: proc "c" (font: Font) ---

Unload font from GPU memory (VRAM)

UnloadImage #

Source 
UnloadImage :: proc "c" (image: Image) ---

Unload image from CPU memory (RAM)

UnloadImageColors #

Source 
UnloadImageColors :: proc "c" (colors: [^]Color) ---

Unload color data loaded with LoadImageColors()

UnloadImagePalette #

Source 
UnloadImagePalette :: proc "c" (colors: [^]Color) ---

Unload colors palette loaded with LoadImagePalette()

UnloadMaterial #

Source 
UnloadMaterial :: proc "c" (material: Material) ---

Unload material from GPU memory (VRAM)

UnloadMesh #

Source 
UnloadMesh :: proc "c" (mesh: Mesh) ---

Unload mesh data from CPU and GPU

UnloadModel #

Source 
UnloadModel :: proc "c" (model: Model) ---

Unload model (including meshes) from memory (RAM and/or VRAM)

UnloadMusicStream #

Source 
UnloadMusicStream :: proc "c" (music: Music) ---

Unload music stream

UnloadRandomSequence #

Source 
UnloadRandomSequence :: proc "c" (sequence: [^]i32) ---

Unload random values sequence

UnloadShader #

Source 
UnloadShader :: proc "c" (shader: Shader) ---

Unload shader from GPU memory (VRAM)

UnloadSoundAlias #

Source 
UnloadSoundAlias :: proc "c" (alias: Sound) ---

Unload a sound alias (does not deallocate sample data)

UnloadTexture #

Source 
UnloadTexture :: proc "c" (texture: Texture) ---

Unload texture from GPU memory (VRAM)

UnloadUTF8 #

Source 
UnloadUTF8 :: proc "c" (text: [^]u8) ---

Unload UTF-8 text encoded from codepoints array

UnloadWaveSamples #

Source 
UnloadWaveSamples :: proc "c" (samples: [^]f32) ---

Unload samples data loaded with LoadWaveSamples()

UpdateCameraPro #

Source 
UpdateCameraPro :: proc "c" (camera: ^Camera3D, movement: [3]f32, rotation: [3]f32, zoom: f32) ---

Update camera movement/rotation

UpdateMeshBuffer #

Source 
UpdateMeshBuffer :: proc "c" (mesh: Mesh, index: i32, data: rawptr, dataSize: i32, offset: i32) ---

Update mesh vertex data in GPU for a specific buffer index

UpdateModelAnimationBones #

Source 
UpdateModelAnimationBones :: proc "c" (model: Model, anim: ModelAnimation, frame: i32) ---

Update model animation mesh bone matrices (GPU skinning)

UpdateMusicStream #

Source 
UpdateMusicStream :: proc "c" (music: Music) ---

Updates buffers for music streaming

UploadMesh #

Source 
UploadMesh :: proc "c" (mesh: ^Mesh, is_dynamic: bool) ---

Upload mesh vertex data in GPU and provide VAO/VBO ids

Vector2Add #

Source 
@(require_results)
@(deprecated="Prefer v1 + v2")
Vector2Add :: proc "c" (v1, v2: [2]f32) -> [2]f32 {…}

Add two vectors (v1 + v2)

Vector2AddValue #

Source 
@(require_results)
@(deprecated="Prefer v + value")
Vector2AddValue :: proc "c" (v: [2]f32, value: f32) -> [2]f32 {…}

Add vector and float value

Vector2Angle #

Source 
@(require_results)
Vector2Angle :: proc "c" (v1, v2: [2]f32) -> f32 {…}

Calculate angle between two vectors NOTE: Angle is calculated from origin point (0, 0)

Vector2Clamp #

Source 
@(require_results)
Vector2Clamp :: proc "c" (v: [2]f32, min, max: [2]f32) -> [2]f32 {…}

Clamp the components of the vector between min and max values specified by the given vectors

Vector2ClampValue #

Source 
@(require_results)
Vector2ClampValue :: proc "c" (v: [2]f32, min, max: f32) -> [2]f32 {…}

Clamp the magnitude of the vector between two min and max values

Vector2Distance #

Source 
@(require_results)
Vector2Distance :: proc "c" (v1, v2: [2]f32) -> f32 {…}

Calculate distance between two vectors

Vector2DistanceSqrt #

Source 
@(require_results)
Vector2DistanceSqrt :: proc "c" (v1, v2: [2]f32) -> f32 {…}

Calculate square distance between two vectors

Vector2Divide #

Source 
@(require_results)
@(deprecated="Prefer v1 / v2")
Vector2Divide :: proc "c" (v1, v2: [2]f32) -> [2]f32 {…}

Divide vector by vector

Vector2DotProduct #

Source 
@(require_results)
Vector2DotProduct :: proc "c" (v1, v2: [2]f32) -> f32 {…}

Calculate two vectors dot product

Vector2Invert #

Source 
@(require_results)
@(deprecated="Prefer 1.0/v")
Vector2Invert :: proc "c" (v: [2]f32) -> [2]f32 {…}

Invert the given vector

Vector2Length #

Source 
@(require_results)
Vector2Length :: proc "c" (v: [2]f32) -> f32 {…}

Calculate vector length

Vector2LengthSqr #

Source 
@(require_results)
Vector2LengthSqr :: proc "c" (v: [2]f32) -> f32 {…}

Calculate vector square length

Vector2Lerp #

Source 
@(require_results)
@(deprecated="Prefer = linalg.lerp(v1, v2, amount)")
Vector2Lerp :: proc "c" (v1, v2: [2]f32, amount: f32) -> [2]f32 {…}

Calculate linear interpolation between two vectors

Vector2LineAngle #

Source 
@(require_results)
Vector2LineAngle :: proc "c" (start, end: [2]f32) -> f32 {…}

Calculate angle defined by a two vectors line NOTE: Parameters need to be normalized Current implementation should be aligned with glm::angle

Vector2MoveTowards #

Source 
@(require_results)
Vector2MoveTowards :: proc "c" (v, target: [2]f32, maxDistance: f32) -> [2]f32 {…}

Move Vector towards target

Vector2Multiply #

Source 
@(require_results)
@(deprecated="Prefer v1 * v2")
Vector2Multiply :: proc "c" (v1, v2: [2]f32) -> [2]f32 {…}

Multiply vector by vector

Vector2Negate #

Source 
@(require_results)
@(deprecated="Prefer -v")
Vector2Negate :: proc "c" (v: [2]f32) -> [2]f32 {…}

Negate vector

Vector2Normalize #

Source 
@(require_results)
Vector2Normalize :: proc "c" (v: [2]f32) -> [2]f32 {…}

Normalize provided vector

Vector2One #

Source 
@(require_results)
@(deprecated="Prefer Vector2(1)")
Vector2One :: proc "c" () -> [2]f32 {…}

Vector with components value 1.0

Vector2Reflect #

Source 
@(require_results)
@(deprecated="Prefer = linalg.reflect(v, normal)")
Vector2Reflect :: proc "c" (v, normal: [2]f32) -> [2]f32 {…}

Calculate reflected vector to normal

Vector2Rotate #

Source 
@(require_results)
Vector2Rotate :: proc "c" (v: [2]f32, angle: f32) -> [2]f32 {…}

Rotate vector by angle

Vector2Scale #

Source 
@(require_results)
@(deprecated="Prefer v * scale")
Vector2Scale :: proc "c" (v: [2]f32, scale: f32) -> [2]f32 {…}

Scale vector (multiply by value)

Vector2Subtract #

Source 
@(require_results)
@(deprecated="Prefer a - b")
Vector2Subtract :: proc "c" (a, b: [2]f32) -> [2]f32 {…}

Subtract two vectors (v1 - v2)

Vector2SubtractValue #

Source 
@(require_results)
@(deprecated="Prefer v + value")
Vector2SubtractValue :: proc "c" (v: [2]f32, value: f32) -> [2]f32 {…}

Subtract vector by float value

Vector2Transform #

Source 
@(require_results)
Vector2Transform :: proc "c" (v: [2]f32, m: matrix[4, 4]f32) -> [2]f32 {…}

Transforms a Vector2 by a given Matrix

Vector2Zero #

Source 
@(require_results)
@(deprecated="Prefer Vector2(0)")
Vector2Zero :: proc "c" () -> [2]f32 {…}

Vector with components value 0.0

Vector3Add #

Source 
@(require_results)
@(deprecated="Prefer v1 + v2")
Vector3Add :: proc "c" (v1, v2: [3]f32) -> [3]f32 {…}

Add two vectors (v1 + v2)

Vector3AddValue #

Source 
@(require_results)
@(deprecated="Prefer v + value")
Vector3AddValue :: proc "c" (v: [3]f32, value: f32) -> [3]f32 {…}

Add vector and float value

Vector3Angle #

Source 
@(require_results)
Vector3Angle :: proc "c" (v1, v2: [3]f32) -> f32 {…}

Calculate angle between two vectors NOTE: Angle is calculated from origin point (0, 0)

Vector3Barycenter #

Source 
@(require_results)
Vector3Barycenter :: proc "c" (p: [3]f32, a, b, c: [3]f32) -> (result: [3]f32) {…}

Compute barycenter coordinates (u, v, w) for point p with respect to triangle (a, b, c) NOTE: Assumes P is on the plane of the triangle

Vector3Clamp #

Source 
@(require_results)
Vector3Clamp :: proc "c" (v: [3]f32, min, max: [3]f32) -> [3]f32 {…}

Clamp the components of the vector between min and max values specified by the given vectors

Vector3ClampValue #

Source 
@(require_results)
Vector3ClampValue :: proc "c" (v: [3]f32, min, max: f32) -> [3]f32 {…}

Clamp the magnitude of the vector between two min and max values

Vector3CrossProduct #

Source 
@(require_results)
Vector3CrossProduct :: proc "c" (v1, v2: [3]f32) -> [3]f32 {…}

Calculate two vectors dot product

Vector3Distance #

Source 
@(require_results)
Vector3Distance :: proc "c" (v1, v2: [3]f32) -> f32 {…}

Calculate distance between two vectors

Vector3DistanceSqrt #

Source 
@(require_results)
Vector3DistanceSqrt :: proc "c" (v1, v2: [3]f32) -> f32 {…}

Calculate square distance between two vectors

Vector3Divide #

Source 
@(require_results)
@(deprecated="Prefer v1 / v2")
Vector3Divide :: proc "c" (v1, v2: [3]f32) -> [3]f32 {…}

Divide vector by vector

Vector3DotProduct #

Source 
@(require_results)
Vector3DotProduct :: proc "c" (v1, v2: [3]f32) -> f32 {…}

Calculate two vectors dot product

Vector3Invert #

Source 
@(require_results)
@(deprecated="Prefer 1.0/v")
Vector3Invert :: proc "c" (v: [3]f32) -> [3]f32 {…}

Invert the given vector

Vector3Length #

Source 
@(require_results)
Vector3Length :: proc "c" (v: [3]f32) -> f32 {…}

Calculate vector length

Vector3LengthSqr #

Source 
@(require_results)
Vector3LengthSqr :: proc "c" (v: [3]f32) -> f32 {…}

Calculate vector square length

Vector3Lerp #

Source 
@(require_results)
@(deprecated="Prefer = linalg.lerp(v1, v2, amount)")
Vector3Lerp :: proc "c" (v1, v2: [3]f32, amount: f32) -> [3]f32 {…}

Calculate linear interpolation between two vectors

Vector3LineAngle #

Source 
@(require_results)
Vector3LineAngle :: proc "c" (start, end: [3]f32) -> f32 {…}

Calculate angle defined by a two vectors line NOTE: Parameters need to be normalized Current implementation should be aligned with glm::angle

Vector3MoveTowards #

Source 
@(require_results)
Vector3MoveTowards :: proc "c" (v, target: [3]f32, maxDistance: f32) -> [3]f32 {…}

Move Vector towards target

Vector3Multiply #

Source 
@(require_results)
@(deprecated="Prefer v1 * v2")
Vector3Multiply :: proc "c" (v1, v2: [3]f32) -> [3]f32 {…}

Multiply vector by vector

Vector3Negate #

Source 
@(require_results)
@(deprecated="Prefer -v")
Vector3Negate :: proc "c" (v: [3]f32) -> [3]f32 {…}

Negate vector

Vector3Normalize #

Source 
@(require_results)
Vector3Normalize :: proc "c" (v: [3]f32) -> [3]f32 {…}

Normalize provided vector

Vector3One #

Source 
@(require_results)
@(deprecated="Prefer Vector3(1)")
Vector3One :: proc "c" () -> [3]f32 {…}

Vector with components value 1.0

Vector3OrthoNormalize #

Source 
Vector3OrthoNormalize :: proc "c" (v1, v2: ^[3]f32) {…}

Orthonormalize provided vectors Makes vectors normalized and orthogonal to each other Gram-Schmidt function implementation

Vector3Project #

Source 
@(require_results)
Vector3Project :: proc "c" (v1, v2: [3]f32) -> [3]f32 {…}

Calculate the projection of the vector v1 on to v2

Vector3Reflect #

Source 
@(require_results)
@(deprecated="Prefer = linalg.reflect(v, normal)")
Vector3Reflect :: proc "c" (v, normal: [3]f32) -> [3]f32 {…}

Calculate reflected vector to normal

Vector3Refract #

Source 
@(require_results)
@(deprecated="Prefer = linalg.refract(v, n, r)")
Vector3Refract :: proc "c" (v, n: [3]f32, r: f32) -> [3]f32 {…}

Compute the direction of a refracted ray v: normalized direction of the incoming ray n: normalized normal vector of the interface of two optical media r: ratio of the refractive index of the medium from where the ray comes to the refractive index of the medium on the other side of the surface

Vector3Reject #

Source 
@(require_results)
Vector3Reject :: proc "c" (v1, v2: [3]f32) -> [3]f32 {…}

Calculate the rejection of the vector v1 on to v2

Vector3RotateByAxisAngle #

Source 
@(require_results)
Vector3RotateByAxisAngle :: proc "c" (v: [3]f32, axis: [3]f32, angle: f32) -> [3]f32 {…}

Rotates a vector around an axis

Vector3RotateByQuaternion #

Source 
@(require_results)
Vector3RotateByQuaternion :: proc "c" (v: [3]f32, q: quaternion128) -> [3]f32 {…}

Transform a vector by quaternion rotation

Vector3Scale #

Source 
@(require_results)
@(deprecated="Prefer v * scale")
Vector3Scale :: proc "c" (v: [3]f32, scale: f32) -> [3]f32 {…}

Scale vector (multiply by value)

Vector3Subtract #

Source 
@(require_results)
@(deprecated="Prefer a - b")
Vector3Subtract :: proc "c" (a, b: [3]f32) -> [3]f32 {…}

Subtract two vectors (v1 - v2)

Vector3SubtractValue #

Source 
@(require_results)
@(deprecated="Prefer v + value")
Vector3SubtractValue :: proc "c" (v: [3]f32, value: f32) -> [3]f32 {…}

Subtract vector by float value

Vector3Transform #

Source 
@(require_results)
Vector3Transform :: proc "c" (v: [3]f32, m: matrix[4, 4]f32) -> [3]f32 {…}

Transforms a Vector3 by a given Matrix

Vector3Unproject #

Source 
@(require_results)
Vector3Unproject :: proc "c" (source: [3]f32, projection: matrix[4, 4]f32, view: matrix[4, 4]f32) -> [3]f32 {…}

Projects a Vector3 from screen space into object space

Vector3Zero #

Source 
@(require_results)
@(deprecated="Prefer Vector3(0)")
Vector3Zero :: proc "c" () -> [3]f32 {…}

Vector with components value 0.0

WaitTime #

Source 
WaitTime :: proc "c" (seconds: f64) ---

Wait for some time (halt program execution)

WaveCrop #

Source 
WaveCrop :: proc "c" (wave: ^Wave, initFrame, finalFrame: i32) ---

Crop a wave to defined samples range

WaveFormat #

Source 
WaveFormat :: proc "c" (wave: ^Wave, sampleRate, sampleSize: i32, channels: i32) ---

Convert wave data to desired format

WindowShouldClose #

Source 
WindowShouldClose :: proc "c" () -> bool ---

Check if application should close (KEY_ESCAPE pressed or windows close icon clicked)

Wrap #

Source 
@(require_results)
Wrap :: proc "c" (value: f32, min, max: f32) -> f32 {…}

Wrap input value from min to max

Procedure Groups

1

Variables

1