|
|
@@ -0,0 +1,1368 @@
|
|
|
+package raylib
|
|
|
+
|
|
|
+import c "core:c/libc"
|
|
|
+
|
|
|
+#assert(size_of(rune) == size_of(c.int))
|
|
|
+
|
|
|
+when ODIN_OS == "windows" do foreign import lib "raylib.lib"
|
|
|
+
|
|
|
+VERSION :: "3.7"
|
|
|
+
|
|
|
+PI :: 3.14159265358979323846
|
|
|
+
|
|
|
+// Some Basic Colors
|
|
|
+// NOTE: Custom raylib color palette for amazing visuals on WHITE background
|
|
|
+LIGHTGRAY :: Color{ 200, 200, 200, 255 } // Light Gray
|
|
|
+GRAY :: Color{ 130, 130, 130, 255 } // Gray
|
|
|
+DARKGRAY :: Color{ 80, 80, 80, 255 } // Dark Gray
|
|
|
+YELLOW :: Color{ 253, 249, 0, 255 } // Yellow
|
|
|
+GOLD :: Color{ 255, 203, 0, 255 } // Gold
|
|
|
+ORANGE :: Color{ 255, 161, 0, 255 } // Orange
|
|
|
+PINK :: Color{ 255, 109, 194, 255 } // Pink
|
|
|
+RED :: Color{ 230, 41, 55, 255 } // Red
|
|
|
+MAROON :: Color{ 190, 33, 55, 255 } // Maroon
|
|
|
+GREEN :: Color{ 0, 228, 48, 255 } // Green
|
|
|
+LIME :: Color{ 0, 158, 47, 255 } // Lime
|
|
|
+DARKGREEN :: Color{ 0, 117, 44, 255 } // Dark Green
|
|
|
+SKYBLUE :: Color{ 102, 191, 255, 255 } // Sky Blue
|
|
|
+BLUE :: Color{ 0, 121, 241, 255 } // Blue
|
|
|
+DARKBLUE :: Color{ 0, 82, 172, 255 } // Dark Blue
|
|
|
+PURPLE :: Color{ 200, 122, 255, 255 } // Purple
|
|
|
+VIOLET :: Color{ 135, 60, 190, 255 } // Violet
|
|
|
+DARKPURPLE :: Color{ 112, 31, 126, 255 } // Dark Purple
|
|
|
+BEIGE :: Color{ 211, 176, 131, 255 } // Beige
|
|
|
+BROWN :: Color{ 127, 106, 79, 255 } // Brown
|
|
|
+DARKBROWN :: Color{ 76, 63, 47, 255 } // Dark Brown
|
|
|
+
|
|
|
+WHITE :: Color{ 255, 255, 255, 255 } // White
|
|
|
+BLACK :: Color{ 0, 0, 0, 255 } // Black
|
|
|
+BLANK :: Color{ 0, 0, 0, 0 } // Blank (Transparent)
|
|
|
+MAGENTA :: Color{ 255, 0, 255, 255 } // Magenta
|
|
|
+RAYWHITE :: Color{ 245, 245, 245, 255 } // My own White (raylib logo)
|
|
|
+
|
|
|
+
|
|
|
+// Vector2 type
|
|
|
+Vector2 :: distinct [2]f32
|
|
|
+// Vector3 type
|
|
|
+Vector3 :: distinct [3]f32
|
|
|
+// Vector4 type
|
|
|
+Vector4 :: distinct [4]f32
|
|
|
+
|
|
|
+// Quaternion type
|
|
|
+Quaternion :: distinct quaternion128
|
|
|
+
|
|
|
+// Matrix type (OpenGL style 4x4 - right handed, column major)
|
|
|
+Matrix :: struct {
|
|
|
+ m0, m4, m8, m12: f32,
|
|
|
+ m1, m5, m9, m13: f32,
|
|
|
+ m2, m6, m10, m14: f32,
|
|
|
+ m3, m7, m11, m15: f32,
|
|
|
+}
|
|
|
+
|
|
|
+// Color type, RGBA (32bit)
|
|
|
+Color :: struct {
|
|
|
+ r, g, b, a: u8,
|
|
|
+}
|
|
|
+
|
|
|
+// Rectangle type
|
|
|
+Rectangle :: struct {
|
|
|
+ x: f32,
|
|
|
+ y: f32,
|
|
|
+ width: f32,
|
|
|
+ height: f32,
|
|
|
+}
|
|
|
+
|
|
|
+// Image type, bpp always RGBA (32bit)
|
|
|
+// NOTE: Data stored in CPU memory (RAM)
|
|
|
+Image :: struct {
|
|
|
+ data: rawptr, // Image raw data
|
|
|
+ width: c.int, // Image base width
|
|
|
+ height: c.int, // Image base height
|
|
|
+ mipmaps: c.int, // Mipmap levels, 1 by default
|
|
|
+ format: c.int, // Data format (PixelFormat type)
|
|
|
+}
|
|
|
+
|
|
|
+// Texture type
|
|
|
+// NOTE: Data stored in GPU memory
|
|
|
+Texture :: struct {
|
|
|
+ id: c.uint, // OpenGL texture id
|
|
|
+ width: c.int, // Texture base width
|
|
|
+ height: c.int, // Texture base height
|
|
|
+ mipmaps: c.int, // Mipmap levels, 1 by default
|
|
|
+ format: c.int, // Data format (PixelFormat type)
|
|
|
+}
|
|
|
+
|
|
|
+// Texture2D type, same as Texture
|
|
|
+Texture2D :: Texture
|
|
|
+
|
|
|
+// TextureCubemap type, actually, same as Texture
|
|
|
+TextureCubemap :: Texture
|
|
|
+
|
|
|
+// RenderTexture type, for texture rendering
|
|
|
+RenderTexture :: struct {
|
|
|
+ id: c.uint, // OpenGL framebuffer object id
|
|
|
+ texture: Texture, // Color buffer attachment texture
|
|
|
+ depth: Texture, // Depth buffer attachment texture
|
|
|
+}
|
|
|
+
|
|
|
+// RenderTexture2D type, same as RenderTexture
|
|
|
+RenderTexture2D :: RenderTexture
|
|
|
+
|
|
|
+// N-Patch layout info
|
|
|
+NPatchInfo :: struct {
|
|
|
+ source: Rectangle, // Texture source rectangle
|
|
|
+ left: c.int, // Left border offset
|
|
|
+ top: c.int, // Top border offset
|
|
|
+ right: c.int, // Right border offset
|
|
|
+ bottom: c.int, // Bottom border offset
|
|
|
+ layout: NPatchLayout, // Layout of the n-patch: 3x3, 1x3 or 3x1
|
|
|
+}
|
|
|
+
|
|
|
+// Font character info
|
|
|
+CharInfo :: struct {
|
|
|
+ value: rune, // Character value (Unicode)
|
|
|
+ offsetX: c.int, // Character offset X when drawing
|
|
|
+ offsetY: c.int, // Character offset Y when drawing
|
|
|
+ advanceX: c.int, // Character advance position X
|
|
|
+ image: Image, // Character image data
|
|
|
+}
|
|
|
+
|
|
|
+// Font type, includes texture and charSet array data
|
|
|
+Font :: struct {
|
|
|
+ baseSize: c.int, // Base size (default chars height)
|
|
|
+ charsCount: c.int, // Number of characters
|
|
|
+ charsPadding: c.int, // Padding around the chars
|
|
|
+ texture: Texture2D, // Characters texture atlas
|
|
|
+ recs: [^]Rectangle, // Characters rectangles in texture
|
|
|
+ chars: [^]CharInfo, // Characters info data
|
|
|
+}
|
|
|
+
|
|
|
+SpriteFont :: Font // SpriteFont type fallback, defaults to Font
|
|
|
+
|
|
|
+// Camera type, defines a camera position/orientation in 3d space
|
|
|
+Camera3D :: struct {
|
|
|
+ position: Vector3, // Camera position
|
|
|
+ target: Vector3, // Camera target it looks-at
|
|
|
+ up: Vector3, // 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 projection: CAMERA_PERSPECTIVE or CAMERA_ORTHOGRAPHIC
|
|
|
+}
|
|
|
+
|
|
|
+Camera :: Camera3D // Camera type fallback, defaults to Camera3D
|
|
|
+
|
|
|
+// Camera2D type, defines a 2d camera
|
|
|
+Camera2D :: struct {
|
|
|
+ offset: Vector2, // Camera offset (displacement from target)
|
|
|
+ target: Vector2, // Camera target (rotation and zoom origin)
|
|
|
+ rotation: f32, // Camera rotation in degrees
|
|
|
+ zoom: f32, // Camera zoom (scaling), should be 1.0f by default
|
|
|
+}
|
|
|
+
|
|
|
+// Vertex data definning a mesh
|
|
|
+// NOTE: Data stored in CPU memory (and GPU)
|
|
|
+Mesh :: struct {
|
|
|
+ vertexCount: c.int, // Number of vertices stored in arrays
|
|
|
+ triangleCount: c.int, // Number of triangles stored (indexed or not)
|
|
|
+
|
|
|
+ // 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, // Vertex indices (in case vertex data comes indexed)
|
|
|
+
|
|
|
+ // Animation vertex data
|
|
|
+ animVertices: [^]f32, // Animated vertex positions (after bones transformations)
|
|
|
+ animNormals: [^]f32, // Animated normals (after bones transformations)
|
|
|
+ boneIds: [^]c.int, // Vertex bone ids, up to 4 bones influence by vertex (skinning)
|
|
|
+ boneWeights: [^]f32, // Vertex bone weight, up to 4 bones influence by vertex (skinning)
|
|
|
+
|
|
|
+ // OpenGL identifiers
|
|
|
+ vaoId: u32, // OpenGL Vertex Array Object id
|
|
|
+ vboId: [^]u32, // OpenGL Vertex Buffer Objects id (default vertex data)
|
|
|
+}
|
|
|
+
|
|
|
+// Shader type (generic)
|
|
|
+Shader :: struct {
|
|
|
+ id: c.uint, // Shader program id
|
|
|
+ locs: [^]i32, // Shader locations array (MAX_SHADER_LOCATIONS)
|
|
|
+}
|
|
|
+
|
|
|
+// Material texture map
|
|
|
+MaterialMap :: struct {
|
|
|
+ texture: Texture2D, // Material map texture
|
|
|
+ color: Color, // Material map color
|
|
|
+ value: f32, // Material map value
|
|
|
+}
|
|
|
+
|
|
|
+// Material type (generic)
|
|
|
+Material :: struct {
|
|
|
+ shader: Shader, // Material shader
|
|
|
+ maps: [^]MaterialMap, // Material maps array (MAX_MATERIAL_MAPS)
|
|
|
+ params: [4]f32, // Material generic parameters (if required)
|
|
|
+}
|
|
|
+
|
|
|
+// Transformation properties
|
|
|
+Transform :: struct {
|
|
|
+ translation: Vector3, // Translation
|
|
|
+ rotation: Quaternion, // Rotation
|
|
|
+ scale: Vector3, // Scale
|
|
|
+}
|
|
|
+
|
|
|
+// Bone information
|
|
|
+BoneInfo :: struct {
|
|
|
+ name: [32]byte, // Bone name
|
|
|
+ parent: c.int, // Bone parent
|
|
|
+}
|
|
|
+
|
|
|
+// Model type
|
|
|
+Model :: struct {
|
|
|
+ transform: Matrix, // Local transform matrix
|
|
|
+
|
|
|
+ meshCount: c.int, // Number of meshes
|
|
|
+ materialCount: c.int, // Number of materials
|
|
|
+ meshes: [^]Mesh, // Meshes array
|
|
|
+ materials: [^]Material, // Materials array
|
|
|
+ meshMaterial: [^]c.int, // Mesh material number
|
|
|
+
|
|
|
+ // Animation data
|
|
|
+ boneCount: c.int, // Number of bones
|
|
|
+ bones: [^]BoneInfo, // Bones information (skeleton)
|
|
|
+ bindPose: [^]Transform, // Bones base transformation (pose)
|
|
|
+}
|
|
|
+
|
|
|
+// Model animation
|
|
|
+ModelAnimation :: struct {
|
|
|
+ boneCount: c.int, // Number of bones
|
|
|
+ frameCount: c.int, // Number of animation frames
|
|
|
+ bones: [^]BoneInfo, // Bones information (skeleton)
|
|
|
+ framePoses: [^]^Transform, // Poses array by frame
|
|
|
+}
|
|
|
+
|
|
|
+// Ray type (useful for raycast)
|
|
|
+Ray :: struct {
|
|
|
+ position: Vector3, // Ray position (origin)
|
|
|
+ direction: Vector3, // Ray direction
|
|
|
+}
|
|
|
+
|
|
|
+// Raycast hit information
|
|
|
+RayHitInfo :: struct {
|
|
|
+ hit: bool, // Did the ray hit something?
|
|
|
+ distance: f32, // Distance to nearest hit
|
|
|
+ position: Vector3, // Position of nearest hit
|
|
|
+ normal: Vector3, // Surface normal of hit
|
|
|
+}
|
|
|
+
|
|
|
+// Bounding box type
|
|
|
+BoundingBox :: struct {
|
|
|
+ min: Vector3, // Minimum vertex box-corner
|
|
|
+ max: Vector3, // Maximum vertex box-corner
|
|
|
+}
|
|
|
+
|
|
|
+// Wave type, defines audio wave data
|
|
|
+Wave :: struct {
|
|
|
+ sampleCount: c.uint, // Total number of samples
|
|
|
+ sampleRate: c.uint, // Frequency (samples per second)
|
|
|
+ sampleSize: c.uint, // Bit depth (bits per sample): 8, 16, 32 (24 not supported)
|
|
|
+ channels: c.uint, // Number of channels (1-mono, 2-stereo)
|
|
|
+ data: rawptr, // Buffer data pointer
|
|
|
+}
|
|
|
+
|
|
|
+rAudioBuffer :: struct {}
|
|
|
+
|
|
|
+// Audio stream type
|
|
|
+// NOTE: Useful to create custom audio streams not bound to a specific file
|
|
|
+AudioStream :: struct {
|
|
|
+ buffer: ^rAudioBuffer, // Pointer to internal data used by the audio system
|
|
|
+
|
|
|
+ sampleRate: c.uint, // Frequency (samples per second)
|
|
|
+ sampleSize: c.uint, // Bit depth (bits per sample): 8, 16, 32 (24 not supported)
|
|
|
+ channels: c.uint, // Number of channels (1-mono, 2-stereo)
|
|
|
+}
|
|
|
+
|
|
|
+// Sound source type
|
|
|
+Sound :: struct {
|
|
|
+ using stream: AudioStream, // Audio stream
|
|
|
+ sampleCount: c.uint, // Total number of samples
|
|
|
+}
|
|
|
+
|
|
|
+// Music stream type (audio file streaming from memory)
|
|
|
+// NOTE: Anything longer than ~10 seconds should be streamed
|
|
|
+Music :: struct {
|
|
|
+ using stream: AudioStream, // Audio stream
|
|
|
+ sampleCount: c.uint, // Total number of samples
|
|
|
+ looping: bool, // Music looping enable
|
|
|
+
|
|
|
+ ctxType: c.int, // Type of music context (audio filetype)
|
|
|
+ ctxData: rawptr, // Audio context data, depends on type
|
|
|
+}
|
|
|
+
|
|
|
+// Head-Mounted-Display device parameters
|
|
|
+VrDeviceInfo :: struct {
|
|
|
+ hResolution: c.int, // Horizontal resolution in pixels
|
|
|
+ vResolution: c.int, // 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, // Chromatic aberration correction parameters
|
|
|
+}
|
|
|
+
|
|
|
+// VR Stereo rendering configuration for simulator
|
|
|
+VrStereoConfig :: struct {
|
|
|
+ projection: [2]Matrix, // VR projection matrices (per eye)
|
|
|
+ viewOffset: [2]Matrix, // 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 distortion scale in
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------------
|
|
|
+// 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
|
|
|
+ConfigFlag :: enum c.int {
|
|
|
+ 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 = 1, // Set to try enabling interlaced video format (for V3D)
|
|
|
+}
|
|
|
+ConfigFlags :: distinct bit_set[ConfigFlag; c.int]
|
|
|
+
|
|
|
+
|
|
|
+// Trace log level
|
|
|
+TraceLogLevel :: enum c.int {
|
|
|
+ ALL = 0, // Display all logs
|
|
|
+ TRACE,
|
|
|
+ DEBUG,
|
|
|
+ INFO,
|
|
|
+ WARNING,
|
|
|
+ ERROR,
|
|
|
+ FATAL,
|
|
|
+ NONE, // Disable logging
|
|
|
+}
|
|
|
+
|
|
|
+// Keyboard keys (US keyboard layout)
|
|
|
+// NOTE: Use GetKeyPressed() to allow redefining
|
|
|
+// required keys for alternative layouts
|
|
|
+KeyboardKey :: enum c.int {
|
|
|
+ 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,
|
|
|
+}
|
|
|
+
|
|
|
+// Mouse buttons
|
|
|
+MouseButton :: enum c.int {
|
|
|
+ LEFT = 0,
|
|
|
+ RIGHT = 1,
|
|
|
+ MIDDLE = 2,
|
|
|
+}
|
|
|
+
|
|
|
+// Mouse cursor
|
|
|
+MouseCursor :: enum c.int {
|
|
|
+ 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
|
|
|
+}
|
|
|
+
|
|
|
+// Gamepad buttons
|
|
|
+GamepadButton :: enum c.int {
|
|
|
+ // 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 axis
|
|
|
+GamepadAxis :: enum c.int {
|
|
|
+ // 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)
|
|
|
+}
|
|
|
+
|
|
|
+// Material map index
|
|
|
+MaterialMapIndex :: enum c.int {
|
|
|
+ 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 = ALBEDO,
|
|
|
+ SPECULAR = METALNESS,
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+// Shader location index
|
|
|
+ShaderLocationIndex :: enum c.int {
|
|
|
+ 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 = MAP_ALBEDO,
|
|
|
+ MAP_SPECULAR = MAP_METALNESS,
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+// Shader uniform data type
|
|
|
+ShaderUniformDataType :: enum c.int {
|
|
|
+ FLOAT = 0,
|
|
|
+ VEC2,
|
|
|
+ VEC3,
|
|
|
+ VEC4,
|
|
|
+ INT,
|
|
|
+ IVEC2,
|
|
|
+ IVEC3,
|
|
|
+ IVEC4,
|
|
|
+ SAMPLER2D,
|
|
|
+}
|
|
|
+
|
|
|
+// Pixel formats
|
|
|
+// NOTE: Support depends on OpenGL version and platform
|
|
|
+PixelFormat :: enum c.int {
|
|
|
+ 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
|
|
|
+}
|
|
|
+
|
|
|
+// Texture parameters: filter mode
|
|
|
+// NOTE 1: Filtering considers mipmaps if available in the texture
|
|
|
+// NOTE 2: Filter is accordingly set for minification and magnification
|
|
|
+TextureFilter :: enum c.int {
|
|
|
+ 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: wrap mode
|
|
|
+TextureWrap :: enum c.int {
|
|
|
+ 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
|
|
|
+}
|
|
|
+
|
|
|
+// Cubemap layouts
|
|
|
+CubemapLayout :: enum c.int {
|
|
|
+ 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)
|
|
|
+}
|
|
|
+
|
|
|
+// Font type, defines generation method
|
|
|
+FontType :: enum c.int {
|
|
|
+ DEFAULT = 0, // Default font generation, anti-aliased
|
|
|
+ BITMAP, // Bitmap font generation, no anti-aliasing
|
|
|
+ SDF, // SDF font generation, requires external shader
|
|
|
+}
|
|
|
+
|
|
|
+// Color blending modes (pre-defined)
|
|
|
+BlendMode :: enum c.int {
|
|
|
+ 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())
|
|
|
+}
|
|
|
+
|
|
|
+// Gestures
|
|
|
+// NOTE: It could be used as flags to enable only some gestures
|
|
|
+Gesture :: enum c.int {
|
|
|
+ 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 :: distinct bit_set[Gesture; c.int]
|
|
|
+
|
|
|
+// Camera system modes
|
|
|
+CameraMode :: enum c.int {
|
|
|
+ CUSTOM = 0,
|
|
|
+ FREE,
|
|
|
+ ORBITAL,
|
|
|
+ FIRST_PERSON,
|
|
|
+ THIRD_PERSON,
|
|
|
+}
|
|
|
+
|
|
|
+// Camera projection
|
|
|
+CameraProjection :: enum c.int {
|
|
|
+ PERSPECTIVE = 0,
|
|
|
+ ORTHOGRAPHIC,
|
|
|
+}
|
|
|
+
|
|
|
+// N-patch layout
|
|
|
+NPatchLayout :: enum c.int {
|
|
|
+ NINE_PATCH = 0, // Npatch layout: 3x3 tiles
|
|
|
+ THREE_PATCH_VERTICAL, // Npatch layout: 1x3 tiles
|
|
|
+ THREE_PATCH_HORIZONTAL, // Npatch layout: 3x1 tiles
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+// Callbacks to hook some internal functions
|
|
|
+// WARNING: This callbacks are intended for advance users
|
|
|
+TraceLogCallback :: #type proc "c" (logLevel: TraceLogLevel, text: cstring, args: c.va_list) // Logging: Redirect trace log messages
|
|
|
+LoadFileDataCallback :: #type proc "c"(fileName: cstring, bytesRead: ^c.uint) -> [^]u8 // FileIO: Load binary data
|
|
|
+SaveFileDataCallback :: #type proc "c" (fileName: cstring, data: rawptr, bytesToWrite: c.uint) -> bool // FileIO: Save binary data
|
|
|
+LoadFileTextCallback :: #type proc "c" (fileName: cstring) -> [^]u8 // FileIO: Load text data
|
|
|
+SaveFileTextCallback :: #type proc "c" (fileName: cstring, text: cstring) -> bool // FileIO: Save text data
|
|
|
+
|
|
|
+
|
|
|
+@(default_calling_convention="c")
|
|
|
+foreign lib {
|
|
|
+ //------------------------------------------------------------------------------------
|
|
|
+ // Global Variables Definition
|
|
|
+ //------------------------------------------------------------------------------------
|
|
|
+ // It's lonely here...
|
|
|
+
|
|
|
+ //------------------------------------------------------------------------------------
|
|
|
+ // Window and Graphics Device Functions (Module: core)
|
|
|
+ //------------------------------------------------------------------------------------
|
|
|
+
|
|
|
+ // Window-related functions
|
|
|
+ InitWindow :: proc(width, height: c.int, title: cstring) --- // Initialize window and OpenGL context
|
|
|
+ WindowShouldClose :: proc() -> bool --- // Check if KEY_ESCAPE pressed or Close icon pressed
|
|
|
+ CloseWindow :: proc() --- // Close window and unload OpenGL context
|
|
|
+ IsWindowReady :: proc() -> bool --- // Check if window has been initialized successfully
|
|
|
+ IsWindowFullscreen :: proc() -> bool --- // Check if window is currently fullscreen
|
|
|
+ IsWindowHidden :: proc() -> bool --- // Check if window is currently hidden (only PLATFORM_DESKTOP)
|
|
|
+ IsWindowMinimized :: proc() -> bool --- // Check if window is currently minimized (only PLATFORM_DESKTOP)
|
|
|
+ IsWindowMaximized :: proc() -> bool --- // Check if window is currently maximized (only PLATFORM_DESKTOP)
|
|
|
+ IsWindowFocused :: proc() -> bool --- // Check if window is currently focused (only PLATFORM_DESKTOP)
|
|
|
+ IsWindowResized :: proc() -> bool --- // Check if window has been resized last frame
|
|
|
+ IsWindowState :: proc(flag: ConfigFlags) -> bool --- // Check if one specific window flag is enabled
|
|
|
+ SetWindowState :: proc(flags: ConfigFlags) --- // Set window configuration state using flags
|
|
|
+ ClearWindowState :: proc(flags: ConfigFlags) --- // Clear window configuration state flags
|
|
|
+ ToggleFullscreen :: proc() --- // Toggle window state: fullscreen/windowed (only PLATFORM_DESKTOP)
|
|
|
+ MaximizeWindow :: proc() --- // Set window state: maximized, if resizable (only PLATFORM_DESKTOP)
|
|
|
+ MinimizeWindow :: proc() --- // Set window state: minimized, if resizable (only PLATFORM_DESKTOP)
|
|
|
+ RestoreWindow :: proc() --- // Set window state: not minimized/maximized (only PLATFORM_DESKTOP)
|
|
|
+ SetWindowIcon :: proc(image: Image) --- // Set icon for window (only PLATFORM_DESKTOP)
|
|
|
+ SetWindowTitle :: proc(title: cstring) --- // Set title for window (only PLATFORM_DESKTOP)
|
|
|
+ SetWindowPosition :: proc(x, y: c.int) --- // Set window position on screen (only PLATFORM_DESKTOP)
|
|
|
+ SetWindowMonitor :: proc(monitor: c.int) --- // Set monitor for the current window (fullscreen mode)
|
|
|
+ SetWindowMinSize :: proc(width, height: c.int) --- // Set window minimum dimensions (for FLAG_WINDOW_RESIZABLE)
|
|
|
+ SetWindowSize :: proc(width, height: c.int) --- // Set window dimensions
|
|
|
+ GetWindowHandle :: proc() -> rawptr --- // Get native window handle
|
|
|
+ GetScreenWidth :: proc() -> c.int --- // Get current screen width
|
|
|
+ GetScreenHeight :: proc() -> c.int --- // Get current screen height
|
|
|
+ GetMonitorCount :: proc() -> c.int --- // Get number of connected monitors
|
|
|
+ GetCurrentMonitor :: proc() -> c.int --- // Get current connected monitor
|
|
|
+ GetMonitorPosition :: proc(monitor: c.int) -> Vector2 --- // Get specified monitor position
|
|
|
+ GetMonitorWidth :: proc(monitor: c.int) -> c.int --- // Get specified monitor width (max available by monitor)
|
|
|
+ GetMonitorHeight :: proc(monitor: c.int) -> c.int --- // Get specified monitor height (max available by monitor)
|
|
|
+ GetMonitorPhysicalWidth :: proc(monitor: c.int) -> c.int --- // Get specified monitor physical width in millimetres
|
|
|
+ GetMonitorPhysicalHeight :: proc(monitor: c.int) -> c.int --- // Get specified monitor physical height in millimetres
|
|
|
+ GetMonitorRefreshRate :: proc(monitor: c.int) -> c.int --- // Get specified monitor refresh rate
|
|
|
+ GetWindowPosition :: proc() -> Vector2 --- // Get window position XY on monitor
|
|
|
+ GetWindowScaleDPI :: proc() -> Vector2 --- // Get window scale DPI factor
|
|
|
+ GetMonitorName :: proc(monitor: c.int) -> cstring --- // Get the human-readable, UTF-8 encoded name of the primary monitor
|
|
|
+ SetClipboardText :: proc(text: cstring) --- // Set clipboard text content
|
|
|
+ GetClipboardText :: proc() -> cstring --- // Get clipboard text content
|
|
|
+
|
|
|
+ // Cursor-related functions
|
|
|
+ ShowCursor :: proc() --- // Shows cursor
|
|
|
+ HideCursor :: proc() --- // Hides cursor
|
|
|
+ IsCursorHidden :: proc() -> bool --- // Check if cursor is not visible
|
|
|
+ EnableCursor :: proc() --- // Enables cursor (unlock cursor)
|
|
|
+ DisableCursor :: proc() --- // Disables cursor (lock cursor)
|
|
|
+ IsCursorOnScreen :: proc() -> bool --- // Check if cursor is on the current screen.
|
|
|
+
|
|
|
+ // Drawing-related functions
|
|
|
+ ClearBackground :: proc(color: Color) --- // Set background color (framebuffer clear color)
|
|
|
+ BeginDrawing :: proc() --- // Setup canvas (framebuffer) to start drawing
|
|
|
+ EndDrawing :: proc() --- // End canvas drawing and swap buffers (double buffering)
|
|
|
+ BeginMode2D :: proc(camera: Camera2D) --- // Initialize 2D mode with custom camera (2D)
|
|
|
+ EndMode2D :: proc() --- // Ends 2D mode with custom camera
|
|
|
+ BeginMode3D :: proc(camera: Camera3D) --- // Initializes 3D mode with custom camera (3D)
|
|
|
+ EndMode3D :: proc() --- // Ends 3D mode and returns to default 2D orthographic mode
|
|
|
+ BeginTextureMode :: proc(target: RenderTexture2D) --- // Initializes render texture for drawing
|
|
|
+ EndTextureMode :: proc() --- // Ends drawing to render texture
|
|
|
+ BeginShaderMode :: proc(shader: Shader) --- // Begin custom shader drawing
|
|
|
+ EndShaderMode :: proc() --- // End custom shader drawing (use default shader)
|
|
|
+ BeginBlendMode :: proc(mode: BlendMode) --- // Begin blending mode (alpha, additive, multiplied)
|
|
|
+ EndBlendMode :: proc() --- // End blending mode (reset to default: alpha blending)
|
|
|
+ BeginScissorMode :: proc(x, y, width, height: c.int) --- // Begin scissor mode (define screen area for following drawing)
|
|
|
+ EndScissorMode :: proc() --- // End scissor mode
|
|
|
+ BeginVrStereoMode :: proc(config: VrStereoConfig) --- // Begin stereo rendering (requires VR simulator)
|
|
|
+ EndVrStereoMode :: proc() --- // End stereo rendering (requires VR simulator)
|
|
|
+
|
|
|
+ // VR stereo config functions for VR simulator
|
|
|
+ LoadVrStereoConfig :: proc(device: VrDeviceInfo) -> VrStereoConfig --- // Load VR stereo config for VR simulator device parameters
|
|
|
+ UnloadVrStereoConfig :: proc(config: VrStereoConfig) --- // Unload VR stereo config
|
|
|
+
|
|
|
+ // Shader management functions
|
|
|
+ // NOTE: Shader functionality is not available on OpenGL 1.1
|
|
|
+ LoadShader :: proc(vsFileName, fsFileName: cstring) -> Shader --- // Load shader from files and bind default locations
|
|
|
+ LoadShaderFromMemory :: proc(vsCode, fsCode: cstring) -> Shader --- // Load shader from code strings and bind default locations
|
|
|
+ GetShaderLocation :: proc(shader: Shader, uniformName: cstring) -> c.int --- // Get shader uniform location
|
|
|
+ GetShaderLocationAttrib :: proc(shader: Shader, attribName: cstring) -> c.int --- // Get shader attribute location
|
|
|
+ SetShaderValue :: proc(shader: Shader, locIndex: ShaderLocationIndex, value: rawptr, uniformType: ShaderUniformDataType) --- // Set shader uniform value
|
|
|
+ SetShaderValueV :: proc(shader: Shader, locIndex: ShaderLocationIndex, value: rawptr, uniformType: ShaderUniformDataType, count: c.int) --- // Set shader uniform value vector
|
|
|
+ SetShaderValueMatrix :: proc(shader: Shader, locIndex: ShaderLocationIndex, mat: Matrix) --- // Set shader uniform value (matrix 4x4)
|
|
|
+ SetShaderValueTexture :: proc(shader: Shader, locIndex: ShaderLocationIndex, texture: Texture2D) --- // Set shader uniform value for texture (sampler2d)
|
|
|
+ UnloadShader :: proc(shader: Shader) --- // Unload shader from GPU memory (VRAM)
|
|
|
+
|
|
|
+ // Screen-space-related functions
|
|
|
+ GetMouseRay :: proc(mousePosition: Vector2, camera: Camera) -> Ray --- // Returns a ray trace from mouse position
|
|
|
+ GetCameraMatrix :: proc(camera: Camera) -> Matrix --- // Returns camera transform matrix (view matrix)
|
|
|
+ GetCameraMatrix2D :: proc(camera: Camera2D) -> Matrix --- // Returns camera 2d transform matrix
|
|
|
+ GetWorldToScreen :: proc(position: Vector3, camera: Camera) -> Vector2 --- // Returns the screen space position for a 3d world space position
|
|
|
+ GetWorldToScreenEx :: proc(position: Vector3, camera: Camera, width, height: c.int) -> Vector2 --- // Returns size position for a 3d world space position
|
|
|
+ GetWorldToScreen2D :: proc(position: Vector2, camera: Camera2D) -> Vector2 --- // Returns the screen space position for a 2d camera world space position
|
|
|
+ GetScreenToWorld2D :: proc(position: Vector2, camera: Camera2D) -> Vector2 --- // Returns the world space position for a 2d camera screen space position
|
|
|
+
|
|
|
+ // Timing-related functions
|
|
|
+ SetTargetFPS :: proc(fps: c.int) --- // Set target FPS (maximum)
|
|
|
+ GetFPS :: proc() -> c.int --- // Returns current FPS
|
|
|
+ GetFrameTime :: proc() -> f32 --- // Returns time in seconds for last frame drawn (delta time)
|
|
|
+ GetTime :: proc() -> f64 --- // Returns elapsed time in seconds since InitWindow()
|
|
|
+
|
|
|
+ // Misc. functions
|
|
|
+ GetRandomValue :: proc(min, max: c.int) -> c.int --- // Returns a random value between min and max (both included)
|
|
|
+ TakeScreenshot :: proc(fileName: cstring) --- // Takes a screenshot of current screen (filename extension defines format)
|
|
|
+ SetConfigFlags :: proc(flags: ConfigFlags) --- // Setup init configuration flags (view FLAGS)
|
|
|
+
|
|
|
+ TraceLog :: proc(logLevel: TraceLogLevel, text: cstring, #c_vararg args: ..any) --- // Show trace log messages (LOG_DEBUG, LOG_INFO, LOG_WARNING, LOG_ERROR)
|
|
|
+ SetTraceLogLevel :: proc(logLevel: TraceLogLevel) --- // Set the current threshold (minimum) log level
|
|
|
+ MemAlloc :: proc(size: c.int) -> rawptr --- // Internal memory allocator
|
|
|
+ MemRealloc :: proc(ptr: rawptr, size: c.int) -> rawptr --- // Internal memory reallocator
|
|
|
+ MemFree :: proc(ptr: rawptr) --- // Internal memory free
|
|
|
+
|
|
|
+ // Set custom callbacks
|
|
|
+ // WARNING: Callbacks setup is intended for advance users
|
|
|
+ SetTraceLogCallback :: proc(callback: TraceLogCallback) --- // Set custom trace log
|
|
|
+ SetLoadFileDataCallback :: proc(callback: LoadFileDataCallback) --- // Set custom file binary data loader
|
|
|
+ SetSaveFileDataCallback :: proc(callback: SaveFileDataCallback) --- // Set custom file binary data saver
|
|
|
+ SetLoadFileTextCallback :: proc(callback: LoadFileTextCallback) --- // Set custom file text data loader
|
|
|
+ SetSaveFileTextCallback :: proc(callback: SaveFileTextCallback) --- // Set custom file text data saver
|
|
|
+
|
|
|
+ // Files management functions
|
|
|
+ LoadFileData :: proc(fileName: cstring, bytesRead: ^c.uint) -> [^]u8 --- // Load file data as byte array (read)
|
|
|
+ UnloadFileData :: proc(data: [^]u8) --- // Unload file data allocated by LoadFileData()
|
|
|
+ SaveFileData :: proc(fileName: cstring, data: rawptr, bytesToWrite: c.uint) -> bool --- // Save data to file from byte array (write), returns true on success
|
|
|
+ LoadFileText :: proc(fileName: cstring) -> [^]u8 --- // Load text data from file (read), returns a '\0' terminated string
|
|
|
+ UnloadFileText :: proc(text: cstring) --- // Unload file text data allocated by LoadFileText()
|
|
|
+ SaveFileText :: proc(fileName: cstring, text: cstring) -> bool --- // Save text data to file (write), string must be '\0' terminated, returns true on success
|
|
|
+ FileExists :: proc(fileName: cstring) -> bool --- // Check if file exists
|
|
|
+ DirectoryExists :: proc(dirPath: cstring) -> bool --- // Check if a directory path exists
|
|
|
+ IsFileExtension :: proc(fileName: cstring, ext: cstring) -> bool --- // Check file extension (including point: .png, .wav)
|
|
|
+ GetFileExtension :: proc(fileName: cstring) -> cstring --- // Get pointer to extension for a filename string (includes dot: ".png")
|
|
|
+ GetFileName :: proc(filePath: cstring) -> cstring --- // Get pointer to filename for a path string
|
|
|
+ GetFileNameWithoutExt :: proc(filePath: cstring) -> cstring --- // Get filename string without extension (uses static string)
|
|
|
+ GetDirectoryPath :: proc(filePath: cstring) -> cstring --- // Get full path for a given fileName with path (uses static string)
|
|
|
+ GetPrevDirectoryPath :: proc(dirPath: cstring) -> cstring --- // Get previous directory path for a given path (uses static string)
|
|
|
+ GetWorkingDirectory :: proc() -> cstring --- // Get current working directory (uses static string)
|
|
|
+ GetDirectoryFiles :: proc(dirPath: cstring, count: ^c.int) -> [^]cstring --- // Get filenames in a directory path (memory should be freed)
|
|
|
+ ClearDirectoryFiles :: proc() --- // Clear directory files paths buffers (free memory)
|
|
|
+ ChangeDirectory :: proc(dir: cstring) -> bool --- // Change working directory, return true on success
|
|
|
+ IsFileDropped :: proc() -> bool --- // Check if a file has been dropped into window
|
|
|
+ GetDroppedFiles :: proc(count: ^c.int) -> [^]cstring --- // Get dropped files names (memory should be freed)
|
|
|
+ ClearDroppedFiles :: proc() --- // Clear dropped files paths buffer (free memory)
|
|
|
+ GetFileModTime :: proc(fileName: cstring) -> c.long --- // Get file modification time (last write time)
|
|
|
+
|
|
|
+ CompressData :: proc(data: [^]u8, dataLength: c.int, compDataLength: ^c.int) -> [^]u8 --- // Compress data (DEFLATE algorithm)
|
|
|
+ DecompressData :: proc(compData: [^]u8, compDataLength: c.int, dataLength: ^c.int) -> [^]u8 --- // Decompress data (DEFLATE algorithm)
|
|
|
+
|
|
|
+ // Persistent storage management
|
|
|
+ SaveStorageValue :: proc(position: c.uint, value: c.int) -> bool --- // Save integer value to storage file (to defined position), returns true on success
|
|
|
+ LoadStorageValue :: proc(position: c.uint) -> c.int --- // Load integer value from storage file (from defined position)
|
|
|
+
|
|
|
+ OpenURL :: proc(url: cstring) --- // Open URL with default system browser (if available)
|
|
|
+
|
|
|
+ //------------------------------------------------------------------------------------
|
|
|
+ // Input Handling Functions (Module: core)
|
|
|
+ //------------------------------------------------------------------------------------
|
|
|
+
|
|
|
+ // Input-related functions: keyboard
|
|
|
+ IsKeyPressed :: proc(key: KeyboardKey) -> bool --- // Detect if a key has been pressed once
|
|
|
+ IsKeyDown :: proc(key: KeyboardKey) -> bool --- // Detect if a key is being pressed
|
|
|
+ IsKeyReleased :: proc(key: KeyboardKey) -> bool --- // Detect if a key has been released once
|
|
|
+ IsKeyUp :: proc(key: KeyboardKey) -> bool --- // Detect if a key is NOT being pressed
|
|
|
+ SetExitKey :: proc(key: KeyboardKey) --- // Set a custom key to exit program (default is ESC)
|
|
|
+ GetKeyPressed :: proc() -> KeyboardKey --- // Get key pressed (keycode), call it multiple times for keys queued
|
|
|
+ GetCharPressed :: proc() -> rune --- // Get char pressed (unicode), call it multiple times for chars queued
|
|
|
+
|
|
|
+ // Input-related functions: gamepads
|
|
|
+ IsGamepadAvailable :: proc(gamepad: c.int) -> bool --- // Detect if a gamepad is available
|
|
|
+ IsGamepadName :: proc(gamepad: c.int, name: cstring) -> bool --- // Check gamepad name (if available)
|
|
|
+ GetGamepadName :: proc(gamepad: c.int) -> cstring --- // Return gamepad internal name id
|
|
|
+ IsGamepadButtonPressed :: proc(gamepad: c.int, button: GamepadButton) -> bool --- // Detect if a gamepad button has been pressed once
|
|
|
+ IsGamepadButtonDown :: proc(gamepad: c.int, button: GamepadButton) -> bool --- // Detect if a gamepad button is being pressed
|
|
|
+ IsGamepadButtonReleased :: proc(gamepad: c.int, button: GamepadButton) -> bool --- // Detect if a gamepad button has been released once
|
|
|
+ IsGamepadButtonUp :: proc(gamepad: c.int, button: GamepadButton) -> bool --- // Detect if a gamepad button is NOT being pressed
|
|
|
+ GetGamepadButtonPressed :: proc() -> c.int --- // Get the last gamepad button pressed
|
|
|
+ GetGamepadAxisCount :: proc(gamepad: c.int) -> c.int --- // Return gamepad axis count for a gamepad
|
|
|
+ GetGamepadAxisMovement :: proc(gamepad: c.int, axis: GamepadAxis) -> f32 --- // Return axis movement value for a gamepad axis
|
|
|
+ SetGamepadMappings :: proc(mappings: cstring) -> c.int --- // Set internal gamepad mappings (SDL_GameControllerDB)
|
|
|
+
|
|
|
+ // Input-related functions: mouse
|
|
|
+ IsMouseButtonPressed :: proc(button: MouseButton) -> bool --- // Detect if a mouse button has been pressed once
|
|
|
+ IsMouseButtonDown :: proc(button: MouseButton) -> bool --- // Detect if a mouse button is being pressed
|
|
|
+ IsMouseButtonReleased :: proc(button: MouseButton) -> bool --- // Detect if a mouse button has been released once
|
|
|
+ IsMouseButtonUp :: proc(button: MouseButton) -> bool --- // Detect if a mouse button is NOT being pressed
|
|
|
+ GetMouseX :: proc() -> c.int --- // Returns mouse position X
|
|
|
+ GetMouseY :: proc() -> c.int --- // Returns mouse position Y
|
|
|
+ GetMousePosition :: proc() -> Vector2 --- // Returns mouse position XY
|
|
|
+ SetMousePosition :: proc(x, y: c.int) --- // Set mouse position XY
|
|
|
+ SetMouseOffset :: proc(offsetX, offsetY: c.int) --- // Set mouse offset
|
|
|
+ SetMouseScale :: proc(scaleX, scaleY: f32) --- // Set mouse scaling
|
|
|
+ GetMouseWheelMove :: proc() -> f32 --- // Returns mouse wheel movement Y
|
|
|
+ SetMouseCursor :: proc(cursor: MouseCursor) --- // Set mouse cursor
|
|
|
+
|
|
|
+ // Input-related functions: touch
|
|
|
+ GetTouchX :: proc() -> c.int --- // Returns touch position X for touch point 0 (relative to screen size)
|
|
|
+ GetTouchY :: proc() -> c.int --- // Returns touch position Y for touch point 0 (relative to screen size)
|
|
|
+ GetTouchPosition :: proc(index: c.int) -> Vector2 --- // Returns touch position XY for a touch point index (relative to screen size)
|
|
|
+
|
|
|
+ //------------------------------------------------------------------------------------
|
|
|
+ // Gestures and Touch Handling Functions (Module: gestures)
|
|
|
+ //------------------------------------------------------------------------------------
|
|
|
+ SetGesturesEnabled :: proc(flags: Gestures) --- // Enable a set of gestures using flags
|
|
|
+ IsGestureDetected :: proc(gesture: Gesture) -> bool --- // Check if a gesture have been detected
|
|
|
+ GetGestureDetected :: proc() -> Gesture --- // Get latest detected gesture
|
|
|
+ GetTouchPointsCount :: proc() -> c.int --- // Get touch points count
|
|
|
+ GetGestureHoldDuration :: proc() -> f32 --- // Get gesture hold time in milliseconds
|
|
|
+ GetGestureDragVector :: proc() -> Vector2 --- // Get gesture drag vector
|
|
|
+ GetGestureDragAngle :: proc() -> f32 --- // Get gesture drag angle
|
|
|
+ GetGesturePinchVector :: proc() -> Vector2 --- // Get gesture pinch delta
|
|
|
+ GetGesturePinchAngle :: proc() -> f32 --- // Get gesture pinch angle
|
|
|
+
|
|
|
+ //------------------------------------------------------------------------------------
|
|
|
+ // Camera System Functions (Module: camera)
|
|
|
+ //------------------------------------------------------------------------------------
|
|
|
+ SetCameraMode :: proc(camera: Camera, mode: CameraMode) --- // Set camera mode (multiple camera modes available)
|
|
|
+ UpdateCamera :: proc(camera: ^Camera) --- // Update camera position for selected mode
|
|
|
+
|
|
|
+ SetCameraPanControl :: proc(keyPan: KeyboardKey) --- // Set camera pan key to combine with mouse movement (free camera)
|
|
|
+ SetCameraAltControl :: proc(keyAlt: KeyboardKey) --- // Set camera alt key to combine with mouse movement (free camera)
|
|
|
+ SetCameraSmoothZoomControl :: proc(keySmoothZoom: KeyboardKey) --- // Set camera smooth zoom key to combine with mouse (free camera)
|
|
|
+ SetCameraMoveControls :: proc(keyFront, keyBack, keyRight, keyLeft, keyUp, keyDown: KeyboardKey) --- // Set camera move controls (1st person and 3rd person cameras)
|
|
|
+
|
|
|
+ //------------------------------------------------------------------------------------
|
|
|
+ // 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
|
|
|
+ SetShapesTexture :: proc(texture: Texture2D, source: Rectangle) ---
|
|
|
+
|
|
|
+ // Basic shapes drawing functions
|
|
|
+ DrawPixel :: proc(posX, posY: c.int, color: Color) --- // Draw a pixel
|
|
|
+ DrawPixelV :: proc(position: Vector2 , color: Color) --- // Draw a pixel (Vector version)
|
|
|
+ DrawLine :: proc(startPosX, startPosY, endPosX, endPosY: c.int, color: Color) --- // Draw a line
|
|
|
+ DrawLineV :: proc(startPos, endPos: Vector2, color: Color) --- // Draw a line (Vector version)
|
|
|
+ DrawLineEx :: proc(startPos, endPos: Vector2, thick: f32, color: Color) --- // Draw a line defining thickness
|
|
|
+ DrawLineBezier :: proc(startPos, endPos: Vector2, thick: f32, color: Color) --- // Draw a line using cubic-bezier curves in-out
|
|
|
+ DrawLineBezierQuad :: proc(startPos, endPos: Vector2, controlPos: Vector2, thick: f32, color: Color) --- // Draw line using quadratic bezier curves with a control point
|
|
|
+ DrawLineStrip :: proc(points: [^]Vector2, pointsCount: c.int, color: Color) --- // Draw lines sequence
|
|
|
+ DrawCircle :: proc(centerX, centerY: c.int, radius: f32, color: Color) --- // Draw a color-filled circle
|
|
|
+ DrawCircleSector :: proc(center: Vector2, radius: f32, startAngle, endAngle: f32, segments: c.int, color: Color) --- // Draw a piece of a circle
|
|
|
+ DrawCircleSectorLines :: proc(center: Vector2, radius: f32, startAngle, endAngle: f32, segments: c.int, color: Color) --- // Draw circle sector outline
|
|
|
+ DrawCircleGradient :: proc(centerX, centerY: c.int, radius: f32, color1: Color, color2: Color) --- // Draw a gradient-filled circle
|
|
|
+ DrawCircleV :: proc(center: Vector2, radius: f32, color: Color) --- // Draw a color-filled circle (Vector version)
|
|
|
+ DrawCircleLines :: proc(centerX, centerY: c.int, radius: f32, color: Color) --- // Draw circle outline
|
|
|
+ DrawEllipse :: proc(centerX, centerY: c.int, radiusH: f32, radiusV: f32, color: Color) --- // Draw ellipse
|
|
|
+ DrawEllipseLines :: proc(centerX, centerY: c.int, radiusH: f32, radiusV: f32, color: Color) --- // Draw ellipse outline
|
|
|
+ DrawRing :: proc(center: Vector2, innerRadius, outerRadius: f32, startAngle, endAngle: f32, segments: c.int, color: Color) --- // Draw ring
|
|
|
+ DrawRingLines :: proc(center: Vector2, innerRadius, outerRadius: f32, startAngle, endAngle: f32, segments: c.int, color: Color) --- // Draw ring outline
|
|
|
+ DrawRectangle :: proc(posX, posY, width, height: c.int, color: Color) --- // Draw a color-filled rectangle
|
|
|
+ DrawRectangleV :: proc(position, size: Vector2, color: Color) --- // Draw a color-filled rectangle (Vector version)
|
|
|
+ DrawRectangleRec :: proc(rec: Rectangle, color: Color) --- // Draw a color-filled rectangle
|
|
|
+ DrawRectanglePro :: proc(rec: Rectangle, origin: Vector2, rotation: f32, color: Color) --- // Draw a color-filled rectangle with pro parameters
|
|
|
+ DrawRectangleGradientV :: proc(posX, posY, width, height: c.int, color1: Color, color2: Color) --- // Draw a vertical-gradient-filled rectangle
|
|
|
+ DrawRectangleGradientH :: proc(posX, posY, width, height: c.int, color1: Color, color2: Color) --- // Draw a horizontal-gradient-filled rectangle
|
|
|
+ DrawRectangleGradientEx :: proc(rec: Rectangle, col1, col2, col3, col4: Color) --- // Draw a gradient-filled rectangle with custom vertex colors
|
|
|
+ DrawRectangleLines :: proc(posX, posY, width, height: c.int, color: Color) --- // Draw rectangle outline
|
|
|
+ DrawRectangleLinesEx :: proc(rec: Rectangle, lineThick: c.int, color: Color) --- // Draw rectangle outline with extended parameters
|
|
|
+ DrawRectangleRounded :: proc(rec: Rectangle, roundness: f32, segments: c.int, color: Color) --- // Draw rectangle with rounded edges
|
|
|
+ DrawRectangleRoundedLines :: proc(rec: Rectangle, roundness: f32, segments: c.int, lineThick: c.int, color: Color) --- // Draw rectangle with rounded edges outline
|
|
|
+ DrawTriangle :: proc(v1, v2, v3: Vector2, color: Color) --- // Draw a color-filled triangle (vertex in counter-clockwise order!)
|
|
|
+ DrawTriangleLines :: proc(v1, v2, v3: Vector2, color: Color) --- // Draw triangle outline (vertex in counter-clockwise order!)
|
|
|
+ DrawTriangleFan :: proc(points: [^]Vector2, pointsCount: c.int, color: Color) --- // Draw a triangle fan defined by points (first vertex is the center)
|
|
|
+ DrawTriangleStrip :: proc(points: [^]Vector2, pointsCount: c.int, color: Color) --- // Draw a triangle strip defined by points
|
|
|
+ DrawPoly :: proc(center: Vector2, sides: c.int, radius: f32, rotation: f32, color: Color) --- // Draw a regular polygon (Vector version)
|
|
|
+ DrawPolyLines :: proc(center: Vector2, sides: c.int, radius: f32, rotation: f32, color: Color) --- // Draw a polygon outline of n sides
|
|
|
+
|
|
|
+ // Basic shapes collision detection functions
|
|
|
+ CheckCollisionRecs :: proc(rec1, rec2: Rectangle) -> bool --- // Check collision between two rectangles
|
|
|
+ CheckCollisionCircles :: proc(center1: Vector2, radius1: f32, center2: Vector2, radius2: f32) -> bool --- // Check collision between two circles
|
|
|
+ CheckCollisionCircleRec :: proc(center: Vector2, radius: f32, rec: Rectangle) -> bool --- // Check collision between circle and rectangle
|
|
|
+ CheckCollisionPointRec :: proc(point: Vector2, rec: Rectangle) -> bool --- // Check if point is inside rectangle
|
|
|
+ CheckCollisionPointCircle :: proc(point: Vector2, center: Vector2, radius: f32) -> bool --- // Check if point is inside circle
|
|
|
+ CheckCollisionPointTriangle :: proc(point, p1, p2, p3: Vector2) -> bool --- // Check if point is inside a triangle
|
|
|
+ CheckCollisionLines :: proc(startPos1, endPos1, startPos2, endPos2: Vector2, collisionPoint: ^Vector2) -> bool --- // Check the collision between two lines defined by two points each, returns collision point by reference
|
|
|
+ GetCollisionRec :: proc(rec1, rec2: Rectangle) -> Rectangle --- // Get collision rectangle for two rectangles collision
|
|
|
+
|
|
|
+ //------------------------------------------------------------------------------------
|
|
|
+ // Texture Loading and Drawing Functions (Module: textures)
|
|
|
+ //------------------------------------------------------------------------------------
|
|
|
+
|
|
|
+ // Image loading functions
|
|
|
+ // NOTE: This functions do not require GPU access
|
|
|
+ LoadImage :: proc(fileName: cstring) -> Image --- // Load image from file into CPU memory (RAM)
|
|
|
+ LoadImageRaw :: proc(fileName: cstring, width, height: c.int, format: PixelFormat, headerSize: c.int) -> Image --- // Load image from RAW file data
|
|
|
+ LoadImageAnim :: proc(fileName: cstring, frames: ^c.int) -> Image --- // Load image sequence from file (frames appended to image.data)
|
|
|
+ LoadImageFromMemory :: proc(fileType: cstring, fileData: rawptr, dataSize: c.int) -> Image --- // Load image from memory buffer, fileType refers to extension: i.e. ".png"
|
|
|
+ UnloadImage :: proc(image: Image) --- // Unload image from CPU memory (RAM)
|
|
|
+ ExportImage :: proc(image: Image, fileName: cstring) -> bool --- // Export image data to file, returns true on success
|
|
|
+ ExportImageAsCode :: proc(image: Image, fileName: cstring) -> bool --- // Export image as code file defining an array of bytes, returns true on success
|
|
|
+
|
|
|
+ // Image generation functions
|
|
|
+ GenImageColor :: proc(width, height: c.int, color: Color) -> Image --- // Generate image: plain color
|
|
|
+ GenImageGradientV :: proc(width, height: c.int, top, bottom: Color) -> Image --- // Generate image: vertical gradient
|
|
|
+ GenImageGradientH :: proc(width, height: c.int, left, right: Color) -> Image --- // Generate image: horizontal gradient
|
|
|
+ GenImageGradientRadial :: proc(width, height: c.int, density: f32, inner, outer: Color) -> Image --- // Generate image: radial gradient
|
|
|
+ GenImageChecked :: proc(width, height: c.int, checksX, checksY: c.int, col1, col2: Color) -> Image --- // Generate image: checked
|
|
|
+ GenImageWhiteNoise :: proc(width, height: c.int, factor: f32) -> Image --- // Generate image: white noise
|
|
|
+ GenImagePerlinNoise :: proc(width, height: c.int, offsetX, offsetY: c.int, scale: f32) -> Image --- // Generate image: perlin noise
|
|
|
+ GenImageCellular :: proc(width, height: c.int, tileSize: c.int) -> Image --- // Generate image: cellular algorithm. Bigger tileSize means bigger cells
|
|
|
+
|
|
|
+ // Image manipulation functions
|
|
|
+ ImageCopy :: proc(image: Image) -> Image --- // Create an image duplicate (useful for transformations)
|
|
|
+ ImageFromImage :: proc(image: Image, rec: Rectangle) -> Image --- // Create an image from another image piece
|
|
|
+ ImageText :: proc(text: cstring, fontSize: c.int, color: Color) -> Image --- // Create an image from text (default font)
|
|
|
+ ImageTextEx :: proc(font: Font, text: cstring, fontSize, spacing: f32, tint: Color) -> Image --- // Create an image from text (custom sprite font)
|
|
|
+ ImageFormat :: proc(image: ^Image, newFormat: PixelFormat) --- // Convert image data to desired format
|
|
|
+ ImageToPOT :: proc(image: ^Image, fill: Color) --- // Convert image to POT (power-of-two)
|
|
|
+ ImageCrop :: proc(image: ^Image, crop: Rectangle) --- // Crop an image to a defined rectangle
|
|
|
+ ImageAlphaCrop :: proc(image: ^Image, threshold: f32) --- // Crop image depending on alpha value
|
|
|
+ ImageAlphaClear :: proc(image: ^Image, color: Color, threshold: f32) --- // Clear alpha channel to desired color
|
|
|
+ ImageAlphaMask :: proc(image: ^Image, alphaMask: Image) --- // Apply alpha mask to image
|
|
|
+ ImageAlphaPremultiply :: proc(image: ^Image) --- // Premultiply alpha channel
|
|
|
+ ImageResize :: proc(image: ^Image, newWidth, newHeight: c.int) --- // Resize image (Bicubic scaling algorithm)
|
|
|
+ ImageResizeNN :: proc(image: ^Image, newWidth, newHeight: c.int) --- // Resize image (Nearest-Neighbor scaling algorithm)
|
|
|
+ ImageResizeCanvas :: proc(image: ^Image, newWidth, newHeight: c.int, offsetX, offsetY: c.int, fill: Color) --- // Resize canvas and fill with color
|
|
|
+ ImageMipmaps :: proc(image: ^Image) --- // Generate all mipmap levels for a provided image
|
|
|
+ ImageDither :: proc(image: ^Image, rBpp, gBpp, bBpp, aBpp: c.int) --- // Dither image data to 16bpp or lower (Floyd-Steinberg dithering)
|
|
|
+ ImageFlipVertical :: proc(image: ^Image) --- // Flip image vertically
|
|
|
+ ImageFlipHorizontal :: proc(image: ^Image) --- // Flip image horizontally
|
|
|
+ ImageRotateCW :: proc(image: ^Image) --- // Rotate image clockwise 90deg
|
|
|
+ ImageRotateCCW :: proc(image: ^Image) --- // Rotate image counter-clockwise 90deg
|
|
|
+ ImageColorTint :: proc(image: ^Image, color: Color) --- // Modify image color: tint
|
|
|
+ ImageColorInvert :: proc(image: ^Image) --- // Modify image color: invert
|
|
|
+ ImageColorGrayscale :: proc(image: ^Image) --- // Modify image color: grayscale
|
|
|
+ ImageColorContrast :: proc(image: ^Image, contrast: f32) --- // Modify image color: contrast (-100 to 100)
|
|
|
+ ImageColorBrightness :: proc(image: ^Image, brightness: c.int) --- // Modify image color: brightness (-255 to 255)
|
|
|
+ ImageColorReplace :: proc(image: ^Image, color, replace: Color) --- // Modify image color: replace color
|
|
|
+ LoadImageColors :: proc(image: Image) -> [^]Color --- // Load color data from image as a Color array (RGBA - 32bit)
|
|
|
+ LoadImagePalette :: proc(image: Image, maxPaletteSize: c.int, colorsCount: [^]c.int) -> [^]Color --- // Load colors palette from image as a Color array (RGBA - 32bit)
|
|
|
+ UnloadImageColors :: proc(colors: [^]Color) --- // Unload color data loaded with LoadImageColors()
|
|
|
+ UnloadImagePalette :: proc(colors: [^]Color) --- // Unload colors palette loaded with LoadImagePalette()
|
|
|
+ GetImageAlphaBorder :: proc(image: Image, threshold: f32) -> Rectangle --- // Get image alpha border rectangle
|
|
|
+
|
|
|
+ // Image drawing functions
|
|
|
+ // NOTE: Image software-rendering functions (CPU)
|
|
|
+ ImageClearBackground :: proc(dst: ^Image, color: Color) --- // Clear image background with given color
|
|
|
+ ImageDrawPixel :: proc(dst: ^Image, posX, posY: c.int, color: Color) --- // Draw pixel within an image
|
|
|
+ ImageDrawPixelV :: proc(dst: ^Image, position: Vector2, color: Color) --- // Draw pixel within an image (Vector version)
|
|
|
+ ImageDrawLine :: proc(dst: ^Image, startPosX, startPosY, endPosX, endPosY: c.int, color: Color) --- // Draw line within an image
|
|
|
+ ImageDrawLineV :: proc(dst: ^Image, start, end: Vector2, color: Color) --- // Draw line within an image (Vector version)
|
|
|
+ ImageDrawCircle :: proc(dst: ^Image, centerX, centerY, radius: c.int, color: Color) --- // Draw circle within an image
|
|
|
+ ImageDrawCircleV :: proc(dst: ^Image, center: Vector2, radius: c.int, color: Color) --- // Draw circle within an image (Vector version)
|
|
|
+ ImageDrawRectangle :: proc(dst: ^Image, posX, posY, width, height: c.int, color: Color) --- // Draw rectangle within an image
|
|
|
+ ImageDrawRectangleV :: proc(dst: ^Image, position, size: Vector2, color: Color) --- // Draw rectangle within an image (Vector version)
|
|
|
+ ImageDrawRectangleRec :: proc(dst: ^Image, rec: Rectangle, color: Color) --- // Draw rectangle within an image
|
|
|
+ ImageDrawRectangleLines :: proc(dst: ^Image, rec: Rectangle, thick: c.int, color: Color) --- // Draw rectangle lines within an image
|
|
|
+ ImageDraw :: proc(dst: ^Image, src: Image, srcRec, dstRec: Rectangle, tint: Color) --- // Draw a source image within a destination image (tint applied to source)
|
|
|
+ ImageDrawText :: proc(dst: ^Image, text: cstring, posX, posY: c.int, fontSize: c.int, color: Color) --- // Draw text (using default font) within an image (destination)
|
|
|
+ ImageDrawTextEx :: proc(dst: ^Image, font: Font, text: cstring, position: Vector2, fontSize, spacing: f32, tint: Color) --- // Draw text (custom sprite font) within an image (destination)
|
|
|
+
|
|
|
+ // Texture loading functions
|
|
|
+ // NOTE: These functions require GPU access
|
|
|
+ LoadTexture :: proc(fileName: cstring) -> Texture2D --- // Load texture from file into GPU memory (VRAM)
|
|
|
+ LoadTextureFromImage :: proc(image: Image) -> Texture2D --- // Load texture from image data
|
|
|
+ LoadTextureCubemap :: proc(image: Image, layout: CubemapLayout) -> TextureCubemap --- // Load cubemap from image, multiple image cubemap layouts supported
|
|
|
+ LoadRenderTexture :: proc(width, height: c.int) -> RenderTexture2D --- // Load texture for rendering (framebuffer)
|
|
|
+ UnloadTexture :: proc(texture: Texture2D) --- // Unload texture from GPU memory (VRAM)
|
|
|
+ UnloadRenderTexture :: proc(target: RenderTexture2D) --- // Unload render texture from GPU memory (VRAM)
|
|
|
+ UpdateTexture :: proc(texture: Texture2D, pixels: rawptr) --- // Update GPU texture with new data
|
|
|
+ UpdateTextureRec :: proc(texture: Texture2D, rec: Rectangle, pixels: rawptr) --- // Update GPU texture rectangle with new data
|
|
|
+ GetTextureData :: proc(texture: Texture2D) -> Image --- // Get pixel data from GPU texture and return an Image
|
|
|
+ GetScreenData :: proc() -> Image --- // Get pixel data from screen buffer and return an Image (screenshot)
|
|
|
+
|
|
|
+ // Texture configuration functions
|
|
|
+ GenTextureMipmaps :: proc(texture: ^Texture2D) --- // Generate GPU mipmaps for a texture
|
|
|
+ SetTextureFilter :: proc(texture: Texture2D, filter: TextureFilter) --- // Set texture scaling filter mode
|
|
|
+ SetTextureWrap :: proc(texture: Texture2D, wrap: TextureWrap) --- // Set texture wrapping mode
|
|
|
+
|
|
|
+ // Texture drawing functions
|
|
|
+ DrawTexture :: proc(texture: Texture2D, posX, posY: c.int, tint: Color) --- // Draw a Texture2D
|
|
|
+ DrawTextureV :: proc(texture: Texture2D, position: Vector2, tint: Color) --- // Draw a Texture2D with position defined as Vector2
|
|
|
+ DrawTextureEx :: proc(texture: Texture2D, position: Vector2, rotation, scale: f32, tint: Color) --- // Draw a Texture2D with extended parameters
|
|
|
+ DrawTextureRec :: proc(texture: Texture2D, source: Rectangle, position: Vector2, tint: Color) --- // Draw a part of a texture defined by a rectangle
|
|
|
+ DrawTextureQuad :: proc(texture: Texture2D, tiling: Vector2, offset: Vector2, quad: Rectangle, tint: Color) --- // Draw texture quad with tiling and offset parameters
|
|
|
+ DrawTextureTiled :: proc(texture: Texture2D, source, dest: Rectangle, origin: Vector2, rotation, scale: f32, tint: Color) --- // Draw part of a texture (defined by a rectangle) with rotation and scale tiled into dest.
|
|
|
+ DrawTexturePro :: proc(texture: Texture2D, source, dest: Rectangle, origin: Vector2, rotation: f32, tint: Color) --- // Draw a part of a texture defined by a rectangle with 'pro' parameters
|
|
|
+ DrawTextureNPatch :: proc(texture: Texture2D, nPatchInfo: NPatchInfo, dest: Rectangle, origin: Vector2, rotation: f32, tint: Color) --- // Draws a texture (or part of it) that stretches or shrinks nicely
|
|
|
+ DrawTexturePoly :: proc(texture: Texture2D, center: Vector2, points: [^]Vector2, texcoords: [^]Vector2, pointsCount: c.int, tint: Color) --- // Draw a textured polygon
|
|
|
+
|
|
|
+ // Color/pixel related functions
|
|
|
+ Fade :: proc(color: Color, alpha: f32) -> Color --- // Returns color with alpha applied, alpha goes from 0.0f to 1.0f
|
|
|
+ ColorToInt :: proc(color: Color) -> c.int --- // Returns hexadecimal value for a Color
|
|
|
+ ColorNormalize :: proc(color: Color) -> Vector4 --- // Returns Color normalized as float [0..1]
|
|
|
+ ColorFromNormalized :: proc(normalized: Vector4) -> Color --- // Returns Color from normalized values [0..1]
|
|
|
+ ColorToHSV :: proc(color: Color) -> Vector3 --- // Returns HSV values for a Color, hue [0..360], saturation/value [0..1]
|
|
|
+ ColorFromHSV :: proc(hue, saturation, value: f32) -> Color --- // Returns a Color from HSV values, hue [0..360], saturation/value [0..1]
|
|
|
+ ColorAlpha :: proc(color: f32, alpha: f32) -> Color --- // Returns color with alpha applied, alpha goes from 0.0f to 1.0f
|
|
|
+ ColorAlphaBlend :: proc(dst, src, tint: Color) -> Color --- // Returns src alpha-blended into dst color with tint
|
|
|
+ GetColor :: proc(hexValue: c.int) -> Color --- // Get Color structure from hexadecimal value
|
|
|
+ GetPixelColor :: proc(srcPtr: rawptr, format: PixelFormat) -> Color --- // Get Color from a source pixel pointer of certain format
|
|
|
+ SetPixelColor :: proc(dstPtr: rawptr, color: Color, format: PixelFormat) --- // Set color formatted into destination pixel pointer
|
|
|
+ GetPixelDataSize :: proc(width, height: c.int, format: PixelFormat) -> c.int --- // Get pixel data size in bytes for certain format
|
|
|
+
|
|
|
+ //------------------------------------------------------------------------------------
|
|
|
+ // Font Loading and Text Drawing Functions (Module: text)
|
|
|
+ //------------------------------------------------------------------------------------
|
|
|
+
|
|
|
+ // Font loading/unloading functions
|
|
|
+ GetFontDefault :: proc() -> Font --- // Get the default Font
|
|
|
+ LoadFont :: proc(fileName: cstring) -> Font --- // Load font from file into GPU memory (VRAM)
|
|
|
+ LoadFontEx :: proc(fileName: cstring, fontSize: c.int, fontChars: [^]rune, charsCount: c.int) -> Font --- // Load font from file with extended parameters
|
|
|
+ LoadFontFromImage :: proc(image: Image, key: Color, firstChar: rune) -> Font --- // Load font from Image (XNA style)
|
|
|
+ LoadFontFromMemory :: proc(fileType: cstring, fileData: rawptr, dataSize: c.int, fontSize: c.int, fontChars: [^]rune, charsCount: c.int) -> Font --- // Load font from memory buffer, fileType refers to extension: i.e. ".ttf"
|
|
|
+ LoadFontData :: proc(fileData: rawptr, dataSize: c.int, fontSize: c.int, fontChars: [^]rune, charsCount: c.int, type: FontType) -> [^]CharInfo --- // Load font data for further use
|
|
|
+ GenImageFontAtlas :: proc(chars: [^]CharInfo, recs: ^[^]Rectangle, charsCount: c.int, fontSize: c.int, padding: c.int, packMethod: c.int) -> Image --- // Generate image font atlas using chars info
|
|
|
+ UnloadFontData :: proc(chars: [^]CharInfo, charsCount: c.int) --- // Unload font chars info data (RAM)
|
|
|
+ UnloadFont :: proc(font: Font) --- // Unload Font from GPU memory (VRAM)
|
|
|
+
|
|
|
+ // Text drawing functions
|
|
|
+ DrawFPS :: proc(posX, posY: c.int) --- // Draw current FPS
|
|
|
+ DrawText :: proc(text: cstring, posX, posY: c.int, fontSize: c.int, color: Color) --- // Draw text (using default font)
|
|
|
+ DrawTextEx :: proc(font: Font, text: cstring, position: Vector2, fontSize: f32, spacing: f32, tint: Color) --- // Draw text using font and additional parameters
|
|
|
+ DrawTextRec :: proc(font: Font, text: cstring, rec: Rectangle, fontSize, spacing: f32, wordWrap: bool, tint: Color) --- // Draw text using font inside rectangle limits
|
|
|
+ DrawTextRecEx :: proc(font: Font, text: cstring, rec: Rectangle, fontSize, spacing: f32, wordWrap: bool, tint: Color,
|
|
|
+ selectStart, selectLength: c.int, selectTint, selectBackTint: Color) --- // Draw text using font inside rectangle limits with support for text selection
|
|
|
+ DrawTextCodepoint :: proc(font: Font, codepoint: rune, position: Vector2, fontSize: f32, tint: Color) --- // Draw one character (codepoint)
|
|
|
+
|
|
|
+ // Text misc. functions
|
|
|
+ MeasureText :: proc(text: cstring, fontSize: c.int) -> c.int --- // Measure string width for default font
|
|
|
+ MeasureTextEx :: proc(font: Font, text: cstring, fontSize, spacing: f32) -> Vector2 --- // Measure string size for Font
|
|
|
+ GetGlyphIndex :: proc(font: Font, codepoint: rune) -> c.int --- // Get index position for a unicode character on font
|
|
|
+
|
|
|
+ // Text strings management functions (no utf8 strings, only byte chars)
|
|
|
+ // NOTE: Some strings allocate memory internally for returned strings, just be careful!
|
|
|
+ TextCopy :: proc(dst: [^]u8, src: cstring) -> c.int --- // Copy one string to another, returns bytes copied
|
|
|
+ TextIsEqual :: proc(text1, text2: cstring) -> bool --- // Check if two text string are equal
|
|
|
+ TextLength :: proc(text: cstring) -> c.uint --- // Get text length, checks for '\0' ending
|
|
|
+ TextFormat :: proc(text: cstring, #c_vararg args: ..any) -> cstring --- // Text formatting with variables (sprintf style)
|
|
|
+ TextSubtext :: proc(text: cstring, position: c.int, length: c.int) -> cstring --- // Get a piece of a text string
|
|
|
+ TextReplace :: proc(text: [^]byte, replace, by: cstring) -> cstring --- // Replace text string (memory must be freed!)
|
|
|
+ TextInsert :: proc(text, insert: cstring, position: c.int) -> cstring --- // Insert text in a position (memory must be freed!)
|
|
|
+ TextJoin :: proc(textList: [^]cstring, count: c.int, delimiter: cstring) -> cstring --- // Join text strings with delimiter
|
|
|
+ TextSplit :: proc(text: cstring, delimiter: byte, count: ^c.int) -> [^]cstring --- // Split text into multiple strings
|
|
|
+ TextAppend :: proc(text: [^]byte, append: cstring, position: ^c.int) --- // Append text at specific position and move cursor!
|
|
|
+ TextFindIndex :: proc(text: cstring, find: cstring) -> c.int --- // Find first text occurrence within a string
|
|
|
+ TextToUpper :: proc(text: cstring) -> cstring --- // Get upper case version of provided string
|
|
|
+ TextToLower :: proc(text: cstring) -> cstring --- // Get lower case version of provided string
|
|
|
+ TextToPascal :: proc(text: cstring) -> cstring --- // Get Pascal case notation version of provided string
|
|
|
+ TextToInteger :: proc(text: cstring) -> c.int --- // Get integer value from text (negative values not supported)
|
|
|
+ TextToUtf8 :: proc(codepoints: [^]rune, length: c.int) -> [^]byte --- // Encode text codepoint into utf8 text (memory must be freed!)
|
|
|
+
|
|
|
+
|
|
|
+ // UTF8 text strings management functions
|
|
|
+ GetCodepoints :: proc(text: cstring, count: ^c.int) -> [^]rune --- // Get all codepoints in a string, codepoints count returned by parameters
|
|
|
+ GetCodepointsCount :: proc(text: cstring) -> c.int --- // Get total number of characters (codepoints) in a UTF8 encoded string
|
|
|
+ GetNextCodepoint :: proc(text: cstring, bytesProcessed: ^c.int) -> c.int --- // Returns next codepoint in a UTF8 encoded string; 0x3f('?') is returned on failure
|
|
|
+ CodepointToUtf8 :: proc(codepoint: rune, byteLength: ^c.int) -> cstring --- // Encode codepoint into utf8 text (char array length returned as parameter)
|
|
|
+
|
|
|
+ //------------------------------------------------------------------------------------
|
|
|
+ // Basic 3d Shapes Drawing Functions (Module: models)
|
|
|
+ //------------------------------------------------------------------------------------
|
|
|
+
|
|
|
+ // Basic geometric 3D shapes drawing functions
|
|
|
+ DrawLine3D :: proc(startPos, endPos: Vector3, color: Color) --- // Draw a line in 3D world space
|
|
|
+ DrawPoint3D :: proc(position: Vector3, color: Color) --- // Draw a point in 3D space, actually a small line
|
|
|
+ DrawCircle3D :: proc(center: Vector3, radius: f32, rotationAxis: Vector3, rotationAngle: f32, color: Color) --- // Draw a circle in 3D world space
|
|
|
+ DrawTriangle3D :: proc(v1, v2, v3: Vector3, color: Color) --- // Draw a color-filled triangle (vertex in counter-clockwise order!)
|
|
|
+ DrawTriangleStrip3D :: proc(points: [^]Vector3, pointsCount: c.int, color: Color) --- // Draw a triangle strip defined by points
|
|
|
+ DrawCube :: proc(position: Vector3, width, height, length: f32, color: Color) --- // Draw cube
|
|
|
+ DrawCubeV :: proc(position: Vector3, size: Vector3, color: Color) --- // Draw cube (Vector version)
|
|
|
+ DrawCubeWires :: proc(position: Vector3, width, height, length: f32, color: Color) --- // Draw cube wires
|
|
|
+ DrawCubeWiresV :: proc(position: Vector3, size: Vector3, color: Color) --- // Draw cube wires (Vector version)
|
|
|
+ DrawCubeTexture :: proc(texture: Texture2D, position: Vector3, width, height, length: f32, color: Color) --- // Draw cube textured
|
|
|
+ DrawSphere :: proc(centerPos: Vector3, radius: f32, color: Color) --- // Draw sphere
|
|
|
+ DrawSphereEx :: proc(centerPos: Vector3, radius: f32, rings, slices: c.int, color: Color) --- // Draw sphere with extended parameters
|
|
|
+ DrawSphereWires :: proc(centerPos: Vector3, radius: f32, rings, slices: c.int, color: Color) --- // Draw sphere wires
|
|
|
+ DrawCylinder :: proc(position: Vector3, radiusTop, radiusBottom: f32, height: f32, slices: c.int, color: Color) --- // Draw a cylinder/cone
|
|
|
+ DrawCylinderWires :: proc(position: Vector3, radiusTop, radiusBottom: f32, height: f32, slices: c.int, color: Color) --- // Draw a cylinder/cone wires
|
|
|
+ DrawPlane :: proc(centerPos, size: Vector2, color: Color) --- // Draw a plane XZ
|
|
|
+ DrawRay :: proc(ray: Ray, color: Color) --- // Draw a ray line
|
|
|
+ DrawGrid :: proc(slices: c.int, spacing: f32) --- // Draw a grid (centered at (0, 0, 0))
|
|
|
+
|
|
|
+ //------------------------------------------------------------------------------------
|
|
|
+ // Model 3d Loading and Drawing Functions (Module: models)
|
|
|
+ //------------------------------------------------------------------------------------
|
|
|
+
|
|
|
+ // Model loading/unloading functions
|
|
|
+ LoadModel :: proc(fileName: cstring) -> Model --- // Load model from files (meshes and materials)
|
|
|
+ LoadModelFromMesh :: proc(mesh: Mesh) -> Model --- // Load model from generated mesh (default material)
|
|
|
+ UnloadModel :: proc(model: Model) --- // Unload model (including meshes) from memory (RAM and/or VRAM)
|
|
|
+ UnloadModelKeepMeshes :: proc(model: Model) --- // Unload model (but not meshes) from memory (RAM and/or VRAM)
|
|
|
+
|
|
|
+ // Mesh loading/unloading functions
|
|
|
+ UploadMesh :: proc(mesh: ^Mesh, is_dynamic: bool) --- // Upload mesh vertex data in GPU and provide VAO/VBO ids
|
|
|
+ UpdateMeshBuffer :: proc(mesh: Mesh, index: c.int, data:rawptr, dataSize, offset: c.int) --- // Update mesh vertex data in GPU for a specific buffer index
|
|
|
+ DrawMesh :: proc(mesh: Mesh, material: Material, transform: Matrix) --- // Draw a 3d mesh with material and transform
|
|
|
+ DrawMeshInstanced :: proc(mesh: Mesh, material: Material, transforms: [^]Matrix, instances: c.int) --- // Draw multiple mesh instances with material and different transforms
|
|
|
+ UnloadMesh :: proc(mesh: Mesh) --- // Unload mesh data from CPU and GPU
|
|
|
+ ExportMesh :: proc(mesh: Mesh, fileName: cstring) -> bool --- // Export mesh data to file, returns true on success
|
|
|
+
|
|
|
+ // Material loading/unloading functions
|
|
|
+ LoadMaterials :: proc(fileName: cstring, materialCount: ^c.int) -> [^]Material --- // Load materials from model file
|
|
|
+ LoadMaterialDefault :: proc() -> Material --- // Load default material (Supports: DIFFUSE, SPECULAR, NORMAL maps)
|
|
|
+ UnloadMaterial :: proc(material: Material) --- // Unload material from GPU memory (VRAM)
|
|
|
+ SetMaterialTexture :: proc(material: ^Material, mapType: MaterialMapIndex, texture: Texture2D) --- // Set texture for a material map type (MATERIAL_MAP_DIFFUSE, MATERIAL_MAP_SPECULAR...)
|
|
|
+ SetModelMeshMaterial :: proc(model: ^Model, meshId: c.int, materialId: c.int) --- // Set material for a mesh
|
|
|
+
|
|
|
+ // Model animations loading/unloading functions
|
|
|
+ LoadModelAnimations :: proc(fileName: cstring, animsCount: ^c.int) -> [^]ModelAnimation --- // Load model animations from file
|
|
|
+ UpdateModelAnimation :: proc(model: Model, anim: ModelAnimation, frame: c.int) --- // Update model animation pose
|
|
|
+ UnloadModelAnimation :: proc(anim: ModelAnimation) --- // Unload animation data
|
|
|
+ UnloadModelAnimations :: proc(animations: [^]ModelAnimation, count: c.uint) --- // Unload animation array data
|
|
|
+ IsModelAnimationValid :: proc(model: Model, anim: ModelAnimation) -> bool --- // Check model animation skeleton match
|
|
|
+
|
|
|
+ // Mesh generation functions
|
|
|
+ GenMeshPoly :: proc(sides: c.int, radius: f32) -> Mesh --- // Generate polygonal mesh
|
|
|
+ GenMeshPlane :: proc(width, length: f32, resX, resZ: c.int) -> Mesh --- // Generate plane mesh (with subdivisions)
|
|
|
+ GenMeshCube :: proc(width, height, length: f32) -> Mesh --- // Generate cuboid mesh
|
|
|
+ GenMeshSphere :: proc(radius: f32, rings, slices: c.int) -> Mesh --- // Generate sphere mesh (standard sphere)
|
|
|
+ GenMeshHemiSphere :: proc(radius: f32, rings, slices: c.int) -> Mesh --- // Generate half-sphere mesh (no bottom cap)
|
|
|
+ GenMeshCylinder :: proc(radius: f32, height: f32, slices: c.int) -> Mesh --- // Generate cylinder mesh
|
|
|
+ GenMeshTorus :: proc(radius: f32, size: f32, radSeg: c.int, sides: c.int) -> Mesh --- // Generate torus mesh
|
|
|
+ GenMeshKnot :: proc(radius: f32, size: f32, radSeg: c.int, sides: c.int) -> Mesh --- // Generate trefoil knot mesh
|
|
|
+ GenMeshHeightmap :: proc(heightmap: Image, size: Vector3) -> Mesh --- // Generate heightmap mesh from image data
|
|
|
+ GenMeshCubicmap :: proc(cubicmap: Image, cubeSize: Vector3) -> Mesh --- // Generate cubes-based map mesh from image data
|
|
|
+
|
|
|
+ // Mesh manipulation functions
|
|
|
+ MeshBoundingBox :: proc(mesh: Mesh) -> BoundingBox --- // Compute mesh bounding box limits
|
|
|
+ MeshTangents :: proc(mesh: ^Mesh) --- // Compute mesh tangents
|
|
|
+ MeshBinormals :: proc(mesh: ^Mesh) --- // Compute mesh binormals
|
|
|
+
|
|
|
+ // Model drawing functions
|
|
|
+ DrawModel :: proc(model: Model, position: Vector3, scale: f32, tint: Color) --- // Draw a model (with texture if set)
|
|
|
+ DrawModelEx :: proc(model: Model, position: Vector3, rotationAxis: Vector3, rotationAngle: f32, scale: Vector3, tint: Color) --- // Draw a model with extended parameters
|
|
|
+ DrawModelWires :: proc(model: Model, position: Vector3, scale: f32, tint: Color) --- // Draw a model wires (with texture if set)
|
|
|
+ DrawModelWiresEx :: proc(model: Model, position: Vector3, rotationAxis: Vector3, rotationAngle: f32, scale: Vector3, tint: Color) --- // Draw a model wires (with texture if set) with extended parameters
|
|
|
+ DrawBoundingBox :: proc(box: BoundingBox, color: Color) --- // Draw bounding box (wires)
|
|
|
+ DrawBillboard :: proc(camera: Camera, texture: Texture2D, center: Vector3, size: f32, tint: Color) --- // Draw a billboard texture
|
|
|
+ DrawBillboardRec :: proc(camera: Camera, texture: Texture2D, source: Rectangle, center: Vector3, size: f32, tint: Color) --- // Draw a billboard texture defined by source
|
|
|
+
|
|
|
+
|
|
|
+ // Collision detection functions
|
|
|
+ CheckCollisionSpheres :: proc(center1: Vector3, radius1: f32, center2: Vector3, radius2: f32) -> bool --- // Detect collision between two spheres
|
|
|
+ CheckCollisionBoxes :: proc(box1, box2: BoundingBox) -> bool --- // Detect collision between two bounding boxes
|
|
|
+ CheckCollisionBoxSphere :: proc(box: BoundingBox, center: Vector3, radius: f32) -> bool --- // Detect collision between box and sphere
|
|
|
+ CheckCollisionRaySphere :: proc(ray: Ray, center: Vector3, radius: f32) -> bool --- // Detect collision between ray and sphere
|
|
|
+ CheckCollisionRaySphereEx :: proc(ray: Ray, center: Vector3, radius: f32, collisionPoint: [^]Vector3) -> bool --- // Detect collision between ray and sphere, returns collision point
|
|
|
+ CheckCollisionRayBox :: proc(ray: Ray, box: BoundingBox) -> bool --- // Detect collision between ray and box
|
|
|
+ GetCollisionRayMesh :: proc(ray: Ray, mesh: Mesh, transform: Matrix) -> RayHitInfo --- // Get collision info between ray and mesh
|
|
|
+ GetCollisionRayModel :: proc(ray: Ray, model: Model) -> RayHitInfo --- // Get collision info between ray and model
|
|
|
+ GetCollisionRayTriangle :: proc(ray: Ray, p1, p2, p3: Vector3) -> RayHitInfo --- // Get collision info between ray and triangle
|
|
|
+ GetCollisionRayGround :: proc(ray: Ray, groundHeight: f32) -> RayHitInfo --- // Get collision info between ray and ground plane (Y-normal plane)
|
|
|
+
|
|
|
+ //------------------------------------------------------------------------------------
|
|
|
+ // Audio Loading and Playing Functions (Module: audio)
|
|
|
+ //------------------------------------------------------------------------------------
|
|
|
+
|
|
|
+ // Audio device management functions
|
|
|
+ InitAudioDevice :: proc() --- // Initialize audio device and context
|
|
|
+ CloseAudioDevice :: proc() --- // Close the audio device and context
|
|
|
+ IsAudioDeviceReady :: proc() -> bool --- // Check if audio device has been initialized successfully
|
|
|
+ SetMasterVolume :: proc(volume: f32) --- // Set master volume (listener)
|
|
|
+
|
|
|
+ // Wave/Sound loading/unloading functions
|
|
|
+ LoadWave :: proc(fileName: cstring) -> Wave --- // Load wave data from file
|
|
|
+ LoadWaveFromMemory :: proc(fileType: cstring, fileData: rawptr, dataSize: c.int) -> Wave --- // Load wave from memory buffer, fileType refers to extension: i.e. ".wav"
|
|
|
+ LoadSound :: proc(fileName: cstring) -> Sound --- // Load sound from file
|
|
|
+ LoadSoundFromWave :: proc(wave: Wave) -> Sound --- // Load sound from wave data
|
|
|
+ UpdateSound :: proc(sound: Sound, data: rawptr, samplesCount: c.int) --- // Update sound buffer with new data
|
|
|
+ UnloadWave :: proc(wave: Wave) --- // Unload wave data
|
|
|
+ UnloadSound :: proc(sound: Sound) --- // Unload sound
|
|
|
+ ExportWave :: proc(wave: Wave, fileName: cstring) -> bool --- // Export wave data to file, returns true on success
|
|
|
+ ExportWaveAsCode :: proc(wave: Wave, fileName: cstring) -> bool --- // Export wave sample data to code (.h), returns true on success
|
|
|
+
|
|
|
+ // Wave/Sound management functions
|
|
|
+ PlaySound :: proc(sound: Sound) --- // Play a sound
|
|
|
+ StopSound :: proc(sound: Sound) --- // Stop playing a sound
|
|
|
+ PauseSound :: proc(sound: Sound) --- // Pause a sound
|
|
|
+ ResumeSound :: proc(sound: Sound) --- // Resume a paused sound
|
|
|
+ PlaySoundMulti :: proc(sound: Sound) --- // Play a sound (using multichannel buffer pool)
|
|
|
+ StopSoundMulti :: proc() --- // Stop any sound playing (using multichannel buffer pool)
|
|
|
+ GetSoundsPlaying :: proc() -> c.int --- // Get number of sounds playing in the multichannel
|
|
|
+ IsSoundPlaying :: proc(sound: Sound) -> bool --- // Check if a sound is currently playing
|
|
|
+ SetSoundVolume :: proc(sound: Sound, volume: f32) --- // Set volume for a sound (1.0 is max level)
|
|
|
+ SetSoundPitch :: proc(sound: Sound, pitch: f32) --- // Set pitch for a sound (1.0 is base level)
|
|
|
+ WaveFormat :: proc(wave: ^Wave, sampleRate, sampleSize: c.int, channels: c.int) --- // Convert wave data to desired format
|
|
|
+ WaveCopy :: proc(wave: Wave) -> Wave --- // Copy a wave to a new wave
|
|
|
+ WaveCrop :: proc(wave: ^Wave, initSample, finalSample: c.int) --- // Crop a wave to defined samples range
|
|
|
+ LoadWaveSamples :: proc(wave: Wave) -> [^]f32 --- // Load samples data from wave as a floats array
|
|
|
+ UnloadWaveSamples :: proc(samples: [^]f32) --- // Unload samples data loaded with LoadWaveSamples()
|
|
|
+
|
|
|
+ // Music management functions
|
|
|
+ LoadMusicStream :: proc(fileName: cstring) -> Music --- // Load music stream from file
|
|
|
+ LoadMusicStreamFromMemory :: proc(fileType: cstring, data: rawptr, dataSize: c.int) -> Music --- // Load music stream from data
|
|
|
+ UnloadMusicStream :: proc(music: Music) --- // Unload music stream
|
|
|
+ PlayMusicStream :: proc(music: Music) --- // Start music playing
|
|
|
+ IsMusicPlaying :: proc(music: Music) -> bool --- // Check if music is playing
|
|
|
+ UpdateMusicStream :: proc(music: Music) --- // Updates buffers for music streaming
|
|
|
+ StopMusicStream :: proc(music: Music) --- // Stop music playing
|
|
|
+ PauseMusicStream :: proc(music: Music) --- // Pause music playing
|
|
|
+ ResumeMusicStream :: proc(music: Music) --- // Resume playing paused music
|
|
|
+ SetMusicVolume :: proc(music: Music, volume: f32) --- // Set volume for music (1.0 is max level)
|
|
|
+ SetMusicPitch :: proc(music: Music, pitch: f32) --- // Set pitch for a music (1.0 is base level)
|
|
|
+ GetMusicTimeLength :: proc(music: Music) -> f32 --- // Get music time length (in seconds)
|
|
|
+ GetMusicTimePlayed :: proc(music: Music) -> f32 --- // Get current music time played (in seconds)
|
|
|
+
|
|
|
+ // AudioStream management functions
|
|
|
+ InitAudioStream :: proc(sampleRate, sampleSize, channels: c.uint) -> AudioStream --- // Init audio stream (to stream raw audio pcm data)
|
|
|
+ UpdateAudioStream :: proc(stream: AudioStream, data: rawptr, samplesCount: c.int) --- // Update audio stream buffers with data
|
|
|
+ CloseAudioStream :: proc(stream: AudioStream) --- // Close audio stream and free memory
|
|
|
+ IsAudioStreamProcessed :: proc(stream: AudioStream) -> AudioStream --- // Check if any audio stream buffers requires refill
|
|
|
+ PlayAudioStream :: proc(stream: AudioStream) --- // Play audio stream
|
|
|
+ PauseAudioStream :: proc(stream: AudioStream) --- // Pause audio stream
|
|
|
+ ResumeAudioStream :: proc(stream: AudioStream) --- // Resume audio stream
|
|
|
+ IsAudioStreamPlaying :: proc(stream: AudioStream) -> AudioStream --- // Check if audio stream is playing
|
|
|
+ StopAudioStream :: proc(stream: AudioStream) --- // Stop audio stream
|
|
|
+ SetAudioStreamVolume :: proc(stream: AudioStream, volume: f32) --- // Set volume for audio stream (1.0 is max level)
|
|
|
+ SetAudioStreamPitch :: proc(stream: AudioStream, pitch: f32) --- // Set pitch for audio stream (1.0 is base level)
|
|
|
+ SetAudioStreamBufferSizeDefault :: proc(size: c.int) --- // Default size for new audio streams
|
|
|
+}
|
gingerBill