Updated raylib cheatsheet

8 files changed, 135 insertions, 99 deletions

diff --git a/cheatsheet/cheatsheet.html b/cheatsheet/cheatsheet.html
index da12099..1fb0966 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">v2.5 quick reference card  [<a id="downpdf" href="raylib_cheatsheet.pdf">download as PDF</a>]</p>
+            <p id="version">v2.6 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 5ba1324..eaa3585 100644
--- a/cheatsheet/raylib_audio.c
+++ b/cheatsheet/raylib_audio.c
@@ -18,9 +18,12 @@
 
     // Wave/Sound management functions
     void PlaySound(Sound sound);                                                    // Play a sound
+    void StopSound(Sound sound);                                                    // Stop playing a sound
     void PauseSound(Sound sound);                                                   // Pause a sound
     void ResumeSound(Sound sound);                                                  // Resume a paused sound
-    void StopSound(Sound sound);                                                    // Stop playing a sound
+    void PlaySoundMulti(Sound sound);                                               // Play a sound (using multichannel buffer pool)
+    void StopSoundMulti(void);                                                      // Stop any sound playing (using multichannel buffer pool)
+    int GetSoundsPlaying(void);                                                     // Get number of sounds playing in the multichannel
     bool IsSoundPlaying(Sound sound);                                               // Check if a sound is currently playing
     void SetSoundVolume(Sound sound, float volume);                                 // Set volume for a sound (1.0 is max level)
     void SetSoundPitch(Sound sound, float pitch);                                   // Set pitch for a sound (1.0 is base level)
diff --git a/cheatsheet/raylib_core.c b/cheatsheet/raylib_core.c
index c1ac75b..b23acff 100644
--- a/cheatsheet/raylib_core.c
+++ b/cheatsheet/raylib_core.c
@@ -24,17 +24,18 @@
     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 GetWindowPosition(void);                                        // Get window position XY on monitor
     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
-
-    // Cursor-related functions
+                
+    // 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)
-            
+                
     // Drawing-related functions            
     void ClearBackground(Color color);                                      // Set background color (framebuffer clear color)
     void BeginDrawing(void);                                                // Setup canvas (framebuffer) to start drawing
@@ -45,42 +46,51 @@
     void EndMode3D(void);                                                   // Ends 3D mode and returns to default 2D orthographic mode
     void BeginTextureMode(RenderTexture2D target);                          // Initializes render texture for drawing
     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           
     Ray GetMouseRay(Vector2 mousePosition, Camera camera);                  // Returns a ray trace from mouse position
-    Vector2 GetWorldToScreen(Vector3 position, Camera camera);              // Returns the screen space position for a 3d world space 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
+                
     // 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 char flags);                               // Setup window configuration flags (view FLAGS)
+    void SetConfigFlags(unsigned int flags);                                // Setup window 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 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           
     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
     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 (memory should be freed)
-    const char *GetDirectoryPath(const char *fileName);                     // Get full path for a given fileName (uses static 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)
+    const char *GetPrevDirectoryPath(const char *dirPath);                  // Get previous directory path for a given path (uses static string)
     const char *GetWorkingDirectory(void);                                  // Get current working directory (uses static string)
     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)
@@ -89,11 +99,14 @@
     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)
-            
-    // Persistent storage management            
+    
+    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)
+    
+    // Persistent storage management
     void StorageSaveValue(int position, int value);                         // Save integer value to storage file (to defined position)
     int StorageLoadValue(int position);                                     // Load integer value from storage file (from defined position)
-            
+    
     void OpenURL(const char *url);                                          // Open URL with default system browser (if available)
 
     //------------------------------------------------------------------------------------
diff --git a/cheatsheet/raylib_models.c b/cheatsheet/raylib_models.c
index 0ac0f8f..070394e 100644
--- a/cheatsheet/raylib_models.c
+++ b/cheatsheet/raylib_models.c
@@ -1,79 +1,80 @@
 
-    // Basic geometric 3D shapes drawing functions
-    void DrawLine3D(Vector3 startPos, Vector3 endPos, Color color);                                     // Draw a line in 3D world space
+      // 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 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
-    void DrawCubeWiresV(Vector3 position, Vector3 size, Color color);                                   // Draw cube wires (Vector version)
+    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
+    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 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 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 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))
-    void DrawGizmo(Vector3 position);                                                                   // Draw simple gizmo
-
+    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))
+    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)
-
+    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
-    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)
-
+    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
-    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
-
+    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
-    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
-
+    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 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
-    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 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 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
+    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 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 MeshBoundingBox(Mesh mesh);                                                             // Compute mesh bounding box limits
-    void MeshTangents(Mesh *mesh);                                                                      // Compute mesh tangents
-    void MeshBinormals(Mesh *mesh);                                                                     // Compute mesh binormals
-
+    BoundingBox MeshBoundingBox(Mesh mesh);                                                            // Compute mesh bounding box limits
+    void MeshTangents(Mesh *mesh);                                                                     // Compute mesh tangents
+    void MeshBinormals(Mesh *mesh);                                                                    // Compute mesh binormals
+    
     // Model drawing functions
-    void DrawModel(Model model, Vector3 position, float scale, Color tint);                             // Draw a model (with texture if set)
+    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 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 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
-
+    
     // Collision detection functions
-    bool CheckCollisionSpheres(Vector3 centerA, float radiusA, Vector3 centerB, float radiusB);         // Detect collision between two spheres
-    bool CheckCollisionBoxes(BoundingBox box1, BoundingBox box2);                                       // Detect collision between two bounding boxes
-    bool CheckCollisionBoxSphere(BoundingBox box, Vector3 centerSphere, float radiusSphere);            // Detect collision between box and sphere
-    bool CheckCollisionRaySphere(Ray ray, Vector3 spherePosition, float sphereRadius);                  // Detect collision between ray and sphere
-    bool CheckCollisionRaySphereEx(Ray ray, Vector3 spherePosition, float sphereRadius, Vector3 *collisionPoint); // Detect collision between ray and sphere, returns collision point
-    bool CheckCollisionRayBox(Ray ray, BoundingBox box);                                                // Detect collision between ray and box
-    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 centerA, float radiusA, Vector3 centerB, float radiusB);        // 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 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 814548c..d7dccf0 100644
--- a/cheatsheet/raylib_shaders.c
+++ b/cheatsheet/raylib_shaders.c
@@ -17,14 +17,13 @@
     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 GetMatrixProjection(void);                                                                   // Get internal projection matrix
 
     // Shading begin/end functions
     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 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
 
     // VR control functions
     void InitVrSimulator(void);                                                                         // Init VR simulator for selected device parameters
diff --git a/cheatsheet/raylib_shapes.c b/cheatsheet/raylib_shapes.c
index 9d5fc88..170a8a4 100644
--- a/cheatsheet/raylib_shapes.c
+++ b/cheatsheet/raylib_shapes.c
@@ -8,13 +8,15 @@
     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 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
-    void DrawRing(Vector2 center, float innerRadius, float outerRadius, int startAngle, int endAngle, int segments, Color color);      // Draw ring
-    void DrawRingLines(Vector2 center, float innerRadius, float outerRadius, int startAngle, int endAngle, int segments, Color color); // Draw ring outline
+    void DrawEllipse(int centerX, int centerY, float radiusH, float radiusV, Color color);              // Draw ellipse
+    void DrawEllipseLines(int centerX, int centerY, float radiusH, float radiusV, Color color);         // Draw ellipse outline
+    void DrawRing(Vector2 center, float innerRadius, float outerRadius, int startAngle, int endAngle, int segments, Color color); // Draw ring
+    void DrawRingLines(Vector2 center, float innerRadius, float outerRadius, int startAngle, int endAngle, int segments, Color color);    // Draw ring outline
     void DrawRectangle(int posX, int posY, int width, int height, Color color);                         // Draw a color-filled rectangle
     void DrawRectangleV(Vector2 position, Vector2 size, Color color);                                   // Draw a color-filled rectangle (Vector version)
     void DrawRectangleRec(Rectangle rec, Color color);                                                  // Draw a color-filled rectangle
@@ -26,10 +28,12 @@
     void DrawRectangleLinesEx(Rectangle rec, int lineThick, Color color);                               // Draw rectangle outline with extended parameters
     void DrawRectangleRounded(Rectangle rec, float roundness, int segments, Color color);               // Draw rectangle with rounded edges
     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
-    void DrawTriangleLines(Vector2 v1, Vector2 v2, Vector2 v3, Color color);                            // Draw triangle outline
-    void DrawTriangleFan(Vector2 *points, int numPoints, Color color);                                  // Draw a triangle fan defined by points
+    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 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 SetShapesTexture(Texture2D texture, Rectangle source);                                         // Define default texture used to draw shapes
 
diff --git a/cheatsheet/raylib_text.c b/cheatsheet/raylib_text.c
index b50ee53..79a5fec 100644
--- a/cheatsheet/raylib_text.c
+++ b/cheatsheet/raylib_text.c
@@ -5,30 +5,32 @@
     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(CharInfo *chars, int charsCount, int fontSize, int padding, int packMethod);  // Generate image font atlas using chars info
+    Image GenImageFontAtlas(const CharInfo *chars, Rectangle **recs, int charsCount, int fontSize, int padding, int packMethod);  // Generate image font atlas using chars info
     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 selectText, Color selectBack);      // Draw text using font inside rectangle limits with support for text selection
-
+                    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)
+    
     // 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 character);                                                      // Get index position for a unicode character on font
-
-    // Text strings management functions
+    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
     bool TextIsEqual(const char *text1, const char *text2);                                           // Check if two text string are equal
     unsigned int TextLength(const char *text);                                                        // Get text length, checks for '\0' ending
     const char *TextFormat(const char *text, ...);                                                    // Text formatting with variables (sprintf style)
     const char *TextSubtext(const char *text, int position, int length);                              // Get a piece of a text string
-    const char *TextReplace(char *text, const char *replace, const char *by);                         // Replace text string (memory should be freed!)
-    const char *TextInsert(const char *text, const char *insert, int position);                       // Insert text in a position (memory should be freed!)
+    char *TextReplace(char *text, const char *replace, const char *by);                               // Replace text string (memory must be freed!)
+    char *TextInsert(const char *text, const char *insert, int position);                             // Insert text in a position (memory must be freed!)
     const char *TextJoin(const char **textList, int count, const char *delimiter);                    // Join text strings with delimiter
     const char **TextSplit(const char *text, char delimiter, int *count);                             // Split text into multiple strings
     void TextAppend(char *text, const char *append, int *position);                                   // Append text at specific position and move cursor!
@@ -37,4 +39,11 @@
     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 c86ebf5..1bdecee 100644
--- a/cheatsheet/raylib_textures.c
+++ b/cheatsheet/raylib_textures.c
@@ -1,5 +1,5 @@
 
-    // Image/Texture2D data loading/unloading/saving functions
+      // Image/Texture2D data loading/unloading/saving functions
     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
@@ -15,6 +15,7 @@
     void UnloadRenderTexture(RenderTexture2D target);                                                   // Unload render texture from GPU memory (VRAM)
     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)
+    Rectangle GetImageAlphaBorder(Image image, float threshold);                                        // Get image alpha border rectangle
     int GetPixelDataSize(int width, int height, int format);                                            // Get pixel data size in bytes (image or texture)
     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)
@@ -22,6 +23,7 @@
                                                                                                         
     // Image manipulation functions                                                                     
     Image ImageCopy(Image image);                                                                       // Create an image duplicate (useful for transformations)
+    Image ImageFromImage(Image image, Rectangle rec);                                                   // Create an image from another image piece
     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
@@ -37,7 +39,7 @@
     Color *ImageExtractPalette(Image image, int maxPaletteSize, int *extractCount);                     // Extract color palette from image to maximum size (memory should be freed)
     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 ImageDraw(Image *dst, Image src, Rectangle srcRec, Rectangle dstRec);                          // Draw a source image within a destination 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 ImageDrawRectangle(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 ImageDrawText(Image *dst, Vector2 position, const char *text, int fontSize, Color color);      // Draw text (default font) within an image (destination)
@@ -68,6 +70,11 @@
     void SetTextureFilter(Texture2D texture, int filterMode);                                           // Set texture scaling filter mode
     void SetTextureWrap(Texture2D texture, int wrapMode);                                               // Set texture wrapping mode
                                                                                                         
+    // Texture2D configuration functions                                                                
+    void GenTextureMipmaps(Texture2D *texture);                                                         // Generate GPU mipmaps for a texture
+    void SetTextureFilter(Texture2D texture, int filterMode);                                           // Set texture scaling filter mode
+    void SetTextureWrap(Texture2D texture, int wrapMode);                                               // Set texture wrapping mode
+                                                                                                        
     // Texture2D drawing functions                                                                      
     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