Add newlines to improve documentation generation

vendor/raylib/raylib.odin

@@ -31,7 +31,7 @@
 *       [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):
+*   OPTIONAL DEPENDENCIES (included):`
 *       [rcore] msf_gif (Miles Fogle) for GIF recording
 *       [rcore] sinfl (Micha Mettke) for DEFLATE decompression algorithm
 *       [rcore] sdefl (Micha Mettke) for DEFLATE compression algorithm
@@ -855,7 +855,7 @@ CameraProjection :: enum c.int {
 	ORTHOGRAPHIC,                     // Orthographic projection
 }
 
-// N-patch layout
+7// N-patch layout
 NPatchLayout :: enum c.int {
 	NINE_PATCH = 0,          // Npatch layout: 3x3 tiles
 	THREE_PATCH_VERTICAL,    // Npatch layout: 1x3 tiles
@@ -887,6 +887,7 @@ foreign lib {
 	//------------------------------------------------------------------------------------
 
 	// 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
@@ -938,12 +939,14 @@ foreign lib {
 	// 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
+
 	SwapScreenBuffer :: proc() ---             // Swap back buffer with front buffer (screen drawing)
 	PollInputEvents  :: proc() ---             // Register all input events
 	WaitTime         :: proc(seconds: f64) --- // Wait for some time (halt program execution)
 
 
 	// Cursor-related functions
+
 	ShowCursor       :: proc() ---                                              // Shows cursor
 	HideCursor       :: proc() ---                                              // Hides cursor
 	IsCursorHidden   :: proc() -> bool ---                                      // Check if cursor is not visible
@@ -952,6 +955,7 @@ foreign lib {
 	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)
@@ -971,11 +975,13 @@ foreign lib {
 	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
 	IsShaderReady           :: proc(shader: Shader) -> bool ---                                                                           // Check if a shader is ready
@@ -988,6 +994,7 @@ foreign lib {
 	UnloadShader            :: proc(shader: Shader) ---                                                                                   // Unload shader from GPU memory (VRAM)
 
 	// Screen-space-related functions
+
 	GetMouseRay        :: proc(mousePosition: Vector2, camera: Camera) -> Ray ---                      // Get a ray trace from mouse position
 	GetCameraMatrix    :: proc(camera: Camera) -> Matrix ---                                           // Get camera transform matrix (view matrix)
 	GetCameraMatrix2D  :: proc(camera: Camera2D) -> Matrix ---                                         // Get camera 2d transform matrix
@@ -997,12 +1004,14 @@ foreign lib {
 	GetWorldToScreen2D :: proc(position: Vector2, camera: Camera2D) -> Vector2 ---                     // Get the screen space position for a 2d camera world 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)
 	SetRandomSeed  :: proc(seed: c.uint) ---             // Set the seed for the random number generator
 	TakeScreenshot :: proc(fileName: cstring) ---        // Takes a screenshot of current screen (filename extension defines format)
@@ -1018,6 +1027,7 @@ foreign lib {
 
 	// 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
@@ -1025,6 +1035,7 @@ foreign lib {
 	SetSaveFileTextCallback :: proc(callback: SaveFileTextCallback) --- // Set custom file text data saver
 
 	// Files management functions
+
 	LoadFileData            :: proc(fileName: cstring, bytesRead: ^c.uint) -> [^]byte ---                      // Load file data as byte array (read)
 	UnloadFileData          :: proc(data: [^]byte) ---                                                         // 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
@@ -1054,6 +1065,7 @@ foreign lib {
 	GetFileModTime          :: proc(fileName: cstring) -> c.long ---                                           // Get file modification time (last write time)
 
 	// Compression/Encoding functionality
+
 	CompressData     :: proc(data: rawptr,     dataSize: c.int,     compDataSize: ^c.int) -> [^]byte ---       // Compress data (DEFLATE algorithm), memory must be MemFree()
 	DecompressData   :: proc(compData: rawptr, compDataSize: c.int, dataSize:     ^c.int) -> [^]byte ---       // Decompress data (DEFLATE algorithm), memory must be MemFree()
 	EncodeDataBase64 :: proc(data: rawptr,     dataSize: c.int,     outputSize:   ^c.int) -> [^]byte ---       // Encode data to Base64 string, memory must be MemFree()
@@ -1064,6 +1076,7 @@ foreign lib {
 	//------------------------------------------------------------------------------------
 
 	// 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
@@ -1073,6 +1086,7 @@ foreign lib {
 	GetCharPressed :: proc() -> rune ---                 // Get char pressed (unicode), call it multiple times for chars queued
 
 	// Input-related functions: gamepads
+
 	IsGamepadAvailable       :: proc(gamepad: c.int) -> bool ---                        // Check if a gamepad is available
 	GetGamepadName           :: proc(gamepad: c.int) -> cstring ---                     // Get gamepad internal name id
 	IsGamepadButtonPressed   :: proc(gamepad: c.int, button: GamepadButton) -> bool --- // Check if a gamepad button has been pressed once
@@ -1085,6 +1099,7 @@ foreign lib {
 	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
@@ -1101,6 +1116,7 @@ foreign lib {
 	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)
@@ -1110,6 +1126,7 @@ foreign lib {
 	//------------------------------------------------------------------------------------
 	// Gestures and Touch Handling Functions (Module: rgestures)
 	//------------------------------------------------------------------------------------
+
 	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
@@ -1122,6 +1139,7 @@ foreign lib {
 	//------------------------------------------------------------------------------------
 	// Camera System Functions (Module: camera)
 	//------------------------------------------------------------------------------------
+
 	UpdateCamera :: proc(camera: ^Camera, mode: CameraMode) ---                                   // Set camera mode (multiple camera modes available)
 	UpdateCameraPro :: proc(camera: ^Camera, movement: Vector3, rotation: Vector3, zoom: f32) --- // Update camera movement/rotation
 
@@ -1131,9 +1149,11 @@ foreign lib {
 	// 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
@@ -1188,6 +1208,7 @@ foreign lib {
 
 	// Image loading functions
 	// NOTE: These 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)
@@ -1200,6 +1221,7 @@ foreign lib {
 	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
@@ -1211,6 +1233,7 @@ foreign lib {
 	GenImageText           :: proc(width, height: c.int, text: cstring) -> Image  ---                                          // Generate image: grayscale image from text data
 
 	// 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)
@@ -1247,6 +1270,7 @@ foreign lib {
 
 	// 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)
@@ -1266,6 +1290,7 @@ foreign lib {
 
 	// 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
@@ -1278,6 +1303,7 @@ foreign lib {
 	UpdateTextureRec     :: proc(texture: Texture2D, rec: Rectangle, pixels: rawptr) ---    // Update GPU texture rectangle with new data
 
 	// 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
@@ -1291,6 +1317,7 @@ foreign lib {
 	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
 
 	// Color/pixel related functions
+
 	Fade                :: proc(color: Color, alpha: f32) -> Color ---                  // Get color with alpha applied, alpha goes from 0.0f to 1.0f
 	ColorToInt          :: proc(color: Color) -> c.uint ---                             // Get hexadecimal value for a Color
 	ColorNormalize      :: proc(color: Color) -> Vector4 ---                            // Get Color normalized as float [0..1]
@@ -1315,6 +1342,7 @@ foreign lib {
 	//------------------------------------------------------------------------------------
 
 	// 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, glyphCount: c.int) -> Font ---                                         // Load font from file with extended parameters, use NULL for fontChars and 0 for glyphCount to load the default character set
@@ -1328,6 +1356,7 @@ foreign lib {
 	ExportFontAsCode   :: proc(font: Font, fileName: cstring) -> bool ---                                                                                     // Export font as code file, returns true on success
 
 	// 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
@@ -1336,6 +1365,7 @@ foreign lib {
 	DrawTextCodepoints :: proc(font: Font, codepoints: [^]rune, count: c.int, position: Vector2, fontSize: f32, spacing: f32, tint: Color) ---    // Draw multiple character (codepoint)
 
 	// Text font info functions
+
 	MeasureText      :: proc(text: cstring, fontSize: c.int) -> c.int ---                               // Measure string width for default font
 	MeasureTextEx    :: proc(font: Font, text: cstring, fontSize: c.int, spacing: c.int) -> Vector2 --- // Measure string size for Font
 	GetGlyphIndex    :: proc(font: Font, codepoint: rune) -> c.int ---                                  // Get glyph index position in font for a codepoint (unicode character), fallback to '?' if not found
@@ -1343,6 +1373,7 @@ foreign lib {
 	GetGlyphAtlasRec :: proc(font: Font, codepoint: rune) -> Rectangle ---                              // Get glyph rectangle in font atlas for a codepoint (unicode character), fallback to '?' if not found
 
 	// Text codepoints management functions (unicode characters)
+
 	LoadUTF8             :: proc(codepoints: [^]rune, length: c.int) -> [^]byte --- // Load UTF-8 text encoded from codepoints array
 	UnloadUTF8           :: proc(text: [^]byte) ---                                 // Unload UTF-8 text encoded from codepoints array
 	LoadCodepoints       :: proc(text: rawptr, count: ^c.int) -> [^]rune ---        // Load all codepoints from a UTF-8 text string, codepoints count returned by parameter
@@ -1355,10 +1386,13 @@ foreign lib {
 
 	// Text strings management functions (no UTF-8 strings, only byte chars)
 	// NOTE: Some strings allocate memory internally for returned strings, just be careful!
+
 	TextCopy      :: proc(dst: [^]byte, 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 is defined at the bottom of this file
+
 	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) -> [^]byte ---                    // Replace text string (WARNING: memory must be freed!)
 	TextInsert    :: proc(text, insert: cstring, position: c.int) -> [^]byte ---                 // Insert text in a position (WARNING: memory must be freed!)
@@ -1377,6 +1411,7 @@ foreign lib {
 	//------------------------------------------------------------------------------------
 
 	// 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
@@ -1404,6 +1439,7 @@ foreign lib {
 	//------------------------------------------------------------------------------------
 
 	// Model management 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)
 	IsModelReady        :: proc(model: Model) -> bool ---        // Check if a model is ready
@@ -1411,6 +1447,7 @@ foreign lib {
 	GetModelBoundingBox :: proc(model: Model) -> BoundingBox --- // Compute model bounding box limits (considers all meshes)
 
 	// 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)
@@ -1421,6 +1458,7 @@ foreign lib {
 	DrawBillboardPro :: proc(camera: Camera, texture: Texture2D, source: Rectangle, position: Vector3, up: Vector3, size: Vector2, origin: Vector2, rotation: f32, tint: Color) --- // Draw a billboard texture defined by source and rotation
 
 	// Mesh management 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: c.int, offset: c.int) ---    // Update mesh vertex data in GPU for a specific buffer index
 	UnloadMesh         :: proc(mesh: Mesh) ---                                                                // Unload mesh data from CPU and GPU
@@ -1431,6 +1469,7 @@ foreign lib {
 	GenMeshTangents    :: proc(mesh: ^Mesh) ---                                                               // Compute mesh tangents
 
 	// Mesh generation functions
+
 	GenMeshPoly       :: proc(sides: c.int, radius: f32) -> Mesh ---               // Generate polygonal mesh
 	GenMeshPlane      :: proc(width, lengthL: f32, resX, resZ: c.int) -> Mesh ---  // Generate plane mesh (with subdivisions)
 	GenMeshCube       :: proc(width, height, length: f32) -> Mesh ---              // Generate cuboid mesh
@@ -1444,6 +1483,7 @@ foreign lib {
 	GenMeshCubicmap   :: proc(cubicmap: Image, cubeSize: Vector3) -> Mesh ---      // Generate cubes-based map mesh from image data
 
 	// 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)
 	IsMaterialReady       :: proc(material: Material) -> bool ---                                         // Check if a material is ready
@@ -1452,6 +1492,7 @@ foreign lib {
 	SetModelMeshMaterial  :: proc(model: ^Model, meshId: c.int, materialId: c.int) ---                    // Set material for a mesh
 
 	// Model animations loading/unloading functions
+
 	LoadModelAnimations   :: proc(fileName: cstring, animCount: ^c.uint) -> [^]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
@@ -1459,6 +1500,7 @@ foreign lib {
 	IsModelAnimationValid :: proc(model: Model, anim: ModelAnimation) -> bool ---                 // Check model animation skeleton match
 
 	// Collision detection functions
+
 	CheckCollisionSpheres   :: proc(center1: Vector3, radius1: f32, center2: Vector3, radius2: f32) -> bool --- // Check collision between two spheres
 	CheckCollisionBoxes     :: proc(box1, box2: BoundingBox) -> bool ---                                        // Check collision between two bounding boxes
 	CheckCollisionBoxSphere :: proc(box: BoundingBox, center: Vector3, radius: f32) -> bool ---                 // Check collision between box and sphere
@@ -1473,12 +1515,14 @@ foreign lib {
 	//------------------------------------------------------------------------------------
 
 	// 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'
 	IsWaveReady        :: proc(wave: Wave) -> bool ---                                           // Checks if wave data is ready
@@ -1492,6 +1536,7 @@ foreign lib {
 	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
@@ -1507,6 +1552,7 @@ foreign lib {
 	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
 	IsMusicReady              :: proc(music: Music) -> bool ---                                      // Checks if a music stream is ready
@@ -1525,6 +1571,7 @@ foreign lib {
 	GetMusicTimePlayed        :: proc(music: Music) -> f32 ---                                       // Get current music time played (in seconds)
 
 	// AudioStream management functions
+
 	LoadAudioStream                 :: proc(sampleRate, sampleSize: c.uint, channels: c.uint) -> AudioStream --- // Load audio stream (to stream raw audio pcm data)
 	IsAudioStreamReady              :: proc(stream: AudioStream) -> bool ---                                     // Checks if an audio stream is ready
 	UnloadAudioStream               :: proc(stream: AudioStream) ---                                             // Unload audio stream and free memory