Updated cheatsheet

8 files changed, 93 insertions, 69 deletions

diff --git a/cheatsheet/cheatsheet.html b/cheatsheet/cheatsheet.html
index c3161fe..62eeb5b 100644
--- a/cheatsheet/cheatsheet.html
+++ b/cheatsheet/cheatsheet.html
@@ -40,7 +40,7 @@
             body{background-color:#f5f5f5;}
             #fulldata{width: 1315px!important;}
 			.eximage img{ margin: 0 auto; border: 1px solid; border-color: black; width:770px; height:auto;}
-			pre code{ width: auto!important; border: 1px solid; border-color:#b0b0b0; width:758px; height:auto; }
+			pre code{ font-family: Courier New; font-size:12px; width: auto!important; border: 1px solid; border-color:#b0b0b0; width:758px; height:auto; }
 			.exdownbtn{width:250px; height:30px; float:left; position: relative; cursor:pointer; font-weight:bold; font-size:10px; 
 						line-height:30px; text-align: center; border-width:5px;	background-color:#e1e1e1; color:#5c5a5a; 
 						border:4px solid #898888; font-family: grixel_acme_7_wide_xtnd, Courier New, Verdana, Arial;}
@@ -126,8 +126,9 @@
         <div id="header">
             <a id="logo" href="http://www.raylib.com/index.html"></a>
             <p id="title">[simple and easy-to-use library to learn videogames programming]</p>
-            <p id="plinks">[<a href="http://www.facebook.com/raylibgames" target="_blank">www.facebook.com/raylibgames</a>][<a href="https://github.com/raysan5/raylib">github.com/raysan5/raylib</a>]</p>
-            <p id="version">v1.8.0 quick reference card</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.0.0 quick reference card</p>
         </div>
         <br>
         <div id="fulldata">
@@ -154,7 +155,7 @@
                 <p id="pcolors">colors</p>
                 <div id="colors"><pre><code class="cpp"></code></pre></div>
             </div>
-            <p id="copyright">raylib quick reference card - Copyright (c) 2013-2017 Ramon Santamaria (<a href="http://www.twitter.com/raysan5">@raysan5</a>)</p>
+            <p id="copyright">raylib quick reference card - Copyright (c) 2013-2018 Ramon Santamaria (<a href="http://www.twitter.com/raysan5">@raysan5</a>)</p>
         </div>
         
 
diff --git a/cheatsheet/raylib_core.c b/cheatsheet/raylib_core.c
index efb4063..de690fd 100644
--- a/cheatsheet/raylib_core.c
+++ b/cheatsheet/raylib_core.c
@@ -1,7 +1,8 @@
 
     // Window-related functions
-    void InitWindow(int width, int height, char* title);                    // Initialize Window and Graphics Context (OpenGL)
+    void InitWindow(int width, int height, const char *title);              // Initialize window and OpenGL context
     void CloseWindow(void);                                                 // Close window and unload OpenGL context
+    bool IsWindowReady(void);                                               // Check if window has been initialized successfully
     bool WindowShouldClose(void);                                           // Check if KEY_ESCAPE pressed or Close icon pressed
     bool IsWindowMinimized(void);                                           // Check if window has been minimized (or lost focus)
     void ToggleFullscreen(void);                                            // Toggle fullscreen mode (only PLATFORM_DESKTOP)
@@ -10,9 +11,10 @@
     void SetWindowPosition(int x, int y);                                   // Set window position on screen (only PLATFORM_DESKTOP)
     void SetWindowMonitor(int monitor);                                     // Set monitor for the current window (fullscreen mode)
     void SetWindowMinSize(int width, int height);                           // Set window minimum dimensions (for FLAG_WINDOW_RESIZABLE)
+    void SetWindowSize(int width, int height);                              // Set window dimensions
     int GetScreenWidth(void);                                               // Get current screen width
     int GetScreenHeight(void);                                              // Get current screen height
-    
+
     // Cursor-related functions
     void ShowCursor(void);                                                  // Shows cursor
     void HideCursor(void);                                                  // Hides cursor
@@ -24,10 +26,10 @@
     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 Begin2dMode(Camera2D camera);                                      // Initialize 2D mode with custom camera (2D)
-    void End2dMode(void);                                                   // Ends 2D mode with custom camera
-    void Begin3dMode(Camera camera);                                        // Initializes 3D mode with custom camera (3D)
-    void End3dMode(void);                                                   // Ends 3D mode and returns to default 2D orthographic mode
+    void BeginMode2D(Camera2D camera);                                      // Initialize 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 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
 
@@ -40,32 +42,29 @@
     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 GetHexValue(Color color);                                           // Returns hexadecimal value for a Color
+    int ColorToInt(Color color);                                            // Returns hexadecimal value for a Color
+    Vector4 ColorNormalize(Color color);                                    // Returns color normalized as float [0..1]
+    Vector3 ColorToHSV(Color color);                                        // Returns HSV values for a Color
     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
-    float *ColorToFloat(Color color);                                       // Converts Color to float array and normalizes
 
-    // Math useful functions (available from raymath.h)
-    float *VectorToFloat(Vector3 vec);                                      // Returns Vector3 as float array
-    float *MatrixToFloat(Matrix mat);                                       // Returns Matrix as float array
-    Vector3 Vector3Zero(void);                                              // Vector with components value 0.0f
-    Vector3 Vector3One(void);                                               // Vector with components value 1.0f
-    Matrix MatrixIdentity(void);                                            // Returns identity matrix
-    
     // Misc. functions
     void ShowLogo(void);                                                    // Activate raylib logo at startup (can be done with flags)
-    void SetConfigFlags(char flags);                                        // Setup window configuration flags (view FLAGS)
-    void TraceLog(int logType, const char *text, ...);                      // Show trace log messages (INFO, WARNING, ERROR, DEBUG)
+    void SetConfigFlags(unsigned char flags);                               // Setup window configuration flags (view FLAGS)
+    void SetTraceLog(unsigned char types);                                  // Enable trace log message types (bit flags based)
+    void TraceLog(int logType, const char *text, ...);                      // Show trace log messages (LOG_INFO, LOG_WARNING, LOG_ERROR, LOG_DEBUG)
     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 IsFileExtension(const char *fileName, const char *ext);            // Check file extension
-    const char *GetExtension(const char *fileName);                         // Get file extension
-    const char *GetDirectoryPath(const char *fileName);                     // Get directory for a given fileName (with path)
-    const char *GetWorkingDirectory(void);                                  // Get current working directory
+    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 *GetDirectoryPath(const char *fileName);                     // Get full path for a given fileName (uses static string)
+    const char *GetWorkingDirectory(void);                                  // Get current working directory (uses static string)
     bool ChangeDirectory(const char *dir);                                  // Change working directory, returns true if success
     bool IsFileDropped(void);                                               // Check if a file has been dropped into window
     char **GetDroppedFiles(int *count);                                     // Get dropped files names
diff --git a/cheatsheet/raylib_models.c b/cheatsheet/raylib_models.c
index 494b893..ba188e0 100644
--- a/cheatsheet/raylib_models.c
+++ b/cheatsheet/raylib_models.c
@@ -28,7 +28,13 @@
     // Mesh loading/unloading functions
     Mesh LoadMesh(const char *fileName);                                                                // Load mesh from file
     void UnloadMesh(Mesh *mesh);                                                                        // Unload mesh from memory (RAM and/or VRAM)
+    void ExportMesh(const char *fileName, Mesh mesh);                                                   // Export mesh as an OBJ file
 
+    // 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
+    
     // Mesh generation functions
     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
@@ -64,8 +70,7 @@
     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 ex.
     bool CheckCollisionRayBox(Ray ray, Vector3 minBBox, Vector3 maxBBox);                                           // Detect collision between ray and box
-    BoundingBox CalculateBoundingBox(Mesh mesh);                                                                    // Calculate mesh bounding box limits
-    RayHitInfo GetCollisionRayMesh(Ray ray, Mesh *mesh);                                                // Get collision info between ray and mesh
+    RayHitInfo GetCollisionRayModel(Ray ray, Model *model);                                             // Get collision info between ray and model
     RayHitInfo GetCollisionRayTriangle(Ray ray, Vector3 p1, Vector3 p2, Vector3 p3);                    // Get collision info between ray and triangle
     RayHitInfo GetCollisionRayGround(Ray ray, float groundHeight);                                      // Get collision info between ray and ground plane (Y-normal plane)
     
diff --git a/cheatsheet/raylib_shaders.c b/cheatsheet/raylib_shaders.c
index 7df2cb3..de952cf 100644
--- a/cheatsheet/raylib_shaders.c
+++ b/cheatsheet/raylib_shaders.c
@@ -2,10 +2,11 @@
     // Shader loading/unloading functions
     char *LoadText(const char *fileName);                                                               // Load chars array from text file
     Shader LoadShader(char *vsFileName, char *fsFileName);                                              // Load a custom shader and bind default locations
+    Shader LoadShaderCode(char *vsCode, char *fsCode);                                                  // Load shader from code strings and bind default locations
     void UnloadShader(Shader shader);                                                                   // Unload a custom shader from memory
     
-    Shader GetDefaultShader(void);                                                                      // Get default shader
-    Texture2D GetDefaultTexture(void);                                                                  // Get default texture
+    Shader GetShaderDefault(void);                                                                      // Get default shader
+    Texture2D GetTextureDefault(void);                                                                  // Get default texture
 
     // Shader access functions
     int GetShaderLocation(Shader shader, const char *uniformName);                                      // Get shader uniform location
@@ -14,6 +15,7 @@
     void SetShaderValueMatrix(Shader shader, int uniformLoc, Matrix mat);                               // Set shader uniform value (matrix 4x4)
     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
 
     // Shading beegin/end functions
     void BeginShaderMode(Shader shader);                                                                // Begin custom shader drawing
diff --git a/cheatsheet/raylib_shapes.c b/cheatsheet/raylib_shapes.c
index da17744..d2d4e22 100644
--- a/cheatsheet/raylib_shapes.c
+++ b/cheatsheet/raylib_shapes.c
@@ -11,14 +11,14 @@
     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 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
     void DrawRectanglePro(Rectangle rec, Vector2 origin, float rotation, Color color);                  // Draw a color-filled rectangle with pro parameters
     void DrawRectangleGradientV(int posX, int posY, int width, int height, Color color1, Color color2); // Draw a vertical-gradient-filled rectangle
     void DrawRectangleGradientH(int posX, int posY, int width, int height, Color color1, Color color2); // Draw a horizontal-gradient-filled rectangle
     void DrawRectangleGradientEx(Rectangle rec, Color col1, Color col2, Color col3, Color col4);        // Draw a gradient-filled rectangle with custom vertex colors
-    void DrawRectangleV(Vector2 position, Vector2 size, Color color);                                   // Draw a color-filled rectangle (Vector version)
     void DrawRectangleLines(int posX, int posY, int width, int height, Color color);                    // Draw rectangle outline
-    void DrawRectangleT(int posX, int posY, int width, int height, Color color);                        // Draw rectangle using text character
+    void DrawRectangleLinesEx(Rectangle rec, int lineThick, Color color);                               // Draw rectangle outline with extended parameters
     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 DrawPoly(Vector2 center, int sides, float radius, float rotation, Color color);                // Draw a regular polygon (Vector version)
diff --git a/cheatsheet/raylib_structs.c b/cheatsheet/raylib_structs.c
index 0929215..79edc85 100644
--- a/cheatsheet/raylib_structs.c
+++ b/cheatsheet/raylib_structs.c
@@ -3,15 +3,17 @@
     struct Rectangle;       // Rectangle type
     struct Vector2;         // Vector2 type
     struct Vector3;         // Vector3 type
+    struct Vector4;         // Vector4 type
+    struct Quaternion;      // Quaternion type
     struct Matrix;          // Matrix type (OpenGL style 4x4)
     
     struct Image;           // Image type (multiple data formats supported)
                             // NOTE: Data stored in CPU memory (RAM)               
-    struct Texture2D;       // Texture2D type (multiple internal formats supported)
+    struct Texture;         // Texture type (multiple internal formats supported)
                             // NOTE: Data stored in GPU memory (VRAM)
-    struct RenderTexture2D; // RenderTexture2D type, for texture rendering
-    struct CharInfo;        // SpriteFont character info
-    struct SpriteFont;      // SpriteFont type, includes texture and chars data
+    struct RenderTexture;   // RenderTexture type, for texture rendering
+    struct CharInfo;        // Font character info
+    struct Font;            // Font type, includes texture and chars data
     
     struct Camera;          // Camera type, defines 3d camera position/orientation
     struct Camera2D;        // Camera2D type, defines a 2d camera
diff --git a/cheatsheet/raylib_text.c b/cheatsheet/raylib_text.c
index 1c164e5..60f89e4 100644
--- a/cheatsheet/raylib_text.c
+++ b/cheatsheet/raylib_text.c
@@ -1,19 +1,21 @@
 
-    // SpriteFont loading/unloading functions
-    SpriteFont GetDefaultFont(void);                                                                    // Get the default SpriteFont
-    SpriteFont LoadSpriteFont(const char *fileName);                                                    // Load a SpriteFont image into GPU memory
-    SpriteFont LoadSpriteFontEx(const char *fileName, int fontSize, int numChars, int *fontChars);     // Load a SpriteFont from TTF font with parameters
-    void UnloadSpriteFont(SpriteFont spriteFont);                                                       // Unload SpriteFont from GPU memory
+    // 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 charsCount, int *fontChars);              // Load font from file with extended parameters
+    CharInfo *LoadFontData(const char *fileName, int fontSize, int *fontChars, int charsCount, bool sdf); // Load font data for further use
+    Image GenImageFontAtlas(CharInfo *chars, int fontSize, int charsCount, 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 on top-left corner
-    void DrawText(const char *text, int posX, int posY, int fontSize, Color color);                     // Draw text (using default font)
-    void DrawTextEx(SpriteFont spriteFont, const char* text, Vector2 position,                          // Draw text using SpriteFont and additional parameters
-                    int fontSize, int spacing, Color tint);
-    
+    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
+
     // Text misc. functions
-    int MeasureText(const char *text, int fontSize);                                                    // Measure string width for default font
-    Vector2 MeasureTextEx(SpriteFont spriteFont, const char *text, int fontSize, int spacing);          // Measure string size for SpriteFont
-    const char *FormatText(const char *text, ...);                                                      // Formatting of text with variables to 'embed'
-    const char *SubText(const char *text, int position, int length);                                    // Get a piece of a text string
+    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
+    const char *FormatText(const char *text, ...);                                                    // Formatting of text with variables to 'embed'
+    const char *SubText(const char *text, int position, int length);                                  // Get a piece of a text string
+    int GetGlyphIndex(Font font, int character);                                                      // Get index position for a unicode character on font
 
diff --git a/cheatsheet/raylib_textures.c b/cheatsheet/raylib_textures.c
index 3ccfd9d..58b9a0e 100644
--- a/cheatsheet/raylib_textures.c
+++ b/cheatsheet/raylib_textures.c
@@ -1,50 +1,63 @@
 
-    // Image/Texture2D data loading/unloading functions
-    Image LoadImage(const char *fileName);                                                              // Load an image into CPU memory (RAM)
-    Image LoadImageEx(Color *pixels, int width, int height);                                            // Load image data from Color array data (RGBA - 32bit)
+    // 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
-    Image LoadImageRaw(const char *fileName, int width, int height, int format, int headerSize);        // Load image data from RAW file
-    Texture2D LoadTexture(const char *fileName);                                                        // Load an image as texture into GPU memory
-    Texture2D LoadTextureFromImage(Image image);                                                        // Load a texture from image data
-    RenderTexture2D LoadRenderTexture(int width, int height);                                           // Load a texture to be used for rendering
+    Image LoadImageRaw(const char *fileName, int width, int height, int format, int headerSize);        // Load image from RAW file data
+    void ExportImage(const char *fileName, Image image);                                                // Export image as a PNG file
+    Texture2D LoadTexture(const char *fileName);                                                        // Load texture from file into GPU memory (VRAM)
+    Texture2D LoadTextureFromImage(Image image);                                                        // Load texture from image data
+    RenderTexture2D LoadRenderTexture(int width, int height);                                           // Load texture for rendering (framebuffer)
     void UnloadImage(Image image);                                                                      // Unload image from CPU memory (RAM)
-    void UnloadTexture(Texture2D texture);                                                              // Unload texture from GPU memory
-    void UnloadRenderTexture(RenderTexture2D target);                                                   // Unload render texture from GPU memory
+    void UnloadTexture(Texture2D texture);                                                              // Unload texture from GPU memory (VRAM)
+    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)
+    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
-    void UpdateTexture(Texture2D texture, void *pixels);                                                // Update GPU texture with new data
-    void SaveImageAs(const char *fileName, Image image);                                                // Save image to a PNG file
-   
+    void UpdateTexture(Texture2D texture, const void *pixels);                                          // Update GPU texture with new data
+
     // Image manipulation functions
+    Image ImageCopy(Image image);                                                                       // Create an image duplicate (useful for transformations)
     void ImageToPOT(Image *image, Color fillColor);                                                     // Convert image to POT (power-of-two)
     void ImageFormat(Image *image, int newFormat);                                                      // Convert image data to desired format
     void ImageAlphaMask(Image *image, Image alphaMask);                                                 // Apply alpha mask to image
-    void ImageDither(Image *image, int rBpp, int gBpp, int bBpp, int aBpp);                             // Dither image data to 16bpp or lower (Floyd-Steinberg dithering)
-    Image ImageCopy(Image image);                                                                       // Create an image duplicate (useful for transformations)
+    void ImageAlphaClear(Image *image, Color color, float threshold);                                   // Clear alpha channel to desired color
+    void ImageAlphaCrop(Image *image, float threshold);                                                 // Crop image depending on alpha value
+    void ImageAlphaPremultiply(Image *image);                                                           // Premultiply alpha channel
     void ImageCrop(Image *image, Rectangle crop);                                                       // Crop an image to a defined rectangle
-    void ImageResize(Image *image, int newWidth, int newHeight);                                        // Resize and image (bilinear filtering)
-    void ImageResizeNN(Image *image,int newWidth,int newHeight);                                        // Resize and image (Nearest-Neighbor scaling algorithm)
+    void ImageResize(Image *image, int newWidth, int newHeight);                                        // Resize image (bilinear filtering)
+    void ImageResizeNN(Image *image, int newWidth,int newHeight);                                       // Resize image (Nearest-Neighbor scaling algorithm)
+    void ImageResizeCanvas(Image *image, int newWidth, int newHeight, 
+                           int offsetX, int offsetY, Color color);                                      // Resize canvas and fill with color
+    void ImageMipmaps(Image *image);                                                                    // Generate all mipmap levels for a provided image
+    void ImageDither(Image *image, int rBpp, int gBpp, int bBpp, int aBpp);                             // Dither image data to 16bpp or lower (Floyd-Steinberg dithering)
     Image ImageText(const char *text, int fontSize, Color color);                                       // Create an image from text (default font)
-    Image ImageTextEx(SpriteFont font, const char *text, int fontSize, int spacing, Color tint);        // Create an image from text (custom sprite 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 ImageDrawRectangle(Image *dst, Vector2 position, Rectangle rec, Color color);                  // Draw rectangle within an image
     void ImageDrawText(Image *dst, Vector2 position, const char *text, int fontSize, Color color);      // Draw text (default font) within an image (destination)
-    void ImageDrawTextEx(Image *dst, Vector2 position, SpriteFont font, const char *text, 
-                         int fontSize, int spacing, Color color);                                       // Draw text (custom sprite font) within image
+    void ImageDrawTextEx(Image *dst, Vector2 position, Font font, const char *text, 
+                         float fontSize, float spacing, Color color);                                   // Draw text (custom sprite font) within an image (destination)
     void ImageFlipVertical(Image *image);                                                               // Flip image vertically
     void ImageFlipHorizontal(Image *image);                                                             // Flip image horizontally
+    void ImageRotateCW(Image *image);                                                                   // Rotate image clockwise 90deg
+    void ImageRotateCCW(Image *image);                                                                  // Rotate image counter-clockwise 90deg
     void ImageColorTint(Image *image, Color color);                                                     // Modify image color: tint
     void ImageColorInvert(Image *image);                                                                // Modify image color: invert
-    void ImageColorGrayscale(Image *image);                                                             // Modify bimage color: grayscale
+    void ImageColorGrayscale(Image *image);                                                             // Modify image color: grayscale
     void ImageColorContrast(Image *image, float contrast);                                              // Modify image color: contrast (-100 to 100)
     void ImageColorBrightness(Image *image, int brightness);                                            // Modify image color: brightness (-255 to 255)
+    void ImageColorReplace(Image *image, Color color, Color replace);                                   // Modify image color: replace color
 
     // Image generation functions
+    Image GenImageColor(int width, int height, Color color);                                            // Generate image: plain color
     Image GenImageGradientV(int width, int height, Color top, Color bottom);                            // Generate image: vertical gradient
     Image GenImageGradientH(int width, int height, Color left, Color right);                            // Generate image: horizontal gradient
     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, float scale);                                      // Generate image: perlin 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
 
     // Texture2D configuration functions