gosu 1.4.6 → 2.0.0.pre6

data/include/Gosu/Math.hpp

@@ -1,96 +1,74 @@
 #pragma once
 
-#include <cmath>
-
-// Portability: Define M_PI, which MSVC's <cmath> does not do by default.
-#if !defined(M_PI) && !defined(SWIG)
-#define M_PI 3.14159265358979323846264338327950288
-#endif
+#include <numbers>
 
 namespace Gosu
 {
-    //! Returns a real value between min (inclusive) and max (exclusive).
-    //! Uses std::rand, so you should call std::srand before using it.
+    /// Returns a double value between min (inclusive) and max (exclusive).
+    /// This function returns random values based on a uniform distribution.
+    /// Special case: If min and max are the same value, then that value is returned.
     double random(double min, double max);
-    
-    //! Translates between Gosu's angle system (where 0 is at the top)
-    //! and radians (where 0 is at the right).
-    inline double gosu_to_radians(double angle)
+
+    /// Translates between 360° degrees (as used by Gosu) and radians, but does not change the
+    /// origin from the top to the right.
+    inline double degrees_to_radians(double angle)
     {
-        return (angle - 90) * M_PI / 180;
+        return angle * std::numbers::pi / 180;
     }
-    //! Translates between Gosu's angle system (where 0 is at the top)
-    //! and radians (where 0 is at the right).
-    inline double radians_to_gosu(double angle)
+
+    /// Translates between 360° degrees (as used by Gosu) and radians, but does not change the
+    /// origin from the right to the top.
+    inline double radians_to_degrees(double angle)
     {
-        return angle * 180 / M_PI + 90;
+        return angle * 180 / std::numbers::pi;
     }
 
-    //! Translates between degrees (used by Gosu) and radians, i.e. it
-    //! does not change the 'origin' of the angle system.
-    inline double degrees_to_radians(double angle)
+    /// Translates between Gosu's 360° angle system, where 0 is at the top, and radians, where 0 is
+    /// to the right.
+    inline double radians_to_angle(double angle)
     {
-        return angle * M_PI / 180;
+        return radians_to_degrees(angle) + 90;
     }
-    //! Translates between degrees (used by Gosu) and radians, i.e. it
-    //! does not change the 'origin' of the angle system.
-    inline double radians_to_degrees(double angle)
+
+    /// Translates between Gosu's 360° angle system, where 0 is at the top, and radians, where 0 is
+    /// to the right.
+    inline double angle_to_radians(double angle)
     {
-        return angle * 180 / M_PI;
+        return degrees_to_radians(angle - 90);
     }
-    
-    //! Returns the horizontal distance between the origin and the point to
-    //! which you would get if you moved radius pixels in the direction
-    //! specified by angle.
-    //! \param angle Angle in degrees where 0.0 means upwards.
+
+    /// Returns the horizontal distance between the origin and the point to
+    /// which you would get if you moved radius pixels in the direction
+    /// specified by angle.
+    /// @param angle Angle in degrees where 0.0 means upwards.
     double offset_x(double angle, double radius);
-    //! Returns the vertical distance between the origin and the point to
-    //! which you would get if you moved radius pixels in the direction
-    //! specified by angle.
-    //! \param angle Angle in degrees where 0.0 means upwards.
+
+    /// Returns the vertical distance between the origin and the point to
+    /// which you would get if you moved radius pixels in the direction
+    /// specified by angle.
+    /// @param angle Angle in degrees where 0.0 means upwards.
     double offset_y(double angle, double radius);
-    //! Returns the angle from point 1 to point 2 in degrees, where 0.0 means
-    //! upwards. Returns def if both points are equal.
-    double angle(double from_x, double from_y, double to_x, double to_y, double def = 0);
-    //! Returns the smallest angle that can be added to angle1 to get to
-    //! angle2 (can be negative if counter-clockwise movement is shorter).
+
+    /// Returns the angle from the first point to the second point in degrees, where 0.0 points up.
+    /// Returns "fallback" if both points are equal.
+    double angle(double from_x, double from_y, double to_x, double to_y, double fallback = 0);
+
+    /// Returns the smallest angle that can be added to angle1 to get to angle2.
+    /// The result can be negative if counter-clockwise movement is shorter.
     double angle_diff(double angle1, double angle2);
-    //! Normalizes an angle to fit into the range [0; 360[.
+
+    /// Normalizes an angle to fit into the range [0; 360[.
     double normalize_angle(double angle);
-    
-    //! Returns value * value.
-    template<typename T>
-    T square(T value)
-    {
-        return value * value;
-    }
 
-    //! Returns (value-min) % (max-min) + min, where % always has a positive
-    //! result for max > min. The results are undefined for max <= min.
-    //! Note: This means that max is exclusive.
+    /// Returns (value-min) % (max-min) + min, where % always has a positive
+    /// result for max > min. The results are undefined for max <= min.
+    /// Note: This means that max is exclusive.
     int wrap(int value, int min, int max);
-    //! Returns (value-min) % (max-min) + min, where % always has a positive
-    //! result for max > min. The results are undefined for max <= min.
-    //! Note: This means that max is exclusive.
-    float wrap(float value, float min, float max);
-    //! Returns (value-min) % (max-min) + min, where % always has a positive
-    //! result for max > min. The results are undefined for max <= min.
-    //! Note: This means that max is exclusive.
+    /// Returns (value-min) % (max-min) + min, where % always has a positive
+    /// result for max > min. The results are undefined for max <= min.
+    /// Note: This means that max is exclusive.
     double wrap(double value, double min, double max);
-    
-    //! Returns the square of the distance between two points.
-    inline double distance_sqr(double x1, double y1, double x2, double y2)
-    {
-        return square(x1 - x2) + square(y1 - y2);
-    }
-    
-    //! Returns the distance between two points.
+
+    /// Returns the distance between two points.
     double distance(double x1, double y1, double x2, double y2);
-    
-    //! Placeholder for std::lerp, will be removed when Gosu requires C++20.
-    template<typename T>
-    T lerp(T a, T b, double t = 0.5)
-    {
-        return a * (1.0 - t) + b * t;
-    }
 }

data/include/Gosu/Transform.hpp

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <array>
+
+namespace Gosu
+{
+    /// Describes an affine transformation that can be temporarily applied to everything on the
+    /// screen using the Gosu::Graphics::transform() method.
+    struct Transform
+    {
+        /// The 4x4 transformation matrix in row-major order: matrix[row * 4 + column].
+        std::array<double, 16> matrix;
+
+        /// Applies this transform to the given point.
+        void apply(double& x, double& y) const;
+
+        [[nodiscard]] static Transform translate(double x, double y);
+        [[nodiscard]] static Transform rotate(double angle);
+        [[nodiscard]] static Transform scale(double factor);
+        [[nodiscard]] static Transform scale(double scale_x, double scale_y);
+        /// This helper is supposed to be used on the return value of rotate() or scale() in order
+        /// to set the center around which to rotate/scale. It will not have any effect on the
+        /// return value of translate().
+        [[nodiscard]] Transform around(double around_x, double around_y) const;
+
+        /// Performs a matrix multiplication that has the effect of "concatenating" transforms.
+        /// The left-hand side will be applied to a point before the right-hand side.
+        Transform operator*(const Transform& rhs) const;
+
+        bool operator==(const Transform&) const = default;
+    };
+}

data/include/Gosu/Utility.hpp

@@ -1,14 +1,32 @@
 #pragma once
 
+#include <Gosu/Platform.hpp>
 #include <string>
+#include <string_view>
 #include <vector>
 
 namespace Gosu
 {
-    std::u32string utf8_to_composed_utc4(const std::string& utf8);
+    /// Converts a UTF-8 string to composed UTC-4, i.e. to a list of Unicode codepoints.
+    ///
+    /// This is not quite as good as splitting a string into graphemes. For example, the "family of
+    /// four" Emoji is actually composed of seven(!) codepoints. But because Gosu's text rendering
+    /// facilities have no support for multi-codepoint graphemes, Gosu::Font and related classes are
+    /// based on codepoints.
+    ///
+    /// This method will silently skip over invalid UTF-8 sequences.
+    std::u32string utf8_to_composed_utc4(std::string_view utf8);
+
+#ifdef GOSU_IS_WIN
+    /// Converts UTF-8 to UTF-16, as it is used in "UNICODE" Windows APIs.
+    std::wstring utf8_to_utf16(const std::string& utf8);
+    /// Converts UTF-16 to UTF-8.
+    std::string utf16_to_utf8(const std::wstring& utf16);
+#endif
 
     /// Returns true if the filename has the given extension.
     /// The comparison is case-insensitive, but you must pass the extension in lower case.
+    /// If the extension does not start with a dot, then it will be implied.
     bool has_extension(std::string_view filename, std::string_view extension);
 
     /// Returns the user's preferred user_languages/locales, e.g. {"en_US", "de_DE", "ja"}.
@@ -17,6 +35,7 @@ namespace Gosu
     /// typically the first language in the returned array that your game supports.
     std::vector<std::string> user_languages();
 
+    /// Base class to quickly make a type non-copyable/non-movable. Same as boost::noncopyable.
     class Noncopyable
     {
     protected:
@@ -30,4 +49,35 @@ namespace Gosu
         Noncopyable(Noncopyable&& other) = delete;
         Noncopyable& operator=(Noncopyable&& other) = delete;
     };
+
+    /// An int-based rectangle class, mostly for internal use.
+    struct Rect
+    {
+        int x = 0, y = 0;
+        int width = 0, height = 0;
+
+        int right() const { return x + width; }
+        int bottom() const { return y + height; }
+
+        bool empty() const { return width <= 0 || height <= 0; }
+
+        /// Returns a Rect that starts at the origin and uses T::width() and T::height() as its
+        /// extents.
+        template <typename T> static Rect covering(const T& object)
+        {
+            return Rect { .x = 0, .y = 0, .width = object.width(), .height = object.height() };
+        }
+
+        bool overlaps(const Rect& other) const;
+        bool contains(const Rect& other) const;
+
+        /// Makes sure that this rectangle does not exceed the bounding box.
+        /// @param adjust_x If the rectangle origin will be moved to the right by this operation,
+        ///                 then the pointed-to int (if any) will be adjusted by the same amount.
+        /// @param adjust_y If the rectangle origin will be moved down by this operation,
+        ///                 then the pointed-to int (if any) will be adjusted by the same amount.
+        void clip_to(const Rect& bounding_box, int* adjust_x = nullptr, int* adjust_y = nullptr);
+
+        bool operator==(const Rect& other) const = default;
+    };
 }

data/include/Gosu/Version.hpp

@@ -2,9 +2,9 @@
 
 #include <string>
 
-#define GOSU_MAJOR_VERSION 1
-#define GOSU_MINOR_VERSION 4
-#define GOSU_POINT_VERSION 6
+#define GOSU_MAJOR_VERSION 2
+#define GOSU_MINOR_VERSION 0
+#define GOSU_POINT_VERSION 0
 
 namespace Gosu
 {

data/include/Gosu/Window.hpp

@@ -7,6 +7,8 @@
 #include <memory>
 #include <string>
 
+struct SDL_Window;
+
 namespace Gosu
 {
     enum WindowFlags
@@ -124,45 +126,49 @@ namespace Gosu
         /// method will be called several times.
         virtual void drop(const std::string& filename) {}
 
-// Ignore when SWIG is wrapping this class for Ruby/Gosu.
-#ifndef SWIG
         // Callbacks for touch events. So far these are only used on iOS.
         virtual void touch_began(Touch touch) {}
         virtual void touch_moved(Touch touch) {}
         virtual void touch_ended(Touch touch) {}
         virtual void touch_cancelled(Touch touch) {}
 
-        const Graphics& graphics() const;
-        Graphics& graphics();
+        const Viewport& viewport() const;
+        Viewport& viewport();
 
         const Input& input() const;
         Input& input();
-#endif
 
 #ifdef GOSU_IS_IPHONE
         void* uikit_window() const;
 #endif
+
+#ifndef GOSU_IS_IPHONE
+        SDL_Window* sdl_window() const;
+#endif
     };
 
+    /// Returns the current framerate.
+    int fps();
+
     /// 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.
-    int screen_width(Window* window = nullptr);
+    int screen_width(const 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.
-    int screen_height(Window* window = nullptr);
+    int screen_height(const 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.
-    int available_width(Window* window = nullptr);
+    int available_width(const 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.
-    int available_height(Window* window = nullptr);
+    int available_height(const Window* window = nullptr);
 }

data/lib/gosu/channel.rb

@@ -0,0 +1,49 @@
+module Gosu
+  class Channel
+    def initialize(pointer)
+      @managed_pointer = FFI::AutoPointer.new(pointer, GosuFFI.method(:Gosu_Channel_destroy))
+    end
+
+    def __pointer
+      @managed_pointer
+    end
+
+    def playing?
+      GosuFFI.check_last_error(GosuFFI.Gosu_Channel_playing(__pointer))
+    end
+
+    def pause
+      GosuFFI.Gosu_Channel_pause(__pointer)
+      GosuFFI.check_last_error
+    end
+
+    def paused?
+      GosuFFI.check_last_error(GosuFFI.Gosu_Channel_paused(__pointer))
+    end
+
+    def resume
+      GosuFFI.Gosu_Channel_resume(__pointer)
+      GosuFFI.check_last_error
+    end
+
+    def stop
+      GosuFFI.Gosu_Channel_stop(__pointer)
+      GosuFFI.check_last_error
+    end
+
+    def volume=(double)
+      GosuFFI.Gosu_Channel_set_volume(__pointer, double)
+      GosuFFI.check_last_error
+    end
+
+    def speed=(double)
+      GosuFFI.Gosu_Channel_set_speed(__pointer, double)
+      GosuFFI.check_last_error
+    end
+
+    def pan=(double)
+      GosuFFI.Gosu_Channel_set_pan(__pointer, double)
+      GosuFFI.check_last_error
+    end
+  end
+end

data/lib/gosu/color.rb

@@ -0,0 +1,150 @@
+module Gosu
+  class Color
+    include Comparable
+
+    # Gosu::Color is stored as an unsigned int in C
+    # this is used for {Gosu::Image#to_blob} and {Gosu::Image.from_blob}
+    SIZEOF = 4
+
+    def self.argb(*args)
+      Gosu::Color.new(*args)
+    end
+
+    def self.rgba(r, g, b, a)
+      Gosu::Color.new(a, r, g, b)
+    end
+
+    def self.rgb(r, g, b)
+      Gosu::Color.new(255, r, g, b)
+    end
+
+    def self.from_ahsv(alpha, h, s, v)
+      __color = GosuFFI.Gosu_Color_create_from_ahsv(alpha.clamp(0.0, 255.0), h % 360.0, s.clamp(0.0, 1.0), v.clamp(0.0, 1.0))
+      GosuFFI.check_last_error
+      Gosu::Color.new(__color)
+    end
+
+    def self.from_hsv(h, s, v)
+      __color = GosuFFI.Gosu_Color_create_from_hsv(h % 360.0, s.clamp(0.0, 1.0), v.clamp(0.0, 1.0))
+      GosuFFI.check_last_error
+      Gosu::Color.new(__color)
+    end
+
+    def initialize(*args)
+      case args.size
+      when 1
+        @__color = GosuFFI.Gosu_Color_create(args.first)
+        GosuFFI.check_last_error
+      when 4
+        @__color = GosuFFI.Gosu_Color_create_argb(args[0].clamp(0, 255), args[1].clamp(0, 255), args[2].clamp(0, 255), args[3].clamp(0, 255))
+        GosuFFI.check_last_error
+      else
+        raise ArgumentError
+      end
+    end
+
+    def alpha
+      GosuFFI.check_last_error(GosuFFI.Gosu_Color_alpha(@__color))
+    end
+
+    def alpha=(value)
+      @__color = GosuFFI.check_last_error(GosuFFI.Gosu_Color_set_alpha(@__color, value.clamp(0, 255)))
+    end
+
+    def red
+      GosuFFI.check_last_error(GosuFFI.Gosu_Color_red(@__color))
+    end
+
+    def red=(value)
+      @__color = GosuFFI.check_last_error(GosuFFI.Gosu_Color_set_red(@__color, value.clamp(0, 255)))
+    end
+
+    def green
+      GosuFFI.check_last_error(GosuFFI.Gosu_Color_green(@__color))
+    end
+
+    def green=(value)
+      @__color = GosuFFI.check_last_error(GosuFFI.Gosu_Color_set_green(@__color, value.clamp(0, 255)))
+    end
+
+    def blue
+      GosuFFI.check_last_error(GosuFFI.Gosu_Color_blue(@__color))
+    end
+
+    def blue=(value)
+      @__color = GosuFFI.check_last_error(GosuFFI.Gosu_Color_set_blue(@__color, value.clamp(0, 255)))
+    end
+
+    def value
+      GosuFFI.check_last_error(GosuFFI.Gosu_Color_value(@__color))
+    end
+
+    def value=(value)
+      @__color = GosuFFI.check_last_error(GosuFFI.Gosu_Color_set_value(@__color, value.clamp(0.0, 1.0)))
+    end
+
+    def saturation
+      GosuFFI.check_last_error(GosuFFI.Gosu_Color_saturation(@__color))
+    end
+
+    def saturation=(value)
+      @__color = GosuFFI.check_last_error(GosuFFI.Gosu_Color_set_saturation(@__color, value.clamp(0.0, 1.0)))
+    end
+
+    def hue
+      GosuFFI.check_last_error(GosuFFI.Gosu_Color_hue(@__color))
+    end
+
+    def hue=(value)
+      @__color = GosuFFI.check_last_error(GosuFFI.Gosu_Color_set_hue(@__color, value % 360.0))
+    end
+
+    def bgr
+      GosuFFI.check_last_error(GosuFFI.Gosu_Color_bgr(@__color))
+    end
+
+    def abgr
+      GosuFFI.check_last_error(GosuFFI.Gosu_Color_abgr(@__color))
+    end
+
+    def argb
+      GosuFFI.check_last_error(GosuFFI.Gosu_Color_argb(@__color))
+    end
+
+    def gl
+      @__color
+    end
+
+    def to_i
+      @__color
+    end
+
+    def <=>(other)
+      if other.is_a? Color
+        to_i <=> other.to_i
+      elsif other.is_a? Numeric
+        to_i <=> other
+      else
+        nil
+      end
+    end
+
+    alias hash gl
+
+    def eql?(other)
+      self == other
+    end
+
+    NONE = Gosu::Color.argb(0x00_000000)
+    BLACK = Gosu::Color.argb(0xff_000000)
+    GRAY = Gosu::Color.argb(0xff_808080)
+    WHITE = Gosu::Color.argb(0xff_ffffff)
+    AQUA = Gosu::Color.argb(0xff_00ffff)
+    RED = Gosu::Color.argb(0xff_ff0000)
+    GREEN = Gosu::Color.argb(0xff_00ff00)
+    BLUE = Gosu::Color.argb(0xff_0000ff)
+    YELLOW = Gosu::Color.argb(0xff_ffff00)
+    FUCHSIA = Gosu::Color.argb(0xff_ff00ff)
+    CYAN = Gosu::Color.argb(0xff_00ffff)
+  end
+end

data/lib/gosu/compat.rb

@@ -59,16 +59,19 @@ Gosu.deprecate Gosu::Color, :abgr, :none
 class Gosu::Image
   alias_method :initialize_without_window, :initialize
 
-  def initialize(*args)
+  def initialize(*args, **kwargs)
     if args[0].is_a? Gosu::Window
-      Gosu.deprecation_message("Passing a Window to Image#initialize has been deprecated in Gosu 0.9 and this method now uses an options hash, see https://www.libgosu.org/rdoc/Gosu/Image.html ")
+      # Old method signature: initialize(window, file_or_image, tileable)
+      Gosu.deprecation_message("Passing a Window to Image#initialize has been deprecated in Gosu 0.9, and this method now uses named arguments. https://www.libgosu.org/rdoc/Gosu/Image.html")
       if args.size == 7
         initialize_without_window args[1], tileable: args[2], rect: args[3..-1]
-      else
+      elsif args.size == 3
         initialize_without_window args[1], tileable: args[2]
+      else
+        raise ArgumentError, "wrong number of arguments (given #{args.size})"
       end
     else
-      initialize_without_window(*args)
+      initialize_without_window(*args, **kwargs)
     end
   end
 
@@ -76,17 +79,30 @@ class Gosu::Image
     alias_method :from_text_without_window, :from_text
   end
 
-  def self.from_text(*args)
+  def self.from_text(*args, **kwargs)
     if args.size == 4
-      Gosu.deprecation_message("Passing a Window to Image.from_text has been deprecated in Gosu 0.9 and this method now uses an options hash, see https://www.libgosu.org/rdoc/Gosu/Image.html ")
+      Gosu.deprecation_message("Passing a Window to Image.from_text has been deprecated in Gosu 0.9 and this method now uses named arguments. https://www.libgosu.org/rdoc/Gosu/Image.html")
       from_text_without_window(args[1], args[3], font: args[2])
     elsif args.size == 7
-      Gosu.deprecation_message("Passing a Window to Image.from_text has been deprecated in Gosu 0.9 and this method now uses an options hash, see https://www.libgosu.org/rdoc/Gosu/Image.html ")
+      Gosu.deprecation_message("Passing a Window to Image.from_text has been deprecated in Gosu 0.9 and this method now uses named arguments. https://www.libgosu.org/rdoc/Gosu/Image.html")
       from_text_without_window(args[1], args[3],
                                font: args[2], spacing: args[4], width: args[5],
                                align: args[6])
     else
-      from_text_without_window(*args)
+      from_text_without_window(*args, **kwargs)
+    end
+  end
+
+  class << self
+    alias_method :load_tiles_without_window, :load_tiles
+  end
+
+  def self.load_tiles(*args, **kwargs)
+    if args.first.is_a? Gosu::Window
+      # Old method signature: load_tiles(window, file_or_image, w, h, tileable)
+      load_tiles_without_window(args[1], args[2], args[3], tileable: args[4])
+    else
+      load_tiles_without_window(*args, **kwargs)
     end
   end
 end
@@ -154,6 +170,11 @@ class Gosu::Window
     end
   end
 
+  def set_mouse_position(x, y)
+    self.mouse_x = x
+    self.mouse_y = y
+  end
+
   Gosu.deprecate Gosu::Window, :set_mouse_position, "Window#mouse_x= and Window#mouse_y="
 end