gosu 1.1.0 → 1.4.0

data/src/Macro.cpp

@@ -1,179 +1,134 @@
 #include "Macro.hpp"
-#include "DrawOpQueue.hpp"
 #include <Gosu/Image.hpp>
-#include <cmath>
-#include <algorithm>
-#include <functional>
-#include <memory>
+#include <Gosu/Utility.hpp>
+#include "DrawOpQueue.hpp"
 #include <stdexcept>
-using namespace std;
 
-struct Gosu::Macro::Impl
+struct Gosu::Macro::Impl : Gosu::Noncopyable
 {
-    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
-        
-        Transform result = {{
-            c[0], c[3], 0, c[6],
-            c[1], c[4], 0, c[7],
-            0, 0, 1, 0,
-            c[2], c[5], 0, 1
-        }};
+        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,          //
+                             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
         // transformation only has to be performed once.
-        
-    #ifndef GOSU_IS_OPENGLES
+
+#ifndef GOSU_IS_OPENGLES
         glEnable(GL_BLEND);
         glMatrixMode(GL_MODELVIEW);
-        
+
         Transform transform = find_transform_for_target(x1, y1, x2, y2, x3, y3, x4, y4);
-        
+
         for (const auto& vertex_array : vertex_arrays) {
             glPushMatrix();
             vertex_array.render_state.apply();
@@ -182,7 +137,7 @@ struct Gosu::Macro::Impl
             glDrawArrays(GL_QUADS, 0, (GLsizei) vertex_array.vertices.size());
             glPopMatrix();
         }
-    #endif
+#endif
     }
 };
 
@@ -204,15 +159,16 @@ int Gosu::Macro::height() const
     return pimpl->height;
 }
 
-void Gosu::Macro::draw(double x1, double y1, Color c1, double x2, double y2, Color c2,
-    double x3, double y3, Color c3, double x4, double y4, Color c4, ZPos z, AlphaMode mode) const
+void Gosu::Macro::draw(double x1, double y1, Color c1, double x2, double y2, Color c2, //
+                       double x3, double y3, Color c3, double x4, double y4, Color c4, //
+                       ZPos z, BlendMode mode) const
 {
     if (c1 != Color::WHITE || c2 != Color::WHITE || c3 != Color::WHITE || c4 != Color::WHITE) {
-        throw invalid_argument("Macros cannot be tinted with colors");
+        throw std::invalid_argument{"Macros cannot be tinted with colors"};
     }
-    
+
     normalize_coordinates(x1, y1, x2, y2, x3, y3, c3, x4, y4, c4);
-    
+
     Gosu::Graphics::gl(z, [=] { pimpl->draw_vertex_arrays(x1, y1, x2, y2, x3, y3, x4, y4); });
 }
 
@@ -223,21 +179,20 @@ const Gosu::GLTexInfo* Gosu::Macro::gl_tex_info() const
 
 Gosu::Bitmap Gosu::Macro::to_bitmap() const
 {
-    return Gosu::Graphics::render(pimpl->width, pimpl->height, [this] {
-        draw(0,            0,             Color::WHITE,
-             pimpl->width, 0,             Color::WHITE,
-             0,            pimpl->height, Color::WHITE,
-             pimpl->width, pimpl->height, Color::WHITE,
-             0, AM_DEFAULT);
-    }).data().to_bitmap();
+    const auto render_this = [this] {
+        draw(0, 0, Color::WHITE, pimpl->width, 0, Color::WHITE, 0, pimpl->height, Color::WHITE,
+             pimpl->width, pimpl->height, Color::WHITE, 0, BM_DEFAULT);
+    };
+
+    return Gosu::Graphics::render(pimpl->width, pimpl->height, render_this).data().to_bitmap();
 }
 
-unique_ptr<Gosu::ImageData> Gosu::Macro::subimage(int x, int y, int width, int height) const
+std::unique_ptr<Gosu::ImageData> Gosu::Macro::subimage(int x, int y, int width, int height) const
 {
-    return unique_ptr<ImageData>();
+    return std::unique_ptr<ImageData>{};
 }
 
 void Gosu::Macro::insert(const Bitmap& bitmap, int x, int y)
 {
-    throw logic_error("Gosu::Macro cannot be updated with a Gosu::Bitmap yet");
+    throw std::logic_error{"Gosu::Macro cannot be updated with a Gosu::Bitmap yet"};
 }

data/src/Macro.hpp

@@ -1,30 +1,30 @@
 #pragma once
 
-#include "GraphicsImpl.hpp"
 #include <Gosu/Fwd.hpp>
 #include <Gosu/ImageData.hpp>
+#include "GraphicsImpl.hpp"
 #include <memory>
 
 class Gosu::Macro : public Gosu::ImageData
 {
     struct Impl;
     std::shared_ptr<Impl> pimpl;
-    
+
 public:
     Macro(DrawOpQueue& queue, int width, int height);
-    
+
     int width() const override;
     int height() const override;
-    
-    void draw(double x1, double y1, Color c1, double x2, double y2, Color c2,
-        double x3, double y3, Color c3, double x4, double y4, Color c4, ZPos z,
-        AlphaMode mode) const override;
-    
+
+    void draw(double x1, double y1, Color c1, double x2, double y2, Color c2, //
+              double x3, double y3, Color c3, double x4, double y4, Color c4, //
+              ZPos z, BlendMode mode) const override;
+
     const Gosu::GLTexInfo* gl_tex_info() const override;
-    
+
     Gosu::Bitmap to_bitmap() const override;
-    
+
     std::unique_ptr<ImageData> subimage(int x, int y, int width, int height) const override;
-    
+
     void insert(const Bitmap& bitmap, int x, int y) override;
 };

data/src/Math.cpp

@@ -23,7 +23,14 @@ double Gosu::angle(double from_x, double from_y, double to_x, double to_y, doubl
     double dist_x = to_x - from_x;
     double dist_y = to_y - from_y;
 
-    if (dist_x == 0 && dist_y == 0) return def;
+    if (dist_x == 0) {
+        // Special-case these values so that for a result of 0°/360° we  never 
+        // run into subtle precision errors by converting from radian to angles.
+        if (dist_y < 0) return 0;
+        if (dist_y > 0) return 180;
+        // dist_y == 0
+        return 0;
+    }
 
     return normalize_angle(radians_to_gosu(atan2(dist_y, dist_x)));
 }

data/src/RenderState.hpp

@@ -10,10 +10,10 @@ struct Gosu::RenderState
     std::shared_ptr<Texture> texture;
     const Transform* transform;
     ClipRect clip_rect;
-    AlphaMode mode;
+    BlendMode mode;
     
     RenderState()
-    : transform(0), mode(AM_DEFAULT)
+    : transform(0), mode(BM_DEFAULT)
     {
         clip_rect.width = NO_CLIPPING;
     }
@@ -39,10 +39,10 @@ struct Gosu::RenderState
     
     void apply_alpha_mode() const
     {
-        if (mode == AM_ADD) {
+        if (mode == BM_ADD) {
             glBlendFunc(GL_SRC_ALPHA, GL_ONE);
         }
-        else if (mode == AM_MULTIPLY) {
+        else if (mode == BM_MULTIPLY) {
             glBlendFunc(GL_DST_COLOR, GL_ZERO);
         }
         else {
@@ -174,7 +174,7 @@ public:
         }
     }
     
-    void set_alpha_mode(AlphaMode new_mode)
+    void set_alpha_mode(BlendMode new_mode)
     {
         if (new_mode == mode) return;
         

data/src/Resolution.cpp

@@ -7,11 +7,12 @@
 
 static SDL_DisplayMode display_mode(Gosu::Window* window)
 {
-    static struct VideoSubsystem {
-        VideoSubsystem()  { SDL_InitSubSystem(SDL_INIT_VIDEO); };
+    static struct VideoSubsystem
+    {
+        VideoSubsystem() { SDL_InitSubSystem(SDL_INIT_VIDEO); };
         ~VideoSubsystem() { SDL_QuitSubSystem(SDL_INIT_VIDEO); };
     } subsystem;
-    
+
     int index = window ? SDL_GetWindowDisplayIndex(Gosu::shared_window()) : 0;
     SDL_DisplayMode result;
     SDL_GetDesktopDisplayMode(index, &result);
@@ -31,88 +32,140 @@ int Gosu::screen_height(Window* window)
 #ifdef GOSU_IS_MAC
 #import <AppKit/AppKit.h>
 
-static NSSize max_window_size(Gosu::Window* window)
+static SDL_Rect max_window_size(Gosu::Window* window)
 {
-    // Keep in sync with SDL_cocoawindow.m.
-    auto style = NSTitledWindowMask|NSClosableWindowMask|NSMiniaturizableWindowMask;
+    // The extra size that a window needs depends on its style.
+    // This logic must be kept in sync with SDL_cocoawindow.m to be 100% accurate.
+    NSUInteger style;
+    if (window && window->borderless()) {
+        style = NSWindowStyleMaskBorderless;
+    }
+    else {
+        style = NSWindowStyleMaskTitled | NSWindowStyleMaskClosable |
+                NSWindowStyleMaskMiniaturizable;
+    }
+    if (window && window->resizable()) {
+        style |= NSWindowStyleMaskResizable;
+    }
 
     auto index = window ? SDL_GetWindowDisplayIndex(Gosu::shared_window()) : 0;
-    auto screen_frame = NSScreen.screens[index].visibleFrame;
-    return [NSWindow contentRectForFrameRect:screen_frame styleMask:style].size;
-}
-
-int Gosu::available_width(Window* window)
-{
-    return max_window_size(window).width;
-}
-
-int Gosu::available_height(Window* window)
-{
-    return max_window_size(window).height;
+    NSRect screen_frame = NSScreen.screens[index].visibleFrame;
+    NSRect content_rect = [NSWindow contentRectForFrameRect:screen_frame styleMask:style];
+
+    SDL_Rect result;
+    result.x = 0;
+    result.y = 0;
+    result.w = content_rect.size.width;
+    result.h = content_rect.size.height;
+    return result;
 }
 #endif
 
+// TODO: Remove this implementation and remove ifdef for GOSU_IS_X once WIN_GetWindowBordersSize is patched
 #ifdef GOSU_IS_WIN
-#include <windows.h>
 #include <SDL_syswm.h>
+#include <dwmapi.h>
+#include <windows.h>
+#pragma comment(lib, "Dwmapi.lib")
 
-static SIZE max_window_size(Gosu::Window* window)
+static SDL_Rect max_window_size(Gosu::Window* window)
 {
-    RECT work_area;
-    
-    if (window == nullptr) {
-        // Easy case: Return the work area of the primary monitor.
-        SystemParametersInfo(SPI_GETWORKAREA, 0, &work_area, 0);
-    }
-    else {
-        // Return the work area of the monitor the window is on.
-        SDL_SysWMinfo wm_info;
-        SDL_VERSION(&wm_info.version);
-        SDL_GetWindowWMInfo(Gosu::shared_window(), &wm_info);
-        HMONITOR monitor = MonitorFromWindow(wm_info.info.win.window, MONITOR_DEFAULTTONEAREST);
-        
-        MONITORINFO monitor_info;
-        monitor_info.cbSize = sizeof(monitor_info);
-        GetMonitorInfo(monitor, &monitor_info);
-        work_area = monitor_info.rcWork;
+    // Replicate SDL's WIN_GetWindowBordersSize implementation (https://github.com/libsdl-org/SDL/blob/9f71a809e9bd6fbb5fa401a45c1537fc26abc1b4/src/video/windows/SDL_windowswindow.c#L514-L554)
+    // until it's patched to ignore the window drop shadow (window border is 1px but with drop shadow it's reported as 8px)
+    // REF: https://github.com/libsdl-org/SDL/issues/3835
+
+    static struct VideoSubsystem
+    {
+        VideoSubsystem() { SDL_InitSubSystem(SDL_INIT_VIDEO); };
+        ~VideoSubsystem() { SDL_QuitSubSystem(SDL_INIT_VIDEO); };
+    } subsystem;
+
+    int index = window ? SDL_GetWindowDisplayIndex(Gosu::shared_window()) : 0;
+    SDL_Rect rect;
+    SDL_GetDisplayUsableBounds(index, &rect);
+
+    if (window) {
+        SDL_SysWMinfo info;
+        SDL_VERSION(&info.version);
+        SDL_GetWindowWMInfo(Gosu::shared_window(), &info);
+        HWND hwnd = info.info.win.window;
+
+        RECT rcClient, rcWindow;
+        POINT ptDiff;
+        int top = 0, left = 0, bottom = 0, right = 0;
+
+        /* rcClient stores the size of the inner window, while rcWindow stores the outer size relative to the top-left
+         * screen position; so the top/left values of rcClient are always {0,0} and bottom/right are {height,width} */
+        GetClientRect(hwnd, &rcClient);
+        DwmGetWindowAttribute(hwnd, DWMWA_EXTENDED_FRAME_BOUNDS, &rcWindow, sizeof(rcWindow));
+
+        /* convert the top/left values to make them relative to
+         * the window; they will end up being slightly negative */
+        ptDiff.y = rcWindow.top;
+        ptDiff.x = rcWindow.left;
+
+        ScreenToClient(hwnd, &ptDiff);
+
+        rcWindow.top = ptDiff.y;
+        rcWindow.left = ptDiff.x;
+
+        /* convert the bottom/right values to make them relative to the window,
+         * these will be slightly bigger than the inner width/height */
+        ptDiff.y = rcWindow.bottom;
+        ptDiff.x = rcWindow.right;
+
+        ScreenToClient(hwnd, &ptDiff);
+
+        rcWindow.bottom = ptDiff.y;
+        rcWindow.right = ptDiff.x;
+
+        /* Now that both the inner and outer rects use the same coordinate system we can substract them to get the border size.
+         * Keep in mind that the top/left coordinates of rcWindow are negative because the border lies slightly before {0,0},
+         * so switch them around because SDL2 wants them in positive. */
+        top = rcClient.top - rcWindow.top;
+        left = rcClient.left - rcWindow.left;
+        bottom = rcWindow.bottom - rcClient.bottom;
+        right = rcWindow.right - rcClient.right;
+
+        rect.w -= left + right;
+        rect.h -= top + bottom;
     }
-    
-    RECT window_size = work_area;
-    // Keep in sync with STYLE_NORMAL in SDL_windowswindow.c.
-    DWORD style = WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX;
-    AdjustWindowRectEx(&window_size, style, FALSE, 0);
-    
-    // Because AdjustWindowRectEx will make our rect larger, not smaller, we need to perform some
-    // unintuitive math here.
-    SIZE size;
-    size.cx = 2 * (work_area.right - work_area.left) - (window_size.right - window_size.left);
-    size.cy = 2 * (work_area.bottom - work_area.top) - (window_size.bottom - window_size.top);
-    return size;
-}
 
-int Gosu::available_width(Window* window)
-{
-    return max_window_size(window).cx;
+    // Return a rect to have one less Gosu::available_width/height implementation.
+    return rect;
 }
+#endif
 
-int Gosu::available_height(Window* window)
+#ifdef GOSU_IS_X
+static SDL_Rect max_window_size(Gosu::Window* window)
 {
-    return max_window_size(window).cy;
+    static struct VideoSubsystem
+    {
+        VideoSubsystem() { SDL_InitSubSystem(SDL_INIT_VIDEO); };
+        ~VideoSubsystem() { SDL_QuitSubSystem(SDL_INIT_VIDEO); };
+    } subsystem;
+
+    int index = window ? SDL_GetWindowDisplayIndex(Gosu::shared_window()) : 0;
+    SDL_Rect rect;
+    int top, left, bottom, right;
+    SDL_GetDisplayUsableBounds(index, &rect);
+    SDL_GetWindowBordersSize(Gosu::shared_window(), &top, &left, &bottom, &right);
+
+    rect.w -= left + right;
+    rect.h -= top + bottom;
+
+    return rect;
 }
 #endif
 
-#ifdef GOSU_IS_X
-// Pessimistic fallback implementation for available_width / available_height.
-// TODO: Look at this NET_WORKAREA based implementation: https://github.com/glfw/glfw/pull/989/files
 int Gosu::available_width(Window* window)
 {
-    return static_cast<unsigned>(Gosu::screen_width(window) * 0.9);
+    return max_window_size(window).w;
 }
 
 int Gosu::available_height(Window* window)
 {
-    return static_cast<unsigned>(Gosu::screen_height(window) * 0.8);
+    return max_window_size(window).h;
 }
-#endif
 
 #endif