From c9ca14e6595c45e3cf71aeaca49c2379302dff99 Mon Sep 17 00:00:00 2001
From: "Jorge A. Gomes" <jorgegomes83@hotmail.com>
Date: Fri, 3 Aug 2018 04:48:46 -0300
Subject: [PATCH 1/9] Update raylib.h

Added NinePatch struc definition and function prototype.
---
 src/raylib.h | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/src/raylib.h b/src/raylib.h
index 8d1389f73..e2d5cc33f 100644
--- a/src/raylib.h
+++ b/src/raylib.h
@@ -412,6 +412,14 @@ typedef struct RenderTexture2D {
 // RenderTexture type, same as RenderTexture2D
 typedef RenderTexture2D RenderTexture;
 
+typedef struct NinePatch {
+    Texture2D texture;      // The texture associated with the 9-patch (maybe Texture2D *, instead?)
+    Rectangle sourceRec;    // The 9-patch region in the texture
+    Vector2 minSize;        // The minimum size the 9-patch can be shrunk to
+    float borderWidth[4];   // The widths of the left, top, right and bottom borders
+    int padding[4];         // Helps the n-patch contents fit nicely inside
+} NinePatch;
+
 // Font character info
 typedef struct CharInfo {
     int value;              // Character value (Unicode)
@@ -999,6 +1007,7 @@ RLAPI void DrawTextureV(Texture2D texture, Vector2 position, Color tint);
 RLAPI void DrawTextureEx(Texture2D texture, Vector2 position, float rotation, float scale, Color tint);  // Draw a Texture2D with extended parameters
 RLAPI void DrawTextureRec(Texture2D texture, Rectangle sourceRec, Vector2 position, Color tint);         // Draw a part of a texture defined by a rectangle
 RLAPI void DrawTexturePro(Texture2D texture, Rectangle sourceRec, Rectangle destRec, Vector2 origin, float rotation, Color tint); // Draw a part of a texture defined by a rectangle with 'pro' parameters
+RLAPI void DrawNinePatch(NinePatch ninePatch, Rectangle destRec, bool usePadding, Vector2 origin, float rotation, Color tint);
 
 //------------------------------------------------------------------------------------
 // Font Loading and Text Drawing Functions (Module: text)

From 7cc2a5585b548510ec9a0756672b9a163fb6d30f Mon Sep 17 00:00:00 2001
From: "Jorge A. Gomes" <jorgegomes83@hotmail.com>
Date: Fri, 3 Aug 2018 04:51:26 -0300
Subject: [PATCH 2/9] Update textures.c

Added DrawNinePatch() function implementation.
---
 src/textures.c | 219 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 219 insertions(+)

diff --git a/src/textures.c b/src/textures.c
index 3530e115e..fb31eeb84 100644
--- a/src/textures.c
+++ b/src/textures.c
@@ -2330,6 +2330,225 @@ void DrawTexturePro(Texture2D texture, Rectangle sourceRec, Rectangle destRec, V
     }
 }
 
+void DrawNinePatch(NinePatch ninePatch, Rectangle destRec, bool usePadding, Vector2 origin, float rotation, Color tint)
+{
+    // Check if n-patch texture is valid
+    if (ninePatch.texture.id > 0)
+    {
+        float width = (float)ninePatch.texture.width;
+        float height = (float)ninePatch.texture.height;
+
+        float contentsWidth = (destRec.width >= ninePatch.minSize.x)? destRec.width : ninePatch.minSize.x;
+        float contentsHeight = (destRec.height >= ninePatch.minSize.y)? destRec.height : ninePatch.minSize.y;
+
+        if (usePadding)
+        {
+            contentsWidth  += (float)(ninePatch.padding[0] + ninePatch.padding[2]);
+            contentsHeight += (float)(ninePatch.padding[1] + ninePatch.padding[3]);
+        }
+        
+        if (ninePatch.sourceRec.width < 0) ninePatch.sourceRec.x -= ninePatch.sourceRec.width;
+        if (ninePatch.sourceRec.height < 0) ninePatch.sourceRec.y -= ninePatch.sourceRec.height;
+
+        rlEnableTexture(ninePatch.texture.id);
+
+        bool drawCenter = true;
+        bool drawMiddle = true;
+
+        float borderWidth[4];   // copy the ninePatch.borderWidth[4] values so they can be adjusted
+        for (int i = 0; i < 4; i++) { borderWidth[i] = ninePatch.borderWidth[i]; }
+
+        // adjust the lateral (left and right) border widths in case contentsWidth < ninePatch.texture.width
+        if (contentsWidth <= ninePatch.borderWidth[0] + ninePatch.borderWidth[2])
+        {
+            drawCenter = false;
+            borderWidth[0] = (borderWidth[0] / (ninePatch.borderWidth[0] + ninePatch.borderWidth[2])) * (borderWidth[0] + borderWidth[2]);
+            borderWidth[2] = contentsWidth - borderWidth[0];
+        }
+        // adjust the lateral (top and bottom) border heights in case contentsHeight < ninePatch.texture.height
+        if (contentsHeight <= ninePatch.borderWidth[1] + ninePatch.borderWidth[3])
+        {
+            drawMiddle = false;
+            borderWidth[1] = (borderWidth[1] / (ninePatch.borderWidth[1] + ninePatch.borderWidth[3])) * (borderWidth[1] + borderWidth[3]);
+            borderWidth[3] = contentsHeight - borderWidth[1];
+        }
+
+        Vector2 vertA, vertB, vertC, vertD;
+        vertA.x = 0.0f;
+        vertA.y = 0.0f;
+        vertB.x = borderWidth[0];
+        vertB.y = borderWidth[1];
+        vertC.x = contentsWidth  - borderWidth[2];
+        vertC.y = contentsHeight - borderWidth[3];
+        vertD.x = contentsWidth;
+        vertD.y = contentsHeight;
+
+        Vector2 coordA, coordB, coordC, coordD;
+        coordA.x = ninePatch.sourceRec.x / width;
+        coordA.y = ninePatch.sourceRec.y / height;
+        coordB.x = (ninePatch.sourceRec.x + borderWidth[0]) / width;
+        coordB.y = (ninePatch.sourceRec.y + borderWidth[1]) / height;
+        coordC.x = (ninePatch.sourceRec.x + ninePatch.sourceRec.width  - borderWidth[2]) / width;
+        coordC.y = (ninePatch.sourceRec.y + ninePatch.sourceRec.height - borderWidth[3]) / height;
+        coordD.x = (ninePatch.sourceRec.x + ninePatch.sourceRec.width)  / width;
+        coordD.y = (ninePatch.sourceRec.y + ninePatch.sourceRec.height) / height;
+
+        rlPushMatrix();
+            if (usePadding)
+            {
+                rlTranslatef(destRec.x - (float)ninePatch.padding[0], destRec.y - (float)ninePatch.padding[2], 0);
+            }
+            else
+            {
+                rlTranslatef(destRec.x, destRec.y, 0);
+            }
+            rlRotatef(rotation, 0, 0, 1);
+            rlTranslatef(-origin.x, -origin.y, 0);
+
+            rlBegin(RL_QUADS);
+                rlColor4ub(tint.r, tint.g, tint.b, tint.a);
+                rlNormal3f(0.0f, 0.0f, 1.0f);                          // Normal vector pointing towards viewer
+
+                // ------------------------------------------------------------
+                // TOP-LEFT QUAD
+                // Bottom-left corner for texture and quad
+                rlTexCoord2f(coordA.x, coordB.y); rlVertex2f(vertA.x, vertB.y);
+
+                // Bottom-right corner for texture and quad
+                rlTexCoord2f(coordB.x, coordB.y); rlVertex2f(vertB.x, vertB.y);
+
+                // Top-right corner for texture and quad
+                rlTexCoord2f(coordB.x, coordA.y); rlVertex2f(vertB.x, vertA.y);
+
+                // Top-left corner for texture and quad
+                rlTexCoord2f(coordA.x, coordA.y); rlVertex2f(vertA.x, vertA.y);
+
+                if (drawCenter)
+                {
+                    // TOP-CENTER QUAD
+                    // Bottom-left corner for texture and quad
+                    rlTexCoord2f(coordB.x, coordB.y); rlVertex2f(vertB.x, vertB.y);
+
+                    // Bottom-right corner for texture and quad
+                    rlTexCoord2f(coordC.x, coordB.y); rlVertex2f(vertC.x, vertB.y);
+
+                    // Top-right corner for texture and quad
+                    rlTexCoord2f(coordC.x, coordA.y); rlVertex2f(vertC.x, vertA.y);
+
+                    // Top-left corner for texture and quad
+                    rlTexCoord2f(coordB.x, coordA.y); rlVertex2f(vertB.x, vertA.y);
+                }
+
+                // TOP-RIGHT QUAD
+                // Bottom-left corner for texture and quad
+                rlTexCoord2f(coordC.x, coordB.y); rlVertex2f(vertC.x, vertB.y);
+
+                // Bottom-right corner for texture and quad
+                rlTexCoord2f(coordD.x, coordB.y); rlVertex2f(vertD.x, vertB.y);
+
+                // Top-right corner for texture and quad
+                rlTexCoord2f(coordD.x, coordA.y); rlVertex2f(vertD.x, vertA.y);
+
+                // Top-left corner for texture and quad
+                rlTexCoord2f(coordC.x, coordA.y); rlVertex2f(vertC.x, vertA.y);
+
+
+                if (drawMiddle)
+                {
+                    // ------------------------------------------------------------
+                    // MIDDLE-LEFT QUAD
+                    // Bottom-left corner for texture and quad
+                    rlTexCoord2f(coordA.x, coordC.y); rlVertex2f(vertA.x, vertC.y);
+
+                    // Bottom-right corner for texture and quad
+                    rlTexCoord2f(coordB.x, coordC.y); rlVertex2f(vertB.x, vertC.y);
+
+                    // Top-right corner for texture and quad
+                    rlTexCoord2f(coordB.x, coordB.y); rlVertex2f(vertB.x, vertB.y);
+
+                    // Top-left corner for texture and quad
+                    rlTexCoord2f(coordA.x, coordB.y); rlVertex2f(vertA.x, vertB.y);
+
+                    if (drawCenter)
+                    {
+                        // MIDDLE-CENTER QUAD
+                        // Bottom-left corner for texture and quad
+                        rlTexCoord2f(coordB.x, coordC.y); rlVertex2f(vertB.x, vertC.y);
+
+                        // Bottom-right corner for texture and quad
+                        rlTexCoord2f(coordC.x, coordC.y); rlVertex2f(vertC.x, vertC.y);
+
+                        // Top-right corner for texture and quad
+                        rlTexCoord2f(coordC.x, coordB.y); rlVertex2f(vertC.x, vertB.y);
+
+                        // Top-left corner for texture and quad
+                        rlTexCoord2f(coordB.x, coordB.y); rlVertex2f(vertB.x, vertB.y);
+                    }
+
+                    // MIDDLE-RIGHT QUAD
+                    // Bottom-left corner for texture and quad
+                    rlTexCoord2f(coordC.x, coordC.y); rlVertex2f(vertC.x, vertC.y);
+
+                    // Bottom-right corner for texture and quad
+                    rlTexCoord2f(coordD.x, coordC.y); rlVertex2f(vertD.x, vertC.y);
+
+                    // Top-right corner for texture and quad
+                    rlTexCoord2f(coordD.x, coordB.y); rlVertex2f(vertD.x, vertB.y);
+
+                    // Top-left corner for texture and quad
+                    rlTexCoord2f(coordC.x, coordB.y); rlVertex2f(vertC.x, vertB.y);
+                }
+
+                // ------------------------------------------------------------
+                // BOTTOM-LEFT QUAD
+                // Bottom-left corner for texture and quad
+                rlTexCoord2f(coordA.x, coordD.y); rlVertex2f(vertA.x, vertD.y);
+
+                // Bottom-right corner for texture and quad
+                rlTexCoord2f(coordB.x, coordD.y); rlVertex2f(vertB.x, vertD.y);
+
+                // Top-right corner for texture and quad
+                rlTexCoord2f(coordB.x, coordC.y); rlVertex2f(vertB.x, vertC.y);
+
+                // Top-left corner for texture and quad
+                rlTexCoord2f(coordA.x, coordC.y); rlVertex2f(vertA.x, vertC.y);
+
+                if (drawCenter)
+                {
+                    // BOTTOM-CENTER QUAD
+                    // Bottom-left corner for texture and quad
+                    rlTexCoord2f(coordB.x, coordD.y); rlVertex2f(vertB.x, vertD.y);
+
+                    // Bottom-right corner for texture and quad
+                    rlTexCoord2f(coordC.x, coordD.y); rlVertex2f(vertC.x, vertD.y);
+
+                    // Top-right corner for texture and quad
+                    rlTexCoord2f(coordC.x, coordC.y); rlVertex2f(vertC.x, vertC.y);
+
+                    // Top-left corner for texture and quad
+                    rlTexCoord2f(coordB.x, coordC.y); rlVertex2f(vertB.x, vertC.y);
+                }
+
+                // BOTTOM-RIGHT QUAD
+                // Bottom-left corner for texture and quad
+                rlTexCoord2f(coordC.x, coordD.y); rlVertex2f(vertC.x, vertD.y);
+
+                // Bottom-right corner for texture and quad
+                rlTexCoord2f(coordD.x, coordD.y); rlVertex2f(vertD.x, vertD.y);
+
+                // Top-right corner for texture and quad
+                rlTexCoord2f(coordD.x, coordC.y); rlVertex2f(vertD.x, vertC.y);
+
+                // Top-left corner for texture and quad
+                rlTexCoord2f(coordC.x, coordC.y); rlVertex2f(vertC.x, vertC.y);
+
+            rlEnd();
+        rlPopMatrix();
+
+        rlDisableTexture();
+    }
+}
+
 //----------------------------------------------------------------------------------
 // Module specific Functions Definition
 //----------------------------------------------------------------------------------

From 6ef03ea4e80a538149c1a09d364182901d08297d Mon Sep 17 00:00:00 2001
From: "Jorge A. Gomes" <jorgegomes83@hotmail.com>
Date: Fri, 3 Aug 2018 20:50:13 -0300
Subject: [PATCH 3/9] Update raylib.h

Added support form vertical and horizontal 3-patches.
Corrected the distortion caused when destRec size is smaller than 4x4. Now even 1x10 or 0x0 sizes are drawn correctly.
---
 src/raylib.h | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/src/raylib.h b/src/raylib.h
index e2d5cc33f..4aa6e299c 100644
--- a/src/raylib.h
+++ b/src/raylib.h
@@ -412,13 +412,14 @@ typedef struct RenderTexture2D {
 // RenderTexture type, same as RenderTexture2D
 typedef RenderTexture2D RenderTexture;
 
-typedef struct NinePatch {
+typedef struct NPatch {
     Texture2D texture;      // The texture associated with the 9-patch (maybe Texture2D *, instead?)
     Rectangle sourceRec;    // The 9-patch region in the texture
     Vector2 minSize;        // The minimum size the 9-patch can be shrunk to
     float borderWidth[4];   // The widths of the left, top, right and bottom borders
     int padding[4];         // Helps the n-patch contents fit nicely inside
-} NinePatch;
+    int type;               // The type of this n-patch: 9-patch, 3-patch vertical or 3-patch horizontal
+} NPatch;
 
 // Font character info
 typedef struct CharInfo {
@@ -737,6 +738,13 @@ typedef enum {
     HMD_SONY_PSVR
 } VrDeviceType;
 
+// Type of n-patch
+typedef enum {
+    NPT_9PATCH = 0,         // 3x3
+    NPT_3PATCH_VERTICAL,    // 1x3
+    NPT_3PATCH_HORIZONTAL   // 3x1
+} NPatchType;
+
 // Callbacks to be implemented by users
 typedef void (*TraceLogCallback)(int msgType, const char *text, va_list args);
 
@@ -1007,7 +1015,7 @@ RLAPI void DrawTextureV(Texture2D texture, Vector2 position, Color tint);
 RLAPI void DrawTextureEx(Texture2D texture, Vector2 position, float rotation, float scale, Color tint);  // Draw a Texture2D with extended parameters
 RLAPI void DrawTextureRec(Texture2D texture, Rectangle sourceRec, Vector2 position, Color tint);         // Draw a part of a texture defined by a rectangle
 RLAPI void DrawTexturePro(Texture2D texture, Rectangle sourceRec, Rectangle destRec, Vector2 origin, float rotation, Color tint); // Draw a part of a texture defined by a rectangle with 'pro' parameters
-RLAPI void DrawNinePatch(NinePatch ninePatch, Rectangle destRec, bool usePadding, Vector2 origin, float rotation, Color tint);
+RLAPI void DrawNPatch(NPatch nPatch, Rectangle destRec, bool usePadding, Vector2 origin, float rotation, Color tint); //Draw 9x9, 3x1 or 1x3 stretchable Texture2D
 
 //------------------------------------------------------------------------------------
 // Font Loading and Text Drawing Functions (Module: text)

From 28424141f000aed5d053845bd0c6b30002864310 Mon Sep 17 00:00:00 2001
From: "Jorge A. Gomes" <jorgegomes83@hotmail.com>
Date: Fri, 3 Aug 2018 20:53:15 -0300
Subject: [PATCH 4/9] Update textures.c

Added support form vertical and horizontal 3-patches.
Corrected the distortion caused when destRec size is smaller than 4x4. Now even 1x10 or 0x0 sizes are drawn correctly.
---
 src/textures.c | 377 +++++++++++++++++++++++++++++++------------------
 1 file changed, 238 insertions(+), 139 deletions(-)

diff --git a/src/textures.c b/src/textures.c
index fb31eeb84..d610d03b7 100644
--- a/src/textures.c
+++ b/src/textures.c
@@ -2330,73 +2330,80 @@ void DrawTexturePro(Texture2D texture, Rectangle sourceRec, Rectangle destRec, V
     }
 }
 
-void DrawNinePatch(NinePatch ninePatch, Rectangle destRec, bool usePadding, Vector2 origin, float rotation, Color tint)
+
+void DrawNPatch(NPatch nPatch, Rectangle destRec, bool usePadding, Vector2 origin, float rotation, Color tint)
 {
     // Check if n-patch texture is valid
-    if (ninePatch.texture.id > 0)
+    if (nPatch.texture.id > 0)
     {
-        float width = (float)ninePatch.texture.width;
-        float height = (float)ninePatch.texture.height;
+        float width = (float)nPatch.texture.width;
+        float height = (float)nPatch.texture.height;
 
-        float contentsWidth = (destRec.width >= ninePatch.minSize.x)? destRec.width : ninePatch.minSize.x;
-        float contentsHeight = (destRec.height >= ninePatch.minSize.y)? destRec.height : ninePatch.minSize.y;
+        float patchWidth = (destRec.width >= nPatch.minSize.x)? destRec.width : nPatch.minSize.x;
+        float patchHeight = (destRec.height >= nPatch.minSize.y)? destRec.height : nPatch.minSize.y;
 
         if (usePadding)
         {
-            contentsWidth  += (float)(ninePatch.padding[0] + ninePatch.padding[2]);
-            contentsHeight += (float)(ninePatch.padding[1] + ninePatch.padding[3]);
+            patchWidth  += (float)(nPatch.padding[0] + nPatch.padding[2]);
+            patchHeight += (float)(nPatch.padding[1] + nPatch.padding[3]);
         }
-        
-        if (ninePatch.sourceRec.width < 0) ninePatch.sourceRec.x -= ninePatch.sourceRec.width;
-        if (ninePatch.sourceRec.height < 0) ninePatch.sourceRec.y -= ninePatch.sourceRec.height;
 
-        rlEnableTexture(ninePatch.texture.id);
+        if (nPatch.sourceRec.width < 0) nPatch.sourceRec.x -= nPatch.sourceRec.width;
+        if (nPatch.sourceRec.height < 0) nPatch.sourceRec.y -= nPatch.sourceRec.height;
+
+        // Ignore the destRec width if the n-patch type is NPT_3PATCH_VERTICAL
+        if (nPatch.type == NPT_3PATCH_VERTICAL) { patchWidth = nPatch.sourceRec.width; }
+        
+        // Ignore the destRec height if the n-patch type is NPT_3PATCH_HORIZONTAL
+        if (nPatch.type == NPT_3PATCH_HORIZONTAL) { patchHeight = nPatch.sourceRec.height; }
 
         bool drawCenter = true;
         bool drawMiddle = true;
 
-        float borderWidth[4];   // copy the ninePatch.borderWidth[4] values so they can be adjusted
-        for (int i = 0; i < 4; i++) { borderWidth[i] = ninePatch.borderWidth[i]; }
+        float borderWidth[4];   // copy the nPatch.borderWidth[4] values so they can be adjusted
+        for (int i = 0; i < 4; i++) { borderWidth[i] = nPatch.borderWidth[i]; }
 
-        // adjust the lateral (left and right) border widths in case contentsWidth < ninePatch.texture.width
-        if (contentsWidth <= ninePatch.borderWidth[0] + ninePatch.borderWidth[2])
+        // adjust the lateral (left and right) border widths in case patchWidth < nPatch.texture.width
+        if (patchWidth <= nPatch.borderWidth[0] + nPatch.borderWidth[2])
         {
             drawCenter = false;
-            borderWidth[0] = (borderWidth[0] / (ninePatch.borderWidth[0] + ninePatch.borderWidth[2])) * (borderWidth[0] + borderWidth[2]);
-            borderWidth[2] = contentsWidth - borderWidth[0];
+            borderWidth[0] = (borderWidth[0] / (nPatch.borderWidth[0] + nPatch.borderWidth[2])) * patchWidth;
+            borderWidth[2] = patchWidth - borderWidth[0];
         }
-        // adjust the lateral (top and bottom) border heights in case contentsHeight < ninePatch.texture.height
-        if (contentsHeight <= ninePatch.borderWidth[1] + ninePatch.borderWidth[3])
+        // adjust the lateral (top and bottom) border heights in case patchHeight < nPatch.texture.height
+        if (patchHeight <= nPatch.borderWidth[1] + nPatch.borderWidth[3])
         {
             drawMiddle = false;
-            borderWidth[1] = (borderWidth[1] / (ninePatch.borderWidth[1] + ninePatch.borderWidth[3])) * (borderWidth[1] + borderWidth[3]);
-            borderWidth[3] = contentsHeight - borderWidth[1];
+            borderWidth[1] = (borderWidth[1] / (nPatch.borderWidth[1] + nPatch.borderWidth[3])) * patchHeight;
+            borderWidth[3] = patchHeight - borderWidth[1];
         }
 
         Vector2 vertA, vertB, vertC, vertD;
-        vertA.x = 0.0f;
-        vertA.y = 0.0f;
-        vertB.x = borderWidth[0];
-        vertB.y = borderWidth[1];
-        vertC.x = contentsWidth  - borderWidth[2];
-        vertC.y = contentsHeight - borderWidth[3];
-        vertD.x = contentsWidth;
-        vertD.y = contentsHeight;
+        vertA.x = 0.0f;                             // outer left
+        vertA.y = 0.0f;                             // outer top
+        vertB.x = borderWidth[0];                   // inner left
+        vertB.y = borderWidth[1];                   // inner top
+        vertC.x = patchWidth  - borderWidth[2];     // inner right
+        vertC.y = patchHeight - borderWidth[3];     // inner bottom
+        vertD.x = patchWidth;                       // outer right
+        vertD.y = patchHeight;                      // outer bottom
 
         Vector2 coordA, coordB, coordC, coordD;
-        coordA.x = ninePatch.sourceRec.x / width;
-        coordA.y = ninePatch.sourceRec.y / height;
-        coordB.x = (ninePatch.sourceRec.x + borderWidth[0]) / width;
-        coordB.y = (ninePatch.sourceRec.y + borderWidth[1]) / height;
-        coordC.x = (ninePatch.sourceRec.x + ninePatch.sourceRec.width  - borderWidth[2]) / width;
-        coordC.y = (ninePatch.sourceRec.y + ninePatch.sourceRec.height - borderWidth[3]) / height;
-        coordD.x = (ninePatch.sourceRec.x + ninePatch.sourceRec.width)  / width;
-        coordD.y = (ninePatch.sourceRec.y + ninePatch.sourceRec.height) / height;
+        coordA.x = nPatch.sourceRec.x / width;
+        coordA.y = nPatch.sourceRec.y / height;
+        coordB.x = (nPatch.sourceRec.x + borderWidth[0]) / width;
+        coordB.y = (nPatch.sourceRec.y + borderWidth[1]) / height;
+        coordC.x = (nPatch.sourceRec.x + nPatch.sourceRec.width  - borderWidth[2]) / width;
+        coordC.y = (nPatch.sourceRec.y + nPatch.sourceRec.height - borderWidth[3]) / height;
+        coordD.x = (nPatch.sourceRec.x + nPatch.sourceRec.width)  / width;
+        coordD.y = (nPatch.sourceRec.y + nPatch.sourceRec.height) / height;
+
+        rlEnableTexture(nPatch.texture.id);
 
         rlPushMatrix();
             if (usePadding)
             {
-                rlTranslatef(destRec.x - (float)ninePatch.padding[0], destRec.y - (float)ninePatch.padding[2], 0);
+                rlTranslatef(destRec.x - (float)nPatch.padding[0], destRec.y - (float)nPatch.padding[2], 0);
             }
             else
             {
@@ -2409,139 +2416,231 @@ void DrawNinePatch(NinePatch ninePatch, Rectangle destRec, bool usePadding, Vect
                 rlColor4ub(tint.r, tint.g, tint.b, tint.a);
                 rlNormal3f(0.0f, 0.0f, 1.0f);                          // Normal vector pointing towards viewer
 
-                // ------------------------------------------------------------
-                // TOP-LEFT QUAD
-                // Bottom-left corner for texture and quad
-                rlTexCoord2f(coordA.x, coordB.y); rlVertex2f(vertA.x, vertB.y);
-
-                // Bottom-right corner for texture and quad
-                rlTexCoord2f(coordB.x, coordB.y); rlVertex2f(vertB.x, vertB.y);
-
-                // Top-right corner for texture and quad
-                rlTexCoord2f(coordB.x, coordA.y); rlVertex2f(vertB.x, vertA.y);
-
-                // Top-left corner for texture and quad
-                rlTexCoord2f(coordA.x, coordA.y); rlVertex2f(vertA.x, vertA.y);
-
-                if (drawCenter)
-                {
-                    // TOP-CENTER QUAD
-                    // Bottom-left corner for texture and quad
-                    rlTexCoord2f(coordB.x, coordB.y); rlVertex2f(vertB.x, vertB.y);
-
-                    // Bottom-right corner for texture and quad
-                    rlTexCoord2f(coordC.x, coordB.y); rlVertex2f(vertC.x, vertB.y);
-
-                    // Top-right corner for texture and quad
-                    rlTexCoord2f(coordC.x, coordA.y); rlVertex2f(vertC.x, vertA.y);
-
-                    // Top-left corner for texture and quad
-                    rlTexCoord2f(coordB.x, coordA.y); rlVertex2f(vertB.x, vertA.y);
-                }
-
-                // TOP-RIGHT QUAD
-                // Bottom-left corner for texture and quad
-                rlTexCoord2f(coordC.x, coordB.y); rlVertex2f(vertC.x, vertB.y);
-
-                // Bottom-right corner for texture and quad
-                rlTexCoord2f(coordD.x, coordB.y); rlVertex2f(vertD.x, vertB.y);
-
-                // Top-right corner for texture and quad
-                rlTexCoord2f(coordD.x, coordA.y); rlVertex2f(vertD.x, vertA.y);
-
-                // Top-left corner for texture and quad
-                rlTexCoord2f(coordC.x, coordA.y); rlVertex2f(vertC.x, vertA.y);
-
-
-                if (drawMiddle)
+                if (nPatch.type == NPT_3PATCH_HORIZONTAL)
                 {
                     // ------------------------------------------------------------
-                    // MIDDLE-LEFT QUAD
+                    // LEFT QUAD
                     // Bottom-left corner for texture and quad
-                    rlTexCoord2f(coordA.x, coordC.y); rlVertex2f(vertA.x, vertC.y);
+                    rlTexCoord2f(coordA.x, coordD.y); rlVertex2f(vertA.x, vertD.y);
 
                     // Bottom-right corner for texture and quad
-                    rlTexCoord2f(coordB.x, coordC.y); rlVertex2f(vertB.x, vertC.y);
+                    rlTexCoord2f(coordB.x, coordD.y); rlVertex2f(vertB.x, vertD.y);
 
                     // Top-right corner for texture and quad
-                    rlTexCoord2f(coordB.x, coordB.y); rlVertex2f(vertB.x, vertB.y);
+                    rlTexCoord2f(coordB.x, coordA.y); rlVertex2f(vertB.x, vertA.y);
 
                     // Top-left corner for texture and quad
-                    rlTexCoord2f(coordA.x, coordB.y); rlVertex2f(vertA.x, vertB.y);
+                    rlTexCoord2f(coordA.x, coordA.y); rlVertex2f(vertA.x, vertA.y);
 
                     if (drawCenter)
                     {
-                        // MIDDLE-CENTER QUAD
+                        // CENTER QUAD
                         // Bottom-left corner for texture and quad
-                        rlTexCoord2f(coordB.x, coordC.y); rlVertex2f(vertB.x, vertC.y);
+                        rlTexCoord2f(coordB.x, coordD.y); rlVertex2f(vertB.x, vertD.y);
 
                         // Bottom-right corner for texture and quad
-                        rlTexCoord2f(coordC.x, coordC.y); rlVertex2f(vertC.x, vertC.y);
+                        rlTexCoord2f(coordC.x, coordD.y); rlVertex2f(vertC.x, vertD.y);
 
                         // Top-right corner for texture and quad
-                        rlTexCoord2f(coordC.x, coordB.y); rlVertex2f(vertC.x, vertB.y);
+                        rlTexCoord2f(coordC.x, coordA.y); rlVertex2f(vertC.x, vertA.y);
 
                         // Top-left corner for texture and quad
-                        rlTexCoord2f(coordB.x, coordB.y); rlVertex2f(vertB.x, vertB.y);
+                        rlTexCoord2f(coordB.x, coordA.y); rlVertex2f(vertB.x, vertA.y);
                     }
 
-                    // MIDDLE-RIGHT QUAD
+                    // RIGHT QUAD
                     // Bottom-left corner for texture and quad
-                    rlTexCoord2f(coordC.x, coordC.y); rlVertex2f(vertC.x, vertC.y);
-
-                    // Bottom-right corner for texture and quad
-                    rlTexCoord2f(coordD.x, coordC.y); rlVertex2f(vertD.x, vertC.y);
-
-                    // Top-right corner for texture and quad
-                    rlTexCoord2f(coordD.x, coordB.y); rlVertex2f(vertD.x, vertB.y);
-
-                    // Top-left corner for texture and quad
-                    rlTexCoord2f(coordC.x, coordB.y); rlVertex2f(vertC.x, vertB.y);
-                }
-
-                // ------------------------------------------------------------
-                // BOTTOM-LEFT QUAD
-                // Bottom-left corner for texture and quad
-                rlTexCoord2f(coordA.x, coordD.y); rlVertex2f(vertA.x, vertD.y);
-
-                // Bottom-right corner for texture and quad
-                rlTexCoord2f(coordB.x, coordD.y); rlVertex2f(vertB.x, vertD.y);
-
-                // Top-right corner for texture and quad
-                rlTexCoord2f(coordB.x, coordC.y); rlVertex2f(vertB.x, vertC.y);
-
-                // Top-left corner for texture and quad
-                rlTexCoord2f(coordA.x, coordC.y); rlVertex2f(vertA.x, vertC.y);
-
-                if (drawCenter)
-                {
-                    // BOTTOM-CENTER QUAD
-                    // Bottom-left corner for texture and quad
-                    rlTexCoord2f(coordB.x, coordD.y); rlVertex2f(vertB.x, vertD.y);
-
-                    // Bottom-right corner for texture and quad
                     rlTexCoord2f(coordC.x, coordD.y); rlVertex2f(vertC.x, vertD.y);
 
+                    // Bottom-right corner for texture and quad
+                    rlTexCoord2f(coordD.x, coordD.y); rlVertex2f(vertD.x, vertD.y);
+
                     // Top-right corner for texture and quad
-                    rlTexCoord2f(coordC.x, coordC.y); rlVertex2f(vertC.x, vertC.y);
+                    rlTexCoord2f(coordD.x, coordA.y); rlVertex2f(vertD.x, vertA.y);
 
                     // Top-left corner for texture and quad
-                    rlTexCoord2f(coordB.x, coordC.y); rlVertex2f(vertB.x, vertC.y);
+                    rlTexCoord2f(coordC.x, coordA.y); rlVertex2f(vertC.x, vertA.y);
                 }
+                else if (nPatch.type == NPT_3PATCH_VERTICAL)
+                {
+                    // ------------------------------------------------------------
+                    // TOP QUAD
+                    // Bottom-left corner for texture and quad
+                    rlTexCoord2f(coordA.x, coordB.y); rlVertex2f(vertA.x, vertB.y);
 
-                // BOTTOM-RIGHT QUAD
-                // Bottom-left corner for texture and quad
-                rlTexCoord2f(coordC.x, coordD.y); rlVertex2f(vertC.x, vertD.y);
+                    // Bottom-right corner for texture and quad
+                    rlTexCoord2f(coordD.x, coordB.y); rlVertex2f(vertD.x, vertB.y);
 
-                // Bottom-right corner for texture and quad
-                rlTexCoord2f(coordD.x, coordD.y); rlVertex2f(vertD.x, vertD.y);
+                    // Top-right corner for texture and quad
+                    rlTexCoord2f(coordD.x, coordA.y); rlVertex2f(vertD.x, vertA.y);
 
-                // Top-right corner for texture and quad
-                rlTexCoord2f(coordD.x, coordC.y); rlVertex2f(vertD.x, vertC.y);
+                    // Top-left corner for texture and quad
+                    rlTexCoord2f(coordA.x, coordA.y); rlVertex2f(vertA.x, vertA.y);
 
-                // Top-left corner for texture and quad
-                rlTexCoord2f(coordC.x, coordC.y); rlVertex2f(vertC.x, vertC.y);
+                    if (drawCenter)
+                    {
+                        // MIDDLE QUAD
+                        // Bottom-left corner for texture and quad
+                        rlTexCoord2f(coordA.x, coordC.y); rlVertex2f(vertA.x, vertC.y);
 
+                        // Bottom-right corner for texture and quad
+                        rlTexCoord2f(coordD.x, coordC.y); rlVertex2f(vertD.x, vertC.y);
+
+                        // Top-right corner for texture and quad
+                        rlTexCoord2f(coordD.x, coordB.y); rlVertex2f(vertD.x, vertB.y);
+
+                        // Top-left corner for texture and quad
+                        rlTexCoord2f(coordA.x, coordB.y); rlVertex2f(vertA.x, vertB.y);
+                    }
+
+                    // BOTTOM QUAD
+                    // Bottom-left corner for texture and quad
+                    rlTexCoord2f(coordA.x, coordD.y); rlVertex2f(vertA.x, vertD.y);
+
+                    // Bottom-right corner for texture and quad
+                    rlTexCoord2f(coordD.x, coordD.y); rlVertex2f(vertD.x, vertD.y);
+
+                    // Top-right corner for texture and quad
+                    rlTexCoord2f(coordD.x, coordC.y); rlVertex2f(vertD.x, vertC.y);
+
+                    // Top-left corner for texture and quad
+                    rlTexCoord2f(coordA.x, coordC.y); rlVertex2f(vertA.x, vertC.y);
+
+                }
+                else if (nPatch.type == NPT_9PATCH)
+                {
+                    // ------------------------------------------------------------
+                    // TOP-LEFT QUAD
+                    // Bottom-left corner for texture and quad
+                    rlTexCoord2f(coordA.x, coordB.y); rlVertex2f(vertA.x, vertB.y);
+
+                    // Bottom-right corner for texture and quad
+                    rlTexCoord2f(coordB.x, coordB.y); rlVertex2f(vertB.x, vertB.y);
+
+                    // Top-right corner for texture and quad
+                    rlTexCoord2f(coordB.x, coordA.y); rlVertex2f(vertB.x, vertA.y);
+
+                    // Top-left corner for texture and quad
+                    rlTexCoord2f(coordA.x, coordA.y); rlVertex2f(vertA.x, vertA.y);
+
+                    if (drawCenter)
+                    {
+                        // TOP-CENTER QUAD
+                        // Bottom-left corner for texture and quad
+                        rlTexCoord2f(coordB.x, coordB.y); rlVertex2f(vertB.x, vertB.y);
+
+                        // Bottom-right corner for texture and quad
+                        rlTexCoord2f(coordC.x, coordB.y); rlVertex2f(vertC.x, vertB.y);
+
+                        // Top-right corner for texture and quad
+                        rlTexCoord2f(coordC.x, coordA.y); rlVertex2f(vertC.x, vertA.y);
+
+                        // Top-left corner for texture and quad
+                        rlTexCoord2f(coordB.x, coordA.y); rlVertex2f(vertB.x, vertA.y);
+                    }
+
+                    // TOP-RIGHT QUAD
+                    // Bottom-left corner for texture and quad
+                    rlTexCoord2f(coordC.x, coordB.y); rlVertex2f(vertC.x, vertB.y);
+
+                    // Bottom-right corner for texture and quad
+                    rlTexCoord2f(coordD.x, coordB.y); rlVertex2f(vertD.x, vertB.y);
+
+                    // Top-right corner for texture and quad
+                    rlTexCoord2f(coordD.x, coordA.y); rlVertex2f(vertD.x, vertA.y);
+
+                    // Top-left corner for texture and quad
+                    rlTexCoord2f(coordC.x, coordA.y); rlVertex2f(vertC.x, vertA.y);
+
+                    if (drawMiddle)
+                    {
+                        // ------------------------------------------------------------
+                        // MIDDLE-LEFT QUAD
+                        // Bottom-left corner for texture and quad
+                        rlTexCoord2f(coordA.x, coordC.y); rlVertex2f(vertA.x, vertC.y);
+
+                        // Bottom-right corner for texture and quad
+                        rlTexCoord2f(coordB.x, coordC.y); rlVertex2f(vertB.x, vertC.y);
+
+                        // Top-right corner for texture and quad
+                        rlTexCoord2f(coordB.x, coordB.y); rlVertex2f(vertB.x, vertB.y);
+
+                        // Top-left corner for texture and quad
+                        rlTexCoord2f(coordA.x, coordB.y); rlVertex2f(vertA.x, vertB.y);
+
+                        if (drawCenter)
+                        {
+                            // MIDDLE-CENTER QUAD
+                            // Bottom-left corner for texture and quad
+                            rlTexCoord2f(coordB.x, coordC.y); rlVertex2f(vertB.x, vertC.y);
+
+                            // Bottom-right corner for texture and quad
+                            rlTexCoord2f(coordC.x, coordC.y); rlVertex2f(vertC.x, vertC.y);
+
+                            // Top-right corner for texture and quad
+                            rlTexCoord2f(coordC.x, coordB.y); rlVertex2f(vertC.x, vertB.y);
+
+                            // Top-left corner for texture and quad
+                            rlTexCoord2f(coordB.x, coordB.y); rlVertex2f(vertB.x, vertB.y);
+                        }
+
+                        // MIDDLE-RIGHT QUAD
+                        // Bottom-left corner for texture and quad
+                        rlTexCoord2f(coordC.x, coordC.y); rlVertex2f(vertC.x, vertC.y);
+
+                        // Bottom-right corner for texture and quad
+                        rlTexCoord2f(coordD.x, coordC.y); rlVertex2f(vertD.x, vertC.y);
+
+                        // Top-right corner for texture and quad
+                        rlTexCoord2f(coordD.x, coordB.y); rlVertex2f(vertD.x, vertB.y);
+
+                        // Top-left corner for texture and quad
+                        rlTexCoord2f(coordC.x, coordB.y); rlVertex2f(vertC.x, vertB.y);
+                    }
+
+                    // ------------------------------------------------------------
+                    // BOTTOM-LEFT QUAD
+                    // Bottom-left corner for texture and quad
+                    rlTexCoord2f(coordA.x, coordD.y); rlVertex2f(vertA.x, vertD.y);
+
+                    // Bottom-right corner for texture and quad
+                    rlTexCoord2f(coordB.x, coordD.y); rlVertex2f(vertB.x, vertD.y);
+
+                    // Top-right corner for texture and quad
+                    rlTexCoord2f(coordB.x, coordC.y); rlVertex2f(vertB.x, vertC.y);
+
+                    // Top-left corner for texture and quad
+                    rlTexCoord2f(coordA.x, coordC.y); rlVertex2f(vertA.x, vertC.y);
+
+                    if (drawCenter)
+                    {
+                        // BOTTOM-CENTER QUAD
+                        // Bottom-left corner for texture and quad
+                        rlTexCoord2f(coordB.x, coordD.y); rlVertex2f(vertB.x, vertD.y);
+
+                        // Bottom-right corner for texture and quad
+                        rlTexCoord2f(coordC.x, coordD.y); rlVertex2f(vertC.x, vertD.y);
+
+                        // Top-right corner for texture and quad
+                        rlTexCoord2f(coordC.x, coordC.y); rlVertex2f(vertC.x, vertC.y);
+
+                        // Top-left corner for texture and quad
+                        rlTexCoord2f(coordB.x, coordC.y); rlVertex2f(vertB.x, vertC.y);
+                    }
+
+                    // BOTTOM-RIGHT QUAD
+                    // Bottom-left corner for texture and quad
+                    rlTexCoord2f(coordC.x, coordD.y); rlVertex2f(vertC.x, vertD.y);
+
+                    // Bottom-right corner for texture and quad
+                    rlTexCoord2f(coordD.x, coordD.y); rlVertex2f(vertD.x, vertD.y);
+
+                    // Top-right corner for texture and quad
+                    rlTexCoord2f(coordD.x, coordC.y); rlVertex2f(vertD.x, vertC.y);
+
+                    // Top-left corner for texture and quad
+                    rlTexCoord2f(coordC.x, coordC.y); rlVertex2f(vertC.x, vertC.y);
+                }
             rlEnd();
         rlPopMatrix();
 

From 34c3ae5ab368bd26eed3f54556fb63af993a5f23 Mon Sep 17 00:00:00 2001
From: "Jorge A. Gomes" <jorgegomes83@hotmail.com>
Date: Wed, 8 Aug 2018 16:21:33 -0300
Subject: [PATCH 5/9] Added 9-patch texture used in the example code.

---
 examples/textures/resources/ninepatch_button.png | Bin 0 -> 5923 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 examples/textures/resources/ninepatch_button.png

diff --git a/examples/textures/resources/ninepatch_button.png b/examples/textures/resources/ninepatch_button.png
new file mode 100644
index 0000000000000000000000000000000000000000..d1b59970763dd6e152717f47ff29e2151d3892c8
GIT binary patch
literal 5923
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

literal 0
HcmV?d00001


From 051cf1346b42ef2f22e5edf3d5bfef08ec113d4f Mon Sep 17 00:00:00 2001
From: "Jorge A. Gomes" <jorgegomes83@hotmail.com>
Date: Wed, 8 Aug 2018 16:22:51 -0300
Subject: [PATCH 6/9] Added texture_image_9patch.c example

---
 examples/textures/textures_image_9patch.c | 108 ++++++++++++++++++++++
 1 file changed, 108 insertions(+)
 create mode 100644 examples/textures/textures_image_9patch.c

diff --git a/examples/textures/textures_image_9patch.c b/examples/textures/textures_image_9patch.c
new file mode 100644
index 000000000..74eda6ad4
--- /dev/null
+++ b/examples/textures/textures_image_9patch.c
@@ -0,0 +1,108 @@
+/*******************************************************************************************
+*
+*   raylib [textures] example - 9-patch drawing
+*
+*   NOTE: Images are loaded in CPU memory (RAM); textures are loaded in GPU memory (VRAM)
+*
+*   This example has been created using raylib 2.0 (www.raylib.com)
+*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*
+*   Copyright (c) 2016 Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+
+int main()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    int screenWidth = 800;
+    int screenHeight = 450;
+
+    InitWindow(screenWidth, screenHeight, "raylib [textures] example - 9-patch drawing");
+
+    // NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required)
+    Texture2D nPatchTexture = LoadTexture("resources/ninepatch_button.png");
+    Vector2 mousePosition;
+    Vector2 origin = {0.0f, 0.0f};
+
+    // The location and size of the n-patches.
+    Rectangle dstRec1 = {480.0f, 160.0f, 32.0f, 32.0f};
+    Rectangle dstRec2 = {160.0f, 160.0f, 32.0f, 32.0f};
+    Rectangle dstRecH = {160.0f, 93.0f, 32.0f, 32.0f};   // this rec's height is ignored
+    Rectangle dstRecV = {92.0f, 160.0f, 32.0f, 32.0f};   // this rec's width is ignored
+
+    // A 9-patch (NPT_9PATCH) changes its sizes in both axis
+    NPatchInfo ninePatchInfo1 = {(Rectangle){0.0f, 0.0f, 64.0f, 64.0f}, 12, 40, 12, 12, NPT_9PATCH };
+    NPatchInfo ninePatchInfo2 = {(Rectangle){0.0f, 128.0f, 64.0f, 64.0f}, 16, 16, 16, 16, NPT_9PATCH };
+    // A horizontal 3-patch (NPT_3PATCH_HORIZONTAL) changes its sizes along the x axis only
+    NPatchInfo h3PatchInfo = {(Rectangle){0.0f,  64.0f, 64.0f, 64.0f}, 8, 8, 8, 8, NPT_3PATCH_HORIZONTAL };
+    // A vertical 3-patch (NPT_3PATCH_VERTICAL) changes its sizes along the y axis only
+    NPatchInfo v3PatchInfo = {(Rectangle){0.0f, 192.0f, 64.0f, 64.0f}, 6, 6, 6, 6, NPT_3PATCH_VERTICAL };
+    
+    SetTargetFPS(60);
+    //---------------------------------------------------------------------------------------
+
+    // Main game loop
+    while (!WindowShouldClose())    // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        mousePosition = GetMousePosition();
+        // resize the n-patches based on mouse position.
+        dstRec1.width = mousePosition.x - dstRec1.x;
+        dstRec1.height = mousePosition.y - dstRec1.y;
+        dstRec2.width = mousePosition.x - dstRec2.x;
+        dstRec2.height = mousePosition.y - dstRec2.y;
+        dstRecH.width = mousePosition.x - dstRecH.x;
+        dstRecV.height = mousePosition.y - dstRecV.y;
+
+        // set a minimum width and/or height
+        if (dstRec1.width < 1.0f) dstRec1.width = 1.0f;
+        if (dstRec1.width > 300.0f) dstRec1.width = 300.0f;
+        if (dstRec1.height < 1.0f) dstRec1.height = 1.0f;
+        if (dstRec2.width < 1.0f) dstRec2.width = 1.0f;
+        if (dstRec2.width > 300.0f) dstRec2.width = 300.0f;
+        if (dstRec2.height < 1.0f) dstRec2.height = 1.0f;
+        if (dstRecH.width < 1.0f) dstRecH.width = 1.0f;
+        if (dstRecV.height < 1.0f) dstRecV.height = 1.0f;
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+
+            ClearBackground(RAYWHITE);
+
+            // Draw the n-patches
+            DrawTextureNPatch(nPatchTexture, ninePatchInfo2, dstRec2, origin, 0.0f, WHITE);
+            DrawTextureNPatch(nPatchTexture, ninePatchInfo1, dstRec1, origin, 0.0f, WHITE);
+            DrawTextureNPatch(nPatchTexture, h3PatchInfo, dstRecH, origin, 0.0f, WHITE);
+            DrawTextureNPatch(nPatchTexture, v3PatchInfo, dstRecV, origin, 0.0f, WHITE);
+            
+            // Draw the source texture
+            DrawRectangleLines( 5, 88, 74, 266, BLUE);
+            DrawTexture(nPatchTexture, 10, 93, WHITE);
+            DrawText("TEXTURE", 15, 360, 10, DARKGRAY);
+
+            DrawRectangle( 10, 10, 250, 73, Fade(SKYBLUE, 0.5));
+            DrawRectangleLines( 10, 10, 250, 73, BLUE);
+
+            DrawText("9-Patch and 3-Patch example", 20, 20, 10, BLACK);
+            DrawText("  Move the mouse to stretch or", 40, 40, 10, DARKGRAY);
+            DrawText("  shrink the n-patches.", 40, 60, 10, DARKGRAY);
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    UnloadTexture(nPatchTexture);       // Texture unloading
+
+    CloseWindow();                // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}

From 921cacacfb057d0447896641e580611be107ca7e Mon Sep 17 00:00:00 2001
From: "Jorge A. Gomes" <jorgegomes83@hotmail.com>
Date: Wed, 8 Aug 2018 16:26:51 -0300
Subject: [PATCH 7/9] Added example screenshot.

---
 examples/textures/textures_image_9patch.png | Bin 0 -> 18306 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 examples/textures/textures_image_9patch.png

diff --git a/examples/textures/textures_image_9patch.png b/examples/textures/textures_image_9patch.png
new file mode 100644
index 0000000000000000000000000000000000000000..5258811b42c76e7662a971a547b81c39f4e58a1b
GIT binary patch
literal 18306
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
O6dF%gKbLh*2~7ZUb&&7?

literal 0
HcmV?d00001


From 5f89e35d1cf6543594569d294190cfdac5be6139 Mon Sep 17 00:00:00 2001
From: "Jorge A. Gomes" <jorgegomes83@hotmail.com>
Date: Wed, 8 Aug 2018 16:39:10 -0300
Subject: [PATCH 8/9] Update raylib.h

---
 src/raylib.h | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/raylib.h b/src/raylib.h
index 4aa6e299c..af31e7794 100644
--- a/src/raylib.h
+++ b/src/raylib.h
@@ -412,14 +412,14 @@ typedef struct RenderTexture2D {
 // RenderTexture type, same as RenderTexture2D
 typedef RenderTexture2D RenderTexture;
 
-typedef struct NPatch {
-    Texture2D texture;      // The texture associated with the 9-patch (maybe Texture2D *, instead?)
-    Rectangle sourceRec;    // The 9-patch region in the texture
-    Vector2 minSize;        // The minimum size the 9-patch can be shrunk to
-    float borderWidth[4];   // The widths of the left, top, right and bottom borders
-    int padding[4];         // Helps the n-patch contents fit nicely inside
-    int type;               // The type of this n-patch: 9-patch, 3-patch vertical or 3-patch horizontal
-} NPatch;
+typedef struct NPatchInfo {
+    Rectangle sourceRec;   // Region in the texture
+    int left;              // left border offset
+    int top;               // top border offset
+    int right;             // right border offset
+    int bottom;            // bottom border offset
+    int type;              // layout of the n-patch: 3x3, 1x3 or 3x1
+} NPatchInfo;
 
 // Font character info
 typedef struct CharInfo {
@@ -1015,7 +1015,7 @@ RLAPI void DrawTextureV(Texture2D texture, Vector2 position, Color tint);
 RLAPI void DrawTextureEx(Texture2D texture, Vector2 position, float rotation, float scale, Color tint);  // Draw a Texture2D with extended parameters
 RLAPI void DrawTextureRec(Texture2D texture, Rectangle sourceRec, Vector2 position, Color tint);         // Draw a part of a texture defined by a rectangle
 RLAPI void DrawTexturePro(Texture2D texture, Rectangle sourceRec, Rectangle destRec, Vector2 origin, float rotation, Color tint); // Draw a part of a texture defined by a rectangle with 'pro' parameters
-RLAPI void DrawNPatch(NPatch nPatch, Rectangle destRec, bool usePadding, Vector2 origin, float rotation, Color tint); //Draw 9x9, 3x1 or 1x3 stretchable Texture2D
+RLAPI void DrawTextureNPatch(Texture2D texture, NPatchInfo nPatchInfo, Rectangle destRec, Vector2 origin, float rotation, Color tint); // Draws a texture (or part of it) that stretches or shrinks nicely.
 
 //------------------------------------------------------------------------------------
 // Font Loading and Text Drawing Functions (Module: text)

From dab78d59f34efcaae46966e35410687a13dd838e Mon Sep 17 00:00:00 2001
From: "Jorge A. Gomes" <jorgegomes83@hotmail.com>
Date: Wed, 8 Aug 2018 16:42:39 -0300
Subject: [PATCH 9/9] Update textures.c

See raylib/examples/textures/textures_image_9patch.c for how to use `DrawTextureNPatch` function.
---
 src/textures.c | 378 +++++++++++++++++--------------------------------
 1 file changed, 128 insertions(+), 250 deletions(-)

diff --git a/src/textures.c b/src/textures.c
index d610d03b7..48bf69acd 100644
--- a/src/textures.c
+++ b/src/textures.c
@@ -2330,85 +2330,67 @@ void DrawTexturePro(Texture2D texture, Rectangle sourceRec, Rectangle destRec, V
     }
 }
 
-
-void DrawNPatch(NPatch nPatch, Rectangle destRec, bool usePadding, Vector2 origin, float rotation, Color tint)
+void DrawTextureNPatch(Texture2D texture, NPatchInfo nPatchInfo, Rectangle destRec, Vector2 origin, float rotation, Color tint)
 {
-    // Check if n-patch texture is valid
-    if (nPatch.texture.id > 0)
+    if (texture.id > 0)
     {
-        float width = (float)nPatch.texture.width;
-        float height = (float)nPatch.texture.height;
+        float width = (float)texture.width;
+        float height = (float)texture.height;
 
-        float patchWidth = (destRec.width >= nPatch.minSize.x)? destRec.width : nPatch.minSize.x;
-        float patchHeight = (destRec.height >= nPatch.minSize.y)? destRec.height : nPatch.minSize.y;
+        float patchWidth = (destRec.width <= 0.0f)? 0.0f : destRec.width;
+        float patchHeight = (destRec.height <= 0.0f)? 0.0f : destRec.height;
 
-        if (usePadding)
-        {
-            patchWidth  += (float)(nPatch.padding[0] + nPatch.padding[2]);
-            patchHeight += (float)(nPatch.padding[1] + nPatch.padding[3]);
-        }
-
-        if (nPatch.sourceRec.width < 0) nPatch.sourceRec.x -= nPatch.sourceRec.width;
-        if (nPatch.sourceRec.height < 0) nPatch.sourceRec.y -= nPatch.sourceRec.height;
-
-        // Ignore the destRec width if the n-patch type is NPT_3PATCH_VERTICAL
-        if (nPatch.type == NPT_3PATCH_VERTICAL) { patchWidth = nPatch.sourceRec.width; }
-        
-        // Ignore the destRec height if the n-patch type is NPT_3PATCH_HORIZONTAL
-        if (nPatch.type == NPT_3PATCH_HORIZONTAL) { patchHeight = nPatch.sourceRec.height; }
+        if (nPatchInfo.sourceRec.width < 0) nPatchInfo.sourceRec.x -= nPatchInfo.sourceRec.width;
+        if (nPatchInfo.sourceRec.height < 0) nPatchInfo.sourceRec.y -= nPatchInfo.sourceRec.height;
+        if (nPatchInfo.type == NPT_3PATCH_HORIZONTAL) patchHeight = nPatchInfo.sourceRec.height;
+        if (nPatchInfo.type == NPT_3PATCH_VERTICAL) patchWidth = nPatchInfo.sourceRec.width;
 
         bool drawCenter = true;
         bool drawMiddle = true;
+        float leftBorder = (float)nPatchInfo.left;
+        float topBorder = (float)nPatchInfo.top;
+        float rightBorder = (float)nPatchInfo.right;
+        float bottomBorder = (float)nPatchInfo.bottom;
 
-        float borderWidth[4];   // copy the nPatch.borderWidth[4] values so they can be adjusted
-        for (int i = 0; i < 4; i++) { borderWidth[i] = nPatch.borderWidth[i]; }
-
-        // adjust the lateral (left and right) border widths in case patchWidth < nPatch.texture.width
-        if (patchWidth <= nPatch.borderWidth[0] + nPatch.borderWidth[2])
+        // adjust the lateral (left and right) border widths in case patchWidth < texture.width
+        if (patchWidth <= (leftBorder + rightBorder) && nPatchInfo.type != NPT_3PATCH_VERTICAL)
         {
             drawCenter = false;
-            borderWidth[0] = (borderWidth[0] / (nPatch.borderWidth[0] + nPatch.borderWidth[2])) * patchWidth;
-            borderWidth[2] = patchWidth - borderWidth[0];
+            leftBorder = (leftBorder / (leftBorder + rightBorder)) * patchWidth;
+            rightBorder = patchWidth - leftBorder;
         }
-        // adjust the lateral (top and bottom) border heights in case patchHeight < nPatch.texture.height
-        if (patchHeight <= nPatch.borderWidth[1] + nPatch.borderWidth[3])
+        // adjust the lateral (top and bottom) border heights in case patchHeight < texture.height
+        if (patchHeight <= (topBorder + bottomBorder) && nPatchInfo.type != NPT_3PATCH_HORIZONTAL)
         {
             drawMiddle = false;
-            borderWidth[1] = (borderWidth[1] / (nPatch.borderWidth[1] + nPatch.borderWidth[3])) * patchHeight;
-            borderWidth[3] = patchHeight - borderWidth[1];
+            topBorder = (topBorder / (topBorder + bottomBorder)) * patchHeight;
+            bottomBorder = patchHeight - topBorder;
         }
 
         Vector2 vertA, vertB, vertC, vertD;
         vertA.x = 0.0f;                             // outer left
         vertA.y = 0.0f;                             // outer top
-        vertB.x = borderWidth[0];                   // inner left
-        vertB.y = borderWidth[1];                   // inner top
-        vertC.x = patchWidth  - borderWidth[2];     // inner right
-        vertC.y = patchHeight - borderWidth[3];     // inner bottom
+        vertB.x = leftBorder;                       // inner left
+        vertB.y = topBorder;                        // inner top
+        vertC.x = patchWidth  - rightBorder;        // inner right
+        vertC.y = patchHeight - bottomBorder;       // inner bottom
         vertD.x = patchWidth;                       // outer right
         vertD.y = patchHeight;                      // outer bottom
 
         Vector2 coordA, coordB, coordC, coordD;
-        coordA.x = nPatch.sourceRec.x / width;
-        coordA.y = nPatch.sourceRec.y / height;
-        coordB.x = (nPatch.sourceRec.x + borderWidth[0]) / width;
-        coordB.y = (nPatch.sourceRec.y + borderWidth[1]) / height;
-        coordC.x = (nPatch.sourceRec.x + nPatch.sourceRec.width  - borderWidth[2]) / width;
-        coordC.y = (nPatch.sourceRec.y + nPatch.sourceRec.height - borderWidth[3]) / height;
-        coordD.x = (nPatch.sourceRec.x + nPatch.sourceRec.width)  / width;
-        coordD.y = (nPatch.sourceRec.y + nPatch.sourceRec.height) / height;
+        coordA.x = nPatchInfo.sourceRec.x / width;
+        coordA.y = nPatchInfo.sourceRec.y / height;
+        coordB.x = (nPatchInfo.sourceRec.x + leftBorder) / width;
+        coordB.y = (nPatchInfo.sourceRec.y + topBorder) / height;
+        coordC.x = (nPatchInfo.sourceRec.x + nPatchInfo.sourceRec.width  - rightBorder) / width;
+        coordC.y = (nPatchInfo.sourceRec.y + nPatchInfo.sourceRec.height - bottomBorder) / height;
+        coordD.x = (nPatchInfo.sourceRec.x + nPatchInfo.sourceRec.width)  / width;
+        coordD.y = (nPatchInfo.sourceRec.y + nPatchInfo.sourceRec.height) / height;
 
-        rlEnableTexture(nPatch.texture.id);
+        rlEnableTexture(texture.id);
 
         rlPushMatrix();
-            if (usePadding)
-            {
-                rlTranslatef(destRec.x - (float)nPatch.padding[0], destRec.y - (float)nPatch.padding[2], 0);
-            }
-            else
-            {
-                rlTranslatef(destRec.x, destRec.y, 0);
-            }
+            rlTranslatef(destRec.x, destRec.y, 0);
             rlRotatef(rotation, 0, 0, 1);
             rlTranslatef(-origin.x, -origin.y, 0);
 
@@ -2416,235 +2398,131 @@ void DrawNPatch(NPatch nPatch, Rectangle destRec, bool usePadding, Vector2 origi
                 rlColor4ub(tint.r, tint.g, tint.b, tint.a);
                 rlNormal3f(0.0f, 0.0f, 1.0f);                          // Normal vector pointing towards viewer
 
-                if (nPatch.type == NPT_3PATCH_HORIZONTAL)
-                {
-                    // ------------------------------------------------------------
-                    // LEFT QUAD
-                    // Bottom-left corner for texture and quad
-                    rlTexCoord2f(coordA.x, coordD.y); rlVertex2f(vertA.x, vertD.y);
-
-                    // Bottom-right corner for texture and quad
-                    rlTexCoord2f(coordB.x, coordD.y); rlVertex2f(vertB.x, vertD.y);
-
-                    // Top-right corner for texture and quad
-                    rlTexCoord2f(coordB.x, coordA.y); rlVertex2f(vertB.x, vertA.y);
-
-                    // Top-left corner for texture and quad
-                    rlTexCoord2f(coordA.x, coordA.y); rlVertex2f(vertA.x, vertA.y);
-
-                    if (drawCenter)
-                    {
-                        // CENTER QUAD
-                        // Bottom-left corner for texture and quad
-                        rlTexCoord2f(coordB.x, coordD.y); rlVertex2f(vertB.x, vertD.y);
-
-                        // Bottom-right corner for texture and quad
-                        rlTexCoord2f(coordC.x, coordD.y); rlVertex2f(vertC.x, vertD.y);
-
-                        // Top-right corner for texture and quad
-                        rlTexCoord2f(coordC.x, coordA.y); rlVertex2f(vertC.x, vertA.y);
-
-                        // Top-left corner for texture and quad
-                        rlTexCoord2f(coordB.x, coordA.y); rlVertex2f(vertB.x, vertA.y);
-                    }
-
-                    // RIGHT QUAD
-                    // Bottom-left corner for texture and quad
-                    rlTexCoord2f(coordC.x, coordD.y); rlVertex2f(vertC.x, vertD.y);
-
-                    // Bottom-right corner for texture and quad
-                    rlTexCoord2f(coordD.x, coordD.y); rlVertex2f(vertD.x, vertD.y);
-
-                    // Top-right corner for texture and quad
-                    rlTexCoord2f(coordD.x, coordA.y); rlVertex2f(vertD.x, vertA.y);
-
-                    // Top-left corner for texture and quad
-                    rlTexCoord2f(coordC.x, coordA.y); rlVertex2f(vertC.x, vertA.y);
-                }
-                else if (nPatch.type == NPT_3PATCH_VERTICAL)
-                {
-                    // ------------------------------------------------------------
-                    // TOP QUAD
-                    // Bottom-left corner for texture and quad
-                    rlTexCoord2f(coordA.x, coordB.y); rlVertex2f(vertA.x, vertB.y);
-
-                    // Bottom-right corner for texture and quad
-                    rlTexCoord2f(coordD.x, coordB.y); rlVertex2f(vertD.x, vertB.y);
-
-                    // Top-right corner for texture and quad
-                    rlTexCoord2f(coordD.x, coordA.y); rlVertex2f(vertD.x, vertA.y);
-
-                    // Top-left corner for texture and quad
-                    rlTexCoord2f(coordA.x, coordA.y); rlVertex2f(vertA.x, vertA.y);
-
-                    if (drawCenter)
-                    {
-                        // MIDDLE QUAD
-                        // Bottom-left corner for texture and quad
-                        rlTexCoord2f(coordA.x, coordC.y); rlVertex2f(vertA.x, vertC.y);
-
-                        // Bottom-right corner for texture and quad
-                        rlTexCoord2f(coordD.x, coordC.y); rlVertex2f(vertD.x, vertC.y);
-
-                        // Top-right corner for texture and quad
-                        rlTexCoord2f(coordD.x, coordB.y); rlVertex2f(vertD.x, vertB.y);
-
-                        // Top-left corner for texture and quad
-                        rlTexCoord2f(coordA.x, coordB.y); rlVertex2f(vertA.x, vertB.y);
-                    }
-
-                    // BOTTOM QUAD
-                    // Bottom-left corner for texture and quad
-                    rlTexCoord2f(coordA.x, coordD.y); rlVertex2f(vertA.x, vertD.y);
-
-                    // Bottom-right corner for texture and quad
-                    rlTexCoord2f(coordD.x, coordD.y); rlVertex2f(vertD.x, vertD.y);
-
-                    // Top-right corner for texture and quad
-                    rlTexCoord2f(coordD.x, coordC.y); rlVertex2f(vertD.x, vertC.y);
-
-                    // Top-left corner for texture and quad
-                    rlTexCoord2f(coordA.x, coordC.y); rlVertex2f(vertA.x, vertC.y);
-
-                }
-                else if (nPatch.type == NPT_9PATCH)
+                if (nPatchInfo.type == NPT_9PATCH)
                 {
                     // ------------------------------------------------------------
                     // TOP-LEFT QUAD
-                    // Bottom-left corner for texture and quad
-                    rlTexCoord2f(coordA.x, coordB.y); rlVertex2f(vertA.x, vertB.y);
-
-                    // Bottom-right corner for texture and quad
-                    rlTexCoord2f(coordB.x, coordB.y); rlVertex2f(vertB.x, vertB.y);
-
-                    // Top-right corner for texture and quad
-                    rlTexCoord2f(coordB.x, coordA.y); rlVertex2f(vertB.x, vertA.y);
-
-                    // Top-left corner for texture and quad
-                    rlTexCoord2f(coordA.x, coordA.y); rlVertex2f(vertA.x, vertA.y);
-
+                    rlTexCoord2f(coordA.x, coordB.y); rlVertex2f(vertA.x, vertB.y);  // Bottom-left corner for texture and quad
+                    rlTexCoord2f(coordB.x, coordB.y); rlVertex2f(vertB.x, vertB.y);  // Bottom-right corner for texture and quad
+                    rlTexCoord2f(coordB.x, coordA.y); rlVertex2f(vertB.x, vertA.y);  // Top-right corner for texture and quad
+                    rlTexCoord2f(coordA.x, coordA.y); rlVertex2f(vertA.x, vertA.y);  // Top-left corner for texture and quad
                     if (drawCenter)
                     {
                         // TOP-CENTER QUAD
-                        // Bottom-left corner for texture and quad
-                        rlTexCoord2f(coordB.x, coordB.y); rlVertex2f(vertB.x, vertB.y);
-
-                        // Bottom-right corner for texture and quad
-                        rlTexCoord2f(coordC.x, coordB.y); rlVertex2f(vertC.x, vertB.y);
-
-                        // Top-right corner for texture and quad
-                        rlTexCoord2f(coordC.x, coordA.y); rlVertex2f(vertC.x, vertA.y);
-
-                        // Top-left corner for texture and quad
-                        rlTexCoord2f(coordB.x, coordA.y); rlVertex2f(vertB.x, vertA.y);
+                        rlTexCoord2f(coordB.x, coordB.y); rlVertex2f(vertB.x, vertB.y);  // Bottom-left corner for texture and quad
+                        rlTexCoord2f(coordC.x, coordB.y); rlVertex2f(vertC.x, vertB.y);  // Bottom-right corner for texture and quad
+                        rlTexCoord2f(coordC.x, coordA.y); rlVertex2f(vertC.x, vertA.y);  // Top-right corner for texture and quad
+                        rlTexCoord2f(coordB.x, coordA.y); rlVertex2f(vertB.x, vertA.y);  // Top-left corner for texture and quad
                     }
-
                     // TOP-RIGHT QUAD
-                    // Bottom-left corner for texture and quad
-                    rlTexCoord2f(coordC.x, coordB.y); rlVertex2f(vertC.x, vertB.y);
-
-                    // Bottom-right corner for texture and quad
-                    rlTexCoord2f(coordD.x, coordB.y); rlVertex2f(vertD.x, vertB.y);
-
-                    // Top-right corner for texture and quad
-                    rlTexCoord2f(coordD.x, coordA.y); rlVertex2f(vertD.x, vertA.y);
-
-                    // Top-left corner for texture and quad
-                    rlTexCoord2f(coordC.x, coordA.y); rlVertex2f(vertC.x, vertA.y);
-
+                    rlTexCoord2f(coordC.x, coordB.y); rlVertex2f(vertC.x, vertB.y);  // Bottom-left corner for texture and quad
+                    rlTexCoord2f(coordD.x, coordB.y); rlVertex2f(vertD.x, vertB.y);  // Bottom-right corner for texture and quad
+                    rlTexCoord2f(coordD.x, coordA.y); rlVertex2f(vertD.x, vertA.y);  // Top-right corner for texture and quad
+                    rlTexCoord2f(coordC.x, coordA.y); rlVertex2f(vertC.x, vertA.y);  // Top-left corner for texture and quad
                     if (drawMiddle)
                     {
                         // ------------------------------------------------------------
                         // MIDDLE-LEFT QUAD
-                        // Bottom-left corner for texture and quad
-                        rlTexCoord2f(coordA.x, coordC.y); rlVertex2f(vertA.x, vertC.y);
-
-                        // Bottom-right corner for texture and quad
-                        rlTexCoord2f(coordB.x, coordC.y); rlVertex2f(vertB.x, vertC.y);
-
-                        // Top-right corner for texture and quad
-                        rlTexCoord2f(coordB.x, coordB.y); rlVertex2f(vertB.x, vertB.y);
-
-                        // Top-left corner for texture and quad
-                        rlTexCoord2f(coordA.x, coordB.y); rlVertex2f(vertA.x, vertB.y);
-
+                        rlTexCoord2f(coordA.x, coordC.y); rlVertex2f(vertA.x, vertC.y);  // Bottom-left corner for texture and quad
+                        rlTexCoord2f(coordB.x, coordC.y); rlVertex2f(vertB.x, vertC.y);  // Bottom-right corner for texture and quad
+                        rlTexCoord2f(coordB.x, coordB.y); rlVertex2f(vertB.x, vertB.y);  // Top-right corner for texture and quad
+                        rlTexCoord2f(coordA.x, coordB.y); rlVertex2f(vertA.x, vertB.y);  // Top-left corner for texture and quad
                         if (drawCenter)
                         {
                             // MIDDLE-CENTER QUAD
-                            // Bottom-left corner for texture and quad
-                            rlTexCoord2f(coordB.x, coordC.y); rlVertex2f(vertB.x, vertC.y);
-
-                            // Bottom-right corner for texture and quad
-                            rlTexCoord2f(coordC.x, coordC.y); rlVertex2f(vertC.x, vertC.y);
-
-                            // Top-right corner for texture and quad
-                            rlTexCoord2f(coordC.x, coordB.y); rlVertex2f(vertC.x, vertB.y);
-
-                            // Top-left corner for texture and quad
-                            rlTexCoord2f(coordB.x, coordB.y); rlVertex2f(vertB.x, vertB.y);
+                            rlTexCoord2f(coordB.x, coordC.y); rlVertex2f(vertB.x, vertC.y);  // Bottom-left corner for texture and quad
+                            rlTexCoord2f(coordC.x, coordC.y); rlVertex2f(vertC.x, vertC.y);  // Bottom-right corner for texture and quad
+                            rlTexCoord2f(coordC.x, coordB.y); rlVertex2f(vertC.x, vertB.y);  // Top-right corner for texture and quad
+                            rlTexCoord2f(coordB.x, coordB.y); rlVertex2f(vertB.x, vertB.y);  // Top-left corner for texture and quad
                         }
 
                         // MIDDLE-RIGHT QUAD
-                        // Bottom-left corner for texture and quad
-                        rlTexCoord2f(coordC.x, coordC.y); rlVertex2f(vertC.x, vertC.y);
-
-                        // Bottom-right corner for texture and quad
-                        rlTexCoord2f(coordD.x, coordC.y); rlVertex2f(vertD.x, vertC.y);
-
-                        // Top-right corner for texture and quad
-                        rlTexCoord2f(coordD.x, coordB.y); rlVertex2f(vertD.x, vertB.y);
-
-                        // Top-left corner for texture and quad
-                        rlTexCoord2f(coordC.x, coordB.y); rlVertex2f(vertC.x, vertB.y);
+                        rlTexCoord2f(coordC.x, coordC.y); rlVertex2f(vertC.x, vertC.y);  // Bottom-left corner for texture and quad
+                        rlTexCoord2f(coordD.x, coordC.y); rlVertex2f(vertD.x, vertC.y);  // Bottom-right corner for texture and quad
+                        rlTexCoord2f(coordD.x, coordB.y); rlVertex2f(vertD.x, vertB.y);  // Top-right corner for texture and quad
+                        rlTexCoord2f(coordC.x, coordB.y); rlVertex2f(vertC.x, vertB.y);  // Top-left corner for texture and quad
                     }
 
                     // ------------------------------------------------------------
                     // BOTTOM-LEFT QUAD
-                    // Bottom-left corner for texture and quad
-                    rlTexCoord2f(coordA.x, coordD.y); rlVertex2f(vertA.x, vertD.y);
-
-                    // Bottom-right corner for texture and quad
-                    rlTexCoord2f(coordB.x, coordD.y); rlVertex2f(vertB.x, vertD.y);
-
-                    // Top-right corner for texture and quad
-                    rlTexCoord2f(coordB.x, coordC.y); rlVertex2f(vertB.x, vertC.y);
-
-                    // Top-left corner for texture and quad
-                    rlTexCoord2f(coordA.x, coordC.y); rlVertex2f(vertA.x, vertC.y);
-
+                    rlTexCoord2f(coordA.x, coordD.y); rlVertex2f(vertA.x, vertD.y);  // Bottom-left corner for texture and quad
+                    rlTexCoord2f(coordB.x, coordD.y); rlVertex2f(vertB.x, vertD.y);  // Bottom-right corner for texture and quad
+                    rlTexCoord2f(coordB.x, coordC.y); rlVertex2f(vertB.x, vertC.y);  // Top-right corner for texture and quad
+                    rlTexCoord2f(coordA.x, coordC.y); rlVertex2f(vertA.x, vertC.y);  // Top-left corner for texture and quad
                     if (drawCenter)
                     {
                         // BOTTOM-CENTER QUAD
-                        // Bottom-left corner for texture and quad
-                        rlTexCoord2f(coordB.x, coordD.y); rlVertex2f(vertB.x, vertD.y);
-
-                        // Bottom-right corner for texture and quad
-                        rlTexCoord2f(coordC.x, coordD.y); rlVertex2f(vertC.x, vertD.y);
-
-                        // Top-right corner for texture and quad
-                        rlTexCoord2f(coordC.x, coordC.y); rlVertex2f(vertC.x, vertC.y);
-
-                        // Top-left corner for texture and quad
-                        rlTexCoord2f(coordB.x, coordC.y); rlVertex2f(vertB.x, vertC.y);
+                        rlTexCoord2f(coordB.x, coordD.y); rlVertex2f(vertB.x, vertD.y);  // Bottom-left corner for texture and quad
+                        rlTexCoord2f(coordC.x, coordD.y); rlVertex2f(vertC.x, vertD.y);  // Bottom-right corner for texture and quad
+                        rlTexCoord2f(coordC.x, coordC.y); rlVertex2f(vertC.x, vertC.y);  // Top-right corner for texture and quad
+                        rlTexCoord2f(coordB.x, coordC.y); rlVertex2f(vertB.x, vertC.y);  // Top-left corner for texture and quad
                     }
 
                     // BOTTOM-RIGHT QUAD
-                    // Bottom-left corner for texture and quad
-                    rlTexCoord2f(coordC.x, coordD.y); rlVertex2f(vertC.x, vertD.y);
-
-                    // Bottom-right corner for texture and quad
-                    rlTexCoord2f(coordD.x, coordD.y); rlVertex2f(vertD.x, vertD.y);
-
-                    // Top-right corner for texture and quad
-                    rlTexCoord2f(coordD.x, coordC.y); rlVertex2f(vertD.x, vertC.y);
-
-                    // Top-left corner for texture and quad
-                    rlTexCoord2f(coordC.x, coordC.y); rlVertex2f(vertC.x, vertC.y);
+                    rlTexCoord2f(coordC.x, coordD.y); rlVertex2f(vertC.x, vertD.y);  // Bottom-left corner for texture and quad
+                    rlTexCoord2f(coordD.x, coordD.y); rlVertex2f(vertD.x, vertD.y);  // Bottom-right corner for texture and quad
+                    rlTexCoord2f(coordD.x, coordC.y); rlVertex2f(vertD.x, vertC.y);  // Top-right corner for texture and quad
+                    rlTexCoord2f(coordC.x, coordC.y); rlVertex2f(vertC.x, vertC.y);  // Top-left corner for texture and quad
+                }
+                else if (nPatchInfo.type == NPT_3PATCH_VERTICAL)
+                {
+                    // TOP QUAD
+                    // -----------------------------------------------------------
+                    // Texture coords                 Vertices
+                    rlTexCoord2f(coordA.x, coordB.y); rlVertex2f(vertA.x, vertB.y);  // Bottom-left corner for texture and quad
+                    rlTexCoord2f(coordD.x, coordB.y); rlVertex2f(vertD.x, vertB.y);  // Bottom-right corner for texture and quad
+                    rlTexCoord2f(coordD.x, coordA.y); rlVertex2f(vertD.x, vertA.y);  // Top-right corner for texture and quad
+                    rlTexCoord2f(coordA.x, coordA.y); rlVertex2f(vertA.x, vertA.y);  // Top-left corner for texture and quad
+                    if (drawCenter)
+                    {
+                        // MIDDLE QUAD
+                        // -----------------------------------------------------------
+                        // Texture coords                 Vertices
+                        rlTexCoord2f(coordA.x, coordC.y); rlVertex2f(vertA.x, vertC.y);  // Bottom-left corner for texture and quad
+                        rlTexCoord2f(coordD.x, coordC.y); rlVertex2f(vertD.x, vertC.y);  // Bottom-right corner for texture and quad
+                        rlTexCoord2f(coordD.x, coordB.y); rlVertex2f(vertD.x, vertB.y);  // Top-right corner for texture and quad
+                        rlTexCoord2f(coordA.x, coordB.y); rlVertex2f(vertA.x, vertB.y);  // Top-left corner for texture and quad
+                    }
+                    // BOTTOM QUAD
+                    // -----------------------------------------------------------
+                    // Texture coords                 Vertices
+                    rlTexCoord2f(coordA.x, coordD.y); rlVertex2f(vertA.x, vertD.y);  // Bottom-left corner for texture and quad
+                    rlTexCoord2f(coordD.x, coordD.y); rlVertex2f(vertD.x, vertD.y);  // Bottom-right corner for texture and quad
+                    rlTexCoord2f(coordD.x, coordC.y); rlVertex2f(vertD.x, vertC.y);  // Top-right corner for texture and quad
+                    rlTexCoord2f(coordA.x, coordC.y); rlVertex2f(vertA.x, vertC.y);  // Top-left corner for texture and quad
+                }
+                else if (nPatchInfo.type == NPT_3PATCH_HORIZONTAL)
+                {
+                    // LEFT QUAD
+                    // -----------------------------------------------------------
+                    // Texture coords                 Vertices
+                    rlTexCoord2f(coordA.x, coordD.y); rlVertex2f(vertA.x, vertD.y);  // Bottom-left corner for texture and quad
+                    rlTexCoord2f(coordB.x, coordD.y); rlVertex2f(vertB.x, vertD.y);  // Bottom-right corner for texture and quad
+                    rlTexCoord2f(coordB.x, coordA.y); rlVertex2f(vertB.x, vertA.y);  // Top-right corner for texture and quad
+                    rlTexCoord2f(coordA.x, coordA.y); rlVertex2f(vertA.x, vertA.y);  // Top-left corner for texture and quad
+                    if (drawCenter)
+                    {
+                        // CENTER QUAD
+                        // -----------------------------------------------------------
+                        // Texture coords                 Vertices
+                        rlTexCoord2f(coordB.x, coordD.y); rlVertex2f(vertB.x, vertD.y);  // Bottom-left corner for texture and quad
+                        rlTexCoord2f(coordC.x, coordD.y); rlVertex2f(vertC.x, vertD.y);  // Bottom-right corner for texture and quad
+                        rlTexCoord2f(coordC.x, coordA.y); rlVertex2f(vertC.x, vertA.y);  // Top-right corner for texture and quad
+                        rlTexCoord2f(coordB.x, coordA.y); rlVertex2f(vertB.x, vertA.y);  // Top-left corner for texture and quad
+                    }
+                    // RIGHT QUAD
+                    // -----------------------------------------------------------
+                    // Texture coords                 Vertices
+                    rlTexCoord2f(coordC.x, coordD.y); rlVertex2f(vertC.x, vertD.y);  // Bottom-left corner for texture and quad
+                    rlTexCoord2f(coordD.x, coordD.y); rlVertex2f(vertD.x, vertD.y);  // Bottom-right corner for texture and quad
+                    rlTexCoord2f(coordD.x, coordA.y); rlVertex2f(vertD.x, vertA.y);  // Top-right corner for texture and quad
+                    rlTexCoord2f(coordC.x, coordA.y); rlVertex2f(vertC.x, vertA.y);  // Top-left corner for texture and quad
                 }
             rlEnd();
         rlPopMatrix();
 
         rlDisableTexture();
+
     }
 }