Update cheatsheet for raylib 3.5

8 files changed, 145 insertions, 111 deletions

diff --git a/cheatsheet/cheatsheet.html b/cheatsheet/cheatsheet.html
index 92f17ad..5e7b94b 100644
--- a/cheatsheet/cheatsheet.html
+++ b/cheatsheet/cheatsheet.html
@@ -135,7 +135,7 @@
             <p id="title">A simple and easy-to-use library to enjoy videogames programming</p>
             <p id="plinks">[<a href="https://discordapp.com/invite/VkzNHUE">raylib Discord server</a>][<a href="https://github.com/raysan5/raylib">github.com/raysan5/raylib</a>]</p>
             <p></p>
-            <p id="version">v3.0 quick reference card  [<a id="downpdf" href="raylib_cheatsheet.pdf">download as PDF</a>]</p>
+            <p id="version">v3.5 quick reference card  [<a id="downpdf" href="raylib_cheatsheet.pdf">download as PDF</a>]</p>
         </div>
         <br>
         <div id="fulldata">
diff --git a/cheatsheet/raylib_audio.c b/cheatsheet/raylib_audio.c
index e6f9793..396dd61 100644
--- a/cheatsheet/raylib_audio.c
+++ b/cheatsheet/raylib_audio.c
@@ -1,19 +1,20 @@
 
     // Audio device management functions
     void InitAudioDevice(void);                                                     // Initialize audio device and context
-    void CloseAudioDevice(void);                                                    // Close the audio device and context (and music stream)
-    bool IsAudioDeviceReady(void);                                                  // Check if audio device is ready
+    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)
 
     // Wave/Sound loading/unloading functions
     Wave LoadWave(const char *fileName);                                            // Load wave data from file
+    Wave LoadWaveFromMemory(const char *fileType, const unsigned char *fileData, int dataSize); // Load wave from memory buffer
     Sound LoadSound(const char *fileName);                                          // Load sound from file
     Sound LoadSoundFromWave(Wave wave);                                             // Load sound from wave data
     void UpdateSound(Sound sound, const void *data, int samplesCount);              // Update sound buffer with new data
     void UnloadWave(Wave wave);                                                     // Unload wave data
     void UnloadSound(Sound sound);                                                  // Unload sound
-    void ExportWave(Wave wave, const char *fileName);                               // Export wave data to file
-    void ExportWaveAsCode(Wave wave, const char *fileName);                         // Export wave sample data to code (.h)
+    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
 
     // Wave/Sound management functions
     void PlaySound(Sound sound);                                                    // Play a sound
@@ -29,7 +30,8 @@
     void WaveFormat(Wave *wave, int sampleRate, int sampleSize, int channels);      // Convert wave data to desired format
     Wave WaveCopy(Wave wave);                                                       // Copy a wave to a new wave
     void WaveCrop(Wave *wave, int initSample, int finalSample);                     // Crop a wave to defined samples range
-    float *GetWaveData(Wave wave);                                                  // Get samples data from wave as a floats array
+    float *LoadWaveSamples(Wave wave);                                              // Load samples data from wave as a floats array
+    void UnloadWaveSamples(float *samples);                                         // Unload samples data loaded with LoadWaveSamples()
 
     // Music management functions
     Music LoadMusicStream(const char *fileName);                                    // Load music stream from file
@@ -42,7 +44,6 @@
     bool IsMusicPlaying(Music music);                                               // Check if music is playing
     void SetMusicVolume(Music music, float volume);                                 // Set volume for music (1.0 is max level)
     void SetMusicPitch(Music music, float pitch);                                   // Set pitch for a music (1.0 is base level)
-    void SetMusicLoopCount(Music music, int count);                                 // Set music loop count (loop repeats)
     float GetMusicTimeLength(Music music);                                          // Get music time length (in seconds)
     float GetMusicTimePlayed(Music music);                                          // Get current music time played (in seconds)
 
diff --git a/cheatsheet/raylib_core.c b/cheatsheet/raylib_core.c
index 4d08523..cd54384 100644
--- a/cheatsheet/raylib_core.c
+++ b/cheatsheet/raylib_core.c
@@ -4,13 +4,19 @@
     bool WindowShouldClose(void);                                           // Check if KEY_ESCAPE pressed or Close icon pressed
     void CloseWindow(void);                                                 // Close window and unload OpenGL context
     bool IsWindowReady(void);                                               // Check if window has been initialized successfully
-    bool IsWindowMinimized(void);                                           // Check if window has been minimized (or lost focus)
-    bool IsWindowResized(void);                                             // Check if window has been resized
-    bool IsWindowHidden(void);                                              // Check if window is currently hidden
     bool IsWindowFullscreen(void);                                          // Check if window is currently fullscreen
-    void ToggleFullscreen(void);                                            // Toggle fullscreen mode (only PLATFORM_DESKTOP)
-    void UnhideWindow(void);                                                // Show the window
-    void HideWindow(void);                                                  // Hide the window
+    bool IsWindowHidden(void);                                              // Check if window is currently hidden (only PLATFORM_DESKTOP)
+    bool IsWindowMinimized(void);                                           // Check if window is currently minimized (only PLATFORM_DESKTOP)
+    bool IsWindowMaximized(void);                                           // Check if window is currently maximized (only PLATFORM_DESKTOP)
+    bool IsWindowFocused(void);                                             // Check if window is currently focused (only PLATFORM_DESKTOP)
+    bool IsWindowResized(void);                                             // Check if window has been resized last frame
+    bool IsWindowState(unsigned int flag);                                  // Check if one specific window flag is enabled
+    void SetWindowState(unsigned int flags);                                // Set window configuration state using flags
+    void ClearWindowState(unsigned int flags);                              // Clear window configuration state flags
+    void ToggleFullscreen(void);                                            // Toggle window state: fullscreen/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 (only PLATFORM_DESKTOP)
     void SetWindowTitle(const char *title);                                 // Set title for window (only PLATFORM_DESKTOP)
     void SetWindowPosition(int x, int y);                                   // Set window position on screen (only PLATFORM_DESKTOP)
@@ -21,22 +27,26 @@
     int GetScreenWidth(void);                                               // Get current screen width
     int GetScreenHeight(void);                                              // Get current screen height
     int GetMonitorCount(void);                                              // Get number of connected monitors
-    int GetMonitorWidth(int monitor);                                       // Get primary monitor width
-    int GetMonitorHeight(int monitor);                                      // Get primary monitor height
-    int GetMonitorPhysicalWidth(int monitor);                               // Get primary monitor physical width in millimetres
-    int GetMonitorPhysicalHeight(int monitor);                              // Get primary monitor physical height in millimetres
+    Vector2 GetMonitorPosition(int monitor);                                // Get specified monitor position
+    int GetMonitorWidth(int monitor);                                       // Get specified monitor width
+    int GetMonitorHeight(int monitor);                                      // Get specified monitor height
+    int GetMonitorPhysicalWidth(int monitor);                               // Get specified monitor physical width in millimetres
+    int GetMonitorPhysicalHeight(int monitor);                              // Get specified monitor physical height in millimetres
+    int GetMonitorRefreshRate(int monitor);                                 // Get specified monitor refresh rate
     Vector2 GetWindowPosition(void);                                        // Get window position XY on monitor
+    Vector2 GetWindowScaleDPI(void);                                        // Get window scale DPI factor
     const char *GetMonitorName(int monitor);                                // Get the human-readable, UTF-8 encoded name of the primary monitor
-    const char *GetClipboardText(void);                                     // Get clipboard text content
     void SetClipboardText(const char *text);                                // Set clipboard text content
-                
+    const char *GetClipboardText(void);                                     // Get clipboard text content
+            
     // Cursor-related functions         
     void ShowCursor(void);                                                  // Shows cursor
     void HideCursor(void);                                                  // Hides cursor
     bool IsCursorHidden(void);                                              // Check if cursor is not visible
     void EnableCursor(void);                                                // Enables cursor (unlock cursor)
     void DisableCursor(void);                                               // Disables cursor (lock cursor)
-                
+    bool IsCursorOnScreen(void);                                            // Check if cursor is on the current screen.
+            
     // Drawing-related functions            
     void ClearBackground(Color color);                                      // Set background color (framebuffer clear color)
     void BeginDrawing(void);                                                // Setup canvas (framebuffer) to start drawing
@@ -49,8 +59,8 @@
     void EndTextureMode(void);                                              // Ends drawing to render texture
     void BeginScissorMode(int x, int y, int width, int height);             // Begin scissor mode (define screen area for following drawing)
     void EndScissorMode(void);                                              // End scissor mode
-                
-    // Screen-space-related functions           
+
+    // Screen-space-related functions
     Ray GetMouseRay(Vector2 mousePosition, Camera camera);                  // Returns a ray trace from mouse position
     Matrix GetCameraMatrix(Camera camera);                                  // Returns camera transform matrix (view matrix)
     Matrix GetCameraMatrix2D(Camera2D camera);                              // Returns camera 2d transform matrix
@@ -58,40 +68,37 @@
     Vector2 GetWorldToScreenEx(Vector3 position, Camera camera, int width, int height); // Returns size position for a 3d world space position
     Vector2 GetWorldToScreen2D(Vector2 position, Camera2D camera);          // Returns the screen space position for a 2d camera world space position
     Vector2 GetScreenToWorld2D(Vector2 position, Camera2D camera);          // Returns the world space position for a 2d camera screen space position
-                
-    // Timing-related functions         
+
+    // Timing-related functions
     void SetTargetFPS(int fps);                                             // Set target FPS (maximum)
     int GetFPS(void);                                                       // Returns current FPS
     float GetFrameTime(void);                                               // Returns time in seconds for last frame drawn
     double GetTime(void);                                                   // Returns elapsed time in seconds since InitWindow()
-                
-    // Color-related functions          
-    int ColorToInt(Color color);                                            // Returns hexadecimal value for a Color
-    Vector4 ColorNormalize(Color color);                                    // Returns color normalized as float [0..1]
-    Color ColorFromNormalized(Vector4 normalized);                          // Returns color from normalized values [0..1]
-    Vector3 ColorToHSV(Color color);                                        // Returns HSV values for a Color
-    Color ColorFromHSV(Vector3 hsv);                                        // Returns a Color from HSV values
-    Color GetColor(int hexValue);                                           // Returns a Color struct from hexadecimal value
-    Color Fade(Color color, float alpha);                                   // Color fade-in or fade-out, alpha goes from 0.0f to 1.0f
-                
+            
     // Misc. functions          
-    void SetConfigFlags(unsigned int flags);                                // Setup window configuration flags (view FLAGS)
+    void SetConfigFlags(unsigned int flags);                                // Setup init configuration flags (view FLAGS)
+            
     void SetTraceLogLevel(int logType);                                     // Set the current threshold (minimum) log level
     void SetTraceLogExit(int logType);                                      // Set the exit threshold (minimum) log level
     void SetTraceLogCallback(TraceLogCallback callback);                    // Set a trace log callback to enable custom logging
     void TraceLog(int logType, const char *text, ...);                      // Show trace log messages (LOG_DEBUG, LOG_INFO, LOG_WARNING, LOG_ERROR)
+            
+    void *MemAlloc(int size);                                               // Internal memory allocator
+    void MemFree(void *ptr);                                                // Internal memory free
     void TakeScreenshot(const char *fileName);                              // Takes a screenshot of current screen (saved a .png)
     int GetRandomValue(int min, int max);                                   // Returns a random value between min and max (both included)
-                
+
     // Files management functions
     unsigned char *LoadFileData(const char *fileName, unsigned int *bytesRead);     // Load file data as byte array (read)
-    void SaveFileData(const char *fileName, void *data, unsigned int bytesToWrite); // Save data to file from byte array (write)
+    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
     char *LoadFileText(const char *fileName);                               // Load text data from file (read), returns a '\0' terminated string
-    void SaveFileText(const char *fileName, char *text);                    // Save text data to file (write), string must be '\0' terminated    
+    void UnloadFileText(unsigned 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
     bool FileExists(const char *fileName);                                  // Check if file exists
-    bool IsFileExtension(const char *fileName, const char *ext);            // Check file extension
     bool DirectoryExists(const char *dirPath);                              // Check if a directory path exists
-    const char *GetExtension(const char *fileName);                         // Get pointer to extension for a filename string
+    bool IsFileExtension(const char *fileName, const char *ext);            // Check file extension (including point: .png, .wav)
+    const char *GetFileExtension(const char *fileName);                     // Get pointer to extension for a filename string (including point: ".png")
     const char *GetFileName(const char *filePath);                          // Get pointer to filename for a path string
     const char *GetFileNameWithoutExt(const char *filePath);                // Get filename string without extension (uses static string)
     const char *GetDirectoryPath(const char *filePath);                     // Get full path for a given fileName with path (uses static string)
@@ -99,32 +106,33 @@
     const char *GetWorkingDirectory(void);                                  // Get current working directory (uses static string)
     char **GetDirectoryFiles(const char *dirPath, int *count);              // Get filenames in a directory path (memory should be freed)
     void ClearDirectoryFiles(void);                                         // Clear directory files paths buffers (free memory)
-    bool ChangeDirectory(const char *dir);                                  // Change working directory, returns true if success
+    bool ChangeDirectory(const char *dir);                                  // Change working directory, return true on success
     bool IsFileDropped(void);                                               // Check if a file has been dropped into window
     char **GetDroppedFiles(int *count);                                     // Get dropped files names (memory should be freed)
     void ClearDroppedFiles(void);                                           // Clear dropped files paths buffer (free memory)
     long GetFileModTime(const char *fileName);                              // Get file modification time (last write time)
-    
-    unsigned char *CompressData(unsigned char *data, int dataLength, int *compDataLength);        // Compress data (DEFLATE algorythm)
-    unsigned char *DecompressData(unsigned char *compData, int compDataLength, int *dataLength);  // Decompress data (DEFLATE algorythm)
-    
+
+    unsigned char *CompressData(unsigned char *data, int dataLength, int *compDataLength);        // Compress data (DEFLATE algorithm)
+    unsigned char *DecompressData(unsigned char *compData, int compDataLength, int *dataLength);  // Decompress data (DEFLATE algorithm)
+
     // Persistent storage management
-    void SaveStorageValue(unsigned int position, int value);                // Save integer value to storage file (to defined position)
+    bool SaveStorageValue(unsigned int position, int value);                // Save integer value to storage file (to defined position), returns true on success
     int LoadStorageValue(unsigned int position);                            // Load integer value from storage file (from defined position)
-    
+
     void OpenURL(const char *url);                                          // Open URL with default system browser (if available)
 
     //------------------------------------------------------------------------------------
-    // Input Handling Functions
+    // Input Handling Functions (Module: core)
     //------------------------------------------------------------------------------------
 
-    // Input-related functions: keyb
+    // Input-related functions: keyboard
     bool IsKeyPressed(int key);                                             // Detect if a key has been pressed once
     bool IsKeyDown(int key);                                                // Detect if a key is being pressed
     bool IsKeyReleased(int key);                                            // Detect if a key has been released once
     bool IsKeyUp(int key);                                                  // Detect if a key is NOT being pressed
-    int GetKeyPressed(void);                                                // Get latest key 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
+    int GetCharPressed(void);                                               // Get char pressed (unicode), call it multiple times for chars queued 
                 
     // Input-related functions: gamepads                
     bool IsGamepadAvailable(int gamepad);                                   // Detect if a gamepad is available
@@ -149,8 +157,10 @@
     void SetMousePosition(int x, int y);                                    // Set mouse position XY
     void SetMouseOffset(int offsetX, int offsetY);                          // Set mouse offset
     void SetMouseScale(float scaleX, float scaleY);                         // Set mouse scaling
-    int GetMouseWheelMove(void);                                            // Returns mouse wheel movement Y
-
+    float GetMouseWheelMove(void);                                          // Returns mouse wheel movement Y
+    int GetMouseCursor(void);                                               // Returns mouse cursor if (MouseCursor enum)
+    void SetMouseCursor(int cursor);                                        // Set mouse cursor
+                
     // Input-related functions: touch               
     int GetTouchX(void);                                                    // Returns touch position X for touch point 0 (relative to screen size)
     int GetTouchY(void);                                                    // Returns touch position Y for touch point 0 (relative to screen size)
@@ -175,9 +185,9 @@
     void SetCameraMode(Camera camera, int mode);                            // Set camera mode (multiple camera modes available)
     void UpdateCamera(Camera *camera);                                      // Update camera position for selected mode
             
-    void SetCameraPanControl(int panKey);                                   // Set camera pan key to combine with mouse movement (free camera)
-    void SetCameraAltControl(int altKey);                                   // Set camera alt key to combine with mouse movement (free camera)
-    void SetCameraSmoothZoomControl(int szKey);                             // Set camera smooth zoom key to combine with mouse (free camera)
+    void SetCameraPanControl(int keyPan);                                   // Set camera pan key to combine with mouse movement (free camera)
+    void SetCameraAltControl(int keyAlt);                                   // Set camera alt key to combine with mouse movement (free camera)
+    void SetCameraSmoothZoomControl(int keySmoothZoom);                     // Set camera smooth zoom key to combine with mouse (free camera)
     void SetCameraMoveControls(int frontKey, int backKey, 
                                int rightKey, int leftKey, 
                                int upKey, int downKey);                     // Set camera move controls (1st person and 3rd person cameras)
diff --git a/cheatsheet/raylib_models.c b/cheatsheet/raylib_models.c
index 070394e..4ad632b 100644
--- a/cheatsheet/raylib_models.c
+++ b/cheatsheet/raylib_models.c
@@ -1,8 +1,10 @@
 
-      // Basic geometric 3D shapes drawing functions
+    // 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
     void DrawCircle3D(Vector3 center, float radius, Vector3 rotationAxis, float rotationAngle, Color color); // Draw a circle in 3D world space
+    void DrawTriangle3D(Vector3 v1, Vector3 v2, Vector3 v3, Color color);                              // Draw a color-filled triangle (vertex in counter-clockwise order!)
+    void DrawTriangleStrip3D(Vector3 *points, int pointsCount, Color color);                           // Draw a triangle strip defined by points
     void DrawCube(Vector3 position, float width, float height, float length, Color color);             // Draw cube
     void DrawCubeV(Vector3 position, Vector3 size, Color color);                                       // Draw cube (Vector version)
     void DrawCubeWires(Vector3 position, float width, float height, float length, Color color);        // Draw cube wires
@@ -17,31 +19,32 @@
     void DrawRay(Ray ray, Color color);                                                                // Draw a ray line
     void DrawGrid(int slices, float spacing);                                                          // Draw a grid (centered at (0, 0, 0))
     void DrawGizmo(Vector3 position);                                                                  // Draw simple gizmo
-    
+
     // Model loading/unloading functions
     Model LoadModel(const char *fileName);                                                             // Load model from files (meshes and materials)
     Model LoadModelFromMesh(Mesh mesh);                                                                // Load model from generated mesh (default material)
-    void UnloadModel(Model model);                                                                     // Unload model from memory (RAM and/or VRAM)
-    
-    // Mesh loading/unloading functions
+    void UnloadModel(Model model);                                                                     // Unload model (including meshes) from memory (RAM and/or VRAM)
+    void UnloadModelKeepMeshes(Model model);                                                           // Unload model (but not meshes) from memory (RAM and/or VRAM)
+                                                                                                       
+    // Mesh loading/unloading functions                                                                
     Mesh *LoadMeshes(const char *fileName, int *meshCount);                                            // Load meshes from model file
-    void ExportMesh(Mesh mesh, const char *fileName);                                                  // Export mesh data to file
     void UnloadMesh(Mesh mesh);                                                                        // Unload mesh from memory (RAM and/or VRAM)
-    
-    // Material loading/unloading functions
+    bool ExportMesh(Mesh mesh, const char *fileName);                                                  // Export mesh data to file, returns true on success
+                                                                                                       
+    // Material loading/unloading functions                                                            
     Material *LoadMaterials(const char *fileName, int *materialCount);                                 // Load materials from model file
     Material LoadMaterialDefault(void);                                                                // Load default material (Supports: DIFFUSE, SPECULAR, NORMAL maps)
     void UnloadMaterial(Material material);                                                            // Unload material from GPU memory (VRAM)
     void SetMaterialTexture(Material *material, int mapType, Texture2D texture);                       // Set texture for a material map type (MAP_DIFFUSE, MAP_SPECULAR...)
     void SetModelMeshMaterial(Model *model, int meshId, int materialId);                               // Set material for a mesh
-    
-    // Model animations loading/unloading functions
+                                                                                                       
+    // Model animations loading/unloading functions                                                    
     ModelAnimation *LoadModelAnimations(const char *fileName, int *animsCount);                        // Load model animations from file
     void UpdateModelAnimation(Model model, ModelAnimation anim, int frame);                            // Update model animation pose
     void UnloadModelAnimation(ModelAnimation anim);                                                    // Unload animation data
     bool IsModelAnimationValid(Model model, ModelAnimation anim);                                      // Check model animation skeleton match
-    
-    // Mesh generation functions
+                                                                                                       
+    // Mesh generation functions                                                                       
     Mesh GenMeshPoly(int sides, float radius);                                                         // Generate polygonal mesh
     Mesh GenMeshPlane(float width, float length, int resX, int resZ);                                  // Generate plane mesh (with subdivisions)
     Mesh GenMeshCube(float width, float height, float length);                                         // Generate cuboid mesh
@@ -52,12 +55,13 @@
     Mesh GenMeshKnot(float radius, float size, int radSeg, int sides);                                 // Generate trefoil knot mesh
     Mesh GenMeshHeightmap(Image heightmap, Vector3 size);                                              // Generate heightmap mesh from image data
     Mesh GenMeshCubicmap(Image cubicmap, Vector3 cubeSize);                                            // Generate cubes-based map mesh from image data
-    
-    // Mesh manipulation functions
+                                                                                                       
+    // Mesh manipulation functions                                                                         
     BoundingBox MeshBoundingBox(Mesh mesh);                                                            // Compute mesh bounding box limits
     void MeshTangents(Mesh *mesh);                                                                     // Compute mesh tangents
     void MeshBinormals(Mesh *mesh);                                                                    // Compute mesh binormals
-    
+    void MeshNormalsSmooth(Mesh *mesh);                                                                // Smooth (average) vertex normals
+
     // Model drawing functions
     void DrawModel(Model model, Vector3 position, float scale, Color tint);                            // Draw a model (with texture if set)
     void DrawModelEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint); // Draw a model with extended parameters
@@ -65,15 +69,16 @@
     void DrawModelWiresEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint); // Draw a model wires (with texture if set) with extended parameters
     void DrawBoundingBox(BoundingBox box, Color color);                                                // Draw bounding box (wires)
     void DrawBillboard(Camera camera, Texture2D texture, Vector3 center, float size, Color tint);      // Draw a billboard texture
-    void DrawBillboardRec(Camera camera, Texture2D texture, Rectangle sourceRec, Vector3 center, float size, Color tint); // Draw a billboard texture defined by sourceRec
-    
+    void DrawBillboardRec(Camera camera, Texture2D texture, Rectangle source, Vector3 center, float size, Color tint); // Draw a billboard texture defined by source
+
     // Collision detection functions
-    bool CheckCollisionSpheres(Vector3 centerA, float radiusA, Vector3 centerB, float radiusB);        // Detect collision between two spheres
+    bool CheckCollisionSpheres(Vector3 center1, float radius1, Vector3 center2, float radius2);        // Detect collision between two spheres
     bool CheckCollisionBoxes(BoundingBox box1, BoundingBox box2);                                      // Detect collision between two bounding boxes
     bool CheckCollisionBoxSphere(BoundingBox box, Vector3 center, float radius);                       // Detect collision between box and sphere
     bool CheckCollisionRaySphere(Ray ray, Vector3 center, float radius);                               // Detect collision between ray and sphere
     bool CheckCollisionRaySphereEx(Ray ray, Vector3 center, float radius, Vector3 *collisionPoint);    // Detect collision between ray and sphere, returns collision point
     bool CheckCollisionRayBox(Ray ray, BoundingBox box);                                               // Detect collision between ray and box
+    RayHitInfo GetCollisionRayMesh(Ray ray, Mesh mesh, Matrix transform);                              // Get collision info between ray and mesh
     RayHitInfo GetCollisionRayModel(Ray ray, Model model);                                             // Get collision info between ray and model
     RayHitInfo GetCollisionRayTriangle(Ray ray, Vector3 p1, Vector3 p2, Vector3 p3);                   // Get collision info between ray and triangle
     RayHitInfo GetCollisionRayGround(Ray ray, float groundHeight);                                     // Get collision info between ray and ground plane (Y-normal plane)
diff --git a/cheatsheet/raylib_shaders.c b/cheatsheet/raylib_shaders.c
index bca5dbe..fa01809 100644
--- a/cheatsheet/raylib_shaders.c
+++ b/cheatsheet/raylib_shaders.c
@@ -1,7 +1,7 @@
 
     // Shader loading/unloading functions
     Shader LoadShader(const char *vsFileName, const char *fsFileName);                                  // Load shader from files and bind default locations
-    Shader LoadShaderCode(char *vsCode, char *fsCode);                                                  // Load shader from code strings and bind default locations
+    Shader LoadShaderCode(const char *vsCode, const char *fsCode);                                      // Load shader from code strings and bind default locations
     void UnloadShader(Shader shader);                                                                   // Unload shader from GPU memory (VRAM)
                                 
     Shader GetShaderDefault(void);                                                                      // Get default shader
@@ -9,16 +9,17 @@
     Texture2D GetShapesTexture(void);                                                                   // Get texture to draw shapes
     Rectangle GetShapesTextureRec(void);                                                                // Get texture rectangle to draw shapes
     void SetShapesTexture(Texture2D texture, Rectangle source);                                         // Define default texture used to draw shapes
-    
-    // Shader configuration functions                               
+
+    // Shader configuration functions
     int GetShaderLocation(Shader shader, const char *uniformName);                                      // Get shader uniform location
+    int GetShaderLocationAttrib(Shader shader, const char *attribName);                                 // Get shader attribute location
     void SetShaderValue(Shader shader, int uniformLoc, const void *value, int uniformType);             // Set shader uniform value
     void SetShaderValueV(Shader shader, int uniformLoc, const void *value, int uniformType, int count); // Set shader uniform value vector
     void SetShaderValueMatrix(Shader shader, int uniformLoc, Matrix mat);                               // Set shader uniform value (matrix 4x4)
     void SetShaderValueTexture(Shader shader, int uniformLoc, Texture2D texture);                       // Set shader uniform value for texture
     void SetMatrixProjection(Matrix proj);                                                              // Set a custom projection matrix (replaces internal projection matrix)
     void SetMatrixModelview(Matrix view);                                                               // Set a custom modelview matrix (replaces internal modelview matrix)
-    Matrix GetMatrixModelview();                                                                        // Get internal modelview matrix
+    Matrix GetMatrixModelview(void);                                                                    // Get internal modelview matrix
     Matrix GetMatrixProjection(void);                                                                   // Get internal projection matrix
 
     // Shading begin/end functions
diff --git a/cheatsheet/raylib_shapes.c b/cheatsheet/raylib_shapes.c
index ef4c1da..73a9c3b 100644
--- a/cheatsheet/raylib_shapes.c
+++ b/cheatsheet/raylib_shapes.c
@@ -6,10 +6,10 @@
     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 DrawLineStrip(Vector2 *points, int numPoints, Color color);                                    // Draw lines sequence
+    void DrawLineStrip(Vector2 *points, int pointsCount, Color color);                                  // Draw lines sequence
     void DrawCircle(int centerX, int centerY, float radius, Color color);                               // Draw a color-filled circle
-    void DrawCircleSector(Vector2 center, float radius, int startAngle, int endAngle, int segments, Color color);     // Draw a piece of a circle
-    void DrawCircleSectorLines(Vector2 center, float radius, int startAngle, int endAngle, int segments, Color color);    // Draw circle sector outline
+    void DrawCircleSector(Vector2 center, float radius, int startAngle, int endAngle, int segments, Color color);      // Draw a piece of a circle
+    void DrawCircleSectorLines(Vector2 center, float radius, int startAngle, int 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
@@ -30,7 +30,7 @@
     void DrawRectangleRoundedLines(Rectangle rec, float roundness, int segments, int lineThick, Color color); // Draw rectangle with rounded edges outline
     void DrawTriangle(Vector2 v1, Vector2 v2, Vector2 v3, Color color);                                 // Draw a color-filled triangle (vertex in counter-clockwise order!)
     void DrawTriangleLines(Vector2 v1, Vector2 v2, Vector2 v3, Color color);                            // Draw triangle outline (vertex in counter-clockwise order!)
-    void DrawTriangleFan(Vector2 *points, int numPoints, Color color);                                  // Draw a triangle fan defined by points (first vertex is the center)
+    void DrawTriangleFan(Vector2 *points, int pointsCount, Color color);                                // Draw a triangle fan defined by points (first vertex is the center)
     void DrawTriangleStrip(Vector2 *points, int pointsCount, Color color);                              // Draw a triangle strip defined by points
     void DrawPoly(Vector2 center, int sides, float radius, float rotation, Color color);                // Draw a regular polygon (Vector version)
     void DrawPolyLines(Vector2 center, int sides, float radius, float rotation, Color color);           // Draw a polygon outline of n sides
@@ -39,8 +39,9 @@
     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
     bool CheckCollisionCircleRec(Vector2 center, float radius, Rectangle rec);                          // Check collision between circle and rectangle
-    Rectangle GetCollisionRec(Rectangle rec1, Rectangle rec2);                                          // Get collision rectangle for two rectangles collision
     bool CheckCollisionPointRec(Vector2 point, Rectangle rec);                                          // Check if point is inside rectangle
     bool CheckCollisionPointCircle(Vector2 point, Vector2 center, float radius);                        // Check if point is inside circle
     bool CheckCollisionPointTriangle(Vector2 point, Vector2 p1, Vector2 p2, Vector2 p3);                // Check if point is inside a triangle
+    bool CheckCollisionLines(Vector2 startPos1, Vector2 endPos1, Vector2 startPos2, Vector2 endPos2, Vector2 *collisionPoint); // Check the collision between two lines 
+    Rectangle GetCollisionRec(Rectangle rec1, Rectangle rec2);                                          // Get collision rectangle for two rectangles collision
 
diff --git a/cheatsheet/raylib_text.c b/cheatsheet/raylib_text.c
index 79a5fec..9ee6f0b 100644
--- a/cheatsheet/raylib_text.c
+++ b/cheatsheet/raylib_text.c
@@ -4,24 +4,26 @@
     Font LoadFont(const char *fileName);                                                              // Load font from file into GPU memory (VRAM)
     Font LoadFontEx(const char *fileName, int fontSize, int *fontChars, int charsCount);              // Load font from file with extended parameters
     Font LoadFontFromImage(Image image, Color key, int firstChar);                                    // Load font from Image (XNA style)
-    CharInfo *LoadFontData(const char *fileName, int fontSize, int *fontChars, int charsCount, int type); // Load font data for further use
-    Image GenImageFontAtlas(const CharInfo *chars, Rectangle **recs, int charsCount, int fontSize, int padding, int packMethod);  // Generate image font atlas using chars info
+    Font LoadFontFromMemory(const char *fileType, const unsigned char *fileData, int dataSize, int fontSize, int *fontChars, int charsCount); // Load font from memory buffer
+    CharInfo *LoadFontData(const unsigned char *fileData, int dataSize, int fontSize, int *fontChars, int charsCount, int type);   // Load font data for further use
+    Image GenImageFontAtlas(const CharInfo *chars, Rectangle **recs, int charsCount, int fontSize, int padding, int packMethod);   // Generate image font atlas using chars info
+    void UnloadFontData(CharInfo *chars, int charsCount);                                             // Unload font chars info data (RAM)
     void UnloadFont(Font font);                                                                       // Unload Font from GPU memory (VRAM)
-    
+
     // Text drawing functions
     void DrawFPS(int posX, int posY);                                                                 // Shows current FPS
     void DrawText(const char *text, int posX, int posY, int fontSize, Color color);                   // Draw text (using default font)
     void DrawTextEx(Font font, const char *text, Vector2 position, float fontSize, float spacing, Color tint);                // Draw text using font and additional parameters
     void DrawTextRec(Font font, const char *text, Rectangle rec, float fontSize, float spacing, bool wordWrap, Color tint);   // Draw text using font inside rectangle limits
     void DrawTextRecEx(Font font, const char *text, Rectangle rec, float fontSize, float spacing, bool wordWrap, Color tint,
-                    int selectStart, int selectLength, Color selectTint, Color selectBackTint);       // Draw text using font inside rectangle limits with support for text selection
-    void DrawTextCodepoint(Font font, int codepoint, Vector2 position, float scale, Color tint);      // Draw one character (codepoint)
-    
+                         int selectStart, int selectLength, Color selectTint, Color selectBackTint);  // Draw text using font inside rectangle limits with support for text selection
+    void DrawTextCodepoint(Font font, int codepoint, Vector2 position, float fontSize, Color tint);   // Draw one character (codepoint)
+
     // Text misc. functions
     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 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!
     int TextCopy(char *dst, const char *src);                                                         // Copy one string to another, returns bytes copied
@@ -41,7 +43,7 @@
     int TextToInteger(const char *text);                                                              // Get integer value from text (negative values not supported)
     char *TextToUtf8(int *codepoints, int length);                                                    // Encode text codepoint into utf8 text (memory must be freed!)
                                                                                                       
-    // UTF8 text strings management functions                                                         
+    // UTF8 text strings management functions
     int *GetCodepoints(const char *text, int *count);                                                 // Get all codepoints in a string, codepoints count returned by parameters
     int GetCodepointsCount(const char *text);                                                         // Get total number of characters (codepoints) in a UTF8 encoded string
     int GetNextCodepoint(const char *text, int *bytesProcessed);                                      // Returns next codepoint in a UTF8 encoded string; 0x3f('?') is returned on failure
diff --git a/cheatsheet/raylib_textures.c b/cheatsheet/raylib_textures.c
index 3feb255..75efc7a 100644
--- a/cheatsheet/raylib_textures.c
+++ b/cheatsheet/raylib_textures.c
@@ -2,14 +2,12 @@
     // Image loading functions
     // NOTE: This functions do not require GPU access
     Image LoadImage(const char *fileName);                                                             // Load image from file into CPU memory (RAM)
-    Image LoadImageEx(Color *pixels, int width, int height);                                           // Load image from Color array data (RGBA - 32bit)
-    Image LoadImagePro(void *data, int width, int height, int format);                                 // Load image from raw data with parameters
     Image LoadImageRaw(const char *fileName, int width, int height, int format, int headerSize);       // Load image from RAW file data
+    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"
     void UnloadImage(Image image);                                                                     // Unload image from CPU memory (RAM)
-    void ExportImage(Image image, const char *fileName);                                               // Export image data to file
-    void ExportImageAsCode(Image image, const char *fileName);                                         // Export image as code file defining an array of bytes
-    Color *GetImageData(Image image);                                                                  // Get pixel data from image as a Color struct array
-    Vector4 *GetImageDataNormalized(Image image);                                                      // Get pixel data from image as Vector4 array (float normalized)
+    bool ExportImage(Image image, const char *fileName);                                               // Export image data to file, returns true on success
+    bool ExportImageAsCode(Image image, const char *fileName);                                         // Export image as code file defining an array of bytes, returns true on success
 
     // Image generation functions
     Image GenImageColor(int width, int height, Color color);                                           // Generate image: plain color
@@ -26,16 +24,16 @@
     Image ImageFromImage(Image image, Rectangle rec);                                                  // Create an image from another image piece
     Image ImageText(const char *text, int fontSize, Color color);                                      // Create an image from text (default font)
     Image ImageTextEx(Font font, const char *text, float fontSize, float spacing, Color tint);         // Create an image from text (custom sprite font)
-    void ImageToPOT(Image *image, Color fillColor);                                                    // Convert image to POT (power-of-two)
     void ImageFormat(Image *image, int newFormat);                                                     // Convert image data to desired format
-    void ImageAlphaMask(Image *image, Image alphaMask);                                                // Apply alpha mask to image
-    void ImageAlphaClear(Image *image, Color color, float threshold);                                  // Clear alpha channel to desired color
+    void ImageToPOT(Image *image, Color fill);                                                         // Convert image to POT (power-of-two)
+    void ImageCrop(Image *image, Rectangle crop);                                                      // Crop an image to a defined rectangle
     void ImageAlphaCrop(Image *image, float threshold);                                                // Crop image depending on alpha value
+    void ImageAlphaClear(Image *image, Color color, float threshold);                                  // Clear alpha channel to desired color
+    void ImageAlphaMask(Image *image, Image alphaMask);                                                // Apply alpha mask to image
     void ImageAlphaPremultiply(Image *image);                                                          // Premultiply alpha channel
-    void ImageCrop(Image *image, Rectangle crop);                                                      // Crop an image to a defined rectangle
     void ImageResize(Image *image, int newWidth, int newHeight);                                       // Resize image (Bicubic scaling algorithm)
     void ImageResizeNN(Image *image, int newWidth,int newHeight);                                      // Resize image (Nearest-Neighbor scaling algorithm)
-    void ImageResizeCanvas(Image *image, int newWidth, int newHeight, int offsetX, int offsetY, Color color);  // Resize canvas and fill with color
+    void ImageResizeCanvas(Image *image, int newWidth, int newHeight, int offsetX, int offsetY, Color fill);  // Resize canvas and fill with color
     void ImageMipmaps(Image *image);                                                                   // Generate all mipmap levels for a provided image
     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
@@ -48,7 +46,10 @@
     void ImageColorContrast(Image *image, float contrast);                                             // Modify image color: contrast (-100 to 100)
     void ImageColorBrightness(Image *image, int brightness);                                           // Modify image color: brightness (-255 to 255)
     void ImageColorReplace(Image *image, Color color, Color replace);                                  // Modify image color: replace color
-    Color *ImageExtractPalette(Image image, int maxPaletteSize, int *extractCount);                    // Extract color palette from image to maximum size (memory should be freed)
+    Color *LoadImageColors(Image image);                                                               // Load color data from image as a Color array (RGBA - 32bit)
+    Color *LoadImagePalette(Image image, int maxPaletteSize, int *colorsCount);                        // Load colors palette from image as a Color array (RGBA - 32bit)
+    void UnloadImageColors(Color *colors);                                                             // Unload color data loaded with LoadImageColors()
+    void UnloadImagePalette(Color *colors);                                                            // Unload colors palette loaded with LoadImagePalette()
     Rectangle GetImageAlphaBorder(Image image, float threshold);                                       // Get image alpha border rectangle
 
     // Image drawing functions
@@ -62,11 +63,11 @@
     void ImageDrawCircleV(Image *dst, Vector2 center, int radius, Color color);                        // Draw circle within an image (Vector version)
     void ImageDrawRectangle(Image *dst, int posX, int posY, int width, int height, Color color);       // Draw rectangle within an image
     void ImageDrawRectangleV(Image *dst, Vector2 position, Vector2 size, Color color);                 // Draw rectangle within an image (Vector version)
-    void ImageDrawRectangleRec(Image *dst, Rectangle rec, Color color);                                // Draw rectangle within an image 
+    void ImageDrawRectangleRec(Image *dst, Rectangle rec, Color color);                                // Draw rectangle within an image
     void ImageDrawRectangleLines(Image *dst, Rectangle rec, int thick, Color color);                   // Draw rectangle lines within an image
     void ImageDraw(Image *dst, Image src, Rectangle srcRec, Rectangle dstRec, Color tint);             // Draw a source image within a destination image (tint applied to source)
-    void ImageDrawText(Image *dst, Vector2 position, const char *text, int fontSize, Color color);     // Draw text (default font) within an image (destination)
-    void ImageDrawTextEx(Image *dst, Vector2 position, Font font, const char *text, float fontSize, float spacing, Color color); // Draw text (custom sprite font) within an image (destination)
+    void ImageDrawText(Image *dst, const char *text, int posX, int posY, int fontSize, Color color);   // Draw text (using default font) within an image (destination)
+    void ImageDrawTextEx(Image *dst, Font font, const char *text, Vector2 position, float fontSize, float spacing, Color tint); // Draw text (custom sprite font) within an image (destination)
 
     // Texture loading functions
     // NOTE: These functions require GPU access
@@ -77,6 +78,7 @@
     void UnloadTexture(Texture2D texture);                                                             // Unload texture from GPU memory (VRAM)
     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
     Image GetTextureData(Texture2D texture);                                                           // Get pixel data from GPU texture and return an Image
     Image GetScreenData(void);                                                                         // Get pixel data from screen buffer and return an Image (screenshot)
 
@@ -89,12 +91,24 @@
     void DrawTexture(Texture2D texture, int posX, int posY, Color tint);                               // Draw a Texture2D
     void DrawTextureV(Texture2D texture, Vector2 position, Color tint);                                // Draw a Texture2D with position defined as Vector2
     void DrawTextureEx(Texture2D texture, Vector2 position, float rotation, float scale, Color tint);  // Draw a Texture2D with extended parameters
-    void DrawTextureRec(Texture2D texture, Rectangle sourceRec, Vector2 position, Color tint);         // Draw a part of a texture defined by a rectangle
+    void DrawTextureRec(Texture2D texture, Rectangle source, Vector2 position, Color tint);            // Draw a part of a texture defined by a rectangle
     void DrawTextureQuad(Texture2D texture, Vector2 tiling, Vector2 offset, Rectangle quad, Color tint);  // Draw texture quad with tiling and offset parameters
-    void DrawTexturePro(Texture2D texture, Rectangle sourceRec, Rectangle destRec, Vector2 origin, float rotation, Color tint);       // Draw a part of a texture defined by a rectangle with 'pro' parameters
-    void DrawTextureNPatch(Texture2D texture, NPatchInfo nPatchInfo, Rectangle destRec, Vector2 origin, float rotation, Color tint);  // Draws a texture (or part of it) that stretches or shrinks nicely
+    void DrawTextureTiled(Texture2D texture, Rectangle source, Rectangle dest, Vector2 origin, float rotation, float scale, Color tint);  // Draw part of a texture (defined by a rectangle) with rotation and scale tiled into dest.
+    void DrawTexturePro(Texture2D texture, Rectangle source, Rectangle dest, Vector2 origin, float rotation, Color tint);          // Draw a part of a texture defined by a rectangle with 'pro' parameters
+    void DrawTextureNPatch(Texture2D texture, NPatchInfo nPatchInfo, Rectangle dest, Vector2 origin, float rotation, Color tint);  // Draws a texture (or part of it) that stretches or shrinks nicely
+
+    // Color/pixel related functions
+    Color Fade(Color color, float alpha);                                                              // Returns color with alpha applied, alpha goes from 0.0f to 1.0f
+    int ColorToInt(Color color);                                                                       // Returns hexadecimal value for a Color
+    Vector4 ColorNormalize(Color color);                                                               // Returns Color normalized as float [0..1]
+    Color ColorFromNormalized(Vector4 normalized);                                                     // Returns Color from normalized values [0..1]
+    Vector3 ColorToHSV(Color color);                                                                   // Returns HSV values for a Color
+    Color ColorFromHSV(float hue, float saturation, float value);                                      // Returns a Color from HSV values
+    Color ColorAlpha(Color color, float alpha);                                                        // Returns color with alpha applied, alpha goes from 0.0f to 1.0f
+    Color ColorAlphaBlend(Color dst, Color src, Color tint);                                           // Returns src alpha-blended into dst color with tint
+    Color GetColor(int hexValue);                                                                      // Get Color structure from hexadecimal value
+    Color GetPixelColor(void *srcPtr, int format);                                                     // Get Color from a source pixel pointer of certain format
+    void SetPixelColor(void *dstPtr, Color color, int format);                                         // Set color formatted into destination pixel pointer
+    int GetPixelDataSize(int width, int height, int format);                                           // Get pixel data size in bytes for certain format
 
-    // Image/Texture misc functions
-    int GetPixelDataSize(int width, int height, int format);                                           // Get pixel data size in bytes (image or texture)
-    
     
\ No newline at end of file