Update cheatsheet for raylib 5.0

8 files changed, 91 insertions, 47 deletions

diff --git a/cheatsheet/cheatsheet.html b/cheatsheet/cheatsheet.html
index 94f1809..3aa3426 100644
--- a/cheatsheet/cheatsheet.html
+++ b/cheatsheet/cheatsheet.html
@@ -130,7 +130,7 @@
             <p id="title">A simple and easy-to-use library to enjoy videogames programming</p>
             <p id="plinks">[<a href="https://discord.gg/raylib">raylib Discord server</a>][<a href="https://github.com/raysan5/raylib">github.com/raysan5/raylib</a>][<a href="https://github.com/raysan5/raylib/blob/master/src/raylib.h">raylib.h</a>]</p>
             <p></p>
-            <p id="version">v4.5 quick reference card  [<a id="downpdf" href="https://www.raylib.com/cheatsheet/raylib_cheatsheet_v4.5.pdf">download as PDF</a>]</p>
+            <p id="version">v5.0 quick reference card  [<a id="downpdf" href="https://www.raylib.com/cheatsheet/raylib_cheatsheet_v5.0.pdf">download as PDF</a>]</p>
         </div>
         <br>
         <p>Chinese Translation: <a href="cheatsheet_zh.html">以下为raylib所有API接口中文释义</a></p>
diff --git a/cheatsheet/raylib_audio.c b/cheatsheet/raylib_audio.c
index 1cbb545..7b1b95f 100644
--- a/cheatsheet/raylib_audio.c
+++ b/cheatsheet/raylib_audio.c
@@ -3,6 +3,7 @@
     void CloseAudioDevice(void);                                    // Close the audio device and context
     bool IsAudioDeviceReady(void);                                  // Check if audio device has been initialized successfully
     void SetMasterVolume(float volume);                             // Set master volume (listener)
+    float GetMasterVolume(void);                                    // Get master volume (listener)
 
     // Wave/Sound loading/unloading functions
     Wave LoadWave(const char *fileName);                            // Load wave data from file
@@ -10,10 +11,12 @@
     bool IsWaveReady(Wave wave);                                    // Checks if wave data is ready
     Sound LoadSound(const char *fileName);                          // Load sound from file
     Sound LoadSoundFromWave(Wave wave);                             // Load sound from wave data
+    Sound LoadSoundAlias(Sound source);                             // Create a new sound that shares the same sample data as the source sound, does not own the sound data
     bool IsSoundReady(Sound sound);                                 // Checks if a sound is ready
     void UpdateSound(Sound sound, const void *data, int sampleCount); // Update sound buffer with new data
     void UnloadWave(Wave wave);                                     // Unload wave data
     void UnloadSound(Sound sound);                                  // Unload sound
+    void UnloadSoundAlias(Sound alias);                             // Unload a sound alias (does not deallocate sample data)
     bool ExportWave(Wave wave, const char *fileName);               // Export wave data to file, returns true on success
     bool ExportWaveAsCode(Wave wave, const char *fileName);         // Export wave sample data to code (.h), returns true on success
 
@@ -65,11 +68,11 @@
     void SetAudioStreamPitch(AudioStream stream, float pitch);      // Set pitch for audio stream (1.0 is base level)
     void SetAudioStreamPan(AudioStream stream, float pan);          // Set pan for audio stream (0.5 is centered)
     void SetAudioStreamBufferSizeDefault(int size);                 // Default size for new audio streams
-    void SetAudioStreamCallback(AudioStream stream, AudioCallback callback);  // Audio thread callback to request new data
+    void SetAudioStreamCallback(AudioStream stream, AudioCallback callback); // Audio thread callback to request new data
 
-    void AttachAudioStreamProcessor(AudioStream stream, AudioCallback processor); // Attach audio stream processor to stream
+    void AttachAudioStreamProcessor(AudioStream stream, AudioCallback processor); // Attach audio stream processor to stream, receives the samples as <float>s
     void DetachAudioStreamProcessor(AudioStream stream, AudioCallback processor); // Detach audio stream processor from stream
 
-    void AttachAudioMixedProcessor(AudioCallback processor); // Attach audio stream processor to the entire audio pipeline
+    void AttachAudioMixedProcessor(AudioCallback processor); // Attach audio stream processor to the entire audio pipeline, receives the samples as <float>s
     void DetachAudioMixedProcessor(AudioCallback processor); // Detach audio stream processor from the entire audio pipeline
 
diff --git a/cheatsheet/raylib_core.c b/cheatsheet/raylib_core.c
index 1297387..5f5b5e5 100644
--- a/cheatsheet/raylib_core.c
+++ b/cheatsheet/raylib_core.c
@@ -1,9 +1,8 @@
 
-
     // Window-related functions
     void InitWindow(int width, int height, const char *title);  // Initialize window and OpenGL context
-    bool WindowShouldClose(void);                               // Check if KEY_ESCAPE pressed or Close icon pressed
     void CloseWindow(void);                                     // Close window and unload OpenGL context
+    bool WindowShouldClose(void);                               // Check if application should close (KEY_ESCAPE pressed or windows close icon clicked)
     bool IsWindowReady(void);                                   // Check if window has been initialized successfully
     bool IsWindowFullscreen(void);                              // Check if window is currently fullscreen
     bool IsWindowHidden(void);                                  // Check if window is currently hidden (only PLATFORM_DESKTOP)
@@ -15,17 +14,20 @@
     void SetWindowState(unsigned int flags);                    // Set window configuration state using flags (only PLATFORM_DESKTOP)
     void ClearWindowState(unsigned int flags);                  // Clear window configuration state flags
     void ToggleFullscreen(void);                                // Toggle window state: fullscreen/windowed (only PLATFORM_DESKTOP)
+    void ToggleBorderlessWindowed(void);                        // Toggle window state: borderless windowed (only PLATFORM_DESKTOP)
     void MaximizeWindow(void);                                  // Set window state: maximized, if resizable (only PLATFORM_DESKTOP)
     void MinimizeWindow(void);                                  // Set window state: minimized, if resizable (only PLATFORM_DESKTOP)
     void RestoreWindow(void);                                   // Set window state: not minimized/maximized (only PLATFORM_DESKTOP)
     void SetWindowIcon(Image image);                            // Set icon for window (single image, RGBA 32bit, only PLATFORM_DESKTOP)
     void SetWindowIcons(Image *images, int count);              // Set icon for window (multiple images, RGBA 32bit, only PLATFORM_DESKTOP)
-    void SetWindowTitle(const char *title);                     // Set title for window (only PLATFORM_DESKTOP)
+    void SetWindowTitle(const char *title);                     // Set title for window (only PLATFORM_DESKTOP and PLATFORM_WEB)
     void SetWindowPosition(int x, int y);                       // Set window position on screen (only PLATFORM_DESKTOP)
-    void SetWindowMonitor(int monitor);                         // Set monitor for the current window (fullscreen mode)
+    void SetWindowMonitor(int monitor);                         // Set monitor for the current window
     void SetWindowMinSize(int width, int height);               // Set window minimum dimensions (for FLAG_WINDOW_RESIZABLE)
+    void SetWindowMaxSize(int width, int height);               // Set window maximum dimensions (for FLAG_WINDOW_RESIZABLE)
     void SetWindowSize(int width, int height);                  // Set window dimensions
     void SetWindowOpacity(float opacity);                       // Set window opacity [0.0f..1.0f] (only PLATFORM_DESKTOP)
+    void SetWindowFocused(void);                                // Set window focused (only PLATFORM_DESKTOP)
     void *GetWindowHandle(void);                                // Get native window handle
     int GetScreenWidth(void);                                   // Get current screen width
     int GetScreenHeight(void);                                  // Get current screen height
@@ -47,14 +49,6 @@
     void EnableEventWaiting(void);                              // Enable waiting for events on EndDrawing(), no automatic event polling
     void DisableEventWaiting(void);                             // Disable waiting for events on EndDrawing(), automatic events polling
 
-    // Custom frame control functions
-    // NOTE: Those functions are intended for advance users that want full control over the frame processing
-    // By default EndDrawing() does this job: draws everything + SwapScreenBuffer() + manage frame timing + PollInputEvents()
-    // To avoid that behaviour and control frame processes manually, enable in config.h: SUPPORT_CUSTOM_FRAME_CONTROL
-    void SwapScreenBuffer(void);                                // Swap back buffer with front buffer (screen drawing)
-    void PollInputEvents(void);                                 // Register all input events
-    void WaitTime(double seconds);                              // Wait for some time (halt program execution)
-
     // Cursor-related functions
     void ShowCursor(void);                                      // Shows cursor
     void HideCursor(void);                                      // Hides cursor
@@ -110,24 +104,37 @@
 
     // Timing-related functions
     void SetTargetFPS(int fps);                                 // Set target FPS (maximum)
-    int GetFPS(void);                                           // Get current FPS
     float GetFrameTime(void);                                   // Get time in seconds for last frame drawn (delta time)
     double GetTime(void);                                       // Get elapsed time in seconds since InitWindow()
+    int GetFPS(void);                                           // Get current FPS
 
-    // Misc. functions
-    int GetRandomValue(int min, int max);                       // Get a random value between min and max (both included)
+    // Custom frame control functions
+    // NOTE: Those functions are intended for advance users that want full control over the frame processing
+    // By default EndDrawing() does this job: draws everything + SwapScreenBuffer() + manage frame timing + PollInputEvents()
+    // To avoid that behaviour and control frame processes manually, enable in config.h: SUPPORT_CUSTOM_FRAME_CONTROL
+    void SwapScreenBuffer(void);                                // Swap back buffer with front buffer (screen drawing)
+    void PollInputEvents(void);                                 // Register all input events
+    void WaitTime(double seconds);                              // Wait for some time (halt program execution)
+
+    // Random values generation functions
     void SetRandomSeed(unsigned int seed);                      // Set the seed for the random number generator
+    int GetRandomValue(int min, int max);                       // Get a random value between min and max (both included)
+    int *LoadRandomSequence(unsigned int count, int min, int max); // Load random values sequence, no values repeated
+    void UnloadRandomSequence(int *sequence);                   // Unload random values sequence
+
+    // Misc. functions
     void TakeScreenshot(const char *fileName);                  // Takes a screenshot of current screen (filename extension defines format)
     void SetConfigFlags(unsigned int flags);                    // Setup init configuration flags (view FLAGS)
+    void OpenURL(const char *url);                              // Open URL with default system browser (if available)
 
+    // NOTE: Following functions implemented in module [utils]
+    //------------------------------------------------------------------
     void TraceLog(int logLevel, const char *text, ...);         // Show trace log messages (LOG_DEBUG, LOG_INFO, LOG_WARNING, LOG_ERROR...)
     void SetTraceLogLevel(int logLevel);                        // Set the current threshold (minimum) log level
     void *MemAlloc(unsigned int size);                          // Internal memory allocator
     void *MemRealloc(void *ptr, unsigned int size);             // Internal memory reallocator
     void MemFree(void *ptr);                                    // Internal memory free
 
-    void OpenURL(const char *url);                              // Open URL with default system browser (if available)
-
     // Set custom callbacks
     // WARNING: Callbacks setup is intended for advance users
     void SetTraceLogCallback(TraceLogCallback callback);         // Set custom trace log
@@ -137,13 +144,16 @@
     void SetSaveFileTextCallback(SaveFileTextCallback callback); // Set custom file text data saver
 
     // Files management functions
-    unsigned char *LoadFileData(const char *fileName, unsigned int *bytesRead);       // Load file data as byte array (read)
+    unsigned char *LoadFileData(const char *fileName, int *dataSize); // Load file data as byte array (read)
     void UnloadFileData(unsigned char *data);                   // Unload file data allocated by LoadFileData()
-    bool SaveFileData(const char *fileName, void *data, unsigned int bytesToWrite);   // Save data to file from byte array (write), returns true on success
-    bool ExportDataAsCode(const unsigned char *data, unsigned int size, const char *fileName); // Export data to code (.h), returns true on success
+    bool SaveFileData(const char *fileName, void *data, int dataSize); // Save data to file from byte array (write), returns true on success
+    bool ExportDataAsCode(const unsigned char *data, int dataSize, const char *fileName); // Export data to code (.h), returns true on success
     char *LoadFileText(const char *fileName);                   // Load text data from file (read), returns a '\0' terminated string
     void UnloadFileText(char *text);                            // Unload file text data allocated by LoadFileText()
     bool SaveFileText(const char *fileName, char *text);        // Save text data to file (write), string must be '\0' terminated, returns true on success
+    //------------------------------------------------------------------
+
+    // File system functions
     bool FileExists(const char *fileName);                      // Check if file exists
     bool DirectoryExists(const char *dirPath);                  // Check if a directory path exists
     bool IsFileExtension(const char *fileName, const char *ext); // Check file extension (including point: .png, .wav)
@@ -154,7 +164,7 @@
     const char *GetDirectoryPath(const char *filePath);         // Get full path for a given fileName with path (uses static string)
     const char *GetPrevDirectoryPath(const char *dirPath);      // Get previous directory path for a given path (uses static string)
     const char *GetWorkingDirectory(void);                      // Get current working directory (uses static string)
-    const char *GetApplicationDirectory(void);                  // Get the directory if the running application (uses static string)
+    const char *GetApplicationDirectory(void);                  // Get the directory of the running application (uses static string)
     bool ChangeDirectory(const char *dir);                      // Change working directory, return true on success
     bool IsPathFile(const char *path);                          // Check if a given path is a file or a directory
     FilePathList LoadDirectoryFiles(const char *dirPath);       // Load directory filepaths
@@ -171,18 +181,29 @@
     char *EncodeDataBase64(const unsigned char *data, int dataSize, int *outputSize);               // Encode data to Base64 string, memory must be MemFree()
     unsigned char *DecodeDataBase64(const unsigned char *data, int *outputSize);                    // Decode Base64 string data, memory must be MemFree()
 
+    // Automation events functionality
+    AutomationEventList LoadAutomationEventList(const char *fileName);                // Load automation events list from file, NULL for empty list, capacity = MAX_AUTOMATION_EVENTS
+    void UnloadAutomationEventList(AutomationEventList *list);                        // Unload automation events list from file
+    bool ExportAutomationEventList(AutomationEventList list, const char *fileName);   // Export automation events list as text file
+    void SetAutomationEventList(AutomationEventList *list);                           // Set automation event list to record to
+    void SetAutomationEventBaseFrame(int frame);                                      // Set automation event internal base frame to start recording
+    void StartAutomationEventRecording(void);                                         // Start recording automation events (AutomationEventList must be set)
+    void StopAutomationEventRecording(void);                                          // Stop recording automation events
+    void PlayAutomationEvent(AutomationEvent event);                                  // Play a recorded automation event
+
     //------------------------------------------------------------------------------------
     // Input Handling Functions (Module: core)
     //------------------------------------------------------------------------------------
 
     // Input-related functions: keyboard
     bool IsKeyPressed(int key);                             // Check if a key has been pressed once
+    bool IsKeyPressedRepeat(int key);                       // Check if a key has been pressed again (Only PLATFORM_DESKTOP)
     bool IsKeyDown(int key);                                // Check if a key is being pressed
     bool IsKeyReleased(int key);                            // Check if a key has been released once
     bool IsKeyUp(int key);                                  // Check if a key is NOT being pressed
-    void SetExitKey(int key);                               // Set a custom key to exit program (default is ESC)
     int GetKeyPressed(void);                                // Get key pressed (keycode), call it multiple times for keys queued, returns 0 when the queue is empty
     int GetCharPressed(void);                               // Get char pressed (unicode), call it multiple times for chars queued, returns 0 when the queue is empty
+    void SetExitKey(int key);                               // Set a custom key to exit program (default is ESC)
 
     // Input-related functions: gamepads
     bool IsGamepadAvailable(int gamepad);                   // Check if a gamepad is available
@@ -223,7 +244,7 @@
     // Gestures and Touch Handling Functions (Module: rgestures)
     //------------------------------------------------------------------------------------
     void SetGesturesEnabled(unsigned int flags);      // Enable a set of gestures using flags
-    bool IsGestureDetected(int gesture);              // Check if a gesture have been detected
+    bool IsGestureDetected(unsigned int gesture);     // Check if a gesture have been detected
     int GetGestureDetected(void);                     // Get latest detected gesture
     float GetGestureHoldDuration(void);               // Get gesture hold time in milliseconds
     Vector2 GetGestureDragVector(void);               // Get gesture drag vector
diff --git a/cheatsheet/raylib_models.c b/cheatsheet/raylib_models.c
index 33332f3..015ffbe 100644
--- a/cheatsheet/raylib_models.c
+++ b/cheatsheet/raylib_models.c
@@ -1,4 +1,3 @@
-
     // Basic geometric 3D shapes drawing functions
     void DrawLine3D(Vector3 startPos, Vector3 endPos, Color color);                                    // Draw a line in 3D world space
     void DrawPoint3D(Vector3 position, Color color);                                                   // Draw a point in 3D space, actually a small line
@@ -75,10 +74,10 @@
     void SetModelMeshMaterial(Model *model, int meshId, int materialId);                  // Set material for a mesh
 
     // Model animations loading/unloading functions
-    ModelAnimation *LoadModelAnimations(const char *fileName, unsigned int *animCount);   // Load model animations from file
+    ModelAnimation *LoadModelAnimations(const char *fileName, int *animCount);            // Load model animations from file
     void UpdateModelAnimation(Model model, ModelAnimation anim, int frame);               // Update model animation pose
     void UnloadModelAnimation(ModelAnimation anim);                                       // Unload animation data
-    void UnloadModelAnimations(ModelAnimation *animations, unsigned int count);           // Unload animation array data
+    void UnloadModelAnimations(ModelAnimation *animations, int animCount);                // Unload animation array data
     bool IsModelAnimationValid(Model model, ModelAnimation anim);                         // Check model animation skeleton match
 
     // Collision detection functions
diff --git a/cheatsheet/raylib_shapes.c b/cheatsheet/raylib_shapes.c
index 465b240..acdc468 100644
--- a/cheatsheet/raylib_shapes.c
+++ b/cheatsheet/raylib_shapes.c
@@ -1,4 +1,3 @@
-
     // 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
     void SetShapesTexture(Texture2D texture, Rectangle source);       // Set texture and rectangle to be used on shapes drawing
@@ -7,18 +6,17 @@
     void DrawPixel(int posX, int posY, Color color);                                                   // Draw a pixel
     void DrawPixelV(Vector2 position, Color color);                                                    // Draw a pixel (Vector version)
     void DrawLine(int startPosX, int startPosY, int endPosX, int endPosY, Color color);                // Draw a line
-    void DrawLineV(Vector2 startPos, Vector2 endPos, Color color);                                     // Draw a line (Vector version)
-    void DrawLineEx(Vector2 startPos, Vector2 endPos, float thick, Color color);                       // Draw a line defining thickness
-    void DrawLineBezier(Vector2 startPos, Vector2 endPos, float thick, Color color);                   // Draw a line using cubic-bezier curves in-out
-    void DrawLineBezierQuad(Vector2 startPos, Vector2 endPos, Vector2 controlPos, float thick, Color color); // Draw line using quadratic bezier curves with a control point
-    void DrawLineBezierCubic(Vector2 startPos, Vector2 endPos, Vector2 startControlPos, Vector2 endControlPos, float thick, Color color); // Draw line using cubic bezier curves with 2 control points
-    void DrawLineStrip(Vector2 *points, int pointCount, Color color);                                  // Draw lines sequence
+    void DrawLineV(Vector2 startPos, Vector2 endPos, Color color);                                     // Draw a line (using gl lines)
+    void DrawLineEx(Vector2 startPos, Vector2 endPos, float thick, Color color);                       // Draw a line (using triangles/quads)
+    void DrawLineStrip(Vector2 *points, int pointCount, Color color);                                  // Draw lines sequence (using gl lines)
+    void DrawLineBezier(Vector2 startPos, Vector2 endPos, float thick, Color color);                   // Draw line segment cubic-bezier in-out interpolation
     void DrawCircle(int centerX, int centerY, float radius, Color color);                              // Draw a color-filled circle
     void DrawCircleSector(Vector2 center, float radius, float startAngle, float endAngle, int segments, Color color);      // Draw a piece of a circle
     void DrawCircleSectorLines(Vector2 center, float radius, float startAngle, float endAngle, int segments, Color color); // Draw circle sector outline
     void DrawCircleGradient(int centerX, int centerY, float radius, Color color1, Color color2);       // Draw a gradient-filled circle
     void DrawCircleV(Vector2 center, float radius, Color color);                                       // Draw a color-filled circle (Vector version)
     void DrawCircleLines(int centerX, int centerY, float radius, Color color);                         // Draw circle outline
+    void DrawCircleLinesV(Vector2 center, float radius, Color color);                                  // Draw circle outline (Vector version)
     void DrawEllipse(int centerX, int centerY, float radiusH, float radiusV, Color color);             // Draw ellipse
     void DrawEllipseLines(int centerX, int centerY, float radiusH, float radiusV, Color color);        // Draw ellipse outline
     void DrawRing(Vector2 center, float innerRadius, float outerRadius, float startAngle, float endAngle, int segments, Color color); // Draw ring
@@ -42,6 +40,25 @@
     void DrawPolyLines(Vector2 center, int sides, float radius, float rotation, Color color);          // Draw a polygon outline of n sides
     void DrawPolyLinesEx(Vector2 center, int sides, float radius, float rotation, float lineThick, Color color); // Draw a polygon outline of n sides with extended parameters
 
+    // Splines drawing functions
+    void DrawSplineLinear(Vector2 *points, int pointCount, float thick, Color color);                  // Draw spline: Linear, minimum 2 points
+    void DrawSplineBasis(Vector2 *points, int pointCount, float thick, Color color);                   // Draw spline: B-Spline, minimum 4 points
+    void DrawSplineCatmullRom(Vector2 *points, int pointCount, float thick, Color color);              // Draw spline: Catmull-Rom, minimum 4 points
+    void DrawSplineBezierQuadratic(Vector2 *points, int pointCount, float thick, Color color);         // Draw spline: Quadratic Bezier, minimum 3 points (1 control point): [p1, c2, p3, c4...]
+    void DrawSplineBezierCubic(Vector2 *points, int pointCount, float thick, Color color);             // Draw spline: Cubic Bezier, minimum 4 points (2 control points): [p1, c2, c3, p4, c5, c6...]
+    void DrawSplineSegmentLinear(Vector2 p1, Vector2 p2, float thick, Color color);                    // Draw spline segment: Linear, 2 points
+    void DrawSplineSegmentBasis(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, float thick, Color color); // Draw spline segment: B-Spline, 4 points
+    void DrawSplineSegmentCatmullRom(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, float thick, Color color); // Draw spline segment: Catmull-Rom, 4 points
+    void DrawSplineSegmentBezierQuadratic(Vector2 p1, Vector2 c2, Vector2 p3, float thick, Color color); // Draw spline segment: Quadratic Bezier, 2 points, 1 control point
+    void DrawSplineSegmentBezierCubic(Vector2 p1, Vector2 c2, Vector2 c3, Vector2 p4, float thick, Color color); // Draw spline segment: Cubic Bezier, 2 points, 2 control points
+
+    // Spline segment point evaluation functions, for a given t [0.0f .. 1.0f]
+    Vector2 GetSplinePointLinear(Vector2 startPos, Vector2 endPos, float t);                           // Get (evaluate) spline point: Linear
+    Vector2 GetSplinePointBasis(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, float t);              // Get (evaluate) spline point: B-Spline
+    Vector2 GetSplinePointCatmullRom(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, float t);         // Get (evaluate) spline point: Catmull-Rom
+    Vector2 GetSplinePointBezierQuad(Vector2 p1, Vector2 c2, Vector2 p3, float t);                     // Get (evaluate) spline point: Quadratic Bezier
+    Vector2 GetSplinePointBezierCubic(Vector2 p1, Vector2 c2, Vector2 c3, Vector2 p4, float t);        // Get (evaluate) spline point: Cubic Bezier
+
     // Basic shapes collision detection functions
     bool CheckCollisionRecs(Rectangle rec1, Rectangle rec2);                                           // Check collision between two rectangles
     bool CheckCollisionCircles(Vector2 center1, float radius1, Vector2 center2, float radius2);        // Check collision between two circles
diff --git a/cheatsheet/raylib_structs.c b/cheatsheet/raylib_structs.c
index e271600..38101a4 100644
--- a/cheatsheet/raylib_structs.c
+++ b/cheatsheet/raylib_structs.c
@@ -36,3 +36,6 @@
     struct VrStereoConfig;         // VrStereoConfig, VR stereo rendering configuration for simulator
 
     struct FilePathList;           // File path list
+
+    struct AutomationEvent;        // Automation event
+    struct AutomationEventList;    // Automation event list
diff --git a/cheatsheet/raylib_text.c b/cheatsheet/raylib_text.c
index 8c41fe4..4dcd4c8 100644
--- a/cheatsheet/raylib_text.c
+++ b/cheatsheet/raylib_text.c
@@ -1,14 +1,13 @@
-
     // Font loading/unloading functions
     Font GetFontDefault(void);                                                            // Get the default Font
     Font LoadFont(const char *fileName);                                                  // Load font from file into GPU memory (VRAM)
-    Font LoadFontEx(const char *fileName, int fontSize, int *fontChars, int glyphCount);  // Load font from file with extended parameters, use NULL for fontChars and 0 for glyphCount to load the default character set
+    Font LoadFontEx(const char *fileName, int fontSize, int *codepoints, int codepointCount);  // Load font from file with extended parameters, use NULL for codepoints and 0 for codepointCount to load the default character set
     Font LoadFontFromImage(Image image, Color key, int firstChar);                        // Load font from Image (XNA style)
-    Font LoadFontFromMemory(const char *fileType, const unsigned char *fileData, int dataSize, int fontSize, int *fontChars, int glyphCount); // Load font from memory buffer, fileType refers to extension: i.e. '.ttf'
+    Font LoadFontFromMemory(const char *fileType, const unsigned char *fileData, int dataSize, int fontSize, int *codepoints, int codepointCount); // Load font from memory buffer, fileType refers to extension: i.e. '.ttf'
     bool IsFontReady(Font font);                                                          // Check if a font is ready
-    GlyphInfo *LoadFontData(const unsigned char *fileData, int dataSize, int fontSize, int *fontChars, int glyphCount, int type); // Load font data for further use
-    Image GenImageFontAtlas(const GlyphInfo *chars, Rectangle **recs, int glyphCount, int fontSize, int padding, int packMethod); // Generate image font atlas using chars info
-    void UnloadFontData(GlyphInfo *chars, int glyphCount);                                // Unload font chars info data (RAM)
+    GlyphInfo *LoadFontData(const unsigned char *fileData, int dataSize, int fontSize, int *codepoints, int codepointCount, int type); // Load font data for further use
+    Image GenImageFontAtlas(const GlyphInfo *glyphs, Rectangle **glyphRecs, int glyphCount, int fontSize, int padding, int packMethod); // Generate image font atlas using chars info
+    void UnloadFontData(GlyphInfo *glyphs, int glyphCount);                               // Unload font chars info data (RAM)
     void UnloadFont(Font font);                                                           // Unload font from GPU memory (VRAM)
     bool ExportFontAsCode(Font font, const char *fileName);                               // Export font as code file, returns true on success
 
@@ -18,9 +17,10 @@
     void DrawTextEx(Font font, const char *text, Vector2 position, float fontSize, float spacing, Color tint); // Draw text using font and additional parameters
     void DrawTextPro(Font font, const char *text, Vector2 position, Vector2 origin, float rotation, float fontSize, float spacing, Color tint); // Draw text using Font and pro parameters (rotation)
     void DrawTextCodepoint(Font font, int codepoint, Vector2 position, float fontSize, Color tint); // Draw one character (codepoint)
-    void DrawTextCodepoints(Font font, const int *codepoints, int count, Vector2 position, float fontSize, float spacing, Color tint); // Draw multiple character (codepoint)
+    void DrawTextCodepoints(Font font, const int *codepoints, int codepointCount, Vector2 position, float fontSize, float spacing, Color tint); // Draw multiple character (codepoint)
 
     // Text font info functions
+    void SetTextLineSpacing(int spacing);                                                 // Set vertical line spacing when drawing with line-breaks
     int MeasureText(const char *text, int fontSize);                                      // Measure string width for default font
     Vector2 MeasureTextEx(Font font, const char *text, float fontSize, float spacing);    // Measure string size for Font
     int GetGlyphIndex(Font font, int codepoint);                                          // Get glyph index position in font for a codepoint (unicode character), fallback to '?' if not found
diff --git a/cheatsheet/raylib_textures.c b/cheatsheet/raylib_textures.c
index f47c97c..5199964 100644
--- a/cheatsheet/raylib_textures.c
+++ b/cheatsheet/raylib_textures.c
@@ -1,8 +1,8 @@
-
     // Image loading functions
     // NOTE: These functions do not require GPU access
     Image LoadImage(const char *fileName);                                                             // Load image from file into CPU memory (RAM)
     Image LoadImageRaw(const char *fileName, int width, int height, int format, int headerSize);       // Load image from RAW file data
+    Image LoadImageSvg(const char *fileNameOrString, int width, int height);                           // Load image from SVG file data or string with specified size
     Image LoadImageAnim(const char *fileName, int *frames);                                            // Load image sequence from file (frames appended to image.data)
     Image LoadImageFromMemory(const char *fileType, const unsigned char *fileData, int dataSize);      // Load image from memory buffer, fileType refers to extension: i.e. '.png'
     Image LoadImageFromTexture(Texture2D texture);                                                     // Load image from GPU texture data
@@ -10,6 +10,7 @@
     bool IsImageReady(Image image);                                                                    // Check if an image is ready
     void UnloadImage(Image image);                                                                     // Unload image from CPU memory (RAM)
     bool ExportImage(Image image, const char *fileName);                                               // Export image data to file, returns true on success
+    unsigned char *ExportImageToMemory(Image image, const char *fileType, int *fileSize);              // Export image to memory buffer
     bool ExportImageAsCode(Image image, const char *fileName);                                         // Export image as code file defining an array of bytes, returns true on success
 
     // Image generation functions
@@ -43,7 +44,7 @@
     void ImageDither(Image *image, int rBpp, int gBpp, int bBpp, int aBpp);                            // Dither image data to 16bpp or lower (Floyd-Steinberg dithering)
     void ImageFlipVertical(Image *image);                                                              // Flip image vertically
     void ImageFlipHorizontal(Image *image);                                                            // Flip image horizontally
-    void ImageRotate(Image *image, int degrees);                                                       // Rotate image by input angle in degrees (-359 to 359) 
+    void ImageRotate(Image *image, int degrees);                                                       // Rotate image by input angle in degrees (-359 to 359)
     void ImageRotateCW(Image *image);                                                                  // Rotate image clockwise 90deg
     void ImageRotateCCW(Image *image);                                                                 // Rotate image counter-clockwise 90deg
     void ImageColorTint(Image *image, Color color);                                                    // Modify image color: tint
@@ -86,7 +87,7 @@
     RenderTexture2D LoadRenderTexture(int width, int height);                                          // Load texture for rendering (framebuffer)
     bool IsTextureReady(Texture2D texture);                                                            // Check if a texture is ready
     void UnloadTexture(Texture2D texture);                                                             // Unload texture from GPU memory (VRAM)
-    bool IsRenderTextureReady(RenderTexture2D target);                                                       // Check if a render texture is ready
+    bool IsRenderTextureReady(RenderTexture2D target);                                                 // Check if a render texture is ready
     void UnloadRenderTexture(RenderTexture2D target);                                                  // Unload render texture from GPU memory (VRAM)
     void UpdateTexture(Texture2D texture, const void *pixels);                                         // Update GPU texture with new data
     void UpdateTextureRec(Texture2D texture, Rectangle rec, const void *pixels);                       // Update GPU texture rectangle with new data