gosu 0.14.4 → 0.15.2

data/src/RubyGosu.h

@@ -1,6 +1,6 @@
 /* ----------------------------------------------------------------------------
  * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 3.0.12
+ * Version 4.0.2
  *
  * This file is not intended to be easily readable and contains a number of
  * coding conventions designed to improve portability and efficiency. Do not make
@@ -28,7 +28,7 @@ public:
 class SwigDirector_Window : public Gosu::Window, public Swig::Director {
 
 public:
-    SwigDirector_Window(VALUE self, unsigned int width, unsigned int height, bool fullscreen = false, double update_interval = 16.666666);
+    SwigDirector_Window(VALUE self, unsigned int width, unsigned int height, bool fullscreen = false, double update_interval = 16.666666, bool resizable = false);
     virtual ~SwigDirector_Window();
     virtual void show();
     virtual bool tick();

data/src/SampleWrapper.cpp

@@ -0,0 +1,30 @@
+#include <Gosu/Audio.hpp>
+#include <Gosu/Sample.h>
+
+extern "C" {
+
+Gosu_Sample *Gosu_Sample_create(const char *filename)
+{
+  return reinterpret_cast<Gosu_Sample *>( new Gosu::Sample(filename) );
+}
+
+void Gosu_Sample_destroy(Gosu_Sample *sample)
+{
+  delete( reinterpret_cast<Gosu::Sample *>( sample ) );
+}
+
+Gosu_Channel *Gosu_Sample_play(Gosu_Sample *sample, double volume, double speed, bool looping)
+{
+  Gosu::Channel channel = reinterpret_cast<Gosu::Sample *>( sample )->play(volume, speed, looping);
+
+  return reinterpret_cast<Gosu_Channel *>( new Gosu::Channel(channel) );
+}
+
+Gosu_Channel *Gosu_Sample_play_pan(Gosu_Sample *sample, double pan, double volume, double speed, bool looping)
+{
+  Gosu::Channel channel = reinterpret_cast<Gosu::Sample *>( sample )->play_pan(pan, volume, speed, looping);
+
+  return reinterpret_cast<Gosu_Channel *>( new Gosu::Channel(channel) );
+}
+
+}

data/src/SongWrapper.cpp

@@ -0,0 +1,52 @@
+#include <Gosu/Audio.hpp>
+#include <Gosu/Song.h>
+
+extern "C" {
+  Gosu_Song* Gosu_Song_create(const char* filename)
+  {
+    return reinterpret_cast<Gosu_Song*>( new Gosu::Song(filename) );
+  }
+
+  void Gosu_Song_destroy(Gosu_Song* song)
+  {
+    delete( reinterpret_cast<Gosu::Song*>( song ));
+  }
+
+  void Gosu_Song_play(Gosu_Song* song, bool looping)
+  {
+    reinterpret_cast<Gosu::Song*>( song )->play(looping);
+  }
+
+  bool Gosu_Song_playing(Gosu_Song* song)
+  {
+    return reinterpret_cast<Gosu::Song*>( song )->playing();
+  }
+
+  void Gosu_Song_pause(Gosu_Song* song)
+  {
+    reinterpret_cast<Gosu::Song*>( song )->pause();
+  }
+
+  bool Gosu_Song_paused(Gosu_Song* song)
+  {
+    return reinterpret_cast<Gosu::Song*>( song )->paused();
+  }
+
+  void Gosu_Song_stop(Gosu_Song* song)
+  {
+    reinterpret_cast<Gosu::Song*>( song )->stop();
+  }
+
+  double Gosu_Song_volume(Gosu_Song* song){
+    return reinterpret_cast<Gosu::Song*>( song )->volume();
+  }
+
+  void Gosu_Song_set_volume(Gosu_Song* song, double volume){
+    return reinterpret_cast<Gosu::Song*>( song )->set_volume(volume);
+  }
+
+  Gosu_Song* Gosu_Song_current_song()
+  {
+    return reinterpret_cast<Gosu_Song*>(Gosu::Song::current_song());
+  }
+}

data/src/TexChunk.cpp

@@ -82,39 +82,49 @@ Gosu::Bitmap Gosu::TexChunk::to_bitmap() const
     return texture->to_bitmap(x, y, w, h);
 }
 
-void Gosu::TexChunk::insert(const Bitmap& original, int x, int y)
+void Gosu::TexChunk::insert(const Bitmap& original_bitmap, int x, int y)
 {
-    Bitmap alternate;
-    const Bitmap* bitmap = &original;
+    Bitmap clipped_bitmap;
+    const Bitmap* bitmap = &original_bitmap;
     
-    if (x < 0 || y < 0 || x + original.width() > w || y + original.height() > h) {
-        int offset_x = 0, offset_y = 0;
-        int trimmed_width = original.width(), trimmed_height = original.height();
+    // If inserting the bitmap at the given position exceeds the boundaries of the space allocated
+    // for this image on the texture, we need to clip the bitmap and insert the clipped version
+    // instead.
+    if (x < 0 || y < 0 || x + original_bitmap.width() > w || y + original_bitmap.height() > h) {
+        // How many pixels to remove at the top and left sides.
+        int clip_left = 0, clip_top = 0;
+        // How large the clipped version needs to be.
+        int clipped_width = original_bitmap.width(), clipped_height = original_bitmap.height();
+
+        // Clip away pixels on the left side, if necessary.
         if (x < 0) {
-            offset_x = x;
-            trimmed_width += x;
+            clip_left = -x;
+            clipped_width -= -x;
             x = 0;
         }
+        // Clip away pixels at the top, if necessary.
         if (y < 0) {
-            offset_y = y;
-            trimmed_height += y;
+            clip_top = -y;
+            clipped_height -= -y;
             y = 0;
         }
-        if (x + trimmed_width > w) {
-            trimmed_width -= (w - x - trimmed_width);
+        // Clip away pixels on the right side, if necessary.
+        if (x + clipped_width > w) {
+            clipped_width = (w - x);
         }
-        if (y + trimmed_height > h) {
-            trimmed_height -= (h - y - trimmed_height);
+        // Clip away pixels on the bottom, if necessary.
+        if (y + clipped_height > h) {
+            clipped_height = (h - y);
         }
 
-        if (trimmed_width <= 0 || trimmed_height <= 0) return;
+        if (clipped_width <= 0 || clipped_height <= 0) return;
         
-        alternate.resize(trimmed_width, trimmed_height);
-        alternate.insert(original, offset_x, offset_y);
-        bitmap = &alternate;
+        clipped_bitmap.resize(clipped_width, clipped_height);
+        clipped_bitmap.insert(original_bitmap, -clip_left, -clip_top);
+        bitmap = &clipped_bitmap;
     }
     
     glBindTexture(GL_TEXTURE_2D, tex_name());
     glTexSubImage2D(GL_TEXTURE_2D, 0, this->x + x, this->y + y, bitmap->width(), bitmap->height(),
-        Color::GL_FORMAT, GL_UNSIGNED_BYTE, bitmap->data());
+                    Color::GL_FORMAT, GL_UNSIGNED_BYTE, bitmap->data());
 }

data/src/Text.cpp

@@ -7,6 +7,7 @@
 #include <cmath>
 #include <algorithm>
 #include <vector>
+#include <stdexcept>
 using namespace std;
 
 double Gosu::text_width(const u32string& text,
@@ -33,6 +34,7 @@ Gosu::Bitmap Gosu::layout_text(const string& text, const string& font_name,
                                double font_height, double line_spacing,
                                int width, Alignment align, unsigned font_flags)
 {
+    // Escape all markup and delegate to layout_markup.
     return layout_markup(escape_markup(text), font_name,
                          font_height, line_spacing,
                          width, align, font_flags);

data/src/TextBuilder.cpp

@@ -58,7 +58,7 @@ void Gosu::TextBuilder::flush_current_line(EndOfLineReason reason)
     }
     
     double whitespace_factor = 1.0;
-    if (align == AL_JUSTIFY && reason == LINE_TOO_LONG) {
+    if (align == AL_JUSTIFY && whitespace_width != 0 && reason == LINE_TOO_LONG) {
         whitespace_factor = (result.width() - words_width) / whitespace_width;
     }
     
@@ -132,7 +132,7 @@ void Gosu::TextBuilder::feed_word(vector&& word)
     current_line.emplace_back(new_word);
     current_line_width += new_word.width;
 
-    if (current_line_width > result.width() || new_word.is_end_of_line) {
-        flush_current_line(new_word.is_end_of_line ? END_OF_PARAGRAPH : LINE_TOO_LONG);
+    if (new_word.is_end_of_line) {
+        flush_current_line(END_OF_PARAGRAPH);
     }
 }

data/src/TextInputWrapper.cpp

@@ -0,0 +1,101 @@
+#include <Gosu/Gosu.hpp>
+
+namespace Gosu
+{
+class TextInputForWrapper : public Gosu::TextInput
+{
+public:
+    TextInputForWrapper();
+    std::string filter(std::string text) const override;
+    std::function<void (const char *text)> filter_callback;
+    std::string filter_result = "";
+};
+} // namespace Gosu
+
+Gosu::TextInputForWrapper::TextInputForWrapper() : Gosu::TextInput()
+{
+}
+
+std::string Gosu::TextInputForWrapper::filter(std::string text) const
+{
+    if (filter_callback != nullptr) {
+        filter_callback(text.c_str());
+        return filter_result;
+    }
+    else {
+        return text;
+    }
+}
+
+extern "C" {
+#include <Gosu/TextInput.h>
+
+Gosu_TextInput *Gosu_TextInput_create()
+{
+    return reinterpret_cast<Gosu_TextInput *>(new Gosu::TextInputForWrapper());
+}
+
+const char *Gosu_TextInput_text(Gosu_TextInput *text_input)
+{
+    thread_local std::string string;
+    string = reinterpret_cast<Gosu::TextInputForWrapper *>(text_input)->text();
+
+    return string.c_str();
+}
+
+void Gosu_TextInput_set_text(Gosu_TextInput *text_input, const char *text)
+{
+    reinterpret_cast<Gosu::TextInputForWrapper *>(text_input)->set_text(text);
+}
+
+unsigned Gosu_TextInput_caret_pos(Gosu_TextInput *text_input)
+{
+    return reinterpret_cast<Gosu::TextInputForWrapper *>(text_input)->caret_pos();
+}
+
+void Gosu_TextInput_set_caret_pos(Gosu_TextInput *text_input, unsigned pos)
+{
+    return reinterpret_cast<Gosu::TextInputForWrapper *>(text_input)->set_caret_pos(pos);
+}
+
+unsigned Gosu_TextInput_selection_start(Gosu_TextInput *text_input)
+{
+    return reinterpret_cast<Gosu::TextInputForWrapper *>(text_input)->selection_start();
+}
+
+void Gosu_TextInput_set_selection_start(Gosu_TextInput *text_input, unsigned pos)
+{
+    return reinterpret_cast<Gosu::TextInputForWrapper *>(text_input)->set_selection_start(pos);
+}
+
+void Gosu_TextInput_set_filter(Gosu_TextInput *text_input, void function(void *data, const char *text), void *data)
+{
+    reinterpret_cast<Gosu::TextInputForWrapper *>(text_input)->filter_callback = [=](const char *text) { function(data, text); };
+}
+
+void Gosu_TextInput_set_filter_result(Gosu_TextInput *text_input, const char *result)
+{
+    reinterpret_cast<Gosu::TextInputForWrapper *>(text_input)->filter_result = result;
+}
+
+void Gosu_TextInput_insert_text(Gosu_TextInput *text_input, const char *text)
+{
+    reinterpret_cast<Gosu::TextInputForWrapper *>(text_input)->insert_text(text);
+}
+
+void Gosu_TextInput_delete_backward(Gosu_TextInput *text_input)
+{
+    reinterpret_cast<Gosu::TextInputForWrapper *>(text_input)->delete_backward();
+}
+
+void Gosu_TextInput_delete_forward(Gosu_TextInput *text_input)
+{
+    reinterpret_cast<Gosu::TextInputForWrapper *>(text_input)->delete_forward();
+}
+
+void Gosu_TextInput_destroy(Gosu_TextInput *text_input)
+{
+    delete (reinterpret_cast<Gosu::TextInputForWrapper *>(text_input));
+}
+
+}

data/src/TrueTypeFont.cpp

@@ -1,6 +1,7 @@
 #include "TrueTypeFont.hpp"
 #include <Gosu/IO.hpp>
 #include <Gosu/Text.hpp>
+#include <stdexcept>
 
 // Disable comma warnings in stb headers.
 #ifdef __GNUC__

data/src/Window.cpp

@@ -85,22 +85,29 @@ struct Gosu::Window::Impl
 {
     bool fullscreen;
     double update_interval;
-    
+    bool resizable;
+    bool resizing = false;
+
     // A single `bool open` is not good enough to support the tick() method: When close() is called
     // from outside the window's call graph, the next call to tick() must return false (transition
     // from CLOSING to CLOSED), but the call after that must return show the window again
     // (transition from CLOSED to OPEN).
     enum { CLOSED, OPEN, CLOSING } state = CLOSED;
-    
+
     unique_ptr<Graphics> graphics;
     unique_ptr<Input> input;
 };
 
-Gosu::Window::Window(unsigned width, unsigned height, bool fullscreen, double update_interval)
+Gosu::Window::Window(unsigned width, unsigned height, bool fullscreen, double update_interval,
+                     bool resizable)
 : pimpl(new Impl)
 {
+#if SDL_VERSION_ATLEAST(2, 0, 5)
+    SDL_SetWindowResizable(shared_window(), (SDL_bool)resizable);
+#endif
+
     // Even in fullscreen mode, temporarily show the window in windowed mode to centre it.
-    // This ensures that the window will be centred correctly when exiting fullscreen mode.
+    // This ensures that the window will be centered correctly when exiting fullscreen mode.
     // Fixes https://github.com/gosu/gosu/issues/369
     // (This will implicitly create graphics() and input(), and make the OpenGL context current.)
     resize(width, height, false);
@@ -108,11 +115,12 @@ Gosu::Window::Window(unsigned width, unsigned height, bool fullscreen, double up
 
     // Really enable fullscreen if desired.
     resize(width, height, fullscreen);
-    
+
     SDL_GL_SetSwapInterval(1);
 
     pimpl->update_interval = update_interval;
-    
+    pimpl->resizable = resizable;
+
     input().on_button_down = [this](Button button) { button_down(button); };
     input().on_button_up   = [this](Button button) { button_up(button); };
 }
@@ -137,6 +145,11 @@ bool Gosu::Window::fullscreen() const
     return pimpl->fullscreen;
 }
 
+bool Gosu::Window::resizable() const
+{
+    return pimpl->resizable;
+}
+
 void Gosu::Window::resize(unsigned width, unsigned height, bool fullscreen)
 {
     pimpl->fullscreen = fullscreen;
@@ -150,31 +163,47 @@ void Gosu::Window::resize(unsigned width, unsigned height, bool fullscreen)
     if (fullscreen) {
         actual_width  = Gosu::screen_width(this);
         actual_height = Gosu::screen_height(this);
-
-        double scale_x = 1.0 * actual_width / width;
-        double scale_y = 1.0 * actual_height / height;
-        scale_factor = min(scale_x, scale_y);
-
-        if (scale_x < scale_y) {
-            black_bar_height = (actual_height / scale_x - height) / 2;
+        
+        if (resizable()) {
+            // Resizable fullscreen windows stubbornly follow the desktop resolution.
+            width  = actual_width;
+            height = actual_height;
         }
-        else if (scale_y < scale_x) {
-            black_bar_width = (actual_width / scale_y - width) / 2;
+        else {
+            // Scale the window to fill the desktop resolution.
+            double scale_x = 1.0 * actual_width / width;
+            double scale_y = 1.0 * actual_height / height;
+            scale_factor = min(scale_x, scale_y);
+            // Add black bars to preserve the aspect ratio, if necessary.
+            if (scale_x < scale_y) {
+                black_bar_height = (actual_height / scale_x - height) / 2;
+            }
+            else if (scale_y < scale_x) {
+                black_bar_width = (actual_width / scale_y - width) / 2;
+            }
         }
     }
     else {
-        double max_width  = Gosu::available_width(this);
-        double max_height = Gosu::available_height(this);
+        unsigned max_width  = Gosu::available_width(this);
+        unsigned max_height = Gosu::available_height(this);
         
-        if (width > max_width || height > max_height) {
-            scale_factor = min(max_width / width, max_height / height);
+        if (resizable()) {
+            // If the window is resizable, limit its size, without preserving the aspect ratio.
+            width  = actual_width  = min(width,  max_width);
+            height = actual_height = min(height, max_height);
+        }
+        else if (width > max_width || height > max_height) {
+            // If the window cannot fit on the screen, shrink its contents.
+            scale_factor = min(1.0 * max_width / width, 1.0 * max_height / height);
             actual_width  = width  * scale_factor;
             actual_height = height * scale_factor;
         }
     }
     
     SDL_SetWindowFullscreen(shared_window(), fullscreen ? SDL_WINDOW_FULLSCREEN_DESKTOP : 0);
-    SDL_SetWindowSize(shared_window(), actual_width, actual_height);
+    if (!pimpl->resizing) {
+        SDL_SetWindowSize(shared_window(), actual_width, actual_height);
+    }
     
 #if SDL_VERSION_ATLEAST(2, 0, 1)
     SDL_GL_GetDrawableSize(shared_window(), &actual_width, &actual_height);
@@ -256,19 +285,24 @@ bool Gosu::Window::tick()
     
     SDL_Event e;
     while (SDL_PollEvent(&e)) {
+
         switch (e.type) {
-        #ifdef GOSU_IS_MAC
-            // Workaround for https://github.com/gosu/gosu/issues/458
-            // "Resize" the window to its current dimensions after it is shown.
-            // Otherwise it will be black on macOS 10.14 (Mojave) until the user moves it around.
-            // TODO: Since this affects `brew install supertux` as well, maybe file an SDL bug?
             case SDL_WINDOWEVENT: {
-                if (e.window.event == SDL_WINDOWEVENT_SHOWN) {
-                    resize(this->width(), this->height(), fullscreen());
+                switch (e.window.event) {
+                    case SDL_WINDOWEVENT_SIZE_CHANGED: {
+                        if (pimpl->resizable && (width() != e.window.data1 || height() != e.window.data2)) {
+                            pimpl->resizing = true;
+                            resize(e.window.data1, e.window.data2, fullscreen());
+                            pimpl->resizing = false;
+                        }
+                        break;
+                    }
+                    default: {
+                        break;
+                    }
                 }
                 break;
             }
-        #endif
             case SDL_QUIT: {
                 close();
                 break;