Update cheatsheet

9 files changed, 134 insertions, 207 deletions

diff --git a/cheatsheet/cheatsheet.html b/cheatsheet/cheatsheet.html
index 68d80fb..a218b26 100644
--- a/cheatsheet/cheatsheet.html
+++ b/cheatsheet/cheatsheet.html
@@ -129,7 +129,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>]</p>
             <p></p>
-            <p id="version">v3.7 quick reference card  [<a id="downpdf" href="raylib_cheatsheet.pdf">download as PDF</a>]</p>
+            <p id="version">v4.0 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 4e39638..8204649 100644
--- a/cheatsheet/raylib_audio.c
+++ b/cheatsheet/raylib_audio.c
@@ -35,14 +35,15 @@
 
     // Music management functions
     Music LoadMusicStream(const char *fileName);                                    // Load music stream from file
-    Music LoadMusicStreamFromMemory(const char *fileType, unsigned char* data, int dataSize); // Load music stream from data
+    Music LoadMusicStreamFromMemory(const char *fileType, unsigned char *data, int dataSize); // Load music stream from data
     void UnloadMusicStream(Music music);                                            // Unload music stream
     void PlayMusicStream(Music music);                                              // Start music playing
-    bool IsMusicPlaying(Music music);                                               // Check if music is playing
+    bool IsMusicStreamPlaying(Music music);                                         // Check if music is playing
     void UpdateMusicStream(Music music);                                            // Updates buffers for music streaming
     void StopMusicStream(Music music);                                              // Stop music playing
     void PauseMusicStream(Music music);                                             // Pause music playing
     void ResumeMusicStream(Music music);                                            // Resume playing paused music
+    void SeekMusicStream(Music music, float position);                              // Seek music to a position (in seconds)
     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)
     float GetMusicTimeLength(Music music);                                          // Get music time length (in seconds)
diff --git a/cheatsheet/raylib_core.c b/cheatsheet/raylib_core.c
index 8f95a7a..17f1a57 100644
--- a/cheatsheet/raylib_core.c
+++ b/cheatsheet/raylib_core.c
@@ -46,26 +46,26 @@
     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.
+    bool IsCursorOnScreen(void);                                            // Check if cursor is on the screen
 
     // Drawing-related functions
     void ClearBackground(Color color);                                      // Set background color (framebuffer clear color)
     void BeginDrawing(void);                                                // Setup canvas (framebuffer) to start drawing
     void EndDrawing(void);                                                  // End canvas drawing and swap buffers (double buffering)
-    void BeginMode2D(Camera2D camera);                                      // Initialize 2D mode with custom camera (2D)
+    void BeginMode2D(Camera2D camera);                                      // Begin 2D mode with custom camera (2D)
     void EndMode2D(void);                                                   // Ends 2D mode with custom camera
-    void BeginMode3D(Camera3D camera);                                      // Initializes 3D mode with custom camera (3D)
+    void BeginMode3D(Camera3D camera);                                      // Begin 3D mode with custom camera (3D)
     void EndMode3D(void);                                                   // Ends 3D mode and returns to default 2D orthographic mode
-    void BeginTextureMode(RenderTexture2D target);                          // Initializes render texture for drawing
+    void BeginTextureMode(RenderTexture2D target);                          // Begin drawing to render texture
     void EndTextureMode(void);                                              // Ends drawing to render texture
     void BeginShaderMode(Shader shader);                                    // Begin custom shader drawing
     void EndShaderMode(void);                                               // End custom shader drawing (use default shader)
-    void BeginBlendMode(int mode);                                          // Begin blending mode (alpha, additive, multiplied)
+    void BeginBlendMode(int mode);                                          // Begin blending mode (alpha, additive, multiplied, subtract, custom)
     void EndBlendMode(void);                                                // End blending mode (reset to default: alpha blending)
     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
-    void BeginVrStereoMode(VrStereoConfig config);                          // Begin stereo rendering
-    void EndVrStereoMode(void);                                             // End stereo rendering
+    void BeginVrStereoMode(VrStereoConfig config);                          // Begin stereo rendering (requires VR simulator)
+    void EndVrStereoMode(void);                                             // End stereo rendering (requires VR simulator)
 
     // VR stereo config functions for VR simulator
     VrStereoConfig LoadVrStereoConfig(VrDeviceInfo device);                 // Load VR stereo config for VR simulator device parameters
@@ -79,31 +79,32 @@
     int GetShaderLocationAttrib(Shader shader, const char *attribName);     // Get shader attribute location
     void SetShaderValue(Shader shader, int locIndex, const void *value, int uniformType);               // Set shader uniform value
     void SetShaderValueV(Shader shader, int locIndex, const void *value, int uniformType, int count);   // Set shader uniform value vector
-    void SetShaderValueMatrix(Shader shader, int locIndex, Matrix mat);     // Set shader uniform value (matrix 4x4)
+    void SetShaderValueMatrix(Shader shader, int locIndex, Matrix mat);         // Set shader uniform value (matrix 4x4)
     void SetShaderValueTexture(Shader shader, int locIndex, Texture2D texture); // Set shader uniform value for texture (sampler2d)
     void UnloadShader(Shader shader);                                       // Unload shader from GPU memory (VRAM)
 
     // 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
-    Vector2 GetWorldToScreen(Vector3 position, Camera camera);              // Returns the screen space position for a 3d world space position
-    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
+    Ray GetMouseRay(Vector2 mousePosition, Camera camera);                  // Get a ray trace from mouse position
+    Matrix GetCameraMatrix(Camera camera);                                  // Get camera transform matrix (view matrix)
+    Matrix GetCameraMatrix2D(Camera2D camera);                              // Get camera 2d transform matrix
+    Vector2 GetWorldToScreen(Vector3 position, Camera camera);              // Get the screen space position for a 3d world space position
+    Vector2 GetWorldToScreenEx(Vector3 position, Camera camera, int width, int height); // Get size position for a 3d world space position
+    Vector2 GetWorldToScreen2D(Vector2 position, Camera2D camera);          // Get the screen space position for a 2d camera world space position
+    Vector2 GetScreenToWorld2D(Vector2 position, Camera2D camera);          // Get the world space position for a 2d camera screen space position
 
     // 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 (delta time)
-    double GetTime(void);                                                   // Returns elapsed time in seconds since InitWindow()
-            
-    // Misc. functions          
-    int GetRandomValue(int min, int max);                                   // Returns a random value between min and max (both included)
+    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()
+
+    // Misc. functions
+    int GetRandomValue(int min, int max);                                   // Get a random value between min and max (both included)
+    void SetRandomSeed(unsigned int seed);                                  // Set the seed for the random number generator
     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 TraceLog(int logLevel, const char *text, ...);                     // Show trace log messages (LOG_DEBUG, LOG_INFO, LOG_WARNING, LOG_ERROR)
+
+    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(int size);                                               // Internal memory allocator
     void *MemRealloc(void *ptr, int size);                                  // Internal memory reallocator
@@ -122,12 +123,12 @@
     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 UnloadFileText(unsigned char *text);                               // Unload file text data allocated by LoadFileText()
+    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
     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)
-    const char *GetFileExtension(const char *fileName);                     // Get pointer to extension for a filename string (includes dot: ".png")
+    const char *GetFileExtension(const char *fileName);                     // Get pointer to extension for a filename string (includes dot: '.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)
@@ -151,65 +152,65 @@
     void OpenURL(const char *url);                                          // Open URL with default system browser (if available)
 
     // 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
+    bool IsKeyPressed(int key);                                             // Check if a key has been pressed once
+    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
-    int GetCharPressed(void);                                               // Get char pressed (unicode), call it multiple times for chars queued
+    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
 
     // Input-related functions: gamepads
-    bool IsGamepadAvailable(int gamepad);                                   // Detect if a gamepad is available
+    bool IsGamepadAvailable(int gamepad);                                   // Check if a gamepad is available
     bool IsGamepadName(int gamepad, const char *name);                      // Check gamepad name (if available)
-    const char *GetGamepadName(int gamepad);                                // Return gamepad internal name id
-    bool IsGamepadButtonPressed(int gamepad, int button);                   // Detect if a gamepad button has been pressed once
-    bool IsGamepadButtonDown(int gamepad, int button);                      // Detect if a gamepad button is being pressed
-    bool IsGamepadButtonReleased(int gamepad, int button);                  // Detect if a gamepad button has been released once
-    bool IsGamepadButtonUp(int gamepad, int button);                        // Detect if a gamepad button is NOT being pressed
+    const char *GetGamepadName(int gamepad);                                // Get gamepad internal name id
+    bool IsGamepadButtonPressed(int gamepad, int button);                   // Check if a gamepad button has been pressed once
+    bool IsGamepadButtonDown(int gamepad, int button);                      // Check if a gamepad button is being pressed
+    bool IsGamepadButtonReleased(int gamepad, int button);                  // Check if a gamepad button has been released once
+    bool IsGamepadButtonUp(int gamepad, int button);                        // Check if a gamepad button is NOT being pressed
     int GetGamepadButtonPressed(void);                                      // Get the last gamepad button pressed
-    int GetGamepadAxisCount(int gamepad);                                   // Return gamepad axis count for a gamepad
-    float GetGamepadAxisMovement(int gamepad, int axis);                    // Return axis movement value for a gamepad axis
+    int GetGamepadAxisCount(int gamepad);                                   // Get gamepad axis count for a gamepad
+    float GetGamepadAxisMovement(int gamepad, int axis);                    // Get axis movement value for a gamepad axis
     int SetGamepadMappings(const char *mappings);                           // Set internal gamepad mappings (SDL_GameControllerDB)
 
     // Input-related functions: mouse
-    bool IsMouseButtonPressed(int button);                                  // Detect if a mouse button has been pressed once
-    bool IsMouseButtonDown(int button);                                     // Detect if a mouse button is being pressed
-    bool IsMouseButtonReleased(int button);                                 // Detect if a mouse button has been released once
-    bool IsMouseButtonUp(int button);                                       // Detect if a mouse button is NOT being pressed
-    int GetMouseX(void);                                                    // Returns mouse position X
-    int GetMouseY(void);                                                    // Returns mouse position Y
-    Vector2 GetMousePosition(void);                                         // Returns mouse position XY
+    bool IsMouseButtonPressed(int button);                                  // Check if a mouse button has been pressed once
+    bool IsMouseButtonDown(int button);                                     // Check if a mouse button is being pressed
+    bool IsMouseButtonReleased(int button);                                 // Check if a mouse button has been released once
+    bool IsMouseButtonUp(int button);                                       // Check if a mouse button is NOT being pressed
+    int GetMouseX(void);                                                    // Get mouse position X
+    int GetMouseY(void);                                                    // Get mouse position Y
+    Vector2 GetMousePosition(void);                                         // Get mouse position XY
+    Vector2 GetMouseDelta(void);                                            // Get mouse delta between frames
     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
-    float GetMouseWheelMove(void);                                          // Returns mouse wheel movement Y
+    float GetMouseWheelMove(void);                                          // Get mouse wheel movement Y
     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)
-    Vector2 GetTouchPosition(int index);                                    // Returns touch position XY for a touch point index (relative to screen size)
+    int GetTouchX(void);                                                    // Get touch position X for touch point 0 (relative to screen size)
+    int GetTouchY(void);                                                    // Get touch position Y for touch point 0 (relative to screen size)
+    Vector2 GetTouchPosition(int index);                                    // Get touch position XY for a touch point index (relative to screen size)
+    int GetTouchPointId(int index);                                         // Get touch point identifier for given index
+    int GetTouchPointCount(void);                                           // Get number of touch points
 
-    // Gestures and Touch Handling Functions (Module: gestures)
+    // 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
     int GetGestureDetected(void);                                           // Get latest detected gesture
-    int GetTouchPointsCount(void);                                          // Get touch points count
     float GetGestureHoldDuration(void);                                     // Get gesture hold time in milliseconds
     Vector2 GetGestureDragVector(void);                                     // Get gesture drag vector
     float GetGestureDragAngle(void);                                        // Get gesture drag angle
     Vector2 GetGesturePinchVector(void);                                    // Get gesture pinch delta
     float GetGesturePinchAngle(void);                                       // Get gesture pinch angle
 
-    // Camera System Functions (Module: camera)
+    // Camera System Functions (Module: rcamera)
     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 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)
+    void SetCameraMoveControls(int keyFront, int keyBack, int keyRight, int keyLeft, int keyUp, int keyDown); // Set camera move controls (1st person and 3rd person cameras)
 
diff --git a/cheatsheet/raylib_defines.c b/cheatsheet/raylib_defines.c
deleted file mode 100644
index db538e5..0000000
--- a/cheatsheet/raylib_defines.c
+++ /dev/null
@@ -1,82 +0,0 @@
-
-
-    // Keyboard Function Keys
-    #define KEY_SPACE            32
-    #define KEY_ESCAPE          256
-    #define KEY_ENTER           257
-    #define KEY_BACKSPACE       259
-    #define KEY_RIGHT           262
-    #define KEY_LEFT            263
-    #define KEY_DOWN            264
-    #define KEY_UP              265
-    #define KEY_F1              290
-    #define KEY_F2              291
-    #define KEY_F3              292
-    #define KEY_F4              293
-    #define KEY_F5              294
-    #define KEY_F6              295
-    #define KEY_F7              296
-    #define KEY_F8              297
-    #define KEY_F9              298
-    #define KEY_F10             299
-    #define KEY_LEFT_SHIFT      340
-    #define KEY_LEFT_CONTROL    341
-    #define KEY_LEFT_ALT        342
-    #define KEY_RIGHT_SHIFT     344
-    #define KEY_RIGHT_CONTROL   345
-    #define KEY_RIGHT_ALT       346
-
-    // Mouse Buttons
-    #define MOUSE_LEFT_BUTTON     0
-    #define MOUSE_RIGHT_BUTTON    1
-    #define MOUSE_MIDDLE_BUTTON   2
-
-    // Gamepad Number
-    #define GAMEPAD_PLAYER1       0
-    #define GAMEPAD_PLAYER2       1
-    #define GAMEPAD_PLAYER3       2
-    #define GAMEPAD_PLAYER4       3
-
-    // Gamepad Buttons
-    // NOTE: Adjusted for a PS3 USB Controller
-    #define GAMEPAD_BUTTON_A      2
-    #define GAMEPAD_BUTTON_B      1
-    #define GAMEPAD_BUTTON_X      3
-    #define GAMEPAD_BUTTON_Y      4
-    #define GAMEPAD_BUTTON_R1     7
-    #define GAMEPAD_BUTTON_R2     5
-    #define GAMEPAD_BUTTON_L1     6
-    #define GAMEPAD_BUTTON_L2     8
-    #define GAMEPAD_BUTTON_SELECT 9
-    #define GAMEPAD_BUTTON_START 10
-
-
-    // Some Basic Colors
-    // NOTE: Custom raylib color palette for amazing visuals
-    #define LIGHTGRAY  (Color){ 200, 200, 200, 255 }   // Light Gray
-    #define GRAY       (Color){ 130, 130, 130, 255 }   // Gray
-    #define DARKGRAY   (Color){ 80, 80, 80, 255 }      // Dark Gray
-    #define YELLOW     (Color){ 253, 249, 0, 255 }     // Yellow
-    #define GOLD       (Color){ 255, 203, 0, 255 }     // Gold
-    #define ORANGE     (Color){ 255, 161, 0, 255 }     // Orange
-    #define PINK       (Color){ 255, 109, 194, 255 }   // Pink
-    #define RED        (Color){ 230, 41, 55, 255 }     // Red
-    #define MAROON     (Color){ 190, 33, 55, 255 }     // Maroon
-    #define GREEN      (Color){ 0, 228, 48, 255 }      // Green
-    #define LIME       (Color){ 0, 158, 47, 255 }      // Lime
-    #define DARKGREEN  (Color){ 0, 117, 44, 255 }      // Dark Green
-    #define SKYBLUE    (Color){ 102, 191, 255, 255 }   // Sky Blue
-    #define BLUE       (Color){ 0, 121, 241, 255 }     // Blue
-    #define DARKBLUE   (Color){ 0, 82, 172, 255 }      // Dark Blue
-    #define PURPLE     (Color){ 200, 122, 255, 255 }   // Purple
-    #define VIOLET     (Color){ 135, 60, 190, 255 }    // Violet
-    #define DARKPURPLE (Color){ 112, 31, 126, 255 }    // Dark Purple
-    #define BEIGE      (Color){ 211, 176, 131, 255 }   // Beige
-    #define BROWN      (Color){ 127, 106, 79, 255 }    // Brown
-    #define DARKBROWN  (Color){ 76, 63, 47, 255 }      // Dark Brown
-
-    #define WHITE      (Color){ 255, 255, 255, 255 }   // White
-    #define BLACK      (Color){ 0, 0, 0, 255 }         // Black
-    #define BLANK      (Color){ 0, 0, 0, 0 }           // Blank (Transparent)
-    #define MAGENTA    (Color){ 255, 0, 255, 255 }     // Magenta
-    #define RAYWHITE   (Color){ 245, 245, 245, 255 }   // Ray White (raylib logo)
\ No newline at end of file
diff --git a/cheatsheet/raylib_models.c b/cheatsheet/raylib_models.c
index 6e3c4bb..8d61eba 100644
--- a/cheatsheet/raylib_models.c
+++ b/cheatsheet/raylib_models.c
@@ -10,11 +10,14 @@
     void DrawCubeWires(Vector3 position, float width, float height, float length, Color color);        // Draw cube wires
     void DrawCubeWiresV(Vector3 position, Vector3 size, Color color);                                  // Draw cube wires (Vector version)
     void DrawCubeTexture(Texture2D texture, Vector3 position, float width, float height, float length, Color color); // Draw cube textured
+    void DrawCubeTextureRec(Texture2D texture, Rectangle source, Vector3 position, float width, float height, float length, Color color); // Draw cube with a region of a texture
     void DrawSphere(Vector3 centerPos, float radius, Color color);                                     // Draw sphere
     void DrawSphereEx(Vector3 centerPos, float radius, int rings, int slices, Color color);            // Draw sphere with extended parameters
     void DrawSphereWires(Vector3 centerPos, float radius, int rings, int slices, Color color);         // Draw sphere wires
-    void DrawCylinder(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color); // Draw a cylinder/cone
-    void DrawCylinderWires(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color); // Draw a cylinder/cone wires
+    void DrawCylinder(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color);        // Draw a cylinder/cone
+    void DrawCylinderEx(Vector3 startPos, Vector3 endPos, float startRadius, float endRadius, int sides, Color color);      // Draw a cylinder with base at startPos and top at endPos
+    void DrawCylinderWires(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color);   // Draw a cylinder/cone wires
+    void DrawCylinderWiresEx(Vector3 startPos, Vector3 endPos, float startRadius, float endRadius, int sides, Color color); // Draw a cylinder wires with base at startPos and top at endPos
     void DrawPlane(Vector3 centerPos, Vector2 size, Color color);                                      // Draw a plane XZ
     void DrawRay(Ray ray, Color color);                                                                // Draw a ray line
     void DrawGrid(int slices, float spacing);                                                          // Draw a grid (centered at (0, 0, 0))
@@ -24,28 +27,28 @@
     Model LoadModelFromMesh(Mesh mesh);                                                                // Load model from generated mesh (default material)
     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)
+    BoundingBox GetModelBoundingBox(Model model);                                                      // Compute model bounding box limits (considers all meshes)
 
-    // Mesh loading/unloading functions
-    void UploadMesh(Mesh *mesh, bool dynamic);                                                         // Upload vertex data into GPU and provided VAO/VBO ids
-    void UpdateMeshBuffer(Mesh mesh, int index, void *data, int dataSize, int offset);                  // Update mesh vertex data in GPU for a specific buffer index
+    // 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
+    void DrawModelWires(Model model, Vector3 position, float scale, Color tint);                       // Draw a model wires (with texture if set)
+    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 position, float size, Color tint);    // Draw a billboard texture
+    void DrawBillboardRec(Camera camera, Texture2D texture, Rectangle source, Vector3 position, Vector2 size, Color tint); // Draw a billboard texture defined by source
+    void DrawBillboardPro(Camera camera, Texture2D texture, Rectangle source, Vector3 position, Vector3 up, Vector2 size, Vector2 origin, float rotation, Color tint); // Draw a billboard texture defined by source and rotation
+
+    // Mesh management functions
+    void UploadMesh(Mesh *mesh, bool dynamic);                                                         // Upload mesh vertex data in GPU and provide VAO/VBO ids
+    void UpdateMeshBuffer(Mesh mesh, int index, void *data, int dataSize, int offset);                 // Update mesh vertex data in GPU for a specific buffer index
+    void UnloadMesh(Mesh mesh);                                                                        // Unload mesh data from CPU and GPU
     void DrawMesh(Mesh mesh, Material material, Matrix transform);                                     // Draw a 3d mesh with material and transform
     void DrawMeshInstanced(Mesh mesh, Material material, Matrix *transforms, int instances);           // Draw multiple mesh instances with material and different transforms
-    void UnloadMesh(Mesh mesh);                                                                        // Unload mesh data from CPU and GPU
     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 (MATERIAL_MAP_DIFFUSE, MATERIAL_MAP_SPECULAR...)
-    void SetModelMeshMaterial(Model *model, int meshId, int materialId);                               // Set material for a mesh
-
-    // 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
-    void UnloadModelAnimations(ModelAnimation* animations, unsigned int count);                        // Unload animation array data
-    bool IsModelAnimationValid(Model model, ModelAnimation anim);                                      // Check model animation skeleton match
+    BoundingBox GetMeshBoundingBox(Mesh mesh);                                                         // Compute mesh bounding box limits
+    void GenMeshTangents(Mesh *mesh);                                                                  // Compute mesh tangents
+    void GenMeshBinormals(Mesh *mesh);                                                                 // Compute mesh binormals
 
     // Mesh generation functions
     Mesh GenMeshPoly(int sides, float radius);                                                         // Generate polygonal mesh
@@ -54,34 +57,34 @@
     Mesh GenMeshSphere(float radius, int rings, int slices);                                           // Generate sphere mesh (standard sphere)
     Mesh GenMeshHemiSphere(float radius, int rings, int slices);                                       // Generate half-sphere mesh (no bottom cap)
     Mesh GenMeshCylinder(float radius, float height, int slices);                                      // Generate cylinder mesh
+    Mesh GenMeshCone(float radius, float height, int slices);                                          // Generate cone/pyramid mesh
     Mesh GenMeshTorus(float radius, float size, int radSeg, int sides);                                // Generate torus mesh
     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
-    BoundingBox GetMeshBoundingBox(Mesh mesh);                                                            // Compute mesh bounding box limits
-    void MeshTangents(Mesh *mesh);                                                                     // Compute mesh tangents
-    void MeshBinormals(Mesh *mesh);                                                                    // Compute mesh binormals
+    // 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 (MATERIAL_MAP_DIFFUSE, MATERIAL_MAP_SPECULAR...)
+    void SetModelMeshMaterial(Model *model, int meshId, int materialId);                               // Set material for a mesh
 
-    // 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
-    void DrawModelWires(Model model, Vector3 position, float scale, Color tint);                       // Draw a model wires (with texture if set)
-    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 source, Vector3 center, float size, Color tint); // Draw a billboard texture defined by source
+    // Model animations loading/unloading functions
+    ModelAnimation *LoadModelAnimations(const char *fileName, unsigned 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
+    bool IsModelAnimationValid(Model model, ModelAnimation anim);                                      // Check model animation skeleton match
 
     // Collision detection functions
-    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)
+    bool CheckCollisionSpheres(Vector3 center1, float radius1, Vector3 center2, float radius2);        // Check collision between two spheres
+    bool CheckCollisionBoxes(BoundingBox box1, BoundingBox box2);                                      // Check collision between two bounding boxes
+    bool CheckCollisionBoxSphere(BoundingBox box, Vector3 center, float radius);                       // Check collision between box and sphere
+    RayCollision GetRayCollisionSphere(Ray ray, Vector3 center, float radius);                         // Get collision info between ray and sphere
+    RayCollision GetRayCollisionBox(Ray ray, BoundingBox box);                                         // Get collision info between ray and box
+    RayCollision GetRayCollisionModel(Ray ray, Model model);                                           // Get collision info between ray and model
+    RayCollision GetRayCollisionMesh(Ray ray, Mesh mesh, Matrix transform);                            // Get collision info between ray and mesh
+    RayCollision GetRayCollisionTriangle(Ray ray, Vector3 p1, Vector3 p2, Vector3 p3);                 // Get collision info between ray and triangle
+    RayCollision GetRayCollisionQuad(Ray ray, Vector3 p1, Vector3 p2, Vector3 p3, Vector3 p4);         // Get collision info between ray and quad
 
diff --git a/cheatsheet/raylib_shapes.c b/cheatsheet/raylib_shapes.c
index 079a078..a9ae21b 100644
--- a/cheatsheet/raylib_shapes.c
+++ b/cheatsheet/raylib_shapes.c
@@ -12,6 +12,7 @@
     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 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, float startAngle, float endAngle, int segments, Color color);      // Draw a piece of a circle
@@ -40,6 +41,7 @@
     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
+    void DrawPolyLinesEx(Vector2 center, int sides, float radius, float rotation, float lineThick, Color color); // Draw a polygon outline of n sides with extended parameters
 
     // Basic shapes collision detection functions
     bool CheckCollisionRecs(Rectangle rec1, Rectangle rec2);                                            // Check collision between two rectangles
@@ -49,5 +51,6 @@
     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 defined by two points each, returns collision point by reference
+    bool CheckCollisionPointLine(Vector2 point, Vector2 p1, Vector2 p2, int threshold);                 // Check if point belongs to line created between two points [p1] and [p2] with defined margin in pixels [threshold]
     Rectangle GetCollisionRec(Rectangle rec1, Rectangle rec2);                                          // Get collision rectangle for two rectangles collision
 
diff --git a/cheatsheet/raylib_structs.c b/cheatsheet/raylib_structs.c
index 7f7e7a2..2e9ff08 100644
--- a/cheatsheet/raylib_structs.c
+++ b/cheatsheet/raylib_structs.c
@@ -13,7 +13,7 @@
                             // NOTE: Data stored in GPU memory (VRAM)
     struct RenderTexture;   // RenderTexture type, for texture rendering
     struct NPatchInfo;      // N-Patch layout info
-    struct CharInfo;        // Font character info
+    struct GlyphInfo;       // Font character glyph info
     struct Font;            // Font type, includes texture and chars data
     
     struct Camera;          // Camera type, defines 3d camera position/orientation
@@ -27,7 +27,7 @@
     struct BoneInfo;        // Bone information
     struct ModelAnimation;  // Model animation data (bones and frames)
     struct Ray;             // Ray type (useful for raycast)
-    struct RayHitInfo;      // Raycast hit information
+    struct RayCollision;    // Raycast hit information
     struct BoundingBox;     // Bounding box type for 3d mesh
     
     struct Wave;            // Wave type, defines audio wave data
diff --git a/cheatsheet/raylib_text.c b/cheatsheet/raylib_text.c
index 172e9de..d9d32fe 100644
--- a/cheatsheet/raylib_text.c
+++ b/cheatsheet/raylib_text.c
@@ -2,28 +2,36 @@
     // 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 charsCount);            // Load font from file with extended parameters
+    Font LoadFontEx(const char *fileName, int fontSize, int *fontChars, int glyphCount);            // Load font from file with extended parameters
     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 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)
+    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'
+    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)
     void UnloadFont(Font font);                                                                     // Unload Font from GPU memory (VRAM)
 
     // Text drawing functions
     void DrawFPS(int posX, int posY);                                                               // Draw 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 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)
 
     // 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
-            
+    int GetGlyphIndex(Font font, int codepoint);                                                    // Get glyph index position in font for a codepoint (unicode character), fallback to '?' if not found
+    GlyphInfo GetGlyphInfo(Font font, int codepoint);                                               // Get glyph font info data for a codepoint (unicode character), fallback to '?' if not found
+    Rectangle GetGlyphAtlasRec(Font font, int codepoint);                                           // Get glyph rectangle in font atlas for a codepoint (unicode character), fallback to '?' if not found
+
+    // Text codepoints management functions (unicode characters)
+    int *LoadCodepoints(const char *text, int *count);                                              // Load all codepoints from a UTF-8 text string, codepoints count returned by parameter
+    void UnloadCodepoints(int *codepoints);                                                         // Unload codepoints data from memory
+    int GetCodepointCount(const char *text);                                                        // Get total number of codepoints in a UTF-8 encoded string
+    int GetCodepoint(const char *text, int *bytesProcessed);                                        // Get next codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure
+    const char *CodepointToUTF8(int codepoint, int *byteSize);                                      // Encode one codepoint into UTF-8 byte array (array length returned as parameter)
+    char *TextCodepointsToUTF8(int *codepoints, int length);                                        // Encode text as codepoints array into UTF-8 text string (WARNING: memory must be freed!)
+
     // 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,11 +49,4 @@
     const char *TextToLower(const char *text);                                                      // Get lower case version of provided string
     const char *TextToPascal(const char *text);                                                     // Get Pascal case notation version of provided string
     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
-    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
-    const char *CodepointToUtf8(int codepoint, int *byteLength);                                    // Encode codepoint into utf8 text (char array length returned as parameter)
 
diff --git a/cheatsheet/raylib_textures.c b/cheatsheet/raylib_textures.c
index 98c4c6a..211bd22 100644
--- a/cheatsheet/raylib_textures.c
+++ b/cheatsheet/raylib_textures.c
@@ -5,6 +5,8 @@
     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
+    Image LoadImageFromTexture(Texture2D texture);                                                     // Load image from GPU texture data
+    Image LoadImageFromScreen(void);                                                                   // Load image from screen buffer and (screenshot)
     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
     bool ExportImageAsCode(Image image, const char *fileName);                                         // Export image as code file defining an array of bytes, returns true on success
@@ -16,7 +18,6 @@
     Image GenImageGradientRadial(int width, int height, float density, Color inner, Color outer);      // Generate image: radial gradient
     Image GenImageChecked(int width, int height, int checksX, int checksY, Color col1, Color col2);    // Generate image: checked
     Image GenImageWhiteNoise(int width, int height, float factor);                                     // Generate image: white noise
-    Image GenImagePerlinNoise(int width, int height, int offsetX, int offsetY, float scale);           // Generate image: perlin noise
     Image GenImageCellular(int width, int height, int tileSize);                                       // Generate image: cellular algorithm. Bigger tileSize means bigger cells
 
     // Image manipulation functions
@@ -51,6 +52,7 @@
     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
+    Color GetImageColor(Image image, int x, int y);                                                    // Get image pixel color at (x, y) position
 
     // Image drawing functions
     // NOTE: Image software-rendering functions (CPU)
@@ -79,8 +81,6 @@
     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)
 
     // Texture configuration functions
     void GenTextureMipmaps(Texture2D *texture);                                                        // Generate GPU mipmaps for a texture
@@ -107,7 +107,7 @@
     Color ColorFromHSV(float hue, float saturation, float value);                                      // Returns a Color from HSV values, hue [0..360], saturation/value [0..1]
     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 GetColor(unsigned 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