package vendor:raylib

Overview

********************************************************************************************* * raylib v4.0 - 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 or ES2 - choose at compile) - Unique OpenGL abstraction layer (usable as standalone module): [rlgl] - Multiple Fonts formats supported (TTF, XNA fonts, AngelCode 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) - 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, 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] rglfw (Camilla Löwy - github.com/glfw/glfw) for window/context management and input (PLATFORM_DESKTOP) [rlgl] glad (David Herberth - github.com/Dav1dde/glad) for OpenGL 3.3 extensions loading (PLATFORM_DESKTOP) [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 algorythm [rcore] sdefl (Micha Mettke) for DEFLATE compression algorythm [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_resize (Sean Barret) for image resizing algorithms [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) [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 * * 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-2021 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. * *********************************************************************************************

Index

Types (72)
Constants (81)
Variables (0)

This section is empty.

Procedures (657)
Procedure Groups (0)

This section is empty.

Types

AudioStream ¶

AudioStream :: struct {
	buffer:     rawptr,
	// Pointer to internal data used by the audio system
	sampleRate: u32,
	// Frequency (samples per second)
	sampleSize: u32,
	// Bit depth (bits per sample): 8, 16, 32 (24 not supported)
	channels:   u32,
}
 

Audio stream type NOTE: Useful to create custom audio streams not bound to a specific file

BlendMode ¶

BlendMode :: enum i32 {
	ALPHA           = 0, // Blend textures considering alpha (default)
	ADDITIVE,            // Blend textures adding colors
	MULTIPLIED,          // Blend textures multiplying colors
	ADD_COLORS,          // Blend textures adding colors (alternative)
	SUBTRACT_COLORS,     // Blend textures subtracting colors (alternative)
	CUSTOM,              // Belnd textures using custom src/dst factors (use rlSetBlendMode())
}
 

Color blending modes (pre-defined)

BoneInfo ¶

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

Bone information

BoundingBox ¶

BoundingBox :: struct {
	min: linalg.Vector3f32,
	// Minimum vertex box-corner
	max: linalg.Vector3f32,
}
 

Bounding box type

Camera2D ¶

Camera2D :: struct {
	offset:   linalg.Vector2f32,
	// Camera offset (displacement from target)
	target:   linalg.Vector2f32,
	// Camera target (rotation and zoom origin)
	rotation: f32,
	// Camera rotation in degrees
	zoom:     f32,
}
 

Camera2D type, defines a 2d camera

Camera3D ¶

Camera3D :: struct {
	position:   linalg.Vector3f32,
	// Camera position
	target:     linalg.Vector3f32,
	// Camera target it looks-at
	up:         linalg.Vector3f32,
	// Camera up vector (rotation over its axis)
	fovy:       f32,
	// Camera field-of-view apperture in Y (degrees) in perspective, used as near plane width in orthographic
	projection: CameraProjection,
}
 

Camera type, defines a camera position/orientation in 3d space

CameraMode ¶

CameraMode :: enum i32 {
	CUSTOM       = 0, 
	FREE, 
	ORBITAL, 
	FIRST_PERSON, 
	THIRD_PERSON, 
}
 

Camera system modes

CameraProjection ¶

CameraProjection :: enum i32 {
	PERSPECTIVE  = 0, 
	ORTHOGRAPHIC, 
}
 

Camera projection

Color ¶

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

Color, 4 components, R8G8B8A8 (32bit)

ConfigFlag ¶

ConfigFlag :: enum i32 {
	VSYNC_HINT         = 6,  // Set to try enabling V-Sync on GPU
	FULLSCREEN_MODE    = 1,  // Set to run program in fullscreen
	WINDOW_RESIZABLE   = 2,  // Set to allow resizable window
	WINDOW_UNDECORATED = 3,  // Set to disable window decoration (frame and buttons)
	WINDOW_HIDDEN      = 7,  // Set to hide window
	WINDOW_MINIMIZED   = 9,  // Set to minimize window (iconify)
	WINDOW_MAXIMIZED   = 10, // Set to maximize window (expanded to monitor)
	WINDOW_UNFOCUSED   = 11, // Set to window non focused
	WINDOW_TOPMOST     = 12, // Set to window always on top
	WINDOW_ALWAYS_RUN  = 8,  // Set to allow windows running while minimized
	WINDOW_TRANSPARENT = 4,  // Set to allow transparent framebuffer
	WINDOW_HIGHDPI     = 13, // Set to support HighDPI
	MSAA_4X_HINT       = 5,  // Set to try enabling MSAA 4X
	INTERLACED_HINT    = 16, // Set to try enabling interlaced video format (for V3D)
}
 

---------------------------------------------------------------------------------- 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

ConfigFlags ¶

ConfigFlags :: distinct bit_set[ConfigFlag; i32]

CubemapLayout ¶

CubemapLayout :: enum i32 {
	AUTO_DETECT         = 0, // Automatically detect layout type
	LINE_VERTICAL,           // Layout is defined by a vertical line with faces
	LINE_HORIZONTAL,         // Layout is defined by an horizontal line with faces
	CROSS_THREE_BY_FOUR,     // Layout is defined by a 3x4 cross with cubemap faces
	CROSS_FOUR_BY_THREE,     // Layout is defined by a 4x3 cross with cubemap faces
	PANORAMA,                // Layout is defined by a panorama image (equirectangular map)
}
 

Cubemap layouts

DrawCall ¶

DrawCall :: struct {
	mode:            i32,
	// Drawing mode: LINES, TRIANGLES, QUADS
	vertexCount:     i32,
	// Number of vertex of the draw
	vertexAlignment: i32,
	// vaoId: u32,                 // Vertex array id to be used on the draw -> Using RLGL.currentBatch->vertexBuffer.vaoId
	// shaderId: u32,              // Shader id to be used on the draw -> Using RLGL.currentShader.id
	textureId:       u32,
}
 

Draw call type NOTE: Only texture changes register a new draw, other state-change-related elements are not used at this moment (vaoId, shaderId, matrices), raylib just forces a batch draw call if any of those state-change happens (this is done in core module)

Font ¶

Font :: struct {
	baseSize:     i32,
	// Base size (default chars height)
	charsCount:   i32,
	// Number of characters
	charsPadding: i32,
	// Padding around the chars
	texture:      Texture,
	// Characters texture atlas
	recs:         [^]Rectangle,
	// Characters rectangles in texture
	chars:        [^]GlyphInfo,
}
 

Font type, includes texture and charSet array data

FontType ¶

FontType :: enum i32 {
	DEFAULT = 0, // Default font generation, anti-aliased
	BITMAP,      // Bitmap font generation, no anti-aliasing
	SDF,         // SDF font generation, requires external shader
}
 

Font type, defines generation method

FramebufferAttachTextureType ¶

FramebufferAttachTextureType :: enum i32 {
	CUBEMAP_POSITIVE_X = 0, 
	CUBEMAP_NEGATIVE_X, 
	CUBEMAP_POSITIVE_Y, 
	CUBEMAP_NEGATIVE_Y, 
	CUBEMAP_POSITIVE_Z, 
	CUBEMAP_NEGATIVE_Z, 
	TEXTURE2D          = 100, 
	RENDERBUFFER       = 200, 
}

FramebufferAttachType ¶

FramebufferAttachType :: enum i32 {
	COLOR_CHANNEL0 = 0, 
	COLOR_CHANNEL1, 
	COLOR_CHANNEL2, 
	COLOR_CHANNEL3, 
	COLOR_CHANNEL4, 
	COLOR_CHANNEL5, 
	COLOR_CHANNEL6, 
	COLOR_CHANNEL7, 
	DEPTH          = 100, 
	STENCIL        = 200, 
}

GamepadAxis ¶

GamepadAxis :: enum i32 {
	// Left stick
	LEFT_X        = 0, 
	LEFT_Y        = 1, 
	// Right stick
	RIGHT_X       = 2, 
	RIGHT_Y       = 3, 
	// Pressure levels for the back triggers
	LEFT_TRIGGER  = 4, // [1..-1] (pressure-level)
	RIGHT_TRIGGER = 5, // [1..-1] (pressure-level)
}
 

Gamepad axis

GamepadButton ¶

GamepadButton :: enum i32 {
	// This is here just for error checking
	UNKNOWN          = 0, 
	// This is normally a DPAD
	LEFT_FACE_UP, 
	LEFT_FACE_RIGHT, 
	LEFT_FACE_DOWN, 
	LEFT_FACE_LEFT, 
	// This normally corresponds with PlayStation and Xbox controllers
	// XBOX: [Y,X,A,B]
	// PS3: [Triangle,Square,Cross,Circle]
	// No support for 6 button controllers though..
	RIGHT_FACE_UP, 
	RIGHT_FACE_RIGHT, 
	RIGHT_FACE_DOWN, 
	RIGHT_FACE_LEFT, 
	// Triggers
	LEFT_TRIGGER_1, 
	LEFT_TRIGGER_2, 
	RIGHT_TRIGGER_1, 
	RIGHT_TRIGGER_2, 
	// These are buttons in the center of the gamepad
	MIDDLE_LEFT,          // PS3 Select
	MIDDLE,               // PS Button/XBOX Button
	MIDDLE_RIGHT,         // PS3 Start
	// These are the joystick press in buttons
	LEFT_THUMB, 
	RIGHT_THUMB, 
}
 

Gamepad buttons

Gesture ¶

Gesture :: enum i32 {
	TAP         = 0, 
	DOUBLETAP   = 1, 
	HOLD        = 2, 
	DRAG        = 3, 
	SWIPE_RIGHT = 4, 
	SWIPE_LEFT  = 5, 
	SWIPE_UP    = 6, 
	SWIPE_DOWN  = 7, 
	PINCH_IN    = 8, 
	PINCH_OUT   = 9, 
}
 

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

Gestures ¶

Gestures :: distinct bit_set[Gesture; i32]

GlVersion ¶

GlVersion :: enum i32 {
	OPENGL_11    = 1, 
	OPENGL_21, 
	OPENGL_33, 
	OPENGL_ES_20, 
}
 

---------------------------------------------------------------------------------- Types and Structures Definition ----------------------------------------------------------------------------------

GlyphInfo ¶

GlyphInfo :: struct {
	value:    rune,
	// Character value (Unicode)
	offsetX:  i32,
	// Character offset X when drawing
	offsetY:  i32,
	// Character offset Y when drawing
	advanceX: i32,
	// Character advance position X
	image:    Image,
}
 

Font character info

Image ¶

Image :: struct {
	data:    rawptr,
	// Image raw data
	width:   i32,
	// Image base width
	height:  i32,
	// Image base height
	mipmaps: i32,
	// Mipmap levels, 1 by default
	format:  PixelFormat,
}
 

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

KeyboardKey ¶

KeyboardKey :: enum i32 {
	NULL          = 0, 
	// Alphanumeric keys
	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, 
	// Function keys
	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, 
	LEFT_BRACKET  = 91, 
	BACKSLASH     = 92, 
	RIGHT_BRACKET = 93, 
	GRAVE         = 96, 
	// Keypad keys
	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, 
	// Android key buttons
	BACK          = 4, 
	MENU          = 82, 
	VOLUME_UP     = 24, 
	VOLUME_DOWN   = 25, 
}
 

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

LoadFileDataCallback ¶

LoadFileDataCallback :: proc "cdecl" (fileName: cstring, bytesRead: ^u32) -> [^]u8

LoadFileTextCallback ¶

LoadFileTextCallback :: proc "cdecl" (name: cstring) -> [^]u8

Material ¶

Material :: struct {
	shader: Shader,
	// Material shader
	maps:   [^]MaterialMap,
	// Material maps array (MAX_MATERIAL_MAPS)
	params: [4]f32,
}
 

Material type (generic)

MaterialMap ¶

MaterialMap :: struct {
	texture: Texture,
	// Material map texture
	color:   Color,
	// Material map color
	value:   f32,
}
 

Material texture map

MaterialMapIndex ¶

MaterialMapIndex :: enum i32 {
	ALBEDO     = 0, // MATERIAL_MAP_DIFFUSE
	METALNESS  = 1, // MATERIAL_MAP_SPECULAR
	NORMAL     = 2, 
	ROUGHNESS  = 3, 
	OCCLUSION, 
	EMISSION, 
	HEIGHT, 
	BRDG, 
	CUBEMAP,        // NOTE: Uses GL_TEXTURE_CUBE_MAP
	IRRADIANCE,     // NOTE: Uses GL_TEXTURE_CUBE_MAP
	PREFILTER,      // NOTE: Uses GL_TEXTURE_CUBE_MAP
	DIFFUSE    = 0, 
	SPECULAR   = 1, 
}
 

Material map index

Matrix ¶

Matrix :: linalg.Matrix4x4f32
 

Matrix type (OpenGL style 4x4 - right handed, column major)

Mesh ¶

Mesh :: struct {
	vertexCount:   i32,
	// Number of vertices stored in arrays
	triangleCount: i32,
	// Default vertex data
	vertices:      [^]f32,
	// Vertex position (XYZ - 3 components per vertex) (shader-location = 0)
	texcoords:     [^]f32,
	// Vertex texture coordinates (UV - 2 components per vertex) (shader-location = 1)
	texcoords2:    [^]f32,
	// Vertex second texture coordinates (useful for lightmaps) (shader-location = 5)
	normals:       [^]f32,
	// Vertex normals (XYZ - 3 components per vertex) (shader-location = 2)
	tangents:      [^]f32,
	// Vertex tangents (XYZW - 4 components per vertex) (shader-location = 4)
	colors:        [^]u8,
	// Vertex colors (RGBA - 4 components per vertex) (shader-location = 3)
	indices:       [^]u16,
	// Animation vertex data
	animVertices:  [^]f32,
	// Animated vertex positions (after bones transformations)
	animNormals:   [^]f32,
	// Animated normals (after bones transformations)
	boneIds:       [^]i32,
	// Vertex bone ids, up to 4 bones influence by vertex (skinning)
	boneWeights:   [^]f32,
	// OpenGL identifiers
	vaoId:         u32,
	// OpenGL Vertex Array Object id
	vboId:         [^]u32,
}
 

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

Model ¶

Model :: struct {
	transform:     linalg.Matrix4x4f32,
	// Local transform matrix
	meshCount:     i32,
	// Number of meshes
	materialCount: i32,
	// Number of materials
	meshes:        [^]Mesh,
	// Meshes array
	materials:     [^]Material,
	// Materials array
	meshMaterial:  [^]i32,
	// Animation data
	boneCount:     i32,
	// Number of bones
	bones:         [^]BoneInfo,
	// Bones information (skeleton)
	bindPose:      [^]Transform,
}
 

Model type

ModelAnimation ¶

ModelAnimation :: struct {
	boneCount:  i32,
	// Number of bones
	frameCount: i32,
	// Number of animation frames
	bones:      [^]BoneInfo,
	// Bones information (skeleton)
	framePoses: [^]^Transform,
}
 

Model animation

MouseButton ¶

MouseButton :: enum i32 {
	LEFT    = 0, // Mouse button left
	RIGHT   = 1, // Mouse button right
	MIDDLE  = 2, // Mouse button middle (pressed wheel)
	SIDE    = 3, // Mouse button side (advanced mouse device)
	EXTRA   = 4, // Mouse button extra (advanced mouse device)
	FORWARD = 5, // Mouse button fordward (advanced mouse device)
	BACK    = 6, // Mouse button back (advanced mouse device)
}
 

Mouse buttons

MouseCursor ¶

MouseCursor :: enum i32 {
	DEFAULT       = 0, 
	ARROW         = 1, 
	IBEAM         = 2, 
	CROSSHAIR     = 3, 
	POINTING_HAND = 4, 
	RESIZE_EW     = 5,  // The horizontal resize/move arrow shape
	RESIZE_NS     = 6,  // The vertical resize/move arrow shape
	RESIZE_NWSE   = 7,  // The top-left to bottom-right diagonal resize/move arrow shape
	RESIZE_NESW   = 8,  // The top-right to bottom-left diagonal resize/move arrow shape
	RESIZE_ALL    = 9,  // The omni-directional resize/move cursor shape
	NOT_ALLOWED   = 10, // The operation-not-allowed shape
}
 

Mouse cursor

Music ¶

Music :: struct {
	stream:      AudioStream,
	// Audio stream
	sampleCount: u32,
	// Total number of samples
	looping:     bool,
	// Music looping enable
	ctxType:     i32,
	// Type of music context (audio filetype)
	ctxData:     rawptr,
}
 

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

NPatchInfo ¶

NPatchInfo :: struct {
	source: Rectangle,
	// Texture source rectangle
	left:   i32,
	// Left border offset
	top:    i32,
	// Top border offset
	right:  i32,
	// Right border offset
	bottom: i32,
	// Bottom border offset
	layout: NPatchLayout,
}
 

N-Patch layout info

NPatchLayout ¶

NPatchLayout :: enum i32 {
	NINE_PATCH             = 0, // Npatch layout: 3x3 tiles
	THREE_PATCH_VERTICAL,       // Npatch layout: 1x3 tiles
	THREE_PATCH_HORIZONTAL,     // Npatch layout: 3x1 tiles
}
 

N-patch layout

PixelFormat ¶

PixelFormat :: enum i32 {
	UNCOMPRESSED_GRAYSCALE    = 1, // 8 bit per pixel (no alpha)
	UNCOMPRESSED_GRAY_ALPHA,       // 8*2 bpp (2 channels)
	UNCOMPRESSED_R5G6B5,           // 16 bpp
	UNCOMPRESSED_R8G8B8,           // 24 bpp
	UNCOMPRESSED_R5G5B5A1,         // 16 bpp (1 bit alpha)
	UNCOMPRESSED_R4G4B4A4,         // 16 bpp (4 bit alpha)
	UNCOMPRESSED_R8G8B8A8,         // 32 bpp
	UNCOMPRESSED_R32,              // 32 bpp (1 channel - float)
	UNCOMPRESSED_R32G32B32,        // 32*3 bpp (3 channels - float)
	UNCOMPRESSED_R32G32B32A32,     // 32*4 bpp (4 channels - float)
	COMPRESSED_DXT1_RGB,           // 4 bpp (no alpha)
	COMPRESSED_DXT1_RGBA,          // 4 bpp (1 bit alpha)
	COMPRESSED_DXT3_RGBA,          // 8 bpp
	COMPRESSED_DXT5_RGBA,          // 8 bpp
	COMPRESSED_ETC1_RGB,           // 4 bpp
	COMPRESSED_ETC2_RGB,           // 4 bpp
	COMPRESSED_ETC2_EAC_RGBA,      // 8 bpp
	COMPRESSED_PVRT_RGB,           // 4 bpp
	COMPRESSED_PVRT_RGBA,          // 4 bpp
	COMPRESSED_ASTC_4x4_RGBA,      // 8 bpp
	COMPRESSED_ASTC_8x8_RGBA,      // 2 bpp
}
 

Pixel formats NOTE: Support depends on OpenGL version and platform

Quaternion ¶

Quaternion :: linalg.Quaternionf32
 

Quaternion type

Ray ¶

Ray :: struct {
	position:  linalg.Vector3f32,
	// Ray position (origin)
	direction: linalg.Vector3f32,
}
 

Ray type (useful for raycast)

RayCollision ¶

RayCollision :: struct {
	hit:      bool,
	// Did the ray hit something?
	distance: f32,
	// Distance to nearest hit
	point:    linalg.Vector3f32,
	// Point of nearest hit
	normal:   linalg.Vector3f32,
}
 

RayCollision, ray hit information

Rectangle ¶

Rectangle :: struct {
	x:      f32,
	// Rectangle top-left corner position x
	y:      f32,
	// Rectangle top-left corner position y
	width:  f32,
	// Rectangle width
	height: f32,
}
 

Rectangle type

RenderBatch ¶

RenderBatch :: struct {
	buffersCount:  i32,
	// Number of vertex buffers (multi-buffering support)
	currentBuffer: i32,
	// Current buffer tracking in case of multi-buffering
	vertexBuffer:  [^]VertexBuffer,
	// Dynamic buffer(s) for vertex data
	draws:         [^]DrawCall,
	// Draw calls array, depends on textureId
	drawsCounter:  i32,
	// Draw calls counter
	currentDepth:  f32,
}
 

RenderBatch type

RenderTexture ¶

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

RenderTexture type, for texture rendering

RenderTexture2D ¶

RenderTexture2D :: RenderTexture
 

RenderTexture2D type, same as RenderTexture

SaveFileDataCallback ¶

SaveFileDataCallback :: proc "cdecl" (fileName: cstring, data: rawptr, bytesToWrite: u32) -> bool

SaveFileTextCallback ¶

SaveFileTextCallback :: proc "cdecl" (fileName: cstring, text: cstring) -> bool

Shader ¶

Shader :: struct {
	id:   u32,
	// Shader program id
	locs: [^]i32,
}
 

Shader type (generic)

ShaderAttributeDataType ¶

ShaderAttributeDataType :: enum i32 {
	FLOAT = 0, 
	VEC2, 
	VEC3, 
	VEC4, 
}
 

Shader attribute data types

ShaderLocationIndex ¶

ShaderLocationIndex :: enum i32 {
	VERTEX_POSITION   = 0, 
	VERTEX_TEXCOORD01, 
	VERTEX_TEXCOORD02, 
	VERTEX_NORMAL, 
	VERTEX_TANGENT, 
	VERTEX_COLOR, 
	MATRIX_MVP, 
	MATRIX_VIEW, 
	MATRIX_PROJECTION, 
	MATRIX_MODEL, 
	MATRIX_NORMAL, 
	VECTOR_VIEW, 
	COLOR_DIFFUSE, 
	COLOR_SPECULAR, 
	COLOR_AMBIENT, 
	MAP_ALBEDO, 
	MAP_METALNESS, 
	MAP_NORMAL, 
	MAP_ROUGHNESS, 
	MAP_OCCLUSION, 
	MAP_EMISSION, 
	MAP_HEIGHT, 
	MAP_CUBEMAP, 
	MAP_IRRADIANCE, 
	MAP_PREFILTER, 
	MAP_BRDF, 
	MAP_DIFFUSE       = 15, 
	MAP_SPECULAR      = 16, 
}
 

Shader location index

ShaderUniformDataType ¶

ShaderUniformDataType :: enum i32 {
	FLOAT     = 0, 
	VEC2, 
	VEC3, 
	VEC4, 
	INT, 
	IVEC2, 
	IVEC3, 
	IVEC4, 
	SAMPLER2D, 
}
 

Shader uniform data type

Sound ¶

Sound :: struct {
	stream:      AudioStream,
	// Audio stream
	sampleCount: u32,
}
 

Sound source type

SpriteFont ¶

SpriteFont :: Font

Texture ¶

Texture :: struct {
	id:      u32,
	// OpenGL texture id
	width:   i32,
	// Texture base width
	height:  i32,
	// Texture base height
	mipmaps: i32,
	// Mipmap levels, 1 by default
	format:  PixelFormat,
}
 

Texture type NOTE: Data stored in GPU memory

Texture2D ¶

Texture2D :: Texture
 

Texture2D type, same as Texture

TextureCubemap ¶

TextureCubemap :: Texture
 

TextureCubemap type, actually, same as Texture

TextureFilter ¶

TextureFilter :: enum i32 {
	POINT           = 0, // No filter, just pixel aproximation
	BILINEAR,            // Linear filtering
	TRILINEAR,           // Trilinear filtering (linear with mipmaps)
	ANISOTROPIC_4X,      // Anisotropic filtering 4x
	ANISOTROPIC_8X,      // Anisotropic filtering 8x
	ANISOTROPIC_16X,     // Anisotropic filtering 16x
}
 

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

TextureWrap ¶

TextureWrap :: enum i32 {
	REPEAT        = 0, // Repeats texture in tiled mode
	CLAMP,             // Clamps texture to edge pixel in tiled mode
	MIRROR_REPEAT,     // Mirrors and repeats the texture in tiled mode
	MIRROR_CLAMP,      // Mirrors and clamps to border the texture in tiled mode
}
 

Texture parameters: wrap mode

TraceLogCallback ¶

TraceLogCallback :: proc "cdecl" (logLevel: TraceLogLevel, text: cstring, args: libc.va_list)
 

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

TraceLogLevel ¶

TraceLogLevel :: enum i32 {
	ALL     = 0, // Display all logs
	TRACE, 
	DEBUG, 
	INFO, 
	WARNING, 
	ERROR, 
	FATAL, 
	NONE,        // Disable logging
}
 

Trace log level

Transform ¶

Transform :: struct {
	translation: linalg.Vector3f32,
	// Translation
	rotation:    linalg.Quaternionf32,
	// Rotation
	scale:       linalg.Vector3f32,
}
 

Transformation properties

Vector2 ¶

Vector2 :: linalg.Vector2f32
 

Vector2 type

Vector3 ¶

Vector3 :: linalg.Vector3f32
 

Vector3 type

Vector4 ¶

Vector4 :: linalg.Vector4f32
 

Vector4 type

VertexBuffer ¶

VertexBuffer :: struct {
	elementsCount: i32,
	// Number of elements in the buffer (QUADS)
	vCounter:      i32,
	// Vertex position counter to process (and draw) from full buffer
	tcCounter:     i32,
	// Vertex texcoord counter to process (and draw) from full buffer
	cCounter:      i32,
	// Vertex color counter to process (and draw) from full buffer
	vertices:      [^]f32,
	// Vertex position (XYZ - 3 components per vertex) (shader-location = 0)
	texcoords:     [^]f32,
	// Vertex texture coordinates (UV - 2 components per vertex) (shader-location = 1)
	colors:        [^]u8,
	// Vertex colors (RGBA - 4 components per vertex) (shader-location = 3)
	indices:       [^]u32,
	// Vertex indices (in case vertex data comes indexed) (6 indices per quad)
	vaoId:         u32,
	// OpenGL Vertex Array Object id
	vboId:         [4]u32,
}
 

Dynamic vertex buffers (position + texcoords + colors + indices arrays)

VertexBufferIndexType ¶

VertexBufferIndexType :: u32

VrDeviceInfo ¶

VrDeviceInfo :: struct {
	hResolution:            i32,
	// Horizontal resolution in pixels
	vResolution:            i32,
	// Vertical resolution in pixels
	hScreenSize:            f32,
	// Horizontal size in meters
	vScreenSize:            f32,
	// Vertical size in meters
	vScreenCenter:          f32,
	// Screen center in meters
	eyeToScreenDistance:    f32,
	// Distance between eye and display in meters
	lensSeparationDistance: f32,
	// Lens separation distance in meters
	interpupillaryDistance: f32,
	// IPD (distance between pupils) in meters
	lensDistortionValues:   [4]f32,
	// Lens distortion constant parameters
	chromaAbCorrection:     [4]f32,
}
 

Head-Mounted-Display device parameters

VrStereoConfig ¶

VrStereoConfig :: struct {
	projection:        [2]linalg.Matrix4x4f32,
	// VR projection matrices (per eye)
	viewOffset:        [2]linalg.Matrix4x4f32,
	// VR view offset matrices (per eye)
	leftLensCenter:    [2]f32,
	// VR left lens center
	rightLensCenter:   [2]f32,
	// VR right lens center
	leftScreenCenter:  [2]f32,
	// VR left screen center
	rightScreenCenter: [2]f32,
	// VR right screen center
	scale:             [2]f32,
	// VR distortion scale
	scaleIn:           [2]f32,
}
 

VR Stereo rendering configuration for simulator

Wave ¶

Wave :: struct {
	sampleCount: u32,
	// Total number of samples
	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:        rawptr,
}
 

Wave type, defines audio wave data

Constants

BEIGE ¶

BEIGE :: Color{211, 176, 131, 255}

BLACK ¶

BLACK :: Color{0, 0, 0, 255}

BLANK ¶

BLANK :: Color{0, 0, 0, 0}

BLUE ¶

BLUE :: Color{0, 121, 241, 255}

BROWN ¶

BROWN :: Color{127, 106, 79, 255}

DARKBLUE ¶

DARKBLUE :: Color{0, 82, 172, 255}

DARKBROWN ¶

DARKBROWN :: Color{76, 63, 47, 255}

DARKGRAY ¶

DARKGRAY :: Color{80, 80, 80, 255}

DARKGREEN ¶

DARKGREEN :: Color{0, 117, 44, 255}

DARKPURPLE ¶

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

DEFAULT_BATCH_BUFFERS ¶

DEFAULT_BATCH_BUFFERS :: 1

DEFAULT_BATCH_BUFFER_ELEMENTS ¶

DEFAULT_BATCH_BUFFER_ELEMENTS :: 8192
 

This is the maximum amount of elements (quads) per batch NOTE: Be careful with text, every letter maps to a quad

DEFAULT_BATCH_DRAWCALLS ¶

DEFAULT_BATCH_DRAWCALLS :: 256

DEG2RAD ¶

DEG2RAD :: PI / 180.0

GOLD ¶

GOLD :: Color{255, 203, 0, 255}

GRAPHICS_API_OPENGL_11 ¶

GRAPHICS_API_OPENGL_11 :: false

GRAPHICS_API_OPENGL_21 ¶

GRAPHICS_API_OPENGL_21 :: true

GRAPHICS_API_OPENGL_33 ¶

GRAPHICS_API_OPENGL_33 :: GRAPHICS_API_OPENGL_21

GRAPHICS_API_OPENGL_43 ¶

GRAPHICS_API_OPENGL_43 :: false

GRAPHICS_API_OPENGL_ES2 ¶

GRAPHICS_API_OPENGL_ES2 :: false

GRAY ¶

GRAY :: Color{130, 130, 130, 255}

GREEN ¶

GREEN :: Color{0, 228, 48, 255}

LIGHTGRAY ¶

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

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

LIME ¶

LIME :: Color{0, 158, 47, 255}

MAGENTA ¶

MAGENTA :: Color{255, 0, 255, 255}

MAROON ¶

MAROON :: Color{190, 33, 55, 255}

MAX_BATCH_ACTIVE_TEXTURES ¶

MAX_BATCH_ACTIVE_TEXTURES :: 4

MAX_MATRIX_STACK_SIZE ¶

MAX_MATRIX_STACK_SIZE :: 32
 

Internal Matrix stack

MAX_SHADER_LOCATIONS ¶

MAX_SHADER_LOCATIONS :: 32
 

Shader limits

MAX_TEXTFORMAT_BUFFERS ¶

MAX_TEXTFORMAT_BUFFERS :: #config(RAYLIB_MAX_TEXTFORMAT_BUFFERS, 4)

MAX_TEXT_BUFFER_LENGTH ¶

MAX_TEXT_BUFFER_LENGTH :: #config(RAYLIB_MAX_TEXT_BUFFER_LENGTH, 1024)

ORANGE ¶

ORANGE :: Color{255, 161, 0, 255}

PI ¶

PI :: 3.14159265358979323846

PINK ¶

PINK :: Color{255, 109, 194, 255}

PURPLE ¶

PURPLE :: Color{200, 122, 255, 255}

RAD2DEG ¶

RAD2DEG :: 180.0 / PI

RAYWHITE ¶

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

RED ¶

RED :: Color{230, 41, 55, 255}

RL_COMPUTE_SHADER ¶

RL_COMPUTE_SHADER :: 0x91B9

RL_CULL_DISTANCE_FAR ¶

RL_CULL_DISTANCE_FAR :: 1000.0

RL_CULL_DISTANCE_NEAR ¶

RL_CULL_DISTANCE_NEAR :: 0.01
 

Projection matrix culling

RL_DYNAMIC_COPY ¶

RL_DYNAMIC_COPY :: 0x88EA

RL_DYNAMIC_DRAW ¶

RL_DYNAMIC_DRAW :: 0x88E8

RL_DYNAMIC_READ ¶

RL_DYNAMIC_READ :: 0x88E9

RL_FLOAT ¶

RL_FLOAT :: 0x1406

RL_FRAGMENT_SHADER ¶

RL_FRAGMENT_SHADER :: 0x8B30
 

GL Shader type

RL_LINES ¶

RL_LINES :: 0x0001
 

Primitive assembly draw modes

RL_MODELVIEW ¶

RL_MODELVIEW :: 0x1700
 

Matrix modes (equivalent to OpenGL)

RL_PROJECTION ¶

RL_PROJECTION :: 0x1701

RL_QUADS ¶

RL_QUADS :: 0x0007

RL_STATIC_COPY ¶

RL_STATIC_COPY :: 0x88E6

RL_STATIC_DRAW ¶

RL_STATIC_DRAW :: 0x88E4

RL_STATIC_READ ¶

RL_STATIC_READ :: 0x88E5

RL_STREAM_COPY ¶

RL_STREAM_COPY :: 0x88E2

RL_STREAM_DRAW ¶

RL_STREAM_DRAW :: 0x88E0
 

Buffer usage hint

RL_STREAM_READ ¶

RL_STREAM_READ :: 0x88E1

RL_TEXTURE ¶

RL_TEXTURE :: 0x1702

RL_TEXTURE_FILTER_ANISOTROPIC ¶

RL_TEXTURE_FILTER_ANISOTROPIC :: 0x3000

RL_TEXTURE_FILTER_LINEAR ¶

RL_TEXTURE_FILTER_LINEAR :: 0x2601

RL_TEXTURE_FILTER_LINEAR_MIP_NEAREST ¶

RL_TEXTURE_FILTER_LINEAR_MIP_NEAREST :: 0x2701

RL_TEXTURE_FILTER_MIP_LINEAR ¶

RL_TEXTURE_FILTER_MIP_LINEAR :: 0x2703

RL_TEXTURE_FILTER_MIP_NEAREST ¶

RL_TEXTURE_FILTER_MIP_NEAREST :: 0x2700

RL_TEXTURE_FILTER_NEAREST ¶

RL_TEXTURE_FILTER_NEAREST :: 0x2600

RL_TEXTURE_FILTER_NEAREST_MIP_LINEAR ¶

RL_TEXTURE_FILTER_NEAREST_MIP_LINEAR :: 0x2702

RL_TEXTURE_MAG_FILTER ¶

RL_TEXTURE_MAG_FILTER :: 0x2800

RL_TEXTURE_MIN_FILTER ¶

RL_TEXTURE_MIN_FILTER :: 0x2801

RL_TEXTURE_WRAP_CLAMP ¶

RL_TEXTURE_WRAP_CLAMP :: 0x812F

RL_TEXTURE_WRAP_MIRROR_CLAMP ¶

RL_TEXTURE_WRAP_MIRROR_CLAMP :: 0x8742

RL_TEXTURE_WRAP_MIRROR_REPEAT ¶

RL_TEXTURE_WRAP_MIRROR_REPEAT :: 0x8370

RL_TEXTURE_WRAP_REPEAT ¶

RL_TEXTURE_WRAP_REPEAT :: 0x2901

RL_TEXTURE_WRAP_S ¶

RL_TEXTURE_WRAP_S :: 0x2802
 

Texture parameters (equivalent to OpenGL defines)

RL_TEXTURE_WRAP_T ¶

RL_TEXTURE_WRAP_T :: 0x2803

RL_TRIANGLES ¶

RL_TRIANGLES :: 0x0004

RL_UNSIGNED_BYTE ¶

RL_UNSIGNED_BYTE :: 0x1401
 

GL equivalent data types

RL_VERTEX_SHADER ¶

RL_VERTEX_SHADER :: 0x8B31

SKYBLUE ¶

SKYBLUE :: Color{102, 191, 255, 255}

USE_LINALG ¶

USE_LINALG :: #config(RAYLIB_USE_LINALG, true)

VERSION ¶

VERSION :: "4.0"

VIOLET ¶

VIOLET :: Color{135, 60, 190, 255}

WHITE ¶

WHITE :: Color{255, 255, 255, 255}

YELLOW ¶

YELLOW :: Color{253, 249, 0, 255}

Variables

This section is empty.

Procedures

BeginBlendMode ¶

BeginBlendMode :: proc "cdecl" (mode: BlendMode) ---

BeginDrawing ¶

BeginDrawing :: proc "cdecl" () ---

BeginMode2D ¶

BeginMode2D :: proc "cdecl" (camera: Camera2D) ---

BeginMode3D ¶

BeginMode3D :: proc "cdecl" (camera: Camera3D) ---

BeginScissorMode ¶

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

BeginShaderMode ¶

BeginShaderMode :: proc "cdecl" (shader: Shader) ---

BeginTextureMode ¶

BeginTextureMode :: proc "cdecl" (target: RenderTexture) ---

BeginVrStereoMode ¶

BeginVrStereoMode :: proc "cdecl" (config: VrStereoConfig) ---

ChangeDirectory ¶

ChangeDirectory :: proc "cdecl" (fileName: cstring) -> bool ---

CheckCollisionBoxSphere ¶

CheckCollisionBoxSphere :: proc "cdecl" (box: BoundingBox, center: linalg.Vector3f32, radius: f32) -> bool ---

CheckCollisionBoxes ¶

CheckCollisionBoxes :: proc "cdecl" (box1, box2: BoundingBox) -> bool ---

CheckCollisionCircleRec ¶

CheckCollisionCircleRec :: proc "cdecl" (center: linalg.Vector2f32, radius: f32, rec: Rectangle) -> bool ---

CheckCollisionCircles ¶

CheckCollisionCircles :: proc "cdecl" (center1: linalg.Vector2f32, radius1: f32, center2: linalg.Vector2f32, radius2: f32) -> bool ---

CheckCollisionLines ¶

CheckCollisionLines :: proc "cdecl" (startPos1, endPos1, startPos2, endPos2: linalg.Vector2f32, collisionPoint: ^linalg.Vector2f32) -> bool ---

CheckCollisionPointCircle ¶

CheckCollisionPointCircle :: proc "cdecl" (point: linalg.Vector2f32, center: linalg.Vector2f32, radius: f32) -> bool ---

CheckCollisionPointLine ¶

CheckCollisionPointLine :: proc "cdecl" (point, p1, p2: linalg.Vector2f32, threshold: i32) -> bool ---

CheckCollisionPointRec ¶

CheckCollisionPointRec :: proc "cdecl" (point: linalg.Vector2f32, rec: Rectangle) -> bool ---

CheckCollisionPointTriangle ¶

CheckCollisionPointTriangle :: proc "cdecl" (point, p1, p2, p3: linalg.Vector2f32) -> bool ---

CheckCollisionRecs ¶

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

Basic shapes collision detection functions

CheckCollisionSpheres ¶

CheckCollisionSpheres :: proc "cdecl" (center1: linalg.Vector3f32, radius1: f32, center2: linalg.Vector3f32, radius2: f32) -> bool ---
 

Collision detection functions

ClearBackground ¶

ClearBackground :: proc "cdecl" (color: Color) ---
 

Drawing-related functions

ClearDirectoryFiles ¶

ClearDirectoryFiles :: proc "cdecl" () ---

ClearDroppedFiles ¶

ClearDroppedFiles :: proc "cdecl" () ---

ClearWindowState ¶

ClearWindowState :: proc "cdecl" (flags: ConfigFlags) ---

CloseAudioDevice ¶

CloseAudioDevice :: proc "cdecl" () ---

CloseWindow ¶

CloseWindow :: proc "cdecl" () ---

CodepointToUTF8 ¶

CodepointToUTF8 :: proc "cdecl" (codepoint: rune, byteSize: ^i32) -> cstring ---

ColorAlpha ¶

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

ColorAlphaBlend ¶

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

ColorFromHSV ¶

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

ColorFromNormalized ¶

ColorFromNormalized :: proc "cdecl" (normalized: linalg.Vector4f32) -> Color ---

ColorNormalize ¶

ColorNormalize :: proc "cdecl" (color: Color) -> linalg.Vector4f32 ---

ColorToHSV ¶

ColorToHSV :: proc "cdecl" (color: Color) -> linalg.Vector3f32 ---

ColorToInt ¶

ColorToInt :: proc "cdecl" (color: Color) -> i32 ---

CompressData ¶

CompressData :: proc "cdecl" (data: [^]u8, dataLength: i32, compDataLength: ^i32) -> [^]u8 ---

DecodeDataBase64 ¶

DecodeDataBase64 :: proc "cdecl" (data: [^]u8, outputLength: ^i32) -> [^]u8 ---

DecompressData ¶

DecompressData :: proc "cdecl" (data: [^]u8, dataLength: i32, compDataLength: ^i32) -> [^]u8 ---

DirectoryExists ¶

DirectoryExists :: proc "cdecl" (fileName: cstring) -> bool ---

DisableCursor ¶

DisableCursor :: proc "cdecl" () ---

DrawBillboard ¶

DrawBillboard :: proc "cdecl" (camera: Camera3D, texture: Texture, center: linalg.Vector3f32, size: f32, tint: Color) ---

DrawBillboardPro ¶

DrawBillboardPro :: proc "cdecl" (
	camera:       Camera3D, 
	texture:      Texture, 
	source:       Rectangle, 
	position, up: linalg.Vector3f32, 
	size, origin: linalg.Vector2f32, 
	rotation:     f32, 
) ---

DrawBillboardRec ¶

DrawBillboardRec :: proc "cdecl" (
	camera:  Camera3D, 
	texture: Texture, 
	source:  Rectangle, 
	center:  linalg.Vector3f32, 
	size:    f32, 
) ---

DrawBoundingBox ¶

DrawBoundingBox :: proc "cdecl" (box: BoundingBox, color: Color) ---

DrawCircle ¶

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

DrawCircle3D ¶

DrawCircle3D :: proc "cdecl" (center: linalg.Vector3f32, radius: f32, rotationAxis: linalg.Vector3f32, rotationAngle: f32, color: Color) ---

DrawCircleGradient ¶

DrawCircleGradient :: proc "cdecl" (centerX, centerY: i32, radius: f32, color1: Color, color2: Color) ---

DrawCircleLines ¶

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

DrawCircleSector ¶

DrawCircleSector :: proc "cdecl" (
	center:               linalg.Vector2f32, 
	radius:               f32, 
	startAngle, endAngle: f32, 
	segments:             i32, 
) ---

DrawCircleSectorLines ¶

DrawCircleSectorLines :: proc "cdecl" (
	center:               linalg.Vector2f32, 
	radius:               f32, 
	startAngle, endAngle: f32, 
	segments:             i32, 
) ---

DrawCircleV ¶

DrawCircleV :: proc "cdecl" (center: linalg.Vector2f32, radius: f32, color: Color) ---

DrawCube ¶

DrawCube :: proc "cdecl" (position: linalg.Vector3f32, width, height, length: f32, color: Color) ---

DrawCubeTexture ¶

DrawCubeTexture :: proc "cdecl" (
	texture:               Texture, 
	position:              linalg.Vector3f32, 
	width, height, length: f32, 
) ---

DrawCubeTextureRec ¶

DrawCubeTextureRec :: proc "cdecl" (
	texture:               Texture, 
	source:                Rectangle, 
	position:              linalg.Vector3f32, 
	width, height, length: f32, 
) ---

DrawCubeV ¶

DrawCubeV :: proc "cdecl" (startPos, endPos: linalg.Vector3f32, color: Color) ---

DrawCubeWires ¶

DrawCubeWires :: proc "cdecl" (position: linalg.Vector3f32, width, height, length: f32, color: Color) ---

DrawCubeWiresV ¶

DrawCubeWiresV :: proc "cdecl" (startPos, endPos: linalg.Vector3f32, color: Color) ---

DrawCylinder ¶

DrawCylinder :: proc "cdecl" (
	position:                linalg.Vector3f32, 
	radiusTop, radiusBottom: f32, 
	height:                  f32, 
	slices:                  i32, 
) ---

DrawCylinderEx ¶

DrawCylinderEx :: proc "cdecl" (
	startPos, endPos:       linalg.Vector3f32, 
	startRadius, endRadius: f32, 
	sides:                  i32, 
) ---

DrawCylinderWires ¶

DrawCylinderWires :: proc "cdecl" (
	position:                linalg.Vector3f32, 
	radiusTop, radiusBottom: f32, 
	height:                  f32, 
	slices:                  i32, 
) ---

DrawCylinderWiresEx ¶

DrawCylinderWiresEx :: proc "cdecl" (
	startPos, endPos:       linalg.Vector3f32, 
	startRadius, endRadius: f32, 
	sides:                  i32, 
) ---

DrawEllipse ¶

DrawEllipse :: proc "cdecl" (centerX, centerY: i32, radiusH: f32, radiusV: f32, color: Color) ---

DrawEllipseLines ¶

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

DrawFPS ¶

DrawFPS :: proc "cdecl" (joy, event: i32) ---
 

Text drawing functions

DrawGrid ¶

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

DrawLine ¶

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

DrawLine3D ¶

DrawLine3D :: proc "cdecl" (startPos, endPos: linalg.Vector3f32, color: Color) ---
 

Basic geometric 3D shapes drawing functions

DrawLineBezier ¶

DrawLineBezier :: proc "cdecl" (startPos, endPos: linalg.Vector2f32, thick: f32, color: Color) ---

DrawLineBezierCubic ¶

DrawLineBezierCubic :: proc "cdecl" (
	startPos, endPos:               linalg.Vector2f32, 
	startControlPos, endControlPos: linalg.Vector2f32, 
	thick:                          f32, 
) ---

DrawLineBezierQuad ¶

DrawLineBezierQuad :: proc "cdecl" (startPos, endPos: linalg.Vector2f32, controlPos: linalg.Vector2f32, thick: f32, color: Color) ---

DrawLineEx ¶

DrawLineEx :: proc "cdecl" (startPos, endPos: linalg.Vector2f32, thick: f32, color: Color) ---

DrawLineStrip ¶

DrawLineStrip :: proc "cdecl" (points: [^]linalg.Vector2f32, pointsCount: i32, color: Color) ---

DrawLineV ¶

DrawLineV :: proc "cdecl" (startPos, endPos: linalg.Vector2f32, color: Color) ---

DrawMesh ¶

DrawMesh :: proc "cdecl" (mesh: Mesh, material: Material, transform: linalg.Matrix4x4f32) ---

DrawMeshInstanced ¶

DrawMeshInstanced :: proc "cdecl" (mesh: Mesh, material: Material, transforms: [^]linalg.Matrix4x4f32, instances: i32) ---

DrawModel ¶

DrawModel :: proc "cdecl" (model: Model, position: linalg.Vector3f32, scale: f32, tint: Color) ---
 

Model drawing functions

DrawModelEx ¶

DrawModelEx :: proc "cdecl" (
	model:         Model, 
	position:      linalg.Vector3f32, 
	rotationAxis:  linalg.Vector3f32, 
	rotationAngle: f32, 
	scale:         linalg.Vector3f32, 
) ---

DrawModelWires ¶

DrawModelWires :: proc "cdecl" (model: Model, position: linalg.Vector3f32, scale: f32, tint: Color) ---

DrawModelWiresEx ¶

DrawModelWiresEx :: proc "cdecl" (
	model:         Model, 
	position:      linalg.Vector3f32, 
	rotationAxis:  linalg.Vector3f32, 
	rotationAngle: f32, 
	scale:         linalg.Vector3f32, 
) ---

DrawPixel ¶

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

Basic shapes drawing functions

DrawPixelV ¶

DrawPixelV :: proc "cdecl" (position: linalg.Vector2f32, color: Color) ---

DrawPlane ¶

DrawPlane :: proc "cdecl" (centerPos: linalg.Vector3f32, size: linalg.Vector2f32, color: Color) ---

DrawPoint3D ¶

DrawPoint3D :: proc "cdecl" (position: linalg.Vector3f32, color: Color) ---

DrawPoly ¶

DrawPoly :: proc "cdecl" (center: linalg.Vector2f32, sides: i32, radius: f32, rotation: f32, color: Color) ---

DrawPolyLines ¶

DrawPolyLines :: proc "cdecl" (center: linalg.Vector2f32, sides: i32, radius: f32, rotation: f32, color: Color) ---

DrawPolyLinesEx ¶

DrawPolyLinesEx :: proc "cdecl" (
	center:    linalg.Vector2f32, 
	sides:     i32, 
	radius:    f32, 
	rotation:  f32, 
	lineThick: f32, 
) ---

DrawRay ¶

DrawRay :: proc "cdecl" (ray: Ray, color: Color) ---

DrawRectangle ¶

DrawRectangle :: proc "cdecl" (startPosX, startPosY, endPosX, endPosY: i32, color: Color) ---

DrawRectangleGradientEx ¶

DrawRectangleGradientEx :: proc "cdecl" (rec: Rectangle, col1, col2, col3, col4: Color) ---

DrawRectangleGradientH ¶

DrawRectangleGradientH :: proc "cdecl" (
	posX, posY, width, height: i32, 
	color1:                    Color, 
) ---

DrawRectangleGradientV ¶

DrawRectangleGradientV :: proc "cdecl" (
	posX, posY, width, height: i32, 
	color1:                    Color, 
) ---

DrawRectangleLines ¶

DrawRectangleLines :: proc "cdecl" (startPosX, startPosY, endPosX, endPosY: i32, color: Color) ---

DrawRectangleLinesEx ¶

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

DrawRectanglePro ¶

DrawRectanglePro :: proc "cdecl" (rec: Rectangle, origin: linalg.Vector2f32, rotation: f32, color: Color) ---

DrawRectangleRec ¶

DrawRectangleRec :: proc "cdecl" (rec: Rectangle, color: Color) ---

DrawRectangleRounded ¶

DrawRectangleRounded :: proc "cdecl" (rec: Rectangle, roundness: f32, segments: i32, color: Color) ---

DrawRectangleRoundedLines ¶

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

DrawRectangleV ¶

DrawRectangleV :: proc "cdecl" (startPos, endPos: linalg.Vector2f32, color: Color) ---

DrawRing ¶

DrawRing :: proc "cdecl" (
	center:                   linalg.Vector2f32, 
	innerRadius, outerRadius: f32, 
	startAngle, endAngle:     f32, 
	segments:                 i32, 
) ---

DrawRingLines ¶

DrawRingLines :: proc "cdecl" (
	center:                   linalg.Vector2f32, 
	innerRadius, outerRadius: f32, 
	startAngle, endAngle:     f32, 
	segments:                 i32, 
) ---

DrawSphere ¶

DrawSphere :: proc "cdecl" (centerPos: linalg.Vector3f32, radius: f32, color: Color) ---

DrawSphereEx ¶

DrawSphereEx :: proc "cdecl" (centerPos: linalg.Vector3f32, radius: f32, rings, slices: i32, color: Color) ---

DrawSphereWires ¶

DrawSphereWires :: proc "cdecl" (centerPos: linalg.Vector3f32, radius: f32, rings, slices: i32, color: Color) ---

DrawText ¶

DrawText :: proc "cdecl" (text: cstring, posX, posY: i32, fontSize: i32, color: Color) ---

DrawTextCodepoint ¶

DrawTextCodepoint :: proc "cdecl" (font: Font, codepoint: rune, position: linalg.Vector2f32, fontSize: f32, tint: Color) ---

DrawTextEx ¶

DrawTextEx :: proc "cdecl" (
	font:     Font, 
	text:     cstring, 
	position: linalg.Vector2f32, 
	fontSize: f32, 
	spacing:  f32, 
) ---

DrawTextPro ¶

DrawTextPro :: proc "cdecl" (
	font:             Font, 
	text:             cstring, 
	position, origin: linalg.Vector2f32, 
	rotation:         f32, 
	fontSize:         f32, 
	spacing:          f32, 
) ---

DrawTexture ¶

DrawTexture :: proc "cdecl" (texture: Texture, posX, posY: i32, tint: Color) ---
 

Texture drawing functions

DrawTextureEx ¶

DrawTextureEx :: proc "cdecl" (texture: Texture, position: linalg.Vector2f32, rotation, scale: f32, tint: Color) ---

DrawTextureNPatch ¶

DrawTextureNPatch :: proc "cdecl" (
	texture:    Texture, 
	nPatchInfo: NPatchInfo, 
	dest:       Rectangle, 
	origin:     linalg.Vector2f32, 
	rotation:   f32, 
) ---

DrawTexturePoly ¶

DrawTexturePoly :: proc "cdecl" (
	texture:     Texture, 
	center:      linalg.Vector2f32, 
	points:      [^]linalg.Vector2f32, 
	texcoords:   [^]linalg.Vector2f32, 
	pointsCount: i32, 
) ---

DrawTexturePro ¶

DrawTexturePro :: proc "cdecl" (
	texture:      Texture, 
	source, dest: Rectangle, 
	origin:       linalg.Vector2f32, 
	rotation:     f32, 
) ---

DrawTextureQuad ¶

DrawTextureQuad :: proc "cdecl" (texture: Texture, tiling: linalg.Vector2f32, offset: linalg.Vector2f32, quad: Rectangle, tint: Color) ---

DrawTextureRec ¶

DrawTextureRec :: proc "cdecl" (texture: Texture, source: Rectangle, position: linalg.Vector2f32, tint: Color) ---

DrawTextureTiled ¶

DrawTextureTiled :: proc "cdecl" (
	texture:         Texture, 
	source, dest:    Rectangle, 
	origin:          linalg.Vector2f32, 
	rotation, scale: f32, 
) ---

DrawTextureV ¶

DrawTextureV :: proc "cdecl" (texture: Texture, position: linalg.Vector2f32, tint: Color) ---

DrawTriangle ¶

DrawTriangle :: proc "cdecl" (v1, v2, v3: linalg.Vector2f32, color: Color) ---

DrawTriangle3D ¶

DrawTriangle3D :: proc "cdecl" (v1, v2, v3: linalg.Vector3f32, color: Color) ---

DrawTriangleFan ¶

DrawTriangleFan :: proc "cdecl" (points: [^]linalg.Vector2f32, pointsCount: i32, color: Color) ---

DrawTriangleLines ¶

DrawTriangleLines :: proc "cdecl" (v1, v2, v3: linalg.Vector2f32, color: Color) ---

DrawTriangleStrip ¶

DrawTriangleStrip :: proc "cdecl" (points: [^]linalg.Vector2f32, pointsCount: i32, color: Color) ---

DrawTriangleStrip3D ¶

DrawTriangleStrip3D :: proc "cdecl" (points: [^]linalg.Vector3f32, pointsCount: i32, color: Color) ---

EaseBackIn ¶

EaseBackIn :: proc "odin" (t, b, c, d: f32) -> f32 {…}
 

Back Easing functions

EaseBackInOut ¶

EaseBackInOut :: proc "odin" (t, b, c, d: f32) -> f32 {…}

EaseBackOut ¶

EaseBackOut :: proc "odin" (t, b, c, d: f32) -> f32 {…}

EaseBounceIn ¶

EaseBounceIn :: proc "odin" (t, b, c, d: f32) -> f32 {…}

EaseBounceInOut ¶

EaseBounceInOut :: proc "odin" (t, b, c, d: f32) -> f32 {…}

EaseBounceOut ¶

EaseBounceOut :: proc "odin" (t, b, c, d: f32) -> f32 {…}
 

Bounce Easing functions

EaseCircIn ¶

EaseCircIn :: proc "odin" (t, b, c, d: f32) -> f32 {…}
 

Circular Easing functions

EaseCircInOut ¶

EaseCircInOut :: proc "odin" (t, b, c, d: f32) -> f32 {…}

EaseCircOut ¶

EaseCircOut :: proc "odin" (t, b, c, d: f32) -> f32 {…}

EaseCubicIn ¶

EaseCubicIn :: proc "odin" (t, b, c, d: f32) -> f32 {…}
 

Cubic Easing functions

EaseCubicInOut ¶

EaseCubicInOut :: proc "odin" (t, b, c, d: f32) -> f32 {…}

EaseCubicOut ¶

EaseCubicOut :: proc "odin" (t, b, c, d: f32) -> f32 {…}

EaseElasticIn ¶

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

Elastic Easing functions

EaseElasticInOut ¶

EaseElasticInOut :: proc "odin" (t, b, c, d: f32) -> f32 {…}

EaseElasticOut ¶

EaseElasticOut :: proc "odin" (t, b, c, d: f32) -> f32 {…}

EaseExpoIn ¶

EaseExpoIn :: proc "odin" (t, b, c, d: f32) -> f32 {…}
 

Exponential Easing functions

EaseExpoInOut ¶

EaseExpoInOut :: proc "odin" (t, b, c, d: f32) -> f32 {…}

EaseExpoOut ¶

EaseExpoOut :: proc "odin" (t, b, c, d: f32) -> f32 {…}

EaseLinearIn ¶

EaseLinearIn :: proc "odin" (t, b, c, d: f32) -> f32 {…}

EaseLinearInOut ¶

EaseLinearInOut :: proc "odin" (t, b, c, d: f32) -> f32 {…}

EaseLinearNone ¶

EaseLinearNone :: proc "odin" (t, b, c, d: f32) -> f32 {…}

EaseLinearOut ¶

EaseLinearOut :: proc "odin" (t, b, c, d: f32) -> f32 {…}

EaseQuadIn ¶

EaseQuadIn :: proc "odin" (t, b, c, d: f32) -> f32 {…}
 

Quadratic Easing functions

EaseQuadInOut ¶

EaseQuadInOut :: proc "odin" (t, b, c, d: f32) -> f32 {…}

EaseQuadOut ¶

EaseQuadOut :: proc "odin" (t, b, c, d: f32) -> f32 {…}

EaseSineIn ¶

EaseSineIn :: proc "odin" (t, b, c, d: f32) -> f32 {…}
 

Sine Easing functions

EaseSineInOut ¶

EaseSineInOut :: proc "odin" (t, b, c, d: f32) -> f32 {…}

EaseSineOut ¶

EaseSineOut :: proc "odin" (t, b, c, d: f32) -> f32 {…}

EnableCursor ¶

EnableCursor :: proc "cdecl" () ---

EncodeDataBase64 ¶

EncodeDataBase64 :: proc "cdecl" (data: [^]u8, dataLength: i32, compDataLength: ^i32) -> [^]u8 ---

EndBlendMode ¶

EndBlendMode :: proc "cdecl" () ---

EndDrawing ¶

EndDrawing :: proc "cdecl" () ---

EndMode2D ¶

EndMode2D :: proc "cdecl" () ---

EndMode3D ¶

EndMode3D :: proc "cdecl" () ---

EndScissorMode ¶

EndScissorMode :: proc "cdecl" () ---

EndShaderMode ¶

EndShaderMode :: proc "cdecl" () ---

EndTextureMode ¶

EndTextureMode :: proc "cdecl" () ---

EndVrStereoMode ¶

EndVrStereoMode :: proc "cdecl" () ---

ExportImage ¶

ExportImage :: proc "cdecl" (image: Image, fileName: cstring) -> bool ---

ExportImageAsCode ¶

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

ExportMesh ¶

ExportMesh :: proc "cdecl" (mesh: Mesh, fileName: cstring) -> bool ---

ExportWave ¶

ExportWave :: proc "cdecl" (wave: Wave, fileName: cstring) -> bool ---

ExportWaveAsCode ¶

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

Fade ¶

Fade :: proc "cdecl" (color: Color, alpha: f32) -> Color ---
 

Color/pixel related functions

FileExists ¶

FileExists :: proc "cdecl" (fileName: cstring) -> bool ---

GenImageCellular ¶

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

GenImageChecked ¶

GenImageChecked :: proc "cdecl" (
	width, height:    i32, 
	checksX, checksY: i32, 
	col1, 
) -> Image ---

GenImageColor ¶

GenImageColor :: proc "cdecl" (width, height: i32, color: Color) -> Image ---
 

Image generation functions

GenImageFontAtlas ¶

GenImageFontAtlas :: proc "cdecl" (
	chars:      [^]GlyphInfo, 
	recs:       ^[^]Rectangle, 
	charsCount: i32, 
	fontSize:   i32, 
	padding:    i32, 
) -> Image ---

GenImageGradientH ¶

GenImageGradientH :: proc "cdecl" (width, height: i32, top, bottom: Color) -> Image ---

GenImageGradientRadial ¶

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

GenImageGradientV ¶

GenImageGradientV :: proc "cdecl" (width, height: i32, top, bottom: Color) -> Image ---

GenImageWhiteNoise ¶

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

GenMeshBinormals ¶

GenMeshBinormals :: proc "cdecl" (mesh: ^Mesh) ---

GenMeshCone ¶

GenMeshCone :: proc "cdecl" (radius: f32, height: f32, slices: i32) -> Mesh ---

GenMeshCube ¶

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

GenMeshCubicmap ¶

GenMeshCubicmap :: proc "cdecl" (heightmap: Image, size: linalg.Vector3f32) -> Mesh ---

GenMeshCylinder ¶

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

GenMeshHeightmap ¶

GenMeshHeightmap :: proc "cdecl" (heightmap: Image, size: linalg.Vector3f32) -> Mesh ---

GenMeshHemiSphere ¶

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

GenMeshKnot ¶

GenMeshKnot :: proc "cdecl" (width, length: f32, resX, resZ: i32) -> Mesh ---

GenMeshPlane ¶

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

GenMeshPoly ¶

GenMeshPoly :: proc "cdecl" (sides: i32, radius: f32) -> Mesh ---
 

Mesh generation functions

GenMeshSphere ¶

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

GenMeshTangents ¶

GenMeshTangents :: proc "cdecl" (mesh: ^Mesh) ---

GenMeshTorus ¶

GenMeshTorus :: proc "cdecl" (width, length: f32, resX, resZ: i32) -> Mesh ---

GenTextureMipmaps ¶

GenTextureMipmaps :: proc "cdecl" (texture: ^Texture) ---
 

Texture configuration functions

GetCameraMatrix ¶

GetCameraMatrix :: proc "cdecl" (camera: Camera3D) -> linalg.Matrix4x4f32 ---

GetCameraMatrix2D ¶

GetCameraMatrix2D :: proc "cdecl" (camera: Camera2D) -> linalg.Matrix4x4f32 ---

GetCharPressed ¶

GetCharPressed :: proc "cdecl" () -> rune ---

GetClipboardText ¶

GetClipboardText :: proc "cdecl" () -> cstring ---

GetCodepoint ¶

GetCodepoint :: proc "cdecl" (text: cstring, bytesProcessed: ^i32) -> i32 ---

GetCodepointCount ¶

GetCodepointCount :: proc "cdecl" (str: cstring) -> i32 ---

GetCollisionRec ¶

GetCollisionRec :: proc "cdecl" (rec1, rec2: Rectangle) -> Rectangle ---

GetColor ¶

GetColor :: proc "cdecl" (hexValue: i32) -> Color ---

GetCurrentMonitor ¶

GetCurrentMonitor :: proc "cdecl" () -> i32 ---

GetDirectoryFiles ¶

GetDirectoryFiles :: proc "cdecl" (dirPath: cstring, count: ^i32) -> [^]cstring ---

GetDirectoryPath ¶

GetDirectoryPath :: proc "cdecl" (fileName: cstring) -> cstring ---

GetDroppedFiles ¶

GetDroppedFiles :: proc "cdecl" (count: ^i32) -> [^]cstring ---

GetFPS ¶

GetFPS :: proc "cdecl" () -> i32 ---

GetFileExtension ¶

GetFileExtension :: proc "cdecl" (fileName: cstring) -> cstring ---

GetFileModTime ¶

GetFileModTime :: proc "cdecl" (str: cstring) -> i32 ---

GetFileName ¶

GetFileName :: proc "cdecl" (fileName: cstring) -> cstring ---

GetFileNameWithoutExt ¶

GetFileNameWithoutExt :: proc "cdecl" (fileName: cstring) -> cstring ---

GetFontDefault ¶

GetFontDefault :: proc "cdecl" () -> Font ---
 

Font loading/unloading functions

GetFrameTime ¶

GetFrameTime :: proc "cdecl" () -> f32 ---

GetGamepadAxisCount ¶

GetGamepadAxisCount :: proc "cdecl" (key: i32) -> i32 ---

GetGamepadAxisMovement ¶

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

GetGamepadButtonPressed ¶

GetGamepadButtonPressed :: proc "cdecl" () -> i32 ---

GetGamepadName ¶

GetGamepadName :: proc "cdecl" (joy: i32) -> cstring ---

GetGestureDetected ¶

GetGestureDetected :: proc "cdecl" () -> Gesture ---

GetGestureDragAngle ¶

GetGestureDragAngle :: proc "cdecl" () -> f32 ---

GetGestureDragVector ¶

GetGestureDragVector :: proc "cdecl" () -> linalg.Vector2f32 ---

GetGestureHoldDuration ¶

GetGestureHoldDuration :: proc "cdecl" () -> f32 ---

GetGesturePinchAngle ¶

GetGesturePinchAngle :: proc "cdecl" () -> f32 ---

GetGesturePinchVector ¶

GetGesturePinchVector :: proc "cdecl" () -> linalg.Vector2f32 ---

GetGlyphAtlasRec ¶

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

GetGlyphIndex ¶

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

GetGlyphInfo ¶

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

GetImageAlphaBorder ¶

GetImageAlphaBorder :: proc "cdecl" (image: Image, threshold: f32) -> Rectangle ---

GetImageColor ¶

GetImageColor :: proc "cdecl" (image: Image, x, y: i32) -> Color ---

GetKeyPressed ¶

GetKeyPressed :: proc "cdecl" () -> KeyboardKey ---

GetMeshBoundingBox ¶

GetMeshBoundingBox :: proc "cdecl" (mesh: Mesh) -> BoundingBox ---

GetModelBoundingBox ¶

GetModelBoundingBox :: proc "cdecl" (model: Model) -> BoundingBox ---

GetMonitorCount ¶

GetMonitorCount :: proc "cdecl" () -> i32 ---

GetMonitorHeight ¶

GetMonitorHeight :: proc "cdecl" (key: i32) -> i32 ---

GetMonitorName ¶

GetMonitorName :: proc "cdecl" (joy: i32) -> cstring ---

GetMonitorPhysicalHeight ¶

GetMonitorPhysicalHeight :: proc "cdecl" (key: i32) -> i32 ---

GetMonitorPhysicalWidth ¶

GetMonitorPhysicalWidth :: proc "cdecl" (key: i32) -> i32 ---

GetMonitorPosition ¶

GetMonitorPosition :: proc "cdecl" (monitor: i32) -> linalg.Vector2f32 ---

GetMonitorRefreshRate ¶

GetMonitorRefreshRate :: proc "cdecl" (key: i32) -> i32 ---

GetMonitorWidth ¶

GetMonitorWidth :: proc "cdecl" (key: i32) -> i32 ---

GetMouseDelta ¶

GetMouseDelta :: proc "cdecl" () -> linalg.Vector2f32 ---

GetMousePosition ¶

GetMousePosition :: proc "cdecl" () -> linalg.Vector2f32 ---

GetMouseRay ¶

GetMouseRay :: proc "cdecl" (mousePosition: linalg.Vector2f32, camera: Camera3D) -> Ray ---
 

Screen-space-related functions

GetMouseWheelMove ¶

GetMouseWheelMove :: proc "cdecl" () -> f32 ---

GetMouseX ¶

GetMouseX :: proc "cdecl" () -> i32 ---

GetMouseY ¶

GetMouseY :: proc "cdecl" () -> i32 ---

GetMusicTimeLength ¶

GetMusicTimeLength :: proc "cdecl" (music: Music) -> f32 ---

GetMusicTimePlayed ¶

GetMusicTimePlayed :: proc "cdecl" (music: Music) -> f32 ---

GetPixelColor ¶

GetPixelColor :: proc "cdecl" (srcPtr: rawptr, format: PixelFormat) -> Color ---

GetPixelDataSize ¶

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

GetPrevDirectoryPath ¶

GetPrevDirectoryPath :: proc "cdecl" (fileName: cstring) -> cstring ---

GetRandomValue ¶

GetRandomValue :: proc "cdecl" (x, y: i32) -> i32 ---
 

Misc. functions

GetRayCollisionBox ¶

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

GetRayCollisionMesh ¶

GetRayCollisionMesh :: proc "cdecl" (ray: Ray, mesh: Mesh, transform: linalg.Matrix4x4f32) -> RayCollision ---

GetRayCollisionModel ¶

GetRayCollisionModel :: proc "cdecl" (ray: Ray, model: Model) -> RayCollision ---

GetRayCollisionQuad ¶

GetRayCollisionQuad :: proc "cdecl" (ray: Ray, p1, p2, p3, p4: linalg.Vector3f32) -> RayCollision ---

GetRayCollisionSphere ¶

GetRayCollisionSphere :: proc "cdecl" (ray: Ray, center: linalg.Vector3f32, radius: f32) -> RayCollision ---

GetRayCollisionTriangle ¶

GetRayCollisionTriangle :: proc "cdecl" (ray: Ray, p1, p2, p3: linalg.Vector3f32) -> RayCollision ---

GetScreenHeight ¶

GetScreenHeight :: proc "cdecl" () -> i32 ---

GetScreenToWorld2D ¶

GetScreenToWorld2D :: proc "cdecl" (position: linalg.Vector2f32, camera: Camera2D) -> linalg.Vector2f32 ---

GetScreenWidth ¶

GetScreenWidth :: proc "cdecl" () -> i32 ---

GetShaderLocation ¶

GetShaderLocation :: proc "cdecl" (shader: Shader, uniformName: cstring) -> i32 ---

GetShaderLocationAttrib ¶

GetShaderLocationAttrib :: proc "cdecl" (shader: Shader, uniformName: cstring) -> i32 ---

GetSoundsPlaying ¶

GetSoundsPlaying :: proc "cdecl" () -> i32 ---

GetTime ¶

GetTime :: proc "cdecl" () -> f64 ---

GetTouchPointCount ¶

GetTouchPointCount :: proc "cdecl" () -> i32 ---

GetTouchPointId ¶

GetTouchPointId :: proc "cdecl" (key: i32) -> i32 ---

GetTouchPosition ¶

GetTouchPosition :: proc "cdecl" (monitor: i32) -> linalg.Vector2f32 ---

GetTouchX ¶

GetTouchX :: proc "cdecl" () -> i32 ---
 

Input-related functions: touch

GetTouchY ¶

GetTouchY :: proc "cdecl" () -> i32 ---

GetWindowHandle ¶

GetWindowHandle :: proc "cdecl" () -> rawptr ---

GetWindowPosition ¶

GetWindowPosition :: proc "cdecl" () -> linalg.Vector2f32 ---

GetWindowScaleDPI ¶

GetWindowScaleDPI :: proc "cdecl" () -> linalg.Vector2f32 ---

GetWorkingDirectory ¶

GetWorkingDirectory :: proc "cdecl" () -> cstring ---

GetWorldToScreen ¶

GetWorldToScreen :: proc "cdecl" (position: linalg.Vector3f32, camera: Camera3D) -> linalg.Vector2f32 ---

GetWorldToScreen2D ¶

GetWorldToScreen2D :: proc "cdecl" (position: linalg.Vector2f32, camera: Camera2D) -> linalg.Vector2f32 ---

GetWorldToScreenEx ¶

GetWorldToScreenEx :: proc "cdecl" (position: linalg.Vector3f32, camera: Camera3D, width, height: i32) -> linalg.Vector2f32 ---

HideCursor ¶

HideCursor :: proc "cdecl" () ---

ImageAlphaClear ¶

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

ImageAlphaCrop ¶

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

ImageAlphaMask ¶

ImageAlphaMask :: proc "cdecl" (image: ^Image, alphaMask: Image) ---

ImageAlphaPremultiply ¶

ImageAlphaPremultiply :: proc "cdecl" (image: ^Image) ---

ImageClearBackground ¶

ImageClearBackground :: proc "cdecl" (image: ^Image, fill: Color) ---
 

Image drawing functions NOTE: Image software-rendering functions (CPU)

ImageColorBrightness ¶

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

ImageColorContrast ¶

ImageColorContrast :: proc "cdecl" (image: ^Image, threshold: f32) ---

ImageColorGrayscale ¶

ImageColorGrayscale :: proc "cdecl" (image: ^Image) ---

ImageColorInvert ¶

ImageColorInvert :: proc "cdecl" (image: ^Image) ---

ImageColorReplace ¶

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

ImageColorTint ¶

ImageColorTint :: proc "cdecl" (image: ^Image, fill: Color) ---

ImageCopy ¶

ImageCopy :: proc "cdecl" (image: Image) -> Image ---
 

Image manipulation functions

ImageCrop ¶

ImageCrop :: proc "cdecl" (image: ^Image, crop: Rectangle) ---

ImageDither ¶

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

ImageDraw ¶

ImageDraw :: proc "cdecl" (dst: ^Image, src: Image, srcRec, dstRec: Rectangle, tint: Color) ---

ImageDrawCircle ¶

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

ImageDrawCircleV ¶

ImageDrawCircleV :: proc "cdecl" (dst: ^Image, center: linalg.Vector2f32, radius: i32, color: Color) ---

ImageDrawLine ¶

ImageDrawLine :: proc "cdecl" (
	image:               ^Image, 
	newWidth, newHeight: i32, 
	offsetX, offsetY:    i32, 
) ---

ImageDrawLineV ¶

ImageDrawLineV :: proc "cdecl" (dst: ^Image, start, end: linalg.Vector2f32, color: Color) ---

ImageDrawPixel ¶

ImageDrawPixel :: proc "cdecl" (dst: ^Image, posX, posY: i32, color: Color) ---

ImageDrawPixelV ¶

ImageDrawPixelV :: proc "cdecl" (dst: ^Image, position: linalg.Vector2f32, color: Color) ---

ImageDrawRectangle ¶

ImageDrawRectangle :: proc "cdecl" (
	image:               ^Image, 
	newWidth, newHeight: i32, 
	offsetX, offsetY:    i32, 
) ---

ImageDrawRectangleLines ¶

ImageDrawRectangleLines :: proc "cdecl" (dst: ^Image, rec: Rectangle, thick: i32, color: Color) ---

ImageDrawRectangleRec ¶

ImageDrawRectangleRec :: proc "cdecl" (dst: ^Image, rec: Rectangle, color: Color) ---

ImageDrawRectangleV ¶

ImageDrawRectangleV :: proc "cdecl" (dst: ^Image, start, end: linalg.Vector2f32, color: Color) ---

ImageDrawText ¶

ImageDrawText :: proc "cdecl" (
	dst:        ^Image, 
	text:       cstring, 
	posX, posY: i32, 
	fontSize:   i32, 
) ---

ImageDrawTextEx ¶

ImageDrawTextEx :: proc "cdecl" (
	dst:               ^Image, 
	font:              Font, 
	text:              cstring, 
	position:          linalg.Vector2f32, 
	fontSize, spacing: f32, 
) ---

ImageFlipHorizontal ¶

ImageFlipHorizontal :: proc "cdecl" (image: ^Image) ---

ImageFlipVertical ¶

ImageFlipVertical :: proc "cdecl" (image: ^Image) ---

ImageFormat ¶

ImageFormat :: proc "cdecl" (image: ^Image, newFormat: PixelFormat) ---

ImageFromImage ¶

ImageFromImage :: proc "cdecl" (image: Image, rec: Rectangle) -> Image ---

ImageMipmaps ¶

ImageMipmaps :: proc "cdecl" (image: ^Image) ---

ImageResize ¶

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

ImageResizeCanvas ¶

ImageResizeCanvas :: proc "cdecl" (
	image:               ^Image, 
	newWidth, newHeight: i32, 
	offsetX, offsetY:    i32, 
) ---

ImageResizeNN ¶

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

ImageRotateCCW ¶

ImageRotateCCW :: proc "cdecl" (image: ^Image) ---

ImageRotateCW ¶

ImageRotateCW :: proc "cdecl" (image: ^Image) ---

ImageText ¶

ImageText :: proc "cdecl" (text: cstring, fontSize: i32, color: Color) -> Image ---

ImageTextEx ¶

ImageTextEx :: proc "cdecl" (font: Font, text: cstring, fontSize, spacing: f32, tint: Color) -> Image ---

ImageToPOT ¶

ImageToPOT :: proc "cdecl" (image: ^Image, fill: Color) ---

InitAudioDevice ¶

InitAudioDevice :: proc "cdecl" () ---
 

Audio device management functions

InitWindow ¶

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

Window-related functions

IsAudioDeviceReady ¶

IsAudioDeviceReady :: proc "cdecl" () -> bool ---

IsAudioStreamPlaying ¶

IsAudioStreamPlaying :: proc "cdecl" (stream: AudioStream) -> bool ---

IsAudioStreamProcessed ¶

IsAudioStreamProcessed :: proc "cdecl" (stream: AudioStream) -> bool ---

IsCursorHidden ¶

IsCursorHidden :: proc "cdecl" () -> bool ---

IsCursorOnScreen ¶

IsCursorOnScreen :: proc "cdecl" () -> bool ---

IsFileDropped ¶

IsFileDropped :: proc "cdecl" () -> bool ---

IsFileExtension ¶

IsFileExtension :: proc "cdecl" (fileName: cstring, text: cstring) -> bool ---

IsGamepadAvailable ¶

IsGamepadAvailable :: proc "cdecl" (gamepad: i32) -> bool ---
 

Input-related functions: gamepads

IsGamepadButtonDown ¶

IsGamepadButtonDown :: proc "cdecl" (gamepad: i32, button: GamepadButton) -> bool ---

IsGamepadButtonPressed ¶

IsGamepadButtonPressed :: proc "cdecl" (gamepad: i32, button: GamepadButton) -> bool ---

IsGamepadButtonReleased ¶

IsGamepadButtonReleased :: proc "cdecl" (gamepad: i32, button: GamepadButton) -> bool ---

IsGamepadButtonUp ¶

IsGamepadButtonUp :: proc "cdecl" (gamepad: i32, button: GamepadButton) -> bool ---

IsGamepadName ¶

IsGamepadName :: proc "cdecl" (gamepad: i32, name: cstring) -> bool ---

IsGestureDetected ¶

IsGestureDetected :: proc "cdecl" (gesture: Gesture) -> bool ---

IsKeyDown ¶

IsKeyDown :: proc "cdecl" (key: KeyboardKey) -> bool ---

IsKeyPressed ¶

IsKeyPressed :: proc "cdecl" (key: KeyboardKey) -> bool ---
 

Input-related functions: keyboard

IsKeyReleased ¶

IsKeyReleased :: proc "cdecl" (key: KeyboardKey) -> bool ---

IsKeyUp ¶

IsKeyUp :: proc "cdecl" (key: KeyboardKey) -> bool ---

IsModelAnimationValid ¶

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

IsMouseButtonDown ¶

IsMouseButtonDown :: proc "cdecl" (button: MouseButton) -> bool ---

IsMouseButtonPressed ¶

IsMouseButtonPressed :: proc "cdecl" (button: MouseButton) -> bool ---
 

Input-related functions: mouse

IsMouseButtonReleased ¶

IsMouseButtonReleased :: proc "cdecl" (button: MouseButton) -> bool ---

IsMouseButtonUp ¶

IsMouseButtonUp :: proc "cdecl" (button: MouseButton) -> bool ---

IsMusicStreamPlaying ¶

IsMusicStreamPlaying :: proc "cdecl" (music: Music) -> bool ---

IsSoundPlaying ¶

IsSoundPlaying :: proc "cdecl" (sound: Sound) -> bool ---

IsWindowFocused ¶

IsWindowFocused :: proc "cdecl" () -> bool ---

IsWindowFullscreen ¶

IsWindowFullscreen :: proc "cdecl" () -> bool ---

IsWindowHidden ¶

IsWindowHidden :: proc "cdecl" () -> bool ---

IsWindowMaximized ¶

IsWindowMaximized :: proc "cdecl" () -> bool ---

IsWindowMinimized ¶

IsWindowMinimized :: proc "cdecl" () -> bool ---

IsWindowReady ¶

IsWindowReady :: proc "cdecl" () -> bool ---

IsWindowResized ¶

IsWindowResized :: proc "cdecl" () -> bool ---

IsWindowState ¶

IsWindowState :: proc "cdecl" (flag: ConfigFlags) -> bool ---

LoadAudioStream ¶

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

AudioStream management functions

LoadCodepoints ¶

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

Text codepoints management functions (unicode characters)

LoadFileData ¶

LoadFileData :: proc "cdecl" (fileName: cstring, bytesRead: ^u32) -> [^]u8 ---
 

Files management functions

LoadFileText ¶

LoadFileText :: proc "cdecl" (name: cstring) -> [^]u8 ---

LoadFont ¶

LoadFont :: proc "cdecl" (fileName: cstring) -> Font ---

LoadFontData ¶

LoadFontData :: proc "cdecl" (
	fileData:   rawptr, 
	dataSize:   i32, 
	fontSize:   i32, 
	fontChars:  [^]rune, 
	charsCount: i32, 
) -> [^]GlyphInfo ---

LoadFontEx ¶

LoadFontEx :: proc "cdecl" (fileName: cstring, fontSize: i32, fontChars: [^]rune, charsCount: i32) -> Font ---

LoadFontFromImage ¶

LoadFontFromImage :: proc "cdecl" (image: Image, key: Color, firstChar: rune) -> Font ---

LoadFontFromMemory ¶

LoadFontFromMemory :: proc "cdecl" (
	fileType:  cstring, 
	fileData:  rawptr, 
	dataSize:  i32, 
	fontSize:  i32, 
	fontChars: [^]rune, 
) -> Font ---

LoadImage ¶

LoadImage :: proc "cdecl" (fileName: cstring) -> Image ---
 

Image loading functions NOTE: This functions do not require GPU access

LoadImageAnim ¶

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

LoadImageColors ¶

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

LoadImageFromMemory ¶

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

LoadImageFromTexture ¶

LoadImageFromTexture :: proc "cdecl" (texture: Texture) -> Image ---

LoadImagePalette ¶

LoadImagePalette :: proc "cdecl" (image: Image, maxPaletteSize: i32, colorsCount: [^]i32) -> [^]Color ---

LoadImageRaw ¶

LoadImageRaw :: proc "cdecl" (fileName: cstring, width, height: i32, format: PixelFormat, headerSize: i32) -> Image ---

LoadMaterialDefault ¶

LoadMaterialDefault :: proc "cdecl" () -> Material ---

LoadMaterials ¶

LoadMaterials :: proc "cdecl" (fileName: cstring, materialCount: ^i32) -> [^]Material ---
 

Material loading/unloading functions

LoadModel ¶

LoadModel :: proc "cdecl" (fileName: cstring) -> Model ---
 

Model loading/unloading functions

LoadModelAnimations ¶

LoadModelAnimations :: proc "cdecl" (fileName: cstring, animsCount: ^i32) -> [^]ModelAnimation ---
 

Model animations loading/unloading functions

LoadModelFromMesh ¶

LoadModelFromMesh :: proc "cdecl" (mesh: Mesh) -> Model ---

LoadMusicStream ¶

LoadMusicStream :: proc "cdecl" (fileName: cstring) -> Music ---
 

Music management functions

LoadMusicStreamFromMemory ¶

LoadMusicStreamFromMemory :: proc "cdecl" (fileType: cstring, data: rawptr, dataSize: i32) -> Music ---

LoadRenderTexture ¶

LoadRenderTexture :: proc "cdecl" (width, height: i32) -> RenderTexture ---

LoadShader ¶

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

Shader management functions NOTE: Shader functionality is not available on OpenGL 1.1

LoadShaderFromMemory ¶

LoadShaderFromMemory :: proc "cdecl" (vsFileName, fsFileName: cstring) -> Shader ---

LoadSound ¶

LoadSound :: proc "cdecl" (fileName: cstring) -> Sound ---

LoadSoundFromWave ¶

LoadSoundFromWave :: proc "cdecl" (wave: Wave) -> Sound ---

LoadStorageValue ¶

LoadStorageValue :: proc "cdecl" (v: u32) -> i32 ---

LoadTexture ¶

LoadTexture :: proc "cdecl" (fileName: cstring) -> Texture ---
 

Texture loading functions NOTE: These functions require GPU access

LoadTextureCubemap ¶

LoadTextureCubemap :: proc "cdecl" (image: Image, layout: CubemapLayout) -> Texture ---

LoadTextureFromImage ¶

LoadTextureFromImage :: proc "cdecl" (image: Image) -> Texture ---

LoadVrStereoConfig ¶

LoadVrStereoConfig :: proc "cdecl" (device: VrDeviceInfo) -> VrStereoConfig ---
 

VR stereo config functions for VR simulator

LoadWave ¶

LoadWave :: proc "cdecl" (fileName: cstring) -> Wave ---
 

Wave/Sound loading/unloading functions

LoadWaveFromMemory ¶

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

LoadWaveSamples ¶

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

MaximizeWindow ¶

MaximizeWindow :: proc "cdecl" () ---

MeasureText ¶

MeasureText :: proc "cdecl" (text: cstring, fontSize: i32) -> i32 ---
 

Text misc. functions

MeasureTextEx ¶

MeasureTextEx :: proc "cdecl" (font: Font, text: cstring, fontSize, spacing: f32) -> linalg.Vector2f32 ---

MemAlloc ¶

MemAlloc :: proc "cdecl" (jid: i32) -> rawptr ---

MemAllocator ¶

MemAllocator :: proc "contextless" () -> runtime.Allocator {…}

MemAllocatorProc ¶

MemAllocatorProc :: proc "odin" (
	allocator_data:  rawptr, 
	mode:            runtime.Allocator_Mode, 
	size, alignment: int, 
	old_memory:      rawptr, 
	old_size:        int, 
) -> ([]u8, runtime.Allocator_Error) {…}

MemFree ¶

MemFree :: proc "cdecl" (_: rawptr) ---

MemRealloc ¶

MemRealloc :: proc "cdecl" (ptr: rawptr, size: i32) -> rawptr ---

MinimizeWindow ¶

MinimizeWindow :: proc "cdecl" () ---

OpenURL ¶

OpenURL :: proc "cdecl" (s: cstring) ---

PauseAudioStream ¶

PauseAudioStream :: proc "cdecl" (stream: AudioStream) ---

PauseMusicStream ¶

PauseMusicStream :: proc "cdecl" (music: Music) ---

PauseSound ¶

PauseSound :: proc "cdecl" (sound: Sound) ---

PlayAudioStream ¶

PlayAudioStream :: proc "cdecl" (stream: AudioStream) ---

PlayMusicStream ¶

PlayMusicStream :: proc "cdecl" (music: Music) ---

PlaySound ¶

PlaySound :: proc "cdecl" (sound: Sound) ---
 

Wave/Sound management functions

PlaySoundMulti ¶

PlaySoundMulti :: proc "cdecl" (sound: Sound) ---

PollInputEvents ¶

PollInputEvents :: proc "cdecl" () ---

RestoreWindow ¶

RestoreWindow :: proc "cdecl" () ---

ResumeAudioStream ¶

ResumeAudioStream :: proc "cdecl" (stream: AudioStream) ---

ResumeMusicStream ¶

ResumeMusicStream :: proc "cdecl" (music: Music) ---

ResumeSound ¶

ResumeSound :: proc "cdecl" (sound: Sound) ---

SaveFileData ¶

SaveFileData :: proc "cdecl" (fileName: cstring, data: rawptr, bytesToWrite: u32) -> bool ---

SaveFileText ¶

SaveFileText :: proc "cdecl" (fileName: cstring, text: cstring) -> bool ---

SaveStorageValue ¶

SaveStorageValue :: proc "cdecl" (position: u32, value: i32) -> bool ---
 

Persistent storage management

SeekMusicStream ¶

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

SetAudioStreamBufferSizeDefault ¶

SetAudioStreamBufferSizeDefault :: proc "cdecl" (interval: i32) ---

SetAudioStreamPitch ¶

SetAudioStreamPitch :: proc "cdecl" (stream: AudioStream, volume: f32) ---

SetAudioStreamVolume ¶

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

SetCameraAltControl ¶

SetCameraAltControl :: proc "cdecl" (key: KeyboardKey) ---

SetCameraMode ¶

SetCameraMode :: proc "cdecl" (camera: Camera3D, mode: CameraMode) ---
 

------------------------------------------------------------------------------------ Camera System Functions (Module: camera) ------------------------------------------------------------------------------------

SetCameraMoveControls ¶

SetCameraMoveControls :: proc "cdecl" (
	keyFront, keyBack, keyRight, keyLeft, keyUp, 
) ---

SetCameraPanControl ¶

SetCameraPanControl :: proc "cdecl" (key: KeyboardKey) ---

SetCameraSmoothZoomControl ¶

SetCameraSmoothZoomControl :: proc "cdecl" (key: KeyboardKey) ---

SetClipboardText ¶

SetClipboardText :: proc "cdecl" (s: cstring) ---

SetConfigFlags ¶

SetConfigFlags :: proc "cdecl" (flags: ConfigFlags) ---

SetExitKey ¶

SetExitKey :: proc "cdecl" (key: KeyboardKey) ---

SetGamepadMappings ¶

SetGamepadMappings :: proc "cdecl" (str: cstring) -> i32 ---

SetGesturesEnabled ¶

SetGesturesEnabled :: proc "cdecl" (flags: Gestures) ---
 

------------------------------------------------------------------------------------ Gestures and Touch Handling Functions (Module: gestures) ------------------------------------------------------------------------------------

SetLoadFileDataCallback ¶

SetLoadFileDataCallback :: proc "cdecl" (callback: LoadFileDataCallback) ---

SetLoadFileTextCallback ¶

SetLoadFileTextCallback :: proc "cdecl" (callback: LoadFileTextCallback) ---

SetMasterVolume ¶

SetMasterVolume :: proc "cdecl" (ms: f32) ---

SetMaterialTexture ¶

SetMaterialTexture :: proc "cdecl" (material: ^Material, mapType: MaterialMapIndex, texture: Texture) ---

SetModelMeshMaterial ¶

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

SetMouseCursor ¶

SetMouseCursor :: proc "cdecl" (cursor: MouseCursor) ---

SetMouseOffset ¶

SetMouseOffset :: proc "cdecl" (joy, event: i32) ---

SetMousePosition ¶

SetMousePosition :: proc "cdecl" (joy, event: i32) ---

SetMouseScale ¶

SetMouseScale :: proc "cdecl" (scaleX, scaleY: f32) ---

SetMusicPitch ¶

SetMusicPitch :: proc "cdecl" (music: Music, position: f32) ---

SetMusicVolume ¶

SetMusicVolume :: proc "cdecl" (music: Music, position: f32) ---

SetPixelColor ¶

SetPixelColor :: proc "cdecl" (dstPtr: rawptr, color: Color, format: PixelFormat) ---

SetRandomSeed ¶

SetRandomSeed :: proc "cdecl" (_: u32) ---

SetSaveFileDataCallback ¶

SetSaveFileDataCallback :: proc "cdecl" (callback: SaveFileDataCallback) ---

SetSaveFileTextCallback ¶

SetSaveFileTextCallback :: proc "cdecl" (callback: SaveFileTextCallback) ---

SetShaderValue ¶

SetShaderValue :: proc "cdecl" (shader: Shader, locIndex: ShaderLocationIndex, value: rawptr, uniformType: ShaderUniformDataType) ---

SetShaderValueMatrix ¶

SetShaderValueMatrix :: proc "cdecl" (shader: Shader, locIndex: ShaderLocationIndex, mat: linalg.Matrix4x4f32) ---

SetShaderValueTexture ¶

SetShaderValueTexture :: proc "cdecl" (shader: Shader, locIndex: ShaderLocationIndex, texture: Texture) ---

SetShaderValueV ¶

SetShaderValueV :: proc "cdecl" (shader: Shader, locIndex: ShaderLocationIndex, value: rawptr, uniformType: ShaderUniformDataType, count: i32) ---

SetShapesTexture ¶

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

------------------------------------------------------------------------------------ Basic Shapes Drawing Functions (Module: shapes) ------------------------------------------------------------------------------------ Set texture and rectangle to be used on shapes drawing NOTE: It can be useful when using basic shapes and one single font, defining a font char white rectangle would allow drawing everything in a single draw call

SetSoundPitch ¶

SetSoundPitch :: proc "cdecl" (sound: Sound, volume: f32) ---

SetSoundVolume ¶

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

SetTargetFPS ¶

SetTargetFPS :: proc "cdecl" (interval: i32) ---
 

Timing-related functions

SetTextureFilter ¶

SetTextureFilter :: proc "cdecl" (texture: Texture, filter: TextureFilter) ---

SetTextureWrap ¶

SetTextureWrap :: proc "cdecl" (texture: Texture, wrap: TextureWrap) ---

SetTraceLogCallback ¶

SetTraceLogCallback :: proc "cdecl" (callback: TraceLogCallback) ---
 

Set custom callbacks WARNING: Callbacks setup is intended for advance users

SetTraceLogLevel ¶

SetTraceLogLevel :: proc "cdecl" (logLevel: TraceLogLevel) ---

SetWindowIcon ¶

SetWindowIcon :: proc "cdecl" (image: Image) ---

SetWindowMinSize ¶

SetWindowMinSize :: proc "cdecl" (joy, event: i32) ---

SetWindowMonitor ¶

SetWindowMonitor :: proc "cdecl" (interval: i32) ---

SetWindowPosition ¶

SetWindowPosition :: proc "cdecl" (joy, event: i32) ---

SetWindowSize ¶

SetWindowSize :: proc "cdecl" (joy, event: i32) ---

SetWindowState ¶

SetWindowState :: proc "cdecl" (flags: ConfigFlags) ---

SetWindowTitle ¶

SetWindowTitle :: proc "cdecl" (s: cstring) ---

ShowCursor ¶

ShowCursor :: proc "cdecl" () ---
 

Cursor-related functions

StopAudioStream ¶

StopAudioStream :: proc "cdecl" (stream: AudioStream) ---

StopMusicStream ¶

StopMusicStream :: proc "cdecl" (music: Music) ---

StopSound ¶

StopSound :: proc "cdecl" (sound: Sound) ---

StopSoundMulti ¶

StopSoundMulti :: proc "cdecl" () ---

SwapScreenBuffer ¶

SwapScreenBuffer :: proc "cdecl" () ---
 

Custom frame control functions NOTE: Those functions are intended for advance users that want full control over the frame processing By default EndDrawing() does this job: draws everything + SwapScreenBuffer() + manage frame timming + PollInputEvents() To avoid that behaviour and control frame processes manually, enable in config.h: SUPPORT_CUSTOM_FRAME_CONTROL

TakeScreenshot ¶

TakeScreenshot :: proc "cdecl" (s: cstring) ---

TextAppend ¶

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

TextCodepointsToUTF8 ¶

TextCodepointsToUTF8 :: proc "cdecl" (codepoints: [^]rune, length: i32) -> cstring ---

TextCopy ¶

TextCopy :: proc "cdecl" (dst: [^]u8, src: cstring) -> i32 ---
 

Text strings management functions (no utf8 strings, only byte chars) NOTE: Some strings allocate memory internally for returned strings, just be careful!

TextFindIndex ¶

TextFindIndex :: proc "cdecl" (old, new: cstring) -> i32 ---

TextFormat ¶

TextFormat :: proc "odin" (text: cstring, args: ..any) -> cstring {…}
 

Text formatting with variables (sprintf style)

TextFormatAlloc ¶

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

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

TextInsert ¶

TextInsert :: proc "cdecl" (text, insert: cstring, position: i32) -> cstring ---

TextIsEqual ¶

TextIsEqual :: proc "cdecl" (fileName: cstring, text: cstring) -> bool ---

TextJoin ¶

TextJoin :: proc "cdecl" (textList: [^]cstring, count: i32, delimiter: cstring) -> cstring ---

TextLength ¶

TextLength :: proc "cdecl" (text: cstring) -> u32 ---

TextReplace ¶

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

TextSplit ¶

TextSplit :: proc "cdecl" (text: cstring, delimiter: u8, count: ^i32) -> [^]cstring ---

TextSubtext ¶

TextSubtext :: proc "cdecl" (text: cstring, position: i32, length: i32) -> cstring ---

TextToInteger ¶

TextToInteger :: proc "cdecl" (str: cstring) -> i32 ---

TextToLower ¶

TextToLower :: proc "cdecl" (fileName: cstring) -> cstring ---

TextToPascal ¶

TextToPascal :: proc "cdecl" (fileName: cstring) -> cstring ---

TextToUpper ¶

TextToUpper :: proc "cdecl" (fileName: cstring) -> cstring ---

ToggleFullscreen ¶

ToggleFullscreen :: proc "cdecl" () ---

TraceLog ¶

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

UnloadAudioStream ¶

UnloadAudioStream :: proc "cdecl" (stream: AudioStream) ---

UnloadCodepoints ¶

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

UnloadFileData ¶

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

UnloadFileText ¶

UnloadFileText :: proc "cdecl" (s: cstring) ---

UnloadFont ¶

UnloadFont :: proc "cdecl" (font: Font) ---

UnloadFontData ¶

UnloadFontData :: proc "cdecl" (chars: [^]GlyphInfo, charsCount: i32) ---

UnloadImage ¶

UnloadImage :: proc "cdecl" (image: Image) ---

UnloadImageColors ¶

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

UnloadImagePalette ¶

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

UnloadMaterial ¶

UnloadMaterial :: proc "cdecl" (material: Material) ---

UnloadMesh ¶

UnloadMesh :: proc "cdecl" (mesh: Mesh) ---

UnloadModel ¶

UnloadModel :: proc "cdecl" (model: Model) ---

UnloadModelAnimation ¶

UnloadModelAnimation :: proc "cdecl" (anim: ModelAnimation) ---

UnloadModelAnimations ¶

UnloadModelAnimations :: proc "cdecl" (animations: [^]ModelAnimation, count: u32) ---

UnloadModelKeepMeshes ¶

UnloadModelKeepMeshes :: proc "cdecl" (model: Model) ---

UnloadMusicStream ¶

UnloadMusicStream :: proc "cdecl" (music: Music) ---

UnloadRenderTexture ¶

UnloadRenderTexture :: proc "cdecl" (target: RenderTexture) ---

UnloadShader ¶

UnloadShader :: proc "cdecl" (shader: Shader) ---

UnloadSound ¶

UnloadSound :: proc "cdecl" (sound: Sound) ---

UnloadTexture ¶

UnloadTexture :: proc "cdecl" (texture: Texture) ---

UnloadVrStereoConfig ¶

UnloadVrStereoConfig :: proc "cdecl" (config: VrStereoConfig) ---

UnloadWave ¶

UnloadWave :: proc "cdecl" (wave: Wave) ---

UnloadWaveSamples ¶

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

UpdateAudioStream ¶

UpdateAudioStream :: proc "cdecl" (stream: AudioStream, data: rawptr, frameCount: i32) ---

UpdateCamera ¶

UpdateCamera :: proc "cdecl" (camera: ^Camera3D) ---

UpdateMeshBuffer ¶

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

UpdateModelAnimation ¶

UpdateModelAnimation :: proc "cdecl" (model: Model, anim: ModelAnimation, frame: i32) ---

UpdateMusicStream ¶

UpdateMusicStream :: proc "cdecl" (music: Music) ---

UpdateSound ¶

UpdateSound :: proc "cdecl" (sound: Sound, data: rawptr, samplesCount: i32) ---

UpdateTexture ¶

UpdateTexture :: proc "cdecl" (texture: Texture, pixels: rawptr) ---

UpdateTextureRec ¶

UpdateTextureRec :: proc "cdecl" (texture: Texture, rec: Rectangle, pixels: rawptr) ---

UploadMesh ¶

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

Mesh management functions

WaitTime ¶

WaitTime :: proc "cdecl" (ms: f32) ---

WaveCopy ¶

WaveCopy :: proc "cdecl" (wave: Wave) -> Wave ---

WaveCrop ¶

WaveCrop :: proc "cdecl" (wave: ^Wave, initSample, finalSample: i32) ---

WaveFormat ¶

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

WindowShouldClose ¶

WindowShouldClose :: proc "cdecl" () -> bool ---

rlActiveDrawBuffers ¶

rlActiveDrawBuffers :: proc "cdecl" (interval: i32) ---

rlActiveTextureSlot ¶

rlActiveTextureSlot :: proc "cdecl" (interval: i32) ---
 

Textures state

rlBegin ¶

rlBegin :: proc "cdecl" (interval: i32) ---
 

------------------------------------------------------------------------------------ Functions Declaration - Vertex level operations ------------------------------------------------------------------------------------

rlBindImageTexture ¶

rlBindImageTexture :: proc "cdecl" (id: u32, index: u32, format: u32, readonly: b32) ---

rlBindShaderBuffer ¶

rlBindShaderBuffer :: proc "cdecl" (id: u32, index: u32) ---

rlCheckErrors ¶

rlCheckErrors :: proc "cdecl" () ---

rlCheckRenderBatchLimit ¶

rlCheckRenderBatchLimit :: proc "cdecl" (gamepad: i32) -> bool ---

rlClearColor ¶

rlClearColor :: proc "cdecl" (r, g, b, a: u8) ---

rlClearScreenBuffers ¶

rlClearScreenBuffers :: proc "cdecl" () ---

rlColor3f ¶

rlColor3f :: proc "cdecl" (x, y, z: f32) ---

rlColor4f ¶

rlColor4f :: proc "cdecl" (angleDeg: f32, x, y, z: f32) ---

rlColor4ub ¶

rlColor4ub :: proc "cdecl" (r, g, b, a: u8) ---

rlCompileShader ¶

rlCompileShader :: proc "cdecl" (shaderCode: cstring, type: i32) -> u32 ---

rlComputeShaderDispatch ¶

rlComputeShaderDispatch :: proc "cdecl" (groupX, groupY, groupZ: u32) ---

rlCopyBuffersElements ¶

rlCopyBuffersElements :: proc "cdecl" (destId, srcId: u32, destOffset, srcOffset: u64, count: u64) ---
 

Buffer management

rlDisableBackfaceCulling ¶

rlDisableBackfaceCulling :: proc "cdecl" () ---

rlDisableColorBlend ¶

rlDisableColorBlend :: proc "cdecl" () ---

rlDisableDepthMask ¶

rlDisableDepthMask :: proc "cdecl" () ---

rlDisableDepthTest ¶

rlDisableDepthTest :: proc "cdecl" () ---

rlDisableFramebuffer ¶

rlDisableFramebuffer :: proc "cdecl" () ---

rlDisableScissorTest ¶

rlDisableScissorTest :: proc "cdecl" () ---

rlDisableShader ¶

rlDisableShader :: proc "cdecl" () ---

rlDisableSmoothLines ¶

rlDisableSmoothLines :: proc "cdecl" () ---

rlDisableStereoRender ¶

rlDisableStereoRender :: proc "cdecl" () ---

rlDisableTexture ¶

rlDisableTexture :: proc "cdecl" () ---

rlDisableTextureCubemap ¶

rlDisableTextureCubemap :: proc "cdecl" () ---

rlDisableVertexArray ¶

rlDisableVertexArray :: proc "cdecl" () ---

rlDisableVertexAttribute ¶

rlDisableVertexAttribute :: proc "cdecl" (_: u32) ---

rlDisableVertexBuffer ¶

rlDisableVertexBuffer :: proc "cdecl" () ---

rlDisableVertexBufferElement ¶

rlDisableVertexBufferElement :: proc "cdecl" () ---

rlDisableWireMode ¶

rlDisableWireMode :: proc "cdecl" () ---

rlDrawRenderBatch ¶

rlDrawRenderBatch :: proc "cdecl" (batch: ^RenderBatch) ---

rlDrawRenderBatchActive ¶

rlDrawRenderBatchActive :: proc "cdecl" () ---

rlDrawVertexArray ¶

rlDrawVertexArray :: proc "cdecl" (joy, event: i32) ---

rlDrawVertexArrayElements ¶

rlDrawVertexArrayElements :: proc "cdecl" (offset: i32, count: i32, buffer: rawptr) ---

rlDrawVertexArrayElementsInstanced ¶

rlDrawVertexArrayElementsInstanced :: proc "cdecl" (offset: i32, count: i32, buffer: rawptr, instances: i32) ---

rlDrawVertexArrayInstanced ¶

rlDrawVertexArrayInstanced :: proc "cdecl" (glSrcFactor, glDstFactor, glEquation: i32) ---

rlEnableBackfaceCulling ¶

rlEnableBackfaceCulling :: proc "cdecl" () ---

rlEnableColorBlend ¶

rlEnableColorBlend :: proc "cdecl" () ---
 

General render state

rlEnableDepthMask ¶

rlEnableDepthMask :: proc "cdecl" () ---

rlEnableDepthTest ¶

rlEnableDepthTest :: proc "cdecl" () ---

rlEnableFramebuffer ¶

rlEnableFramebuffer :: proc "cdecl" (_: u32) ---
 

Framebuffer state

rlEnableScissorTest ¶

rlEnableScissorTest :: proc "cdecl" () ---

rlEnableShader ¶

rlEnableShader :: proc "cdecl" (_: u32) ---
 

Shader state

rlEnableSmoothLines ¶

rlEnableSmoothLines :: proc "cdecl" () ---

rlEnableStereoRender ¶

rlEnableStereoRender :: proc "cdecl" () ---

rlEnableTexture ¶

rlEnableTexture :: proc "cdecl" (_: u32) ---

rlEnableTextureCubemap ¶

rlEnableTextureCubemap :: proc "cdecl" (_: u32) ---

rlEnableVertexArray ¶

rlEnableVertexArray :: proc "cdecl" (vaoId: u32) -> bool ---
 

Vertex buffers state

rlEnableVertexAttribute ¶

rlEnableVertexAttribute :: proc "cdecl" (_: u32) ---

rlEnableVertexBuffer ¶

rlEnableVertexBuffer :: proc "cdecl" (_: u32) ---

rlEnableVertexBufferElement ¶

rlEnableVertexBufferElement :: proc "cdecl" (_: u32) ---

rlEnableWireMode ¶

rlEnableWireMode :: proc "cdecl" () ---

rlEnd ¶

rlEnd :: proc "cdecl" () ---

rlFramebufferAttach ¶

rlFramebufferAttach :: proc "cdecl" (fboId: u32, texId: u32, attachType: i32, texType: i32, mipLevel: i32) ---

rlFramebufferComplete ¶

rlFramebufferComplete :: proc "cdecl" (vaoId: u32) -> bool ---

rlFrustum ¶

rlFrustum :: proc "cdecl" (
	left, right, bottom, top, znear, 
) ---

rlGenerateMipmaps ¶

rlGenerateMipmaps :: proc "cdecl" (texture: ^Texture) ---

rlGetFramebufferHeight ¶

rlGetFramebufferHeight :: proc "cdecl" () -> i32 ---

rlGetFramebufferWidth ¶

rlGetFramebufferWidth :: proc "cdecl" () -> i32 ---

rlGetGlTextureFormats ¶

rlGetGlTextureFormats :: proc "cdecl" (format: i32, glInternalFormat: ^u32, glFormat: ^u32, glType: ^u32) ---

rlGetLineWidth ¶

rlGetLineWidth :: proc "cdecl" () -> f32 ---

rlGetLocationAttrib ¶

rlGetLocationAttrib :: proc "cdecl" (shaderId: u32, uniformName: cstring) -> i32 ---

rlGetLocationUniform ¶

rlGetLocationUniform :: proc "cdecl" (shaderId: u32, uniformName: cstring) -> i32 ---

rlGetMatrixModelview ¶

rlGetMatrixModelview :: proc "cdecl" () -> linalg.Matrix4x4f32 ---
 

Matrix state management

rlGetMatrixProjection ¶

rlGetMatrixProjection :: proc "cdecl" () -> linalg.Matrix4x4f32 ---

rlGetMatrixProjectionStereo ¶

rlGetMatrixProjectionStereo :: proc "cdecl" (eye: i32) -> linalg.Matrix4x4f32 ---

rlGetMatrixTransform ¶

rlGetMatrixTransform :: proc "cdecl" () -> linalg.Matrix4x4f32 ---

rlGetMatrixViewOffsetStereo ¶

rlGetMatrixViewOffsetStereo :: proc "cdecl" (eye: i32) -> linalg.Matrix4x4f32 ---

rlGetPixelFormatName ¶

rlGetPixelFormatName :: proc "cdecl" (format: PixelFormat) -> cstring ---

rlGetShaderBufferSize ¶

rlGetShaderBufferSize :: proc "cdecl" (id: u32) -> u64 ---

rlGetShaderIdDefault ¶

rlGetShaderIdDefault :: proc "cdecl" () -> u32 ---

rlGetShaderLocsDefault ¶

rlGetShaderLocsDefault :: proc "cdecl" () -> [^]i32 ---

rlGetTextureIdDefault ¶

rlGetTextureIdDefault :: proc "cdecl" () -> u32 ---

rlGetVersion ¶

rlGetVersion :: proc "cdecl" () -> GlVersion ---

rlIsStereoRenderEnabled ¶

rlIsStereoRenderEnabled :: proc "cdecl" () -> bool ---

rlLoadComputeShaderProgram ¶

rlLoadComputeShaderProgram :: proc "cdecl" (x: u32) -> u32 ---
 

Compute shader management

rlLoadDrawCube ¶

rlLoadDrawCube :: proc "cdecl" () ---
 

Quick and dirty cube/quad buffers load->draw->unload

rlLoadDrawQuad ¶

rlLoadDrawQuad :: proc "cdecl" () ---

rlLoadExtensions ¶

rlLoadExtensions :: proc "cdecl" (_: rawptr) ---

rlLoadFramebuffer ¶

rlLoadFramebuffer :: proc "cdecl" (width, height: i32) -> u32 ---
 

Framebuffer management (fbo)

rlLoadIdentity ¶

rlLoadIdentity :: proc "cdecl" () ---

rlLoadRenderBatch ¶

rlLoadRenderBatch :: proc "cdecl" (numBuffers, bufferElements: i32) -> RenderBatch ---
 

Render batch management NOTE: rlgl provides a default render batch to behave like OpenGL 1.1 immediate mode but this render batch API is exposed in case of custom batches are required

rlLoadShaderBuffer ¶

rlLoadShaderBuffer :: proc "cdecl" (size: u64, data: rawptr, usageHint: i32) -> u32 ---
 

Shader buffer storage object management (ssbo)

rlLoadShaderCode ¶

rlLoadShaderCode :: proc "cdecl" (vsCode, fsCode: cstring) -> u32 ---
 

Shaders management

rlLoadShaderProgram ¶

rlLoadShaderProgram :: proc "cdecl" (x, y: u32) -> u32 ---

rlLoadTexture ¶

rlLoadTexture :: proc "cdecl" (data: rawptr, width, height: i32, format: i32, mipmapCount: i32) -> u32 ---
 

Textures management

rlLoadTextureCubemap ¶

rlLoadTextureCubemap :: proc "cdecl" (data: rawptr, size: i32, format: i32) -> u32 ---

rlLoadTextureDepth ¶

rlLoadTextureDepth :: proc "cdecl" (width, height: i32, useRenderBuffer: bool) -> u32 ---

rlLoadVertexArray ¶

rlLoadVertexArray :: proc "cdecl" () -> u32 ---
 

Vertex buffers management

rlLoadVertexBuffer ¶

rlLoadVertexBuffer :: proc "cdecl" (buffer: rawptr, size: i32, is_dynamic: bool) -> u32 ---

rlLoadVertexBufferElement ¶

rlLoadVertexBufferElement :: proc "cdecl" (buffer: rawptr, size: i32, is_dynamic: bool) -> u32 ---

rlMatrixMode ¶

rlMatrixMode :: proc "cdecl" (interval: i32) ---
 

------------------------------------------------------------------------------------ Functions Declaration - Matrix operations ------------------------------------------------------------------------------------

rlMultMatrixf ¶

rlMultMatrixf :: proc "cdecl" (samples: [^]f32) ---

rlNormal3f ¶

rlNormal3f :: proc "cdecl" (x, y, z: f32) ---

rlOrtho ¶

rlOrtho :: proc "cdecl" (
	left, right, bottom, top, znear, 
) ---

rlPopMatrix ¶

rlPopMatrix :: proc "cdecl" () ---

rlPushMatrix ¶

rlPushMatrix :: proc "cdecl" () ---

rlReadScreenPixels ¶

rlReadScreenPixels :: proc "cdecl" (width, height: i32) -> [^]u8 ---

rlReadShaderBufferElements ¶

rlReadShaderBufferElements :: proc "cdecl" (id: u32, data: rawptr, dataSize: u64, offset: u64) ---

rlReadTexturePixels ¶

rlReadTexturePixels :: proc "cdecl" (texture: Texture) -> rawptr ---

rlRotatef ¶

rlRotatef :: proc "cdecl" (angleDeg: f32, x, y, z: f32) ---

rlScalef ¶

rlScalef :: proc "cdecl" (x, y, z: f32) ---

rlScissor ¶

rlScissor :: proc "cdecl" (x, y, width, height: i32) ---

rlSetBlendFactors ¶

rlSetBlendFactors :: proc "cdecl" (glSrcFactor, glDstFactor, glEquation: i32) ---

rlSetBlendMode ¶

rlSetBlendMode :: proc "cdecl" (interval: i32) ---

rlSetLineWidth ¶

rlSetLineWidth :: proc "cdecl" (ms: f32) ---

rlSetMatrixModelview ¶

rlSetMatrixModelview :: proc "cdecl" (proj: linalg.Matrix4x4f32) ---

rlSetMatrixProjection ¶

rlSetMatrixProjection :: proc "cdecl" (proj: linalg.Matrix4x4f32) ---

rlSetMatrixProjectionStereo ¶

rlSetMatrixProjectionStereo :: proc "cdecl" (right, left: linalg.Matrix4x4f32) ---

rlSetMatrixViewOffsetStereo ¶

rlSetMatrixViewOffsetStereo :: proc "cdecl" (right, left: linalg.Matrix4x4f32) ---

rlSetRenderBatchActive ¶

rlSetRenderBatchActive :: proc "cdecl" (batch: ^RenderBatch) ---

rlSetShader ¶

rlSetShader :: proc "cdecl" (shader: Shader) ---

rlSetTexture ¶

rlSetTexture :: proc "cdecl" (_: u32) ---

rlSetUniform ¶

rlSetUniform :: proc "cdecl" (locIndex: i32, value: rawptr, attribType: i32, count: i32) ---

rlSetUniformMatrix ¶

rlSetUniformMatrix :: proc "cdecl" (locIndex: i32, mat: linalg.Matrix4x4f32) ---

rlSetUniformSampler ¶

rlSetUniformSampler :: proc "cdecl" (locIndex: i32, textureId: u32) ---

rlSetVertexAttribute ¶

rlSetVertexAttribute :: proc "cdecl" (
	index:      u32, 
	compSize:   i32, 
	type:       i32, 
	normalized: bool, 
	stride:     i32, 
) ---

rlSetVertexAttributeDefault ¶

rlSetVertexAttributeDefault :: proc "cdecl" (locIndex: i32, value: rawptr, attribType: i32, count: i32) ---

rlSetVertexAttributeDivisor ¶

rlSetVertexAttributeDivisor :: proc "cdecl" (index: u32, divisor: i32) ---

rlTexCoord2f ¶

rlTexCoord2f :: proc "cdecl" (scaleX, scaleY: f32) ---

rlTextureParameters ¶

rlTextureParameters :: proc "cdecl" (id: u32, param: i32, value: i32) ---

rlTranslatef ¶

rlTranslatef :: proc "cdecl" (x, y, z: f32) ---

rlUnloadFramebuffer ¶

rlUnloadFramebuffer :: proc "cdecl" (_: u32) ---

rlUnloadRenderBatch ¶

rlUnloadRenderBatch :: proc "cdecl" (batch: RenderBatch) ---

rlUnloadShaderBuffer ¶

rlUnloadShaderBuffer :: proc "cdecl" (_: u32) ---

rlUnloadShaderProgram ¶

rlUnloadShaderProgram :: proc "cdecl" (_: u32) ---

rlUnloadTexture ¶

rlUnloadTexture :: proc "cdecl" (_: u32) ---

rlUnloadVertexArray ¶

rlUnloadVertexArray :: proc "cdecl" (_: u32) ---

rlUnloadVertexBuffer ¶

rlUnloadVertexBuffer :: proc "cdecl" (_: u32) ---

rlUpdateShaderBufferElements ¶

rlUpdateShaderBufferElements :: proc "cdecl" (id: u32, data: rawptr, dataSize: u64, offset: u64) ---

rlUpdateTexture ¶

rlUpdateTexture :: proc "cdecl" (
	id:                              u32, 
	offsetX, offsetY, width, height: i32, 
	format:                          i32, 
) ---

rlUpdateVertexBuffer ¶

rlUpdateVertexBuffer :: proc "cdecl" (bufferId: i32, data: rawptr, dataSize: i32, offset: i32) -> u32 ---

rlVertex2f ¶

rlVertex2f :: proc "cdecl" (scaleX, scaleY: f32) ---

rlVertex2i ¶

rlVertex2i :: proc "cdecl" (joy, event: i32) ---

rlVertex3f ¶

rlVertex3f :: proc "cdecl" (x, y, z: f32) ---

rlViewport ¶

rlViewport :: proc "cdecl" (x, y, width, height: i32) ---

rlglClose ¶

rlglClose :: proc "cdecl" () ---

rlglInit ¶

rlglInit :: proc "cdecl" (joy, event: i32) ---
 

------------------------------------------------------------------------------------ Functions Declaration - rlgl functionality ------------------------------------------------------------------------------------ rlgl initialization functions

Procedure Groups

This section is empty.

Source Files

Generation Information

Generated with odin version dev-2022-10 (vendor "odin") Windows_amd64 @ 2022-10-05 21:11:47.775559400 +0000 UTC