gosu 1.0.0 → 1.1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9c9b393a63015707256dca78e9079b01dbc004d85b89c6bf68d021085f65a905
-  data.tar.gz: 60396892082e2fa81a7ab03f8662fe00630745f84b1e0a47e9abcd7bed5c7692
+  metadata.gz: 444c045288619f5db21634cb5bbdd24bf16c93799d16dc84147cab982282804b
+  data.tar.gz: cab4e8823a7b19893cfd3f5b280176ed2b99f76c76278859fe5957bec8aa283a
 SHA512:
-  metadata.gz: fb477140be8f524abfeb3694277bd815690c4c0ae432ac011956a43640f49309aca3c0a9b3619c17cc83461ae5c9c9b6fb1bfa155e72f1be19b4f166e23b3022
-  data.tar.gz: 24707e94f193a4fe949a447a01b732057860eb271a8a0d61ba6c45a0b1b5da8c2894ffc65d3ff3fe2b97fe7e8b9c5b38b9995d4d443d014fe6059f520f900393
+  metadata.gz: c4c1168ca82b6e0c969ca8943469010d1eeadc32908ac3b78fc4b61567e0905076dedc2e4509bb55abedccf9ba4f3ccf79ae900093f1de996112548bc0fbad31
+  data.tar.gz: 6f7b1cea866fecc2b8bde836790f684fff6990dc89844a66f7a304f7f405625a33200bb6ffe2db987444ecc53e7a8ddee26cb75f7e77f7891393fd564e2ae81b

data/COPYING

@@ -1,4 +1,4 @@
-Copyright (C) 2001-2020 Julian Raschke, Jan Lücker and all contributors.
+Copyright (C) 2001-2021 Julian Raschke, Jan Lücker and all contributors.
 
 Permission is hereby granted, free of charge, to any person obtaining a
 copy of this software and associated documentation files (the "Software"),

data/ext/gosu/extconf.rb

@@ -51,7 +51,7 @@ if windows
   else
     $LDFLAGS << "  -L../../dependencies/al_soft/x86 -L../../dependencies/SDL/lib/x86"
   end
-  $LDFLAGS << " -lgdi32 -lwinmm -lOpenGL32 -lOpenAL32 -lSDL2"
+  $LDFLAGS << " -lgdi32 -lwinmm -ldwmapi -lOpenGL32 -lOpenAL32 -lSDL2"
   # Link libstdc++ statically to avoid having another DLL dependency when using Ocra.
   $LDFLAGS << " -static-libstdc++"
 elsif macos
@@ -62,6 +62,10 @@ elsif macos
   # rvm will sometimes try to override this:
   # https://github.com/shawn42/gamebox/issues/96
   $CXXFLAGS << " -stdlib=libc++"
+
+  # Disable an error that is disabled by default and prevents Gosu from building with universal Ruby:
+  # https://trac.macports.org/ticket/58255 / https://github.com/gosu/gosu/issues/424
+  $CXXFLAGS << " -Wno-reserved-user-defined-literal"
   
   # Dependencies.
   $CFLAGS << " #{`sdl2-config --cflags`.chomp}"

data/include/Gosu/Font.hpp

@@ -22,11 +22,9 @@ namespace Gosu
 
     public:
         //! Constructs a font that can be drawn onto the graphics object.
-        //! \param font_name Name of a system font, or a filename to a TTF
-        //!        file (must contain '/', does not work on Linux).
-        //! \param font_height Height of the font, in pixels.
-        //! \param font_flags Flags used to render individual characters of
-        //!        the font.
+        //! \param name   Name of a system font, or a filename to a TTF file.
+        //! \param height Height of the font, in pixels.
+        //! \param flags  Flags used to render individual characters of the font.
         Font(int height, const std::string& name = default_font_name(), unsigned flags = 0);
         
         //! Returns the name of the font that was used to create it.

data/include/Gosu/Text.hpp

@@ -20,7 +20,7 @@ namespace Gosu
     double text_width(const std::u32string& text, const std::string& font_name, double font_height,
                       unsigned font_flags = 0);
 
-    //! Draws a line of unformatted text on a bitmap. This is a low-level function that does not
+    //! Draws a line of plain text on a bitmap. This is a low-level function that does not
     //! understand any of Gosu's HTML-like markup.
     //! \param text A UCS-4 string, normalization: NFC.
     //! \param font_name Name of a system font, or filename of a TTF file (must contain '/' or '.').
@@ -29,9 +29,9 @@ namespace Gosu
     double draw_text(Bitmap& bitmap, double x, double y, Color c, const std::u32string& text,
                      const std::string& font_name, double font_height, unsigned font_flags = 0);
 
-    //! Creates a bitmap that is filled with the formatted text given to the function.
+    //! Creates a bitmap that is filled with the plain text given to the function.
     //! The line can contain line breaks and HTML-like markup.
-    //! \param text Formatted text.
+    //! \param text Plain text.
     //! \param font_name Name of a system font, or filename of a TTF file (must contain '/' or '.').
     //! \param font_height Height of the font in pixels.
     //! \param line_spacing Spacing between two lines of text in pixels. Can be negative to make
@@ -48,7 +48,7 @@ namespace Gosu
     
     //! Creates a bitmap that is filled with the formatted text given to the function.
     //! The line can contain line breaks and HTML-like markup.
-    //! \param text Formatted text.
+    //! \param markup Formatted text.
     //! \param font_name Name of a system font, or filename of a TTF file (must contain '/' or '.').
     //! \param font_height Height of the font in pixels.
     //! \param line_spacing Spacing between two lines of text in pixels. Can be negative to make

data/include/Gosu/Version.hpp

@@ -3,8 +3,8 @@
 #include <string>
 
 #define GOSU_MAJOR_VERSION 1
-#define GOSU_MINOR_VERSION 0
-#define GOSU_POINT_VERSION 0
+#define GOSU_MINOR_VERSION 1
+#define GOSU_POINT_VERSION 1
 
 namespace Gosu
 {

data/include/Gosu/Window.hpp

@@ -8,6 +8,14 @@
 
 namespace Gosu
 {
+    enum WindowFlags
+    {
+        WF_WINDOWED,
+        WF_FULLSCREEN = 1,
+        WF_RESIZABLE  = 2,
+        WF_BORDERLESS = 4
+    };
+
     //! Convenient all-in-one class that serves as the foundation of a standard Gosu application.
     //! Manages initialization of all of Gosu's core components and provides timing functionality.
     //! Note that you should really only use one instance of this class at the same time.
@@ -21,17 +29,23 @@ namespace Gosu
         //! \param width Width of the window in points; that is, pixels on a normal display, and
         //! 'points' on a high-resolution display.
         //! \param height See width.
+        //! \param window_flags A bitmask of values from Gosu::WindowFlags.
         //! \param update_interval Interval in milliseconds between two calls to the update member
         //! function.
-        Window(unsigned width, unsigned height, bool fullscreen = false,
-            double update_interval = 16.666666, bool resizable = false);
+        Window(int width, int height, unsigned window_flags = WF_WINDOWED,
+               double update_interval = 16.666666);
         virtual ~Window();
 
-        unsigned width() const;
-        unsigned height() const;
+        int width() const;
+        int height() const;
         bool fullscreen() const;
+        void resize(int width, int height, bool fullscreen);
+
         bool resizable() const;
-        void resize(unsigned width, unsigned height, bool fullscreen);
+        void set_resizable(bool resizable);
+
+        bool borderless() const;
+        void set_borderless(bool borderless);
 
         double update_interval() const;
         void set_update_interval(double update_interval);
@@ -129,22 +143,22 @@ namespace Gosu
     //! Returns the width (in pixels) of a screen.
     //! \param window The result describes the screen on which the window is shown, or the
     //!               primary screen if no window is given.
-    unsigned screen_width(Window* window = nullptr);
+    int screen_width(Window* window = nullptr);
 
     //! Returns the height (in pixels) of the user's primary screen.
     //! \param window The result describes the screen on which the window is shown, or the
     //!               primary screen if no window is given.
-    unsigned screen_height(Window* window = nullptr);
+    int screen_height(Window* window = nullptr);
 
     //! Returns the maximum width (in 'points') that is available for a non-fullscreen Window.
     //! All windows larger than this size will automatically be shrunk to fit.
     //! \param window The result describes the screen on which the window is shown, or the
     //!               primary screen if no window is given.
-    unsigned available_width(Window* window = nullptr);
+    int available_width(Window* window = nullptr);
 
     //! Returns the maximum height (in 'points') that is available for a non-fullscreen Window.
     //! All windows larger than this size will automatically be shrunk to fit.
     //! \param window The result describes the screen on which the window is shown, or the
     //!               primary screen if no window is given.
-    unsigned available_height(Window* window = nullptr);
+    int available_height(Window* window = nullptr);
 }

data/lib/gosu/swig_patches.rb

@@ -3,19 +3,20 @@
 # compatible, but I just call protected_update etc. in the Ruby wrapper so I can add this
 # custom debugging help:
 class Gosu::Window
-  alias_method :initialize_without_hash, :initialize
+  alias_method :initialize_with_bitmask, :initialize
 
-  def initialize width, height, *args
-    if args.empty? or args.first.is_a? Hash
-      options = args.first || {}
-      fullscreen = options[:fullscreen]
-      update_interval = options[:update_interval]
-      resizable = options[:resizable]
+  def initialize(width, height, *args)
+    $gosu_gl_blocks = nil
+
+    if args.first.is_a? Hash
+      flags = 0
+      flags |= 1 if args.first[:fullscreen]
+      flags |= 2 if args.first[:resizable]
+      flags |= 4 if args.first[:borderless]
+      initialize_with_bitmask(width, height, flags, args.first[:update_interval] || 16.666666)
     else
-      fullscreen, update_interval = *args
+      initialize_with_bitmask(width, height, args[0] ? 1 : 0, args[1] || 16.666666)
     end
-    $gosu_gl_blocks = nil
-    initialize_without_hash width, height, !!fullscreen, update_interval || 16.666666, !!resizable
   end
 
   %w(update draw needs_redraw? needs_cursor?

data/rdoc/gosu.rb

@@ -811,6 +811,18 @@ module Gosu
     # @return [true, false] whether this window is resizable.
     def resizable?; end
 
+    ##
+    # Toggles between resizable and fixed modes.
+    attr_writer :resizable
+
+    ##
+    # @return [true, false] whether this window is borderless.
+    def borderless?; end
+
+    ##
+    # Toggles between borderless mode and having window chrome.
+    attr_writer :borderless
+
     ##
     # @return [Float] the interval between calls to {#update}, in milliseconds.
     attr_accessor :update_interval
@@ -828,7 +840,8 @@ module Gosu
     # @param height [Integer] the desired window height.
     # @param [Hash] options
     # @option options [true, false] :fullscreen (false) whether to present the window in fullscreen mode.
-    # @option options [true, false] :resizable (false) whether the window can be resized by the user.
+    # @option options [true, false] :resizable (false) whether the window can be resized by the user. Not useful if the window is either fullscreen or borderless.
+    # @option options [true, false] :borderless (false) whether the window should hide all its window chrome. Does not affect fullscreen windows.
     # @option options [Float] :update_interval (16.666666) the interval between frames, in milliseconds.
     def initialize(width, height, options); end
 

data/src/Input.cpp

@@ -78,20 +78,11 @@ struct Gosu::Input::Impl
 
     void update_mouse_position()
     {
-    #if SDL_VERSION_ATLEAST(2, 0, 5)
-        // SDL_GetGlobalMouseState was added in SDL 2.0.4, but it only started using the same
-        // coordinate system as SDL_GetWindowPosition on X11 in 2.0.5.
         int x, y, window_x, window_y;
         SDL_GetWindowPosition(window, &window_x, &window_y);
         SDL_GetGlobalMouseState(&x, &y);
         mouse_x = x - window_x;
         mouse_y = y - window_y;
-    #else
-        int x, y;
-        SDL_GetMouseState(&x, &y);
-        mouse_x = x;
-        mouse_y = y;
-    #endif
     }
 
     void set_mouse_position(double x, double y)
@@ -100,7 +91,7 @@ struct Gosu::Input::Impl
                               static_cast<int>((x - mouse_offset_x) / mouse_scale_x),
                               static_cast<int>((y - mouse_offset_y) / mouse_scale_y));
 
-    #if SDL_VERSION_ATLEAST(2, 0, 4) && !defined(GOSU_IS_X)
+    #if !defined(GOSU_IS_X)
         // On systems where we have a working GetGlobalMouseState, we can warp the mouse and
         // retrieve its position directly afterwards.
         update_mouse_position();

data/src/Macro.cpp

@@ -1,168 +1,125 @@
 #include "Macro.hpp"
 #include "DrawOpQueue.hpp"
 #include <Gosu/Image.hpp>
-#include <cmath>
-#include <algorithm>
-#include <functional>
-#include <memory>
 #include <stdexcept>
 using namespace std;
 
 struct Gosu::Macro::Impl
 {
-    typedef double Float;
-    
     VertexArrays vertex_arrays;
     int width, height;
-    
-    Transform find_transform_for_target(Float x1, Float y1, Float x2, Float y2,
-        Float x3, Float y3, Float x4, Float y4) const
+
+    // Solves the 2x2 linear system for x:
+    // (a11 a12) (x1) = (b1)
+    // (a21 a22) (x2) = (b2)
+    // x1, x2 are output parameters. Returns false if the matrix is singular.
+    static bool solve_2x2(double a11, double a12, double a21, double a22, double b1, double b2,
+                          double& x1, double& x2)
+    {
+        const double det = a11 * a22 - a21 * a12;
+        if (det == 0) return false;
+        x1 = (a22 * b1 - a12 * b2) / det;
+        x2 = (a11 * b2 - a21 * b1) / det;
+        return true;
+    }
+
+    Transform find_transform_for_target(double x1, double y1, double x2, double y2,
+        double x3, double y3, double x4, double y4) const
     {
         // Transformation logic follows a discussion on the ImageMagick mailing
         // list (on which ImageMagick's perspective_transform.pl is based).
-        
+
         // To draw a macro at an arbitrary position, we solve the following system:
-        
-        // 0, 0, 1, 0, 0, 0,    0,    0 | x1
-        // 0, 0, 0, 0, 0, 1,    0,    0 | y1
-        // w, 0, 1, 0, 0, 0, -x2w,    0 | x2
-        // 0, 0, 0, w, 0, 1, -y2w,    0 | y2
-        // 0, h, 1, 0, 0, 0,    0, -x3h | x3
-        // 0, 0, 0, 0, h, 1,    0, -y3h | y3
-        // w, h, 1, 0, 0, 0, -x4w, -x4h | x4
-        // 0, 0, 0, w, h, 1, -y4w, -y4h | y4
-        
+
+        // 0, 0, 1, 0, 0, 0,     0,     0 | x1
+        // 0, 0, 0, 0, 0, 1,     0,     0 | y1
+        // w, 0, 1, 0, 0, 0, -x2 w,     0 | x2
+        // 0, 0, 0, w, 0, 1, -y2 w,     0 | y2
+        // 0, h, 1, 0, 0, 0,     0, -x3 h | x3
+        // 0, 0, 0, 0, h, 1,     0, -y3 h | y3
+        // w, h, 1, 0, 0, 0, -x4 w, -x4 h | x4
+        // 0, 0, 0, w, h, 1, -y4 w, -y4 h | y4
+
         // Equivalent:
-        
-        // 0, 0, 1, 0, 0, 0,        0,        0 | x1
-        // 0, 0, 0, 0, 0, 1,        0,        0 | y1
-        // w, 0, 0, 0, 0, 0,     -x2w,        0 | x2-x1
-        // 0, 0, 0, w, 0, 0,     -y2w,        0 | y2-y1
-        // 0, h, 0, 0, 0, 0,        0,     -x3h | x3-x1
-        // 0, 0, 0, 0, h, 0,        0,     -y3h | y3-y1
-        // 0, 0, 0, 0, 0, 0, (x2-x4)w, (x3-x4)h | x1-x2-x3+x4
-        // 0, 0, 0, 0, 0, 0, (y2-y4)w, (y3-y4)h | y1-y2-y3+y4
-        
-        // Since this matrix is relatively sparse, we unroll all three solving paths.
-        
-        static const Transform null_transform = {{ 0 }};
-        
-        // Row 7 is completely useless
-        if (x2 == x4 && x3 == x4) return null_transform;
-        // Row 8 is completely useless
-        if (y2 == y3 && y3 == y4) return null_transform;
-        // Col 7 is completely useless
-        if (x2 == x4 && y2 == y4) return null_transform;
-        // Col 8 is completely useless
-        if (x3 == x4 && y3 == y4) return null_transform;
-        
-        Float c[8];
-        
-        // Rows 1, 2
+
+        // 0, 0, 1, 0, 0, 0,         0,         0 | x1
+        // 0, 0, 0, 0, 0, 1,         0,         0 | y1
+        // w, 0, 0, 0, 0, 0,     -x2 w,         0 | x2-x1
+        // 0, 0, 0, w, 0, 0,     -y2 w,         0 | y2-y1
+        // 0, h, 0, 0, 0, 0,         0,     -x3 h | x3-x1
+        // 0, 0, 0, 0, h, 0,         0,     -y3 h | y3-y1
+        // 0, 0, 0, 0, 0, 0, (x2-x4) w, (x3-x4) h | x1-x2-x3+x4
+        // 0, 0, 0, 0, 0, 0, (y2-y4) w, (y3-y4) h | y1-y2-y3+y4
+
+        // The last two rows only involve the last two variables.
+        // We can directly solve this as a separate 2x2 linear system.
+
+        // Set up 2x2 linear system of the lower right corner entries.
+        const double a11 = (x2 - x4) * width;
+        const double a12 = (x3 - x4) * height;
+        const double a21 = (y2 - y4) * width;
+        const double a22 = (y3 - y4) * height;
+        const double b1 = x1 - x2 - x3 + x4;
+        const double b2 = y1 - y2 - y3 + y4;
+
+        // Solve:
+        double qx, qy;
+        if (!solve_2x2(a11, a12, a21, a22, b1, b2, qx, qy)) return Transform{{0}};
+
+        // Updating the last two rows with the computed solution yields
+
+        // 0, 0, 1, 0, 0, 0,     0,     0 | x1
+        // 0, 0, 0, 0, 0, 1,     0,     0 | y1
+        // w, 0, 0, 0, 0, 0, -x2 w,     0 | x2-x1
+        // 0, 0, 0, w, 0, 0, -y2 w,     0 | y2-y1
+        // 0, h, 0, 0, 0, 0,     0, -x3 h | x3-x1
+        // 0, 0, 0, 0, h, 0,     0, -y3 h | y3-y1
+        // 0, 0, 0, 0, 0, 0,     1,     0 | qx
+        // 0, 0, 0, 0, 0, 0,     0,     1 | qy
+
+        // We can use the last two rows to eliminate entries in rows 3, 4, 5, and 6:
+
+        // 0, 0, 1, 0, 0, 0, 0, 0 | x1
+        // 0, 0, 0, 0, 0, 1, 0, 0 | y1
+        // w, 0, 0, 0, 0, 0, 0, 0 | x2-x1 + qx x2 w
+        // 0, 0, 0, w, 0, 0, 0, 0 | y2-y1 + qx y2 w
+        // 0, h, 0, 0, 0, 0, 0, 0 | x3-x1 + qy x3 h
+        // 0, 0, 0, 0, h, 0, 0, 0 | y3-y1 + qy y3 h
+        // 0, 0, 0, 0, 0, 0, 1, 0 | qx
+        // 0, 0, 0, 0, 0, 0, 0, 1 | qy
+
+        // Normalize and reorder rows so we can read off the solution:
+
+        // 1, 0, 0, 0, 0, 0, 0, 0 | (x2-x1) / w + qx x2
+        // 0, 1, 0, 0, 0, 0, 0, 0 | (x3-x1) / h + qy x3
+        // 0, 0, 1, 0, 0, 0, 0, 0 | x1
+        // 0, 0, 0, 1, 0, 0, 0, 0 | (y2-y1) / w + qx y2
+        // 0, 0, 0, 0, 1, 0, 0, 0 | (y3-y1) / h + qy y3
+        // 0, 0, 0, 0, 0, 1, 0, 0 | y1
+        // 0, 0, 0, 0, 0, 0, 1, 0 | qx
+        // 0, 0, 0, 0, 0, 0, 0, 1 | qy
+
+        double c[8];
+        c[0] = (x2 - x1) / width  + qx * x2;
+        c[1] = (x3 - x1) / height + qy * x3;
         c[2] = x1;
+        c[3] = (y2 - y1) / width  + qx * y2;
+        c[4] = (y3 - y1) / height + qy * y3;
         c[5] = y1;
-        
-        // The logic below assumes x2 != x4, i.e. row7 can be used to eliminate
-        // the leftmost value in row 8 and afterwards the values in rows 3 & 4.
-        // If x2 == x4, we need to exchange rows 7 and 8.
-        
-        // TODO: x2==x4 is the normal case where an image is
-        // drawn upright; the code should rather swap in the rare case that x3==x4!
-        
-        Float left_cell7 = (x2 - x4) * width;
-        Float right_cell7 = (x3 - x4) * height;
-        Float orig_right_side7 = (x1 - x2 - x3 + x4);
-        Float left_cell8 = (y2 - y4) * width;
-        Float right_cell8 = (y3 - y4) * height;
-        Float orig_right_side8 = (y1 - y2 - y3 + y4);
-        
-        bool swap_rows78 = x2 == x4;
-        if (swap_rows78) {
-            swap(left_cell7, left_cell8);
-            swap(right_cell7, right_cell8);
-            swap(orig_right_side7, orig_right_side8);
-        }
-        
-        // 0, 0, 1, 0, 0, 0,         0,           0 | x1
-        // 0, 0, 0, 0, 0, 1,         0,           0 | y1
-        // w, 0, 0, 0, 0, 0,      -x2w,           0 | x2-x1
-        // 0, 0, 0, w, 0, 0,      -y2w,           0 | y2-y1
-        // 0, h, 0, 0, 0, 0,         0,        -x3h | x3-x1
-        // 0, 0, 0, 0, h, 0,         0,        -y3h | y3-y1
-        // 0, 0, 0, 0, 0, 0, left_cell7, right_cell7 | orig_right_side7
-        // 0, 0, 0, 0, 0, 0, left_cell8, right_cell8 | orig_right_side8
-        
-        // Use row 7 to eliminate the left cell in row 8
-        // Row8 = Row8 - factor78 * Row7
-        Float factor78 = left_cell8 / left_cell7;
-        Float rem_cell8 = right_cell8 - right_cell7 * factor78;
-        Float right_side8 = orig_right_side8 - orig_right_side7 * factor78;
-        c[7] = right_side8 / rem_cell8;
-        
-        // 0, 0, 1, 0, 0, 0,         0,          0 | x1
-        // 0, 0, 0, 0, 0, 1,         0,          0 | y1
-        // w, 0, 0, 0, 0, 0,      -x2w,          0 | x2-x1
-        // 0, 0, 0, w, 0, 0,      -y2w,          0 | y2-y1
-        // 0, h, 0, 0, 0, 0,         0,       -x3h | x3-x1
-        // 0, 0, 0, 0, h, 0,         0,       -y3h | y3-y1
-        // 0, 0, 0, 0, 0, 0, left_cell7, right_cell7 | orig_right_side7
-        // 0, 0, 0, 0, 0, 0,         0,   rem_cell8 | right_side8
-        
-        // Use the remaining value in row 8 to eliminate the right value in row 7.
-        // Row7 = Row7 - factor87 * Row8
-        Float factor87 = right_cell7 / rem_cell8;
-        Float rem_cell7 = left_cell7;
-        Float right_side7 = orig_right_side7 - right_side8 * factor87;
-        c[6] = right_side7 / rem_cell7;
-        
-        // 0, 0, 1, 0, 0, 0,        0,        0 | x1
-        // 0, 0, 0, 0, 0, 1,        0,        0 | y1
-        // w, 0, 0, 0, 0, 0,     -x2w,        0 | x2-x1
-        // 0, 0, 0, w, 0, 0,     -y2w,        0 | y2-y1
-        // 0, h, 0, 0, 0, 0,        0,     -x3h | x3-x1
-        // 0, 0, 0, 0, h, 0,        0,     -y3h | y3-y1
-        // 0, 0, 0, 0, 0, 0, rem_cell7,        0 | right_side7
-        // 0, 0, 0, 0, 0, 0,        0, rem_cell8 | right_side8
-        
-        // Use the new rows 7 and 8 to calculate c0, c1, c3 & c4.
-        // Row3 = Row3 - factor73 * Row7
-        Float factor73 = -x2 * width / rem_cell7;
-        Float rem_cell3 = width;
-        Float right_side3 = (x2 - x1) - right_side7 * factor73;
-        c[0] = right_side3 / rem_cell3;
-        // Row4 = Row4 - factor74 * Row7
-        Float factor74 = -y2 * width / rem_cell7;
-        Float rem_cell4 = width;
-        Float right_side4 = (y2 - y1) - right_side7 * factor74;
-        c[3] = right_side4 / rem_cell4;
-        // Row5 = Row5 - factor85 * Row7
-        Float factor85 = -x3 * height / rem_cell8;
-        Float rem_cell5 = height;
-        Float right_side5 = (x3 - x1) - right_side8 * factor85;
-        c[1] = right_side5 / rem_cell5;
-        // Row6 = Row6 - factor86 * Row8
-        Float factor86 = -y3 * height / rem_cell8;
-        Float rem_cell6 = height;
-        Float right_side6 = (y3 - y1) - right_side8 * factor86;
-        c[4] = right_side6 / rem_cell6;
-        
-        if (swap_rows78) {
-            swap(c[6], c[7]);
-        }
-        
-        // Let's hope I never have to debug/understand this again! :D
-        
+        c[6] = qx;
+        c[7] = qy;
+
         Transform result = {{
             c[0], c[3], 0, c[6],
             c[1], c[4], 0, c[7],
-            0, 0, 1, 0,
+            0,    0,    1, 0,
             c[2], c[5], 0, 1
         }};
         return result;
     }
-    
-    void draw_vertex_arrays(Float x1, Float y1, Float x2, Float y2, Float x3, Float y3,
-        Float x4, Float y4) const
+
+    void draw_vertex_arrays(double x1, double y1, double x2, double y2, double x3, double y3,
+        double x4, double y4) const
     {
         // TODO: Macros should not be split up just because they have different transforms.
         // They should be premultiplied and have the same transform by definition. Then the