gosu 1.4.6 → 2.0.0.pre6

data/lib/gosu/window.rb

@@ -0,0 +1,228 @@
+module Gosu
+  class Window
+    %w(update draw needs_redraw? needs_cursor? capture_cursor? hit_test gain_focus lose_focus
+       button_down button_up gamepad_connected gamepad_disconnected drop close).each do |callback|
+      define_method "protected_#{callback}" do |*args|
+        begin
+          # If there has been an exception, don't do anything as to not make matters worse.
+          # Conveniently turn the return value into a boolean result (for needs_cursor? etc).
+          defined?(@__exception) ? false : send(callback, *args)
+        rescue Exception => e
+          # Exit the message loop naturally, then re-throw during the next tick.
+          @__exception = e
+          close!
+          false
+        ensure
+          $gosu_gl_blocks = nil if callback == "draw"
+        end
+      end
+    end
+
+    def initialize(width, height, _fullscreen = nil, _update_interval = nil, _resizable = nil, _borderless = nil,
+                   fullscreen: false, update_interval: 16.66666667, resizable: false, borderless: false)
+      fullscreen = _fullscreen if _fullscreen
+      update_interval = _update_interval if _update_interval
+      resizable = _resizable if _resizable
+      borderless = _borderless if _borderless
+
+      window_flags = GosuFFI.window_flags(fullscreen: fullscreen, resizable: resizable, borderless: borderless)
+
+      __window = GosuFFI.Gosu_Window_create(width, height, window_flags, update_interval)
+      GosuFFI.check_last_error
+      @memory_pointer = FFI::AutoPointer.new(__window, GosuFFI.method(:Gosu_Window_destroy))
+      @text_input = nil
+
+      {
+        update: [],
+        draw: [],
+        button_down: [:id],
+        button_up: [:id],
+        gamepad_connected: [:id],
+        gamepad_disconnected: [:id],
+        drop: [:filename],
+        needs_redraw?: [],
+        needs_cursor?: [],
+        close: [],
+        gain_focus: [],
+        lose_focus: [],
+      }.each do |callback, args|
+        callback_safename = callback.to_s.sub("?", "")
+
+        instance_eval("@__#{callback_safename}_proc = proc { |#{[:data, args].flatten.join(",")}| protected_#{callback}(#{args.join(",")}) }")
+        GosuFFI.send(:"Gosu_Window_set_#{callback_safename}", __pointer, instance_variable_get(:"@__#{callback_safename}_proc"), nil)
+        GosuFFI.check_last_error
+      end
+    end
+
+    # Returns FFI pointer of C side Gosu::Window
+    def __pointer
+      @memory_pointer
+    end
+
+    def update
+    end
+
+    def draw
+    end
+
+    def button_down(id)
+      GosuFFI.Gosu_Window_default_button_down(__pointer, id)
+      GosuFFI.check_last_error
+    end
+
+    def button_up(id)
+    end
+
+    def gamepad_connected(id)
+    end
+
+    def gamepad_disconnected(id)
+    end
+
+    def drop(filename)
+    end
+
+    def needs_redraw?
+      true
+    end
+
+    def needs_cursor?
+      false
+    end
+
+    def capture_cursor?
+      false
+    end
+
+    def close
+      close!
+    end
+
+    def gain_focus
+    end
+
+    def lose_focus
+    end
+
+    def caption
+      GosuFFI.check_last_error(GosuFFI.Gosu_Window_caption(__pointer))
+    end
+
+    def caption=(text)
+      GosuFFI.Gosu_Window_set_caption(__pointer, text)
+      GosuFFI.check_last_error
+    end
+
+    def fullscreen?
+      GosuFFI.check_last_error(GosuFFI.Gosu_Window_is_fullscreen(__pointer))
+    end
+
+    def fullscreen=(boolean)
+      GosuFFI.Gosu_Window_resize(__pointer, width, height, !!boolean)
+      GosuFFI.check_last_error
+    end
+
+    def resizable?
+      GosuFFI.check_last_error(GosuFFI.Gosu_Window_is_resizable(__pointer))
+    end
+
+    def resizable=(boolean)
+      GosuFFI.Gosu_Window_set_resizable(__pointer, !!boolean)
+      GosuFFI.check_last_error
+    end
+
+    def borderless?
+      GosuFFI.check_last_error(GosuFFI.Gosu_Window_is_borderless(__pointer))
+    end
+
+    def borderless=(boolean)
+      GosuFFI.Gosu_Window_set_borderless(__pointer, !!boolean)
+      GosuFFI.check_last_error
+    end
+
+    def text_input
+      @text_input || nil
+    end
+
+    def text_input=(text_input)
+      if not text_input.nil? and not text_input.is_a? Gosu::TextInput
+        raise ArgumentError, "text_input must be nil or a Gosu::TextInput"
+      end
+
+      @text_input = text_input
+
+      GosuFFI.Gosu_Window_set_text_input(__pointer, text_input&.__pointer)
+      GosuFFI.check_last_error
+    end
+
+    def update_interval
+      GosuFFI.check_last_error(GosuFFI.Gosu_Window_update_interval(__pointer))
+    end
+
+    def update_interval=(double)
+      GosuFFI.Gosu_Window_set_update_interval(__pointer, double)
+      GosuFFI.check_last_error
+    end
+
+    def width
+      GosuFFI.check_last_error(GosuFFI.Gosu_Window_width(__pointer))
+    end
+
+    def width=(int)
+      GosuFFI.Gosu_Window_resize(__pointer, int, height, fullscreen?)
+      GosuFFI.check_last_error
+    end
+
+    def height
+      GosuFFI.check_last_error(GosuFFI.Gosu_Window_height(__pointer))
+    end
+
+    def height=(int)
+      GosuFFI.Gosu_Window_resize(__pointer, width, int, fullscreen?)
+      GosuFFI.check_last_error
+    end
+
+    def mouse_x
+      GosuFFI.check_last_error(GosuFFI.Gosu_Window_mouse_x(__pointer))
+    end
+
+    def mouse_x=(double)
+      GosuFFI.Gosu_Window_set_mouse_x(__pointer, double)
+      GosuFFI.check_last_error
+    end
+
+    def mouse_y
+      GosuFFI.check_last_error(GosuFFI.Gosu_Window_mouse_y(__pointer))
+    end
+
+    def mouse_y=(double)
+      GosuFFI.Gosu_Window_set_mouse_y(__pointer, double)
+      GosuFFI.check_last_error
+    end
+
+    def show
+      GosuFFI.Gosu_Window_show(__pointer)
+
+      raise @__exception if defined?(@__exception)
+
+      GosuFFI.check_last_error
+    end
+
+    def tick
+      value = GosuFFI.check_last_error(GosuFFI.Gosu_Window_tick(__pointer))
+
+      raise @__exception if defined?(@__exception)
+
+      value
+    end
+
+    def close!
+      GosuFFI.Gosu_Window_close_immediately(__pointer)
+      GosuFFI.check_last_error
+    end
+
+    def sdl_window
+      GosuFFI.check_last_error(GosuFFI.Gosu_Window_sdl_window(__pointer))
+    end
+  end
+end

data/lib/gosu.rb

@@ -1,14 +1,14 @@
-require 'rbconfig'
+require "ffi"
 
 if RUBY_PLATFORM =~ /mswin$|mingw|win32\-|\-win32/
-  binary_path = File.dirname(__FILE__)
-  # 64-bit builds of Windows use "x64-mingw32" as RUBY_PLATFORM
+  binary_path = File.expand_path("../lib", __dir__)
+  # 64-bit builds of Windows use "x64-mingw" as RUBY_PLATFORM
   binary_path += "64" if RUBY_PLATFORM =~ /^x64-/
 
   begin
     # Make DLLs available as shown here:
     # https://github.com/oneclick/rubyinstaller2/wiki/For-gem-developers
-    require 'ruby_installer'
+    require "ruby_installer"
     RubyInstaller::Runtime.add_dll_directory(binary_path)
   rescue LoadError
     # Add this gem to the PATH on Windows so that bundled DLLs can be found.
@@ -17,10 +17,31 @@ if RUBY_PLATFORM =~ /mswin$|mingw|win32\-|\-win32/
     path_encoding = ENV["PATH"].encoding
     ENV["PATH"] = "#{binary_path.encode(path_encoding)};#{ENV["PATH"]}"
   end
+
+  # Add the correct lib directory for the current version of Ruby (major.minor).
+  $LOAD_PATH.prepend File.join(binary_path, RUBY_VERSION[/^\d+.\d+/])
+end
+
+module Gosu
 end
 
-require "gosu.#{RbConfig::CONFIG["DLEXT"]}"
+require_relative "gosu/ffi"
+require_relative "gosu/constants"
+
+require_relative "gosu/numeric"
+
+# Individual classes need to be loaded after defining GosuFFI.check_last_error.
+
+require_relative "gosu/gosu"
+
+require_relative "gosu/channel"
+require_relative "gosu/color"
+require_relative "gosu/font"
+require_relative "gosu/gl_tex_info"
+require_relative "gosu/image"
+require_relative "gosu/sample"
+require_relative "gosu/song"
+require_relative "gosu/text_input"
+require_relative "gosu/window"
 
-require "gosu/swig_patches"
-require "gosu/patches"
-require "gosu/compat"
+require_relative "gosu/compat"

data/rdoc/gosu.rb

@@ -1,5 +1,3 @@
-## Encoding: UTF-8
-
 module Gosu
   ##
   # The first component of the version.

data/src/Audio.cpp

@@ -1,5 +1,5 @@
 #include <Gosu/Audio.hpp>
-#include <Gosu/IO.hpp>
+#include <Gosu/Buffer.hpp>
 #include <Gosu/Math.hpp>
 #include "AudioFile.hpp"
 #include "AudioImpl.hpp"
@@ -42,12 +42,12 @@ Gosu::Sample::Sample()
 }
 
 Gosu::Sample::Sample(const std::string& filename)
-: m_impl{new Impl(AudioFile(filename))}
+    : m_impl(new Impl(AudioFile(filename)))
 {
 }
 
-Gosu::Sample::Sample(Gosu::Reader reader)
-: m_impl{new Impl(AudioFile(reader))}
+Gosu::Sample::Sample(Buffer buffer)
+    : m_impl(new Impl(AudioFile(std::move(buffer))))
 {
 }
 
@@ -101,16 +101,16 @@ private:
 
 public:
     explicit Impl(const std::string& filename)
-    : m_buffers{},
-      m_file{new AudioFile{filename}}
+        : m_buffers {},
+          m_file(new AudioFile(filename))
     {
         al_initialize();
         alGenBuffers(2, m_buffers);
     }
 
-    explicit Impl(Reader reader)
-    : m_buffers{},
-      m_file{new AudioFile{reader}}
+    explicit Impl(Buffer buffer)
+        : m_buffers {},
+          m_file(new AudioFile(std::move(buffer)))
     {
         al_initialize();
         alGenBuffers(2, m_buffers);
@@ -229,12 +229,12 @@ public:
 };
 
 Gosu::Song::Song(const std::string& filename)
-: m_impl{new Impl(filename)}
+: m_impl(new Impl(filename))
 {
 }
 
-Gosu::Song::Song(Reader reader)
-: m_impl{new Impl(reader)}
+Gosu::Song::Song(Buffer buffer)
+: m_impl(new Impl(std::move(buffer)))
 {
 }
 

data/src/AudioFile.hpp

@@ -1,10 +1,10 @@
 #pragma once
 
-#include <Gosu/IO.hpp>
+#include <Gosu/Fwd.hpp>
 
 #ifdef GOSU_IS_IPHONE
-// Ignore OpenAL deprecation warnings. If macOS stops shipping OpenAL, it's more likely that we bundle our own version
-// of it than that we switch to another audio API.
+// Ignore OpenAL deprecation warnings. If iOS stops shipping OpenAL, it's more likely that we
+// bundle our own version of it than that we switch to another audio API.
 #define OPENAL_DEPRECATED
 #include <OpenAL/al.h>
 #else
@@ -12,6 +12,7 @@
 #endif
 
 #include <cstddef>
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -24,7 +25,7 @@ namespace Gosu
 
     public:
         explicit AudioFile(const std::string& filename);
-        explicit AudioFile(Reader reader);
+        explicit AudioFile(Buffer buffer);
         ~AudioFile();
 
         ALenum format() const;

data/src/AudioFileAudioToolbox.cpp

@@ -8,6 +8,7 @@
 
 #include "AudioFile.hpp"
 #include "AudioImpl.hpp"
+#include <Gosu/Buffer.hpp>
 #include <Gosu/Utility.hpp>
 
 #import <AudioToolbox/AudioToolbox.h>
@@ -18,6 +19,7 @@
 
 #include <algorithm>
 #include <arpa/inet.h>
+#include <cstring>
 #include <stdexcept>
 #include <vector>
 
@@ -53,16 +55,16 @@ struct Gosu::AudioFile::Impl : private Gosu::Noncopyable
     static OSStatus AudioFile_ReadProc(void* in_client_data, SInt64 in_position,
                                        UInt32 request_count, void* buffer, UInt32* actual_count)
     {
-        const Resource& res = *static_cast<Resource*>(in_client_data);
+        const Buffer& res = *static_cast<Buffer*>(in_client_data);
         *actual_count = std::min<UInt32>(request_count,
                                          static_cast<UInt32>(res.size() - in_position));
-        res.read(in_position, *actual_count, buffer);
+        std::memcpy(buffer, res.data() + in_position, *actual_count);
         return noErr;
     }
 
     static SInt64 AudioFile_GetSizeProc(void* in_client_data)
     {
-        const Resource& res = *static_cast<Resource*>(in_client_data);
+        const Buffer& res = *static_cast<Buffer*>(in_client_data);
         return res.size();
     }
 
@@ -162,14 +164,12 @@ Gosu::AudioFile::AudioFile(const std::string& filename)
     pimpl->init();
 }
 
-Gosu::AudioFile::AudioFile(Reader reader)
+Gosu::AudioFile::AudioFile(Buffer buffer)
 : pimpl(new Impl)
 {
-    pimpl->buffer.resize(reader.resource().size() - reader.position());
-    reader.read(pimpl->buffer.data(), pimpl->buffer.size());
+    pimpl->buffer = std::move(buffer);
     
-    void* client_data = &pimpl->buffer;
-    CHECK_OS(AudioFileOpenWithCallbacks(client_data, Impl::AudioFile_ReadProc, nullptr,
+    CHECK_OS(AudioFileOpenWithCallbacks(&pimpl->buffer, Impl::AudioFile_ReadProc, nullptr,
                                         Impl::AudioFile_GetSizeProc, nullptr, 0, &pimpl->file_id));
     CHECK_OS(ExtAudioFileWrapAudioFileID(pimpl->file_id, false, &pimpl->file));
     

data/src/AudioFileSDLSound.cpp

@@ -1,20 +1,18 @@
+#include <Gosu/Buffer.hpp>
 #include <Gosu/Platform.hpp>
 
 #ifndef GOSU_IS_IPHONE
 
 #include "AudioFile.hpp"
 #include "AudioImpl.hpp"
-
 #include <SDL_sound.h>
-
+#include <algorithm>
 #include <cstdlib>
 #include <cstring>
-#include <algorithm>
 #include <memory>
 #include <mutex>
 #include <stdexcept>
 #include <vector>
-#include <stdexcept>
 
 struct Gosu::AudioFile::Impl : private Gosu::Noncopyable
 {
@@ -57,14 +55,13 @@ Gosu::AudioFile::AudioFile(const std::string& filename)
     }
 }
 
-Gosu::AudioFile::AudioFile(Reader reader)
+Gosu::AudioFile::AudioFile(Gosu::Buffer buffer)
 : pimpl(new Impl)
 {
-    pimpl->buffer.resize(reader.resource().size() - reader.position());
-    reader.read(pimpl->buffer.data(), pimpl->buffer.size());
-    pimpl->sample.reset(Sound_NewSampleFromMem(reinterpret_cast<Uint8*>(pimpl->buffer.data()),
-                                               static_cast<Uint32>(pimpl->buffer.size()),
-                                               "", nullptr, 4096),
+    pimpl->buffer = std::move(buffer);
+    pimpl->sample.reset(Sound_NewSampleFromMem(pimpl->buffer.data(),
+                                               static_cast<Uint32>(pimpl->buffer.size()), "",
+                                               nullptr, 4096),
                         Sound_FreeSample);
     if (!pimpl->sample) {
         std::string message = "Could not parse audio file";

data/src/BinPacker.cpp

@@ -0,0 +1,187 @@
+#include <Gosu/Utility.hpp>
+#include "BinPacker.hpp"
+#include <algorithm>
+
+#ifndef NDEBUG
+#include <cassert>
+#endif
+
+Gosu::BinPacker::BinPacker(int width, int height)
+    : m_width(width),
+      m_height(height),
+      m_free_rects { Rect { 0, 0, width, height } }
+{
+}
+
+std::shared_ptr<const Gosu::Rect> Gosu::BinPacker::alloc(int width, int height)
+{
+    std::unique_lock lock(m_mutex);
+
+    const Rect* best_rect = best_free_rect(width, height);
+
+    // We didn't find a single free rectangle that can fit the required size? Exit.
+    if (best_rect == nullptr) {
+        return nullptr;
+    }
+
+    // We found a free area, place the result in the top left corner of it.
+    // (Also make sure that the pointer's deleter returns the rectangle. Note: Even though
+    // shared_ptr may call its deleter with a nullptr in general, it will not do so here.)
+    std::shared_ptr<const Rect> result(new Rect { best_rect->x, best_rect->y, width, height },
+                                       [this](const Rect* p) { add_free_rect(*p); });
+
+    // We need to split the remaining rectangle into two. We use the axis with the longer side.
+    // (Called "Longer Axis Split Rule", "-LAS" in the paper.)
+    Rect new_rect_right = *best_rect;
+    Rect new_rect_below = *best_rect;
+    if (best_rect->width < best_rect->height) {
+        // ┏━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━┓
+        // ┃     result     ┃ new_rect_right ┃
+        // ┣━━━━━━━━━━━━━━━━┻━━━━━━━━━━━━━━━━┫
+        // ┃          new_rect_below         ┃
+        // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+        new_rect_right.x += width;
+        new_rect_right.width -= width;
+        new_rect_right.height = height;
+
+        new_rect_below.y += height;
+        new_rect_below.height -= height;
+    }
+    else {
+        // ┏━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━┓
+        // ┃    result      ┃                ┃
+        // ┣━━━━━━━━━━━━━━━━┫ new_rect_right ┃
+        // ┃ new_rect_below ┃                ┃
+        // ┗━━━━━━━━━━━━━━━━┻━━━━━━━━━━━━━━━━┛
+        new_rect_right.x += width;
+        new_rect_right.width -= width;
+
+        new_rect_below.y += height;
+        new_rect_below.height -= height;
+        new_rect_below.width = width;
+    }
+
+    remove_free_rect(static_cast<int>(best_rect - m_free_rects.data()));
+
+    // Release the mutex lock before calling add_free_rect to avoid a deadlock.
+    lock.unlock();
+
+    if (!new_rect_below.empty()) {
+        add_free_rect(new_rect_below);
+    }
+    if (!new_rect_right.empty()) {
+        add_free_rect(new_rect_right);
+    }
+
+    return result;
+}
+
+void Gosu::BinPacker::add_free_rect(const Rect& rect)
+{
+    const std::scoped_lock lock(m_mutex);
+
+#ifndef NDEBUG
+    for (const Rect& other_free_rect : m_free_rects) {
+        assert(!rect.overlaps(other_free_rect));
+    }
+#endif
+
+    m_free_rects.push_back(rect);
+    merge_neighbors(static_cast<int>(m_free_rects.size() - 1));
+}
+
+const Gosu::Rect* Gosu::BinPacker::best_free_rect(int width, int height) const
+{
+    // The rect wouldn't even fit onto the texture!
+    if (width > m_width || height > m_height) {
+        return nullptr;
+    }
+
+    const Rect* best_rect = nullptr;
+    int best_weight = 0;
+
+    for (const Rect& free_rect : m_free_rects) {
+        // This implements the "Best Short Side Fit" (BSSF) metric for choosing a free area.
+        int weight = std::min(free_rect.width - width, free_rect.height - height);
+        if (weight < 0) {
+            continue;
+        }
+        if (best_rect == nullptr || weight < best_weight) {
+            best_rect = &free_rect;
+            best_weight = weight;
+        }
+    }
+
+    return best_rect;
+}
+
+void Gosu::BinPacker::remove_free_rect(int index, int* other_index)
+{
+    std::swap(m_free_rects.at(index), m_free_rects.back());
+    if (other_index && *other_index == m_free_rects.size() - 1) {
+        *other_index = index;
+    }
+
+    m_free_rects.pop_back();
+}
+
+void Gosu::BinPacker::merge_neighbors(int index)
+{
+    // This algorithm tries to merge adjacent free rectangles into larger ones where possible.
+    // However, it only finds pairwise combinations of rectangles that can be merged into a single,
+    // larger rectangle. You may find that textures/bins sometimes end up with free rectangles that
+    // are shaped like this:
+    //   ┏━━━━┳━┓
+    //   ┣━┳━━┫ ┃
+    //   ┃ ┣━━┻━┫
+    //   ┗━┻━━━━┛
+    // In this case, the texture gets stuck in this fragmented state. We assume that this is not an
+    // issue in practice, just like memory
+
+    // Merge any of the other rectangles in the list into the one with the given index if they share
+    // any of their four sides.
+    for (int j = 0; j < m_free_rects.size(); ++j) {
+        Rect& rect = m_free_rects[index];
+
+        const Rect& other_rect = m_free_rects[j];
+        bool merged = false;
+        if (rect.x == other_rect.x && rect.width == other_rect.width) {
+            // Both rectangles are horizontally aligned.
+
+            if (rect.y == other_rect.bottom()) {
+                // rect is directly below other_rect, expand it upward.
+                rect.y = other_rect.y;
+                rect.height += other_rect.height;
+                merged = true;
+            }
+            else if (other_rect.y == rect.bottom()) {
+                // rect is directly above other_rect, expand it downward.
+                rect.height += other_rect.height;
+                merged = true;
+            }
+        }
+        else if (rect.y == other_rect.y && rect.height == other_rect.height) {
+            // Both rectangles are vertically aligned.
+
+            if (rect.x == other_rect.right()) {
+                // rect is directly to the right of other_rect, expand it to the left.
+                rect.x = other_rect.x;
+                rect.width += other_rect.width;
+                merged = true;
+            }
+            else if (other_rect.x == rect.right()) {
+                // rect is directly to the left of other_rect, expand it to the right.
+                rect.width += other_rect.width;
+                merged = true;
+            }
+        }
+
+        // If we merged two rectangles, then we need to start over because the longer sides of the
+        // combined rectangle might allow new mergers with other adjacent rectangles, and so on.
+        if (merged) {
+            remove_free_rect(j, &index);
+            // Reset j to -1 so that the next loop iteration will resume at j == 0.
+            j = -1;
+        }
+    }
+}