diff --git a/Source/ThirdParty/msdfgen/msdfgen/core/Bitmap.h b/Source/ThirdParty/msdfgen/msdfgen/core/Bitmap.h
index 9a08749f4..05c305d64 100644
--- a/Source/ThirdParty/msdfgen/msdfgen/core/Bitmap.h
+++ b/Source/ThirdParty/msdfgen/msdfgen/core/Bitmap.h
@@ -1,6 +1,7 @@
 
 #pragma once
 
+#include "YAxisOrientation.h"
 #include "BitmapRef.hpp"
 
 namespace msdfgen {
@@ -11,14 +12,16 @@ class Bitmap {
 
 public:
     Bitmap();
-    Bitmap(int width, int height);
-    Bitmap(const BitmapConstRef<T, N> &orig);
+    Bitmap(int width, int height, YAxisOrientation yOrientation = MSDFGEN_Y_AXIS_DEFAULT_ORIENTATION);
+    explicit Bitmap(const BitmapConstRef<T, N> &orig);
+    explicit Bitmap(const BitmapConstSection<T, N> &orig);
     Bitmap(const Bitmap<T, N> &orig);
 #ifdef MSDFGEN_USE_CPP11
     Bitmap(Bitmap<T, N> &&orig);
 #endif
     ~Bitmap();
     Bitmap<T, N> &operator=(const BitmapConstRef<T, N> &orig);
+    Bitmap<T, N> &operator=(const BitmapConstSection<T, N> &orig);
     Bitmap<T, N> &operator=(const Bitmap<T, N> &orig);
 #ifdef MSDFGEN_USE_CPP11
     Bitmap<T, N> &operator=(Bitmap<T, N> &&orig);
@@ -38,10 +41,17 @@ public:
 #endif
     operator BitmapRef<T, N>();
     operator BitmapConstRef<T, N>() const;
+    operator BitmapSection<T, N>();
+    operator BitmapConstSection<T, N>() const;
+    /// Returns a reference to a rectangular section of the bitmap specified by bounds (excluding xMax, yMax).
+    BitmapSection<T, N> getSection(int xMin, int yMin, int xMax, int yMax);
+    /// Returns a constant reference to a rectangular section of the bitmap specified by bounds (excluding xMax, yMax).
+    BitmapConstSection<T, N> getConstSection(int xMin, int yMin, int xMax, int yMax) const;
 
 private:
     T *pixels;
     int w, h;
+    YAxisOrientation yOrientation;
 
 };
 
diff --git a/Source/ThirdParty/msdfgen/msdfgen/core/Bitmap.hpp b/Source/ThirdParty/msdfgen/msdfgen/core/Bitmap.hpp
index 940435778..afb53942f 100644
--- a/Source/ThirdParty/msdfgen/msdfgen/core/Bitmap.hpp
+++ b/Source/ThirdParty/msdfgen/msdfgen/core/Bitmap.hpp
@@ -7,28 +7,41 @@
 namespace msdfgen {
 
 template <typename T, int N>
-Bitmap<T, N>::Bitmap() : pixels(NULL), w(0), h(0) { }
+Bitmap<T, N>::Bitmap() : pixels(NULL), w(0), h(0), yOrientation(MSDFGEN_Y_AXIS_DEFAULT_ORIENTATION) { }
 
 template <typename T, int N>
-Bitmap<T, N>::Bitmap(int width, int height) : w(width), h(height) {
+Bitmap<T, N>::Bitmap(int width, int height, YAxisOrientation yOrientation) : w(width), h(height), yOrientation(yOrientation) {
     pixels = new T[N*w*h];
 }
 
 template <typename T, int N>
-Bitmap<T, N>::Bitmap(const BitmapConstRef<T, N> &orig) : w(orig.width), h(orig.height) {
+Bitmap<T, N>::Bitmap(const BitmapConstRef<T, N> &orig) : w(orig.width), h(orig.height), yOrientation(orig.yOrientation) {
     pixels = new T[N*w*h];
     memcpy(pixels, orig.pixels, sizeof(T)*N*w*h);
 }
 
 template <typename T, int N>
-Bitmap<T, N>::Bitmap(const Bitmap<T, N> &orig) : w(orig.w), h(orig.h) {
+Bitmap<T, N>::Bitmap(const BitmapConstSection<T, N> &orig) : w(orig.width), h(orig.height), yOrientation(orig.yOrientation) {
+    pixels = new T[N*w*h];
+    T *dst = pixels;
+    const T *src = orig.pixels;
+    int rowLength = N*w;
+    for (int y = 0; y < h; ++y) {
+        memcpy(dst, src, sizeof(T)*rowLength);
+        dst += rowLength;
+        src += orig.rowStride;
+    }
+}
+
+template <typename T, int N>
+Bitmap<T, N>::Bitmap(const Bitmap<T, N> &orig) : w(orig.w), h(orig.h), yOrientation(orig.yOrientation) {
     pixels = new T[N*w*h];
     memcpy(pixels, orig.pixels, sizeof(T)*N*w*h);
 }
 
 #ifdef MSDFGEN_USE_CPP11
 template <typename T, int N>
-Bitmap<T, N>::Bitmap(Bitmap<T, N> &&orig) : pixels(orig.pixels), w(orig.w), h(orig.h) {
+Bitmap<T, N>::Bitmap(Bitmap<T, N> &&orig) : pixels(orig.pixels), w(orig.w), h(orig.h), yOrientation(orig.yOrientation) {
     orig.pixels = NULL;
     orig.w = 0, orig.h = 0;
 }
@@ -36,25 +49,46 @@ Bitmap<T, N>::Bitmap(Bitmap<T, N> &&orig) : pixels(orig.pixels), w(orig.w), h(or
 
 template <typename T, int N>
 Bitmap<T, N>::~Bitmap() {
-    delete [] pixels;
+    delete[] pixels;
 }
 
 template <typename T, int N>
 Bitmap<T, N> &Bitmap<T, N>::operator=(const BitmapConstRef<T, N> &orig) {
     if (pixels != orig.pixels) {
-        delete [] pixels;
+        delete[] pixels;
         w = orig.width, h = orig.height;
+        yOrientation = orig.yOrientation;
         pixels = new T[N*w*h];
         memcpy(pixels, orig.pixels, sizeof(T)*N*w*h);
     }
     return *this;
 }
 
+template <typename T, int N>
+Bitmap<T, N> &Bitmap<T, N>::operator=(const BitmapConstSection<T, N> &orig) {
+    if (orig.pixels && orig.pixels >= pixels && orig.pixels < pixels+N*w*h)
+        return *this = Bitmap<T, N>(orig);
+    delete[] pixels;
+    w = orig.width, h = orig.height;
+    yOrientation = orig.yOrientation;
+    pixels = new T[N*w*h];
+    T *dst = pixels;
+    const T *src = orig.pixels;
+    int rowLength = N*w;
+    for (int y = 0; y < h; ++y) {
+        memcpy(dst, src, sizeof(T)*rowLength);
+        dst += rowLength;
+        src += orig.rowStride;
+    }
+    return *this;
+}
+
 template <typename T, int N>
 Bitmap<T, N> &Bitmap<T, N>::operator=(const Bitmap<T, N> &orig) {
     if (this != &orig) {
-        delete [] pixels;
+        delete[] pixels;
         w = orig.w, h = orig.h;
+        yOrientation = orig.yOrientation;
         pixels = new T[N*w*h];
         memcpy(pixels, orig.pixels, sizeof(T)*N*w*h);
     }
@@ -65,9 +99,10 @@ Bitmap<T, N> &Bitmap<T, N>::operator=(const Bitmap<T, N> &orig) {
 template <typename T, int N>
 Bitmap<T, N> &Bitmap<T, N>::operator=(Bitmap<T, N> &&orig) {
     if (this != &orig) {
-        delete [] pixels;
+        delete[] pixels;
         pixels = orig.pixels;
         w = orig.w, h = orig.h;
+        yOrientation = orig.yOrientation;
         orig.pixels = NULL;
     }
     return *this;
@@ -106,12 +141,32 @@ Bitmap<T, N>::operator const T *() const {
 
 template <typename T, int N>
 Bitmap<T, N>::operator BitmapRef<T, N>() {
-    return BitmapRef<T, N>(pixels, w, h);
+    return BitmapRef<T, N>(pixels, w, h, yOrientation);
 }
 
 template <typename T, int N>
 Bitmap<T, N>::operator BitmapConstRef<T, N>() const {
-    return BitmapConstRef<T, N>(pixels, w, h);
+    return BitmapConstRef<T, N>(pixels, w, h, yOrientation);
+}
+
+template <typename T, int N>
+Bitmap<T, N>::operator BitmapSection<T, N>() {
+    return BitmapSection<T, N>(pixels, w, h, yOrientation);
+}
+
+template <typename T, int N>
+Bitmap<T, N>::operator BitmapConstSection<T, N>() const {
+    return BitmapConstSection<T, N>(pixels, w, h, yOrientation);
+}
+
+template <typename T, int N>
+BitmapSection<T, N> Bitmap<T, N>::getSection(int xMin, int yMin, int xMax, int yMax) {
+    return BitmapSection<T, N>(pixels+N*(w*yMin+xMin), xMax-xMin, yMax-yMin, N*w, yOrientation);
+}
+
+template <typename T, int N>
+BitmapConstSection<T, N> Bitmap<T, N>::getConstSection(int xMin, int yMin, int xMax, int yMax) const {
+    return BitmapConstSection<T, N>(pixels+N*(w*yMin+xMin), xMax-xMin, yMax-yMin, N*w, yOrientation);
 }
 
 }
diff --git a/Source/ThirdParty/msdfgen/msdfgen/core/BitmapRef.hpp b/Source/ThirdParty/msdfgen/msdfgen/core/BitmapRef.hpp
index cb17f95dc..6e93fe983 100644
--- a/Source/ThirdParty/msdfgen/msdfgen/core/BitmapRef.hpp
+++ b/Source/ThirdParty/msdfgen/msdfgen/core/BitmapRef.hpp
@@ -1,41 +1,154 @@
 
 #pragma once
 
-#include "base.h"
+#include "YAxisOrientation.h"
 
 namespace msdfgen {
 
 /// Reference to a 2D image bitmap or a buffer acting as one. Pixel storage not owned or managed by the object.
 template <typename T, int N = 1>
+struct BitmapRef;
+/// Constant reference to a 2D image bitmap or a buffer acting as one. Pixel storage not owned or managed by the object.
+template <typename T, int N = 1>
+struct BitmapConstRef;
+/// Reference to a 2D image bitmap with non-contiguous rows of pixels. Pixel storage not owned or managed by the object. Can represent e.g. a section of a larger bitmap, bitmap with padded rows, or vertically flipped bitmap (rowStride can be negative).
+template <typename T, int N = 1>
+struct BitmapSection;
+/// Constant reference to a 2D image bitmap with non-contiguous rows of pixels. Pixel storage not owned or managed by the object. Can represent e.g. a section of a larger bitmap, bitmap with padded rows, or vertically flipped bitmap (rowStride can be negative).
+template <typename T, int N = 1>
+struct BitmapConstSection;
+
+template <typename T, int N>
 struct BitmapRef {
 
     T *pixels;
     int width, height;
+    YAxisOrientation yOrientation;
 
-    inline BitmapRef() : pixels(NULL), width(0), height(0) { }
-    inline BitmapRef(T *pixels, int width, int height) : pixels(pixels), width(width), height(height) { }
+    inline BitmapRef() : pixels(NULL), width(0), height(0), yOrientation(MSDFGEN_Y_AXIS_DEFAULT_ORIENTATION) { }
+    inline BitmapRef(T *pixels, int width, int height, YAxisOrientation yOrientation = MSDFGEN_Y_AXIS_DEFAULT_ORIENTATION) : pixels(pixels), width(width), height(height), yOrientation(yOrientation) { }
 
     inline T *operator()(int x, int y) const {
         return pixels+N*(width*y+x);
     }
 
+    /// Returns a reference to a rectangular section of the bitmap specified by bounds (excluding xMax, yMax).
+    inline BitmapSection<T, N> getSection(int xMin, int yMin, int xMax, int yMax) const {
+        return BitmapSection<T, N>(pixels+N*(width*yMin+xMin), xMax-xMin, yMax-yMin, N*width, yOrientation);
+    }
+
+    /// Returns a constant reference to a rectangular section of the bitmap specified by bounds (excluding xMax, yMax).
+    inline BitmapConstSection<T, N> getConstSection(int xMin, int yMin, int xMax, int yMax) const {
+        return BitmapConstSection<T, N>(pixels+N*(width*yMin+xMin), xMax-xMin, yMax-yMin, N*width, yOrientation);
+    }
+
 };
 
-/// Constant reference to a 2D image bitmap or a buffer acting as one. Pixel storage not owned or managed by the object.
-template <typename T, int N = 1>
+template <typename T, int N>
 struct BitmapConstRef {
 
     const T *pixels;
     int width, height;
+    YAxisOrientation yOrientation;
 
-    inline BitmapConstRef() : pixels(NULL), width(0), height(0) { }
-    inline BitmapConstRef(const T *pixels, int width, int height) : pixels(pixels), width(width), height(height) { }
-    inline BitmapConstRef(const BitmapRef<T, N> &orig) : pixels(orig.pixels), width(orig.width), height(orig.height) { }
+    inline BitmapConstRef() : pixels(NULL), width(0), height(0), yOrientation(MSDFGEN_Y_AXIS_DEFAULT_ORIENTATION) { }
+    inline BitmapConstRef(const T *pixels, int width, int height, YAxisOrientation yOrientation = MSDFGEN_Y_AXIS_DEFAULT_ORIENTATION) : pixels(pixels), width(width), height(height), yOrientation(yOrientation) { }
+    inline BitmapConstRef(const BitmapRef<T, N> &orig) : pixels(orig.pixels), width(orig.width), height(orig.height), yOrientation(orig.yOrientation) { }
 
     inline const T *operator()(int x, int y) const {
         return pixels+N*(width*y+x);
     }
 
+    /// Returns a constant reference to a rectangular section of the bitmap specified by bounds (excluding xMax, yMax).
+    inline BitmapConstSection<T, N> getSection(int xMin, int yMin, int xMax, int yMax) const {
+        return BitmapConstSection<T, N>(pixels+N*(width*yMin+xMin), xMax-xMin, yMax-yMin, N*width, yOrientation);
+    }
+
+    /// Returns a constant reference to a rectangular section of the bitmap specified by bounds (excluding xMax, yMax).
+    inline BitmapConstSection<T, N> getConstSection(int xMin, int yMin, int xMax, int yMax) const {
+        return getSection(xMin, yMin, xMax, yMax);
+    }
+
+};
+
+template <typename T, int N>
+struct BitmapSection {
+
+    T *pixels;
+    int width, height;
+    /// Specifies the difference between the beginnings of adjacent pixel rows as the number of T elements, can be negative.
+    int rowStride;
+    YAxisOrientation yOrientation;
+
+    inline BitmapSection() : pixels(NULL), width(0), height(0), rowStride(0), yOrientation(MSDFGEN_Y_AXIS_DEFAULT_ORIENTATION) { }
+    inline BitmapSection(T *pixels, int width, int height, YAxisOrientation yOrientation = MSDFGEN_Y_AXIS_DEFAULT_ORIENTATION) : pixels(pixels), width(width), height(height), rowStride(N*width), yOrientation(yOrientation) { }
+    inline BitmapSection(T *pixels, int width, int height, int rowStride, YAxisOrientation yOrientation = MSDFGEN_Y_AXIS_DEFAULT_ORIENTATION) : pixels(pixels), width(width), height(height), rowStride(rowStride), yOrientation(yOrientation) { }
+    inline BitmapSection(const BitmapRef<T, N> &orig) : pixels(orig.pixels), width(orig.width), height(orig.height), rowStride(N*orig.width), yOrientation(orig.yOrientation) { }
+
+    inline T *operator()(int x, int y) const {
+        return pixels+rowStride*y+N*x;
+    }
+
+    /// Returns a reference to a rectangular subsection of the bitmap specified by bounds (excluding xMax, yMax).
+    inline BitmapSection<T, N> getSection(int xMin, int yMin, int xMax, int yMax) const {
+        return BitmapSection<T, N>(pixels+rowStride*yMin+N*xMin, xMax-xMin, yMax-yMin, rowStride, yOrientation);
+    }
+
+    /// Returns a constant reference to a rectangular subsection of the bitmap specified by bounds (excluding xMax, yMax).
+    inline BitmapConstSection<T, N> getConstSection(int xMin, int yMin, int xMax, int yMax) const {
+        return BitmapConstSection<T, N>(pixels+rowStride*yMin+N*xMin, xMax-xMin, yMax-yMin, rowStride, yOrientation);
+    }
+
+    /// Makes sure that the section's Y-axis orientation matches the argument by potentially reordering its rows.
+    inline void reorient(YAxisOrientation newYAxisOrientation) {
+        if (yOrientation != newYAxisOrientation) {
+            pixels += rowStride*(height-1);
+            rowStride = -rowStride;
+            yOrientation = newYAxisOrientation;
+        }
+    }
+
+};
+
+template <typename T, int N>
+struct BitmapConstSection {
+
+    const T *pixels;
+    int width, height;
+    /// Specifies the difference between the beginnings of adjacent pixel rows as the number of T elements, can be negative.
+    int rowStride;
+    YAxisOrientation yOrientation;
+
+    inline BitmapConstSection() : pixels(NULL), width(0), height(0), rowStride(0), yOrientation(MSDFGEN_Y_AXIS_DEFAULT_ORIENTATION) { }
+    inline BitmapConstSection(const T *pixels, int width, int height, YAxisOrientation yOrientation = MSDFGEN_Y_AXIS_DEFAULT_ORIENTATION) : pixels(pixels), width(width), height(height), rowStride(N*width), yOrientation(yOrientation) { }
+    inline BitmapConstSection(const T *pixels, int width, int height, int rowStride, YAxisOrientation yOrientation = MSDFGEN_Y_AXIS_DEFAULT_ORIENTATION) : pixels(pixels), width(width), height(height), rowStride(rowStride), yOrientation(yOrientation) { }
+    inline BitmapConstSection(const BitmapRef<T, N> &orig) : pixels(orig.pixels), width(orig.width), height(orig.height), rowStride(N*orig.width), yOrientation(orig.yOrientation) { }
+    inline BitmapConstSection(const BitmapConstRef<T, N> &orig) : pixels(orig.pixels), width(orig.width), height(orig.height), rowStride(N*orig.width), yOrientation(orig.yOrientation) { }
+    inline BitmapConstSection(const BitmapSection<T, N> &orig) : pixels(orig.pixels), width(orig.width), height(orig.height), rowStride(orig.rowStride), yOrientation(orig.yOrientation) { }
+
+    inline const T *operator()(int x, int y) const {
+        return pixels+rowStride*y+N*x;
+    }
+
+    /// Returns a constant reference to a rectangular subsection of the bitmap specified by bounds (excluding xMax, yMax).
+    inline BitmapConstSection<T, N> getSection(int xMin, int yMin, int xMax, int yMax) const {
+        return BitmapConstSection<T, N>(pixels+rowStride*yMin+N*xMin, xMax-xMin, yMax-yMin, rowStride, yOrientation);
+    }
+
+    /// Returns a constant reference to a rectangular subsection of the bitmap specified by bounds (excluding xMax, yMax).
+    inline BitmapConstSection<T, N> getConstSection(int xMin, int yMin, int xMax, int yMax) const {
+        return getSection(xMin, yMin, xMax, yMax);
+    }
+
+    /// Makes sure that the section's Y-axis orientation matches the argument by potentially reordering its rows.
+    inline void reorient(YAxisOrientation newYAxisOrientation) {
+        if (yOrientation != newYAxisOrientation) {
+            pixels += rowStride*(height-1);
+            rowStride = -rowStride;
+            yOrientation = newYAxisOrientation;
+        }
+    }
+
 };
 
 }
diff --git a/Source/ThirdParty/msdfgen/msdfgen/core/Contour.h b/Source/ThirdParty/msdfgen/msdfgen/core/Contour.h
index 4cae48fad..53ceb8eda 100644
--- a/Source/ThirdParty/msdfgen/msdfgen/core/Contour.h
+++ b/Source/ThirdParty/msdfgen/msdfgen/core/Contour.h
@@ -21,9 +21,9 @@ public:
     /// Creates a new edge in the contour and returns its reference.
     EdgeHolder &addEdge();
     /// Adjusts the bounding box to fit the contour.
-    void bound(double &l, double &b, double &r, double &t) const;
+    void bound(double &xMin, double &yMin, double &xMax, double &yMax) const;
     /// Adjusts the bounding box to fit the contour border's mitered corners.
-    void boundMiters(double &l, double &b, double &r, double &t, double border, double miterLimit, int polarity) const;
+    void boundMiters(double &xMin, double &yMin, double &xMax, double &yMax, double border, double miterLimit, int polarity) const;
     /// Computes the winding of the contour. Returns 1 if positive, -1 if negative.
     int winding() const;
     /// Reverses the sequence of edges on the contour.
diff --git a/Source/ThirdParty/msdfgen/msdfgen/core/MSDFErrorCorrection.h b/Source/ThirdParty/msdfgen/msdfgen/core/MSDFErrorCorrection.h
index 9cd14eccf..995b1d614 100644
--- a/Source/ThirdParty/msdfgen/msdfgen/core/MSDFErrorCorrection.h
+++ b/Source/ThirdParty/msdfgen/msdfgen/core/MSDFErrorCorrection.h
@@ -20,7 +20,7 @@ public:
     };
 
     MSDFErrorCorrection();
-    explicit MSDFErrorCorrection(const BitmapRef<byte, 1> &stencil, const SDFTransformation &transformation);
+    explicit MSDFErrorCorrection(const BitmapSection<byte, 1> &stencil, const SDFTransformation &transformation);
     /// Sets the minimum ratio between the actual and maximum expected distance delta to be considered an error.
     void setMinDeviationRatio(double minDeviationRatio);
     /// Sets the minimum ratio between the pre-correction distance error and the post-correction distance error.
@@ -29,23 +29,23 @@ public:
     void protectCorners(const Shape &shape);
     /// Flags all texels that contribute to edges as protected.
     template <int N>
-    void protectEdges(const BitmapConstRef<float, N> &sdf);
+    void protectEdges(const BitmapConstSection<float, N> &sdf);
     /// Flags all texels as protected.
     void protectAll();
     /// Flags texels that are expected to cause interpolation artifacts based on analysis of the SDF only.
     template <int N>
-    void findErrors(const BitmapConstRef<float, N> &sdf);
+    void findErrors(const BitmapConstSection<float, N> &sdf);
     /// Flags texels that are expected to cause interpolation artifacts based on analysis of the SDF and comparison with the exact shape distance.
     template <template <typename> class ContourCombiner, int N>
-    void findErrors(const BitmapConstRef<float, N> &sdf, const Shape &shape);
+    void findErrors(BitmapConstSection<float, N> sdf, const Shape &shape);
     /// Modifies the MSDF so that all texels with the error flag are converted to single-channel.
     template <int N>
-    void apply(const BitmapRef<float, N> &sdf) const;
+    void apply(BitmapSection<float, N> sdf) const;
     /// Returns the stencil in its current state (see Flags).
-    BitmapConstRef<byte, 1> getStencil() const;
+    BitmapConstSection<byte, 1> getStencil() const;
 
 private:
-    BitmapRef<byte, 1> stencil;
+    BitmapSection<byte, 1> stencil;
     SDFTransformation transformation;
     double minDeviationRatio;
     double minImproveRatio;
diff --git a/Source/ThirdParty/msdfgen/msdfgen/core/Shape.h b/Source/ThirdParty/msdfgen/msdfgen/core/Shape.h
index 248b19225..d47b43ac1 100644
--- a/Source/ThirdParty/msdfgen/msdfgen/core/Shape.h
+++ b/Source/ThirdParty/msdfgen/msdfgen/core/Shape.h
@@ -3,6 +3,7 @@
 
 #include <vector>
 #include "Contour.h"
+#include "YAxisOrientation.h"
 #include "Scanline.h"
 
 namespace msdfgen {
@@ -15,12 +16,14 @@ class Shape {
 
 public:
     struct Bounds {
+        // NOTE: b is actually the lower Y-coordinate and t the higher Y-coordinate. For Y_DOWNWARD orientation, b is actually the top and t the bottom. May be renamed in a future version.
         double l, b, r, t;
     };
 
     /// The list of contours the shape consists of.
     std::vector<Contour> contours;
     /// Specifies whether the shape uses bottom-to-top (false) or top-to-bottom (true) Y coordinates.
+    /// DEPRECATED - use getYAxisOrientation / setYAxisOrientation instead.
     bool inverseYAxis;
 
     Shape();
@@ -36,9 +39,9 @@ public:
     /// Performs basic checks to determine if the object represents a valid shape.
     bool validate() const;
     /// Adjusts the bounding box to fit the shape.
-    void bound(double &l, double &b, double &r, double &t) const;
+    void bound(double &xMin, double &yMin, double &xMax, double &yMax) const;
     /// Adjusts the bounding box to fit the shape border's mitered corners.
-    void boundMiters(double &l, double &b, double &r, double &t, double border, double miterLimit, int polarity) const;
+    void boundMiters(double &xMin, double &yMin, double &xMax, double &yMax, double border, double miterLimit, int polarity) const;
     /// Computes the minimum bounding box that fits the shape, optionally with a (mitered) border.
     Bounds getBounds(double border = 0, double miterLimit = 0, int polarity = 0) const;
     /// Outputs the scanline that intersects the shape at y.
@@ -47,6 +50,10 @@ public:
     int edgeCount() const;
     /// Assumes its contours are unoriented (even-odd fill rule). Attempts to orient them to conform to the non-zero winding rule.
     void orientContours();
+    /// Returns the orientation of the axis of the shape's Y coordinates.
+    YAxisOrientation getYAxisOrientation() const;
+    /// Sets the orientation of the axis of the shape's Y coordinates.
+    void setYAxisOrientation(YAxisOrientation yAxisOrientation);
 
 };
 
diff --git a/Source/ThirdParty/msdfgen/msdfgen/core/YAxisOrientation.h b/Source/ThirdParty/msdfgen/msdfgen/core/YAxisOrientation.h
new file mode 100644
index 000000000..803acdce4
--- /dev/null
+++ b/Source/ThirdParty/msdfgen/msdfgen/core/YAxisOrientation.h
@@ -0,0 +1,17 @@
+
+#pragma once
+
+#include "base.h"
+
+namespace msdfgen {
+
+/// Specifies whether the Y component of the coordinate system increases in the upward or downward direction.
+enum YAxisOrientation {
+    Y_UPWARD,
+    Y_DOWNWARD
+};
+
+}
+
+#define MSDFGEN_Y_AXIS_DEFAULT_ORIENTATION msdfgen::Y_UPWARD
+#define MSDFGEN_Y_AXIS_NONDEFAULT_ORIENTATION (MSDFGEN_Y_AXIS_DEFAULT_ORIENTATION == msdfgen::Y_DOWNWARD ? msdfgen::Y_UPWARD : msdfgen::Y_DOWNWARD)
diff --git a/Source/ThirdParty/msdfgen/msdfgen/core/bitmap-interpolation.hpp b/Source/ThirdParty/msdfgen/msdfgen/core/bitmap-interpolation.hpp
index ca2e48c08..3e2576f7b 100644
--- a/Source/ThirdParty/msdfgen/msdfgen/core/bitmap-interpolation.hpp
+++ b/Source/ThirdParty/msdfgen/msdfgen/core/bitmap-interpolation.hpp
@@ -8,7 +8,9 @@
 namespace msdfgen {
 
 template <typename T, int N>
-static void interpolate(T *output, const BitmapConstRef<T, N> &bitmap, Point2 pos) {
+inline void interpolate(T *output, const BitmapConstSection<T, N> &bitmap, Point2 pos) {
+    pos.x = clamp(pos.x, double(bitmap.width));
+    pos.y = clamp(pos.y, double(bitmap.height));
     pos -= .5;
     int l = (int) floor(pos.x);
     int b = (int) floor(pos.y);
diff --git a/Source/ThirdParty/msdfgen/msdfgen/core/edge-segments.h b/Source/ThirdParty/msdfgen/msdfgen/core/edge-segments.h
index 815241685..10b803a28 100644
--- a/Source/ThirdParty/msdfgen/msdfgen/core/edge-segments.h
+++ b/Source/ThirdParty/msdfgen/msdfgen/core/edge-segments.h
@@ -42,7 +42,7 @@ public:
     /// Outputs a list of (at most three) intersections (their X coordinates) with an infinite horizontal scanline at y and returns how many there are.
     virtual int scanlineIntersections(double x[3], int dy[3], double y) const = 0;
     /// Adjusts the bounding box to fit the edge segment.
-    virtual void bound(double &l, double &b, double &r, double &t) const = 0;
+    virtual void bound(double &xMin, double &yMin, double &xMax, double &yMax) const = 0;
 
     /// Reverses the edge (swaps its start point and end point).
     virtual void reverse() = 0;
@@ -75,7 +75,7 @@ public:
     double length() const;
     SignedDistance signedDistance(Point2 origin, double &param) const;
     int scanlineIntersections(double x[3], int dy[3], double y) const;
-    void bound(double &l, double &b, double &r, double &t) const;
+    void bound(double &xMin, double &yMin, double &xMax, double &yMax) const;
 
     void reverse();
     void moveStartPoint(Point2 to);
@@ -104,7 +104,7 @@ public:
     double length() const;
     SignedDistance signedDistance(Point2 origin, double &param) const;
     int scanlineIntersections(double x[3], int dy[3], double y) const;
-    void bound(double &l, double &b, double &r, double &t) const;
+    void bound(double &xMin, double &yMin, double &xMax, double &yMax) const;
 
     void reverse();
     void moveStartPoint(Point2 to);
@@ -134,7 +134,7 @@ public:
     Vector2 directionChange(double param) const;
     SignedDistance signedDistance(Point2 origin, double &param) const;
     int scanlineIntersections(double x[3], int dy[3], double y) const;
-    void bound(double &l, double &b, double &r, double &t) const;
+    void bound(double &xMin, double &yMin, double &xMax, double &yMax) const;
 
     void reverse();
     void moveStartPoint(Point2 to);
diff --git a/Source/ThirdParty/msdfgen/msdfgen/core/msdf-error-correction.h b/Source/ThirdParty/msdfgen/msdfgen/core/msdf-error-correction.h
index c92cbe17a..3edc2510f 100644
--- a/Source/ThirdParty/msdfgen/msdfgen/core/msdf-error-correction.h
+++ b/Source/ThirdParty/msdfgen/msdfgen/core/msdf-error-correction.h
@@ -12,29 +12,29 @@
 namespace msdfgen {
 
 /// Predicts potential artifacts caused by the interpolation of the MSDF and corrects them by converting nearby texels to single-channel.
-void msdfErrorCorrection(const BitmapRef<float, 3> &sdf, const Shape &shape, const SDFTransformation &transformation, const MSDFGeneratorConfig &config = MSDFGeneratorConfig());
-void msdfErrorCorrection(const BitmapRef<float, 4> &sdf, const Shape &shape, const SDFTransformation &transformation, const MSDFGeneratorConfig &config = MSDFGeneratorConfig());
-void msdfErrorCorrection(const BitmapRef<float, 3> &sdf, const Shape &shape, const Projection &projection, Range range, const MSDFGeneratorConfig &config = MSDFGeneratorConfig());
-void msdfErrorCorrection(const BitmapRef<float, 4> &sdf, const Shape &shape, const Projection &projection, Range range, const MSDFGeneratorConfig &config = MSDFGeneratorConfig());
+void msdfErrorCorrection(const BitmapSection<float, 3> &sdf, const Shape &shape, const SDFTransformation &transformation, const MSDFGeneratorConfig &config = MSDFGeneratorConfig());
+void msdfErrorCorrection(const BitmapSection<float, 4> &sdf, const Shape &shape, const SDFTransformation &transformation, const MSDFGeneratorConfig &config = MSDFGeneratorConfig());
+void msdfErrorCorrection(const BitmapSection<float, 3> &sdf, const Shape &shape, const Projection &projection, Range range, const MSDFGeneratorConfig &config = MSDFGeneratorConfig());
+void msdfErrorCorrection(const BitmapSection<float, 4> &sdf, const Shape &shape, const Projection &projection, Range range, const MSDFGeneratorConfig &config = MSDFGeneratorConfig());
 
 /// Applies the simplified error correction to all discontiunous distances (INDISCRIMINATE mode). Does not need shape or translation.
-void msdfFastDistanceErrorCorrection(const BitmapRef<float, 3> &sdf, const SDFTransformation &transformation, double minDeviationRatio = ErrorCorrectionConfig::defaultMinDeviationRatio);
-void msdfFastDistanceErrorCorrection(const BitmapRef<float, 4> &sdf, const SDFTransformation &transformation, double minDeviationRatio = ErrorCorrectionConfig::defaultMinDeviationRatio);
-void msdfFastDistanceErrorCorrection(const BitmapRef<float, 3> &sdf, const Projection &projection, Range range, double minDeviationRatio = ErrorCorrectionConfig::defaultMinDeviationRatio);
-void msdfFastDistanceErrorCorrection(const BitmapRef<float, 4> &sdf, const Projection &projection, Range range, double minDeviationRatio = ErrorCorrectionConfig::defaultMinDeviationRatio);
-void msdfFastDistanceErrorCorrection(const BitmapRef<float, 3> &sdf, Range pxRange, double minDeviationRatio = ErrorCorrectionConfig::defaultMinDeviationRatio);
-void msdfFastDistanceErrorCorrection(const BitmapRef<float, 4> &sdf, Range pxRange, double minDeviationRatio = ErrorCorrectionConfig::defaultMinDeviationRatio);
+void msdfFastDistanceErrorCorrection(const BitmapSection<float, 3> &sdf, const SDFTransformation &transformation, double minDeviationRatio = ErrorCorrectionConfig::defaultMinDeviationRatio);
+void msdfFastDistanceErrorCorrection(const BitmapSection<float, 4> &sdf, const SDFTransformation &transformation, double minDeviationRatio = ErrorCorrectionConfig::defaultMinDeviationRatio);
+void msdfFastDistanceErrorCorrection(const BitmapSection<float, 3> &sdf, const Projection &projection, Range range, double minDeviationRatio = ErrorCorrectionConfig::defaultMinDeviationRatio);
+void msdfFastDistanceErrorCorrection(const BitmapSection<float, 4> &sdf, const Projection &projection, Range range, double minDeviationRatio = ErrorCorrectionConfig::defaultMinDeviationRatio);
+void msdfFastDistanceErrorCorrection(const BitmapSection<float, 3> &sdf, Range pxRange, double minDeviationRatio = ErrorCorrectionConfig::defaultMinDeviationRatio);
+void msdfFastDistanceErrorCorrection(const BitmapSection<float, 4> &sdf, Range pxRange, double minDeviationRatio = ErrorCorrectionConfig::defaultMinDeviationRatio);
 
 /// Applies the simplified error correction to edges only (EDGE_ONLY mode). Does not need shape or translation.
-void msdfFastEdgeErrorCorrection(const BitmapRef<float, 3> &sdf, const SDFTransformation &transformation, double minDeviationRatio = ErrorCorrectionConfig::defaultMinDeviationRatio);
-void msdfFastEdgeErrorCorrection(const BitmapRef<float, 4> &sdf, const SDFTransformation &transformation, double minDeviationRatio = ErrorCorrectionConfig::defaultMinDeviationRatio);
-void msdfFastEdgeErrorCorrection(const BitmapRef<float, 3> &sdf, const Projection &projection, Range range, double minDeviationRatio = ErrorCorrectionConfig::defaultMinDeviationRatio);
-void msdfFastEdgeErrorCorrection(const BitmapRef<float, 4> &sdf, const Projection &projection, Range range, double minDeviationRatio = ErrorCorrectionConfig::defaultMinDeviationRatio);
-void msdfFastEdgeErrorCorrection(const BitmapRef<float, 3> &sdf, Range pxRange, double minDeviationRatio = ErrorCorrectionConfig::defaultMinDeviationRatio);
-void msdfFastEdgeErrorCorrection(const BitmapRef<float, 4> &sdf, Range pxRange, double minDeviationRatio = ErrorCorrectionConfig::defaultMinDeviationRatio);
+void msdfFastEdgeErrorCorrection(const BitmapSection<float, 3> &sdf, const SDFTransformation &transformation, double minDeviationRatio = ErrorCorrectionConfig::defaultMinDeviationRatio);
+void msdfFastEdgeErrorCorrection(const BitmapSection<float, 4> &sdf, const SDFTransformation &transformation, double minDeviationRatio = ErrorCorrectionConfig::defaultMinDeviationRatio);
+void msdfFastEdgeErrorCorrection(const BitmapSection<float, 3> &sdf, const Projection &projection, Range range, double minDeviationRatio = ErrorCorrectionConfig::defaultMinDeviationRatio);
+void msdfFastEdgeErrorCorrection(const BitmapSection<float, 4> &sdf, const Projection &projection, Range range, double minDeviationRatio = ErrorCorrectionConfig::defaultMinDeviationRatio);
+void msdfFastEdgeErrorCorrection(const BitmapSection<float, 3> &sdf, Range pxRange, double minDeviationRatio = ErrorCorrectionConfig::defaultMinDeviationRatio);
+void msdfFastEdgeErrorCorrection(const BitmapSection<float, 4> &sdf, Range pxRange, double minDeviationRatio = ErrorCorrectionConfig::defaultMinDeviationRatio);
 
 /// The original version of the error correction algorithm.
-void msdfErrorCorrection_legacy(const BitmapRef<float, 3> &output, const Vector2 &threshold);
-void msdfErrorCorrection_legacy(const BitmapRef<float, 4> &output, const Vector2 &threshold);
+void msdfErrorCorrection_legacy(const BitmapSection<float, 3> &output, const Vector2 &threshold);
+void msdfErrorCorrection_legacy(const BitmapSection<float, 4> &output, const Vector2 &threshold);
 
 }
diff --git a/Source/ThirdParty/msdfgen/msdfgen/core/rasterization.h b/Source/ThirdParty/msdfgen/msdfgen/core/rasterization.h
index 8ba41cd64..876a87bdc 100644
--- a/Source/ThirdParty/msdfgen/msdfgen/core/rasterization.h
+++ b/Source/ThirdParty/msdfgen/msdfgen/core/rasterization.h
@@ -10,16 +10,19 @@
 namespace msdfgen {
 
 /// Rasterizes the shape into a monochrome bitmap.
-void rasterize(const BitmapRef<float, 1> &output, const Shape &shape, const Projection &projection, FillRule fillRule = FILL_NONZERO);
+void rasterize(BitmapSection<float, 1> output, const Shape &shape, const Projection &projection, FillRule fillRule = FILL_NONZERO);
 /// Fixes the sign of the input signed distance field, so that it matches the shape's rasterized fill.
-void distanceSignCorrection(const BitmapRef<float, 1> &sdf, const Shape &shape, const Projection &projection, FillRule fillRule = FILL_NONZERO);
-void distanceSignCorrection(const BitmapRef<float, 3> &sdf, const Shape &shape, const Projection &projection, FillRule fillRule = FILL_NONZERO);
-void distanceSignCorrection(const BitmapRef<float, 4> &sdf, const Shape &shape, const Projection &projection, FillRule fillRule = FILL_NONZERO);
+void distanceSignCorrection(BitmapSection<float, 1> sdf, const Shape &shape, const Projection &projection, float sdfZeroValue = .5f, FillRule fillRule = FILL_NONZERO);
+void distanceSignCorrection(BitmapSection<float, 3> sdf, const Shape &shape, const Projection &projection, float sdfZeroValue = .5f, FillRule fillRule = FILL_NONZERO);
+void distanceSignCorrection(BitmapSection<float, 4> sdf, const Shape &shape, const Projection &projection, float sdfZeroValue = .5f, FillRule fillRule = FILL_NONZERO);
 
-// Old version of the function API's kept for backwards compatibility
-void rasterize(const BitmapRef<float, 1> &output, const Shape &shape, const Vector2 &scale, const Vector2 &translate, FillRule fillRule = FILL_NONZERO);
-void distanceSignCorrection(const BitmapRef<float, 1> &sdf, const Shape &shape, const Vector2 &scale, const Vector2 &translate, FillRule fillRule = FILL_NONZERO);
-void distanceSignCorrection(const BitmapRef<float, 3> &sdf, const Shape &shape, const Vector2 &scale, const Vector2 &translate, FillRule fillRule = FILL_NONZERO);
-void distanceSignCorrection(const BitmapRef<float, 4> &sdf, const Shape &shape, const Vector2 &scale, const Vector2 &translate, FillRule fillRule = FILL_NONZERO);
+// Old versions of the function API's kept for backwards compatibility
+void rasterize(const BitmapSection<float, 1> &output, const Shape &shape, const Vector2 &scale, const Vector2 &translate, FillRule fillRule = FILL_NONZERO);
+void distanceSignCorrection(BitmapSection<float, 1> sdf, const Shape &shape, const Projection &projection, FillRule fillRule);
+void distanceSignCorrection(BitmapSection<float, 3> sdf, const Shape &shape, const Projection &projection, FillRule fillRule);
+void distanceSignCorrection(BitmapSection<float, 4> sdf, const Shape &shape, const Projection &projection, FillRule fillRule);
+void distanceSignCorrection(const BitmapSection<float, 1> &sdf, const Shape &shape, const Vector2 &scale, const Vector2 &translate, FillRule fillRule = FILL_NONZERO);
+void distanceSignCorrection(const BitmapSection<float, 3> &sdf, const Shape &shape, const Vector2 &scale, const Vector2 &translate, FillRule fillRule = FILL_NONZERO);
+void distanceSignCorrection(const BitmapSection<float, 4> &sdf, const Shape &shape, const Vector2 &scale, const Vector2 &translate, FillRule fillRule = FILL_NONZERO);
 
 }
diff --git a/Source/ThirdParty/msdfgen/msdfgen/core/render-sdf.h b/Source/ThirdParty/msdfgen/msdfgen/core/render-sdf.h
index e8ee46c55..b61823ad0 100644
--- a/Source/ThirdParty/msdfgen/msdfgen/core/render-sdf.h
+++ b/Source/ThirdParty/msdfgen/msdfgen/core/render-sdf.h
@@ -8,16 +8,16 @@
 namespace msdfgen {
 
 /// Reconstructs the shape's appearance into output from the distance field sdf.
-void renderSDF(const BitmapRef<float, 1> &output, const BitmapConstRef<float, 1> &sdf, Range sdfPxRange = 0, float sdThreshold = .5f);
-void renderSDF(const BitmapRef<float, 3> &output, const BitmapConstRef<float, 1> &sdf, Range sdfPxRange = 0, float sdThreshold = .5f);
-void renderSDF(const BitmapRef<float, 1> &output, const BitmapConstRef<float, 3> &sdf, Range sdfPxRange = 0, float sdThreshold = .5f);
-void renderSDF(const BitmapRef<float, 3> &output, const BitmapConstRef<float, 3> &sdf, Range sdfPxRange = 0, float sdThreshold = .5f);
-void renderSDF(const BitmapRef<float, 1> &output, const BitmapConstRef<float, 4> &sdf, Range sdfPxRange = 0, float sdThreshold = .5f);
-void renderSDF(const BitmapRef<float, 4> &output, const BitmapConstRef<float, 4> &sdf, Range sdfPxRange = 0, float sdThreshold = .5f);
+void renderSDF(const BitmapSection<float, 1> &output, const BitmapConstSection<float, 1> &sdf, Range sdfPxRange = 0, float sdThreshold = .5f);
+void renderSDF(const BitmapSection<float, 3> &output, const BitmapConstSection<float, 1> &sdf, Range sdfPxRange = 0, float sdThreshold = .5f);
+void renderSDF(const BitmapSection<float, 1> &output, const BitmapConstSection<float, 3> &sdf, Range sdfPxRange = 0, float sdThreshold = .5f);
+void renderSDF(const BitmapSection<float, 3> &output, const BitmapConstSection<float, 3> &sdf, Range sdfPxRange = 0, float sdThreshold = .5f);
+void renderSDF(const BitmapSection<float, 1> &output, const BitmapConstSection<float, 4> &sdf, Range sdfPxRange = 0, float sdThreshold = .5f);
+void renderSDF(const BitmapSection<float, 4> &output, const BitmapConstSection<float, 4> &sdf, Range sdfPxRange = 0, float sdThreshold = .5f);
 
 /// Snaps the values of the floating-point bitmaps into one of the 256 values representable in a standard 8-bit bitmap.
-void simulate8bit(const BitmapRef<float, 1> &bitmap);
-void simulate8bit(const BitmapRef<float, 3> &bitmap);
-void simulate8bit(const BitmapRef<float, 4> &bitmap);
+void simulate8bit(const BitmapSection<float, 1> &bitmap);
+void simulate8bit(const BitmapSection<float, 3> &bitmap);
+void simulate8bit(const BitmapSection<float, 4> &bitmap);
 
 }
diff --git a/Source/ThirdParty/msdfgen/msdfgen/core/save-bmp.h b/Source/ThirdParty/msdfgen/msdfgen/core/save-bmp.h
index 98f852921..286727558 100644
--- a/Source/ThirdParty/msdfgen/msdfgen/core/save-bmp.h
+++ b/Source/ThirdParty/msdfgen/msdfgen/core/save-bmp.h
@@ -6,11 +6,11 @@
 namespace msdfgen {
 
 /// Saves the bitmap as a BMP file.
-bool saveBmp(const BitmapConstRef<byte, 1> &bitmap, const char *filename);
-bool saveBmp(const BitmapConstRef<byte, 3> &bitmap, const char *filename);
-bool saveBmp(const BitmapConstRef<byte, 4> &bitmap, const char *filename);
-bool saveBmp(const BitmapConstRef<float, 1> &bitmap, const char *filename);
-bool saveBmp(const BitmapConstRef<float, 3> &bitmap, const char *filename);
-bool saveBmp(const BitmapConstRef<float, 4> &bitmap, const char *filename);
+bool saveBmp(BitmapConstSection<byte, 1> bitmap, const char *filename);
+bool saveBmp(BitmapConstSection<byte, 3> bitmap, const char *filename);
+bool saveBmp(BitmapConstSection<byte, 4> bitmap, const char *filename);
+bool saveBmp(BitmapConstSection<float, 1> bitmap, const char *filename);
+bool saveBmp(BitmapConstSection<float, 3> bitmap, const char *filename);
+bool saveBmp(BitmapConstSection<float, 4> bitmap, const char *filename);
 
 }
diff --git a/Source/ThirdParty/msdfgen/msdfgen/core/save-fl32.h b/Source/ThirdParty/msdfgen/msdfgen/core/save-fl32.h
index eded7f336..473e0c04f 100644
--- a/Source/ThirdParty/msdfgen/msdfgen/core/save-fl32.h
+++ b/Source/ThirdParty/msdfgen/msdfgen/core/save-fl32.h
@@ -7,6 +7,6 @@ namespace msdfgen {
 
 /// Saves the bitmap as an uncompressed floating-point FL32 file, which can be decoded trivially.
 template <int N>
-bool saveFl32(const BitmapConstRef<float, N> &bitmap, const char *filename);
+bool saveFl32(BitmapConstSection<float, N> bitmap, const char *filename);
 
 }
diff --git a/Source/ThirdParty/msdfgen/msdfgen/core/save-rgba.h b/Source/ThirdParty/msdfgen/msdfgen/core/save-rgba.h
index 50e839645..45a6bb6ac 100644
--- a/Source/ThirdParty/msdfgen/msdfgen/core/save-rgba.h
+++ b/Source/ThirdParty/msdfgen/msdfgen/core/save-rgba.h
@@ -6,11 +6,11 @@
 namespace msdfgen {
 
 /// Saves the bitmap as a simple RGBA file, which can be decoded trivially.
-bool saveRgba(const BitmapConstRef<byte, 1> &bitmap, const char *filename);
-bool saveRgba(const BitmapConstRef<byte, 3> &bitmap, const char *filename);
-bool saveRgba(const BitmapConstRef<byte, 4> &bitmap, const char *filename);
-bool saveRgba(const BitmapConstRef<float, 1> &bitmap, const char *filename);
-bool saveRgba(const BitmapConstRef<float, 3> &bitmap, const char *filename);
-bool saveRgba(const BitmapConstRef<float, 4> &bitmap, const char *filename);
+bool saveRgba(BitmapConstSection<byte, 1> bitmap, const char *filename);
+bool saveRgba(BitmapConstSection<byte, 3> bitmap, const char *filename);
+bool saveRgba(BitmapConstSection<byte, 4> bitmap, const char *filename);
+bool saveRgba(BitmapConstSection<float, 1> bitmap, const char *filename);
+bool saveRgba(BitmapConstSection<float, 3> bitmap, const char *filename);
+bool saveRgba(BitmapConstSection<float, 4> bitmap, const char *filename);
 
 }
diff --git a/Source/ThirdParty/msdfgen/msdfgen/core/save-tiff.h b/Source/ThirdParty/msdfgen/msdfgen/core/save-tiff.h
index 072cd71d5..7884fc9a3 100644
--- a/Source/ThirdParty/msdfgen/msdfgen/core/save-tiff.h
+++ b/Source/ThirdParty/msdfgen/msdfgen/core/save-tiff.h
@@ -6,8 +6,8 @@
 namespace msdfgen {
 
 /// Saves the bitmap as an uncompressed floating-point TIFF file.
-bool saveTiff(const BitmapConstRef<float, 1> &bitmap, const char *filename);
-bool saveTiff(const BitmapConstRef<float, 3> &bitmap, const char *filename);
-bool saveTiff(const BitmapConstRef<float, 4> &bitmap, const char *filename);
+bool saveTiff(const BitmapConstSection<float, 1> &bitmap, const char *filename);
+bool saveTiff(const BitmapConstSection<float, 3> &bitmap, const char *filename);
+bool saveTiff(const BitmapConstSection<float, 4> &bitmap, const char *filename);
 
 }
diff --git a/Source/ThirdParty/msdfgen/msdfgen/core/sdf-error-estimation.h b/Source/ThirdParty/msdfgen/msdfgen/core/sdf-error-estimation.h
index f9008222a..a669c5955 100644
--- a/Source/ThirdParty/msdfgen/msdfgen/core/sdf-error-estimation.h
+++ b/Source/ThirdParty/msdfgen/msdfgen/core/sdf-error-estimation.h
@@ -10,21 +10,24 @@
 namespace msdfgen {
 
 /// Analytically constructs a scanline at y evaluating fill by linear interpolation of the SDF.
-void scanlineSDF(Scanline &line, const BitmapConstRef<float, 1> &sdf, const Projection &projection, double y, bool inverseYAxis = false);
-void scanlineSDF(Scanline &line, const BitmapConstRef<float, 3> &sdf, const Projection &projection, double y, bool inverseYAxis = false);
-void scanlineSDF(Scanline &line, const BitmapConstRef<float, 4> &sdf, const Projection &projection, double y, bool inverseYAxis = false);
+void scanlineSDF(Scanline &line, const BitmapConstSection<float, 1> &sdf, const Projection &projection, double y, YAxisOrientation yAxisOrientation = MSDFGEN_Y_AXIS_DEFAULT_ORIENTATION);
+void scanlineSDF(Scanline &line, const BitmapConstSection<float, 3> &sdf, const Projection &projection, double y, YAxisOrientation yAxisOrientation = MSDFGEN_Y_AXIS_DEFAULT_ORIENTATION);
+void scanlineSDF(Scanline &line, const BitmapConstSection<float, 4> &sdf, const Projection &projection, double y, YAxisOrientation yAxisOrientation = MSDFGEN_Y_AXIS_DEFAULT_ORIENTATION);
 
 /// Estimates the portion of the area that will be filled incorrectly when rendering using the SDF.
-double estimateSDFError(const BitmapConstRef<float, 1> &sdf, const Shape &shape, const Projection &projection, int scanlinesPerRow, FillRule fillRule = FILL_NONZERO);
-double estimateSDFError(const BitmapConstRef<float, 3> &sdf, const Shape &shape, const Projection &projection, int scanlinesPerRow, FillRule fillRule = FILL_NONZERO);
-double estimateSDFError(const BitmapConstRef<float, 4> &sdf, const Shape &shape, const Projection &projection, int scanlinesPerRow, FillRule fillRule = FILL_NONZERO);
+double estimateSDFError(const BitmapConstSection<float, 1> &sdf, const Shape &shape, const Projection &projection, int scanlinesPerRow, FillRule fillRule = FILL_NONZERO);
+double estimateSDFError(const BitmapConstSection<float, 3> &sdf, const Shape &shape, const Projection &projection, int scanlinesPerRow, FillRule fillRule = FILL_NONZERO);
+double estimateSDFError(const BitmapConstSection<float, 4> &sdf, const Shape &shape, const Projection &projection, int scanlinesPerRow, FillRule fillRule = FILL_NONZERO);
 
 // Old version of the function API's kept for backwards compatibility
-void scanlineSDF(Scanline &line, const BitmapConstRef<float, 1> &sdf, const Vector2 &scale, const Vector2 &translate, bool inverseYAxis, double y);
-void scanlineSDF(Scanline &line, const BitmapConstRef<float, 3> &sdf, const Vector2 &scale, const Vector2 &translate, bool inverseYAxis, double y);
-void scanlineSDF(Scanline &line, const BitmapConstRef<float, 4> &sdf, const Vector2 &scale, const Vector2 &translate, bool inverseYAxis, double y);
-double estimateSDFError(const BitmapConstRef<float, 1> &sdf, const Shape &shape, const Vector2 &scale, const Vector2 &translate, int scanlinesPerRow, FillRule fillRule = FILL_NONZERO);
-double estimateSDFError(const BitmapConstRef<float, 3> &sdf, const Shape &shape, const Vector2 &scale, const Vector2 &translate, int scanlinesPerRow, FillRule fillRule = FILL_NONZERO);
-double estimateSDFError(const BitmapConstRef<float, 4> &sdf, const Shape &shape, const Vector2 &scale, const Vector2 &translate, int scanlinesPerRow, FillRule fillRule = FILL_NONZERO);
+void scanlineSDF(Scanline &line, const BitmapConstSection<float, 1> &sdf, const Projection &projection, double y, bool inverseYAxis);
+void scanlineSDF(Scanline &line, const BitmapConstSection<float, 3> &sdf, const Projection &projection, double y, bool inverseYAxis);
+void scanlineSDF(Scanline &line, const BitmapConstSection<float, 4> &sdf, const Projection &projection, double y, bool inverseYAxis);
+void scanlineSDF(Scanline &line, const BitmapConstSection<float, 1> &sdf, const Vector2 &scale, const Vector2 &translate, bool inverseYAxis, double y);
+void scanlineSDF(Scanline &line, const BitmapConstSection<float, 3> &sdf, const Vector2 &scale, const Vector2 &translate, bool inverseYAxis, double y);
+void scanlineSDF(Scanline &line, const BitmapConstSection<float, 4> &sdf, const Vector2 &scale, const Vector2 &translate, bool inverseYAxis, double y);
+double estimateSDFError(const BitmapConstSection<float, 1> &sdf, const Shape &shape, const Vector2 &scale, const Vector2 &translate, int scanlinesPerRow, FillRule fillRule = FILL_NONZERO);
+double estimateSDFError(const BitmapConstSection<float, 3> &sdf, const Shape &shape, const Vector2 &scale, const Vector2 &translate, int scanlinesPerRow, FillRule fillRule = FILL_NONZERO);
+double estimateSDFError(const BitmapConstSection<float, 4> &sdf, const Shape &shape, const Vector2 &scale, const Vector2 &translate, int scanlinesPerRow, FillRule fillRule = FILL_NONZERO);
 
 }
diff --git a/Source/ThirdParty/msdfgen/msdfgen/msdfgen-config.h b/Source/ThirdParty/msdfgen/msdfgen/msdfgen-config.h
index ebcd5942f..ab36f7791 100644
--- a/Source/ThirdParty/msdfgen/msdfgen/msdfgen-config.h
+++ b/Source/ThirdParty/msdfgen/msdfgen/msdfgen-config.h
@@ -4,10 +4,10 @@
 #define MSDFGEN_PUBLIC
 #define MSDFGEN_EXT_PUBLIC
 
-#define MSDFGEN_VERSION 1.12.1
+#define MSDFGEN_VERSION 1.13.0
 #define MSDFGEN_VERSION_MAJOR 1
-#define MSDFGEN_VERSION_MINOR 12
-#define MSDFGEN_VERSION_REVISION 1
-#define MSDFGEN_COPYRIGHT_YEAR 2025
+#define MSDFGEN_VERSION_MINOR 13
+#define MSDFGEN_VERSION_REVISION 0
+#define MSDFGEN_COPYRIGHT_YEAR 2026
 
 #define MSDFGEN_USE_CPP11
diff --git a/Source/ThirdParty/msdfgen/msdfgen/msdfgen.h b/Source/ThirdParty/msdfgen/msdfgen/msdfgen.h
index e5dd67260..bf0ae2bad 100644
--- a/Source/ThirdParty/msdfgen/msdfgen/msdfgen.h
+++ b/Source/ThirdParty/msdfgen/msdfgen/msdfgen.h
@@ -44,35 +44,35 @@
 namespace msdfgen {
 
 /// Generates a conventional single-channel signed distance field.
-void generateSDF(const BitmapRef<float, 1> &output, const Shape &shape, const SDFTransformation &transformation, const GeneratorConfig &config = GeneratorConfig());
+void generateSDF(const BitmapSection<float, 1> &output, const Shape &shape, const SDFTransformation &transformation, const GeneratorConfig &config = GeneratorConfig());
 
 /// Generates a single-channel signed perpendicular distance field.
-void generatePSDF(const BitmapRef<float, 1> &output, const Shape &shape, const SDFTransformation &transformation, const GeneratorConfig &config = GeneratorConfig());
+void generatePSDF(const BitmapSection<float, 1> &output, const Shape &shape, const SDFTransformation &transformation, const GeneratorConfig &config = GeneratorConfig());
 
 /// Generates a multi-channel signed distance field. Edge colors must be assigned first! (See edgeColoringSimple)
-void generateMSDF(const BitmapRef<float, 3> &output, const Shape &shape, const SDFTransformation &transformation, const MSDFGeneratorConfig &config = MSDFGeneratorConfig());
+void generateMSDF(const BitmapSection<float, 3> &output, const Shape &shape, const SDFTransformation &transformation, const MSDFGeneratorConfig &config = MSDFGeneratorConfig());
 
 /// Generates a multi-channel signed distance field with true distance in the alpha channel. Edge colors must be assigned first.
-void generateMTSDF(const BitmapRef<float, 4> &output, const Shape &shape, const SDFTransformation &transformation, const MSDFGeneratorConfig &config = MSDFGeneratorConfig());
+void generateMTSDF(const BitmapSection<float, 4> &output, const Shape &shape, const SDFTransformation &transformation, const MSDFGeneratorConfig &config = MSDFGeneratorConfig());
 
 // Old version of the function API's kept for backwards compatibility
-void generateSDF(const BitmapRef<float, 1> &output, const Shape &shape, const Projection &projection, Range range, const GeneratorConfig &config = GeneratorConfig());
-void generatePSDF(const BitmapRef<float, 1> &output, const Shape &shape, const Projection &projection, Range range, const GeneratorConfig &config = GeneratorConfig());
-void generatePseudoSDF(const BitmapRef<float, 1> &output, const Shape &shape, const Projection &projection, Range range, const GeneratorConfig &config = GeneratorConfig());
-void generateMSDF(const BitmapRef<float, 3> &output, const Shape &shape, const Projection &projection, Range range, const MSDFGeneratorConfig &config = MSDFGeneratorConfig());
-void generateMTSDF(const BitmapRef<float, 4> &output, const Shape &shape, const Projection &projection, Range range, const MSDFGeneratorConfig &config = MSDFGeneratorConfig());
+void generateSDF(const BitmapSection<float, 1> &output, const Shape &shape, const Projection &projection, Range range, const GeneratorConfig &config = GeneratorConfig());
+void generatePSDF(const BitmapSection<float, 1> &output, const Shape &shape, const Projection &projection, Range range, const GeneratorConfig &config = GeneratorConfig());
+void generatePseudoSDF(const BitmapSection<float, 1> &output, const Shape &shape, const Projection &projection, Range range, const GeneratorConfig &config = GeneratorConfig());
+void generateMSDF(const BitmapSection<float, 3> &output, const Shape &shape, const Projection &projection, Range range, const MSDFGeneratorConfig &config = MSDFGeneratorConfig());
+void generateMTSDF(const BitmapSection<float, 4> &output, const Shape &shape, const Projection &projection, Range range, const MSDFGeneratorConfig &config = MSDFGeneratorConfig());
 
-void generateSDF(const BitmapRef<float, 1> &output, const Shape &shape, Range range, const Vector2 &scale, const Vector2 &translate, bool overlapSupport = true);
-void generatePSDF(const BitmapRef<float, 1> &output, const Shape &shape, Range range, const Vector2 &scale, const Vector2 &translate, bool overlapSupport = true);
-void generatePseudoSDF(const BitmapRef<float, 1> &output, const Shape &shape, Range range, const Vector2 &scale, const Vector2 &translate, bool overlapSupport = true);
-void generateMSDF(const BitmapRef<float, 3> &output, const Shape &shape, Range range, const Vector2 &scale, const Vector2 &translate, const ErrorCorrectionConfig &errorCorrectionConfig = ErrorCorrectionConfig(), bool overlapSupport = true);
-void generateMTSDF(const BitmapRef<float, 4> &output, const Shape &shape, Range range, const Vector2 &scale, const Vector2 &translate, const ErrorCorrectionConfig &errorCorrectionConfig = ErrorCorrectionConfig(), bool overlapSupport = true);
+void generateSDF(const BitmapSection<float, 1> &output, const Shape &shape, Range range, const Vector2 &scale, const Vector2 &translate, bool overlapSupport = true);
+void generatePSDF(const BitmapSection<float, 1> &output, const Shape &shape, Range range, const Vector2 &scale, const Vector2 &translate, bool overlapSupport = true);
+void generatePseudoSDF(const BitmapSection<float, 1> &output, const Shape &shape, Range range, const Vector2 &scale, const Vector2 &translate, bool overlapSupport = true);
+void generateMSDF(const BitmapSection<float, 3> &output, const Shape &shape, Range range, const Vector2 &scale, const Vector2 &translate, const ErrorCorrectionConfig &errorCorrectionConfig = ErrorCorrectionConfig(), bool overlapSupport = true);
+void generateMTSDF(const BitmapSection<float, 4> &output, const Shape &shape, Range range, const Vector2 &scale, const Vector2 &translate, const ErrorCorrectionConfig &errorCorrectionConfig = ErrorCorrectionConfig(), bool overlapSupport = true);
 
 // Original simpler versions of the previous functions, which work well under normal circumstances, but cannot deal with overlapping contours.
-void generateSDF_legacy(const BitmapRef<float, 1> &output, const Shape &shape, Range range, const Vector2 &scale, const Vector2 &translate);
-void generatePSDF_legacy(const BitmapRef<float, 1> &output, const Shape &shape, Range range, const Vector2 &scale, const Vector2 &translate);
-void generatePseudoSDF_legacy(const BitmapRef<float, 1> &output, const Shape &shape, Range range, const Vector2 &scale, const Vector2 &translate);
-void generateMSDF_legacy(const BitmapRef<float, 3> &output, const Shape &shape, Range range, const Vector2 &scale, const Vector2 &translate, ErrorCorrectionConfig errorCorrectionConfig = ErrorCorrectionConfig());
-void generateMTSDF_legacy(const BitmapRef<float, 4> &output, const Shape &shape, Range range, const Vector2 &scale, const Vector2 &translate, ErrorCorrectionConfig errorCorrectionConfig = ErrorCorrectionConfig());
+void generateSDF_legacy(BitmapSection<float, 1> output, const Shape &shape, Range range, const Vector2 &scale, const Vector2 &translate);
+void generatePSDF_legacy(BitmapSection<float, 1> output, const Shape &shape, Range range, const Vector2 &scale, const Vector2 &translate);
+void generatePseudoSDF_legacy(BitmapSection<float, 1> output, const Shape &shape, Range range, const Vector2 &scale, const Vector2 &translate);
+void generateMSDF_legacy(BitmapSection<float, 3> output, const Shape &shape, Range range, const Vector2 &scale, const Vector2 &translate, ErrorCorrectionConfig errorCorrectionConfig = ErrorCorrectionConfig());
+void generateMTSDF_legacy(BitmapSection<float, 4> output, const Shape &shape, Range range, const Vector2 &scale, const Vector2 &translate, ErrorCorrectionConfig errorCorrectionConfig = ErrorCorrectionConfig());
 
 }
diff --git a/Source/ThirdParty/msdfgen/msdfgen/msdfgen/msdfgen-config.h b/Source/ThirdParty/msdfgen/msdfgen/msdfgen/msdfgen-config.h
index ebcd5942f..ab36f7791 100644
--- a/Source/ThirdParty/msdfgen/msdfgen/msdfgen/msdfgen-config.h
+++ b/Source/ThirdParty/msdfgen/msdfgen/msdfgen/msdfgen-config.h
@@ -4,10 +4,10 @@
 #define MSDFGEN_PUBLIC
 #define MSDFGEN_EXT_PUBLIC
 
-#define MSDFGEN_VERSION 1.12.1
+#define MSDFGEN_VERSION 1.13.0
 #define MSDFGEN_VERSION_MAJOR 1
-#define MSDFGEN_VERSION_MINOR 12
-#define MSDFGEN_VERSION_REVISION 1
-#define MSDFGEN_COPYRIGHT_YEAR 2025
+#define MSDFGEN_VERSION_MINOR 13
+#define MSDFGEN_VERSION_REVISION 0
+#define MSDFGEN_COPYRIGHT_YEAR 2026
 
 #define MSDFGEN_USE_CPP11
diff --git a/Source/Tools/Flax.Build/Deps/Dependencies/msdfgen.cs b/Source/Tools/Flax.Build/Deps/Dependencies/msdfgen.cs
index 31f61d873..1829f9ff0 100644
--- a/Source/Tools/Flax.Build/Deps/Dependencies/msdfgen.cs
+++ b/Source/Tools/Flax.Build/Deps/Dependencies/msdfgen.cs
@@ -90,7 +90,7 @@ namespace Flax.Deps.Dependencies
             var cmakeArgs = string.Join(" ", args);
 
             // Get the source
-            CloneGitRepoSingleBranch(root, "https://github.com/Chlumsky/msdfgen.git", "master", "a4dafbac1c29021613fbc89768963f3a7e2105aa");
+            CloneGitRepoSingleBranch(root, "https://github.com/Chlumsky/msdfgen.git", "master", "1874bcf7d9624ccc85b4bc9a85d78116f690f35b");
 
             foreach (var platform in options.Platforms)
             {