gosu 1.4.6 → 2.0.0.pre6

data/ffi/Gosu_Window.cpp

@@ -0,0 +1,314 @@
+#include "Gosu_FFI_internal.h"
+
+// Lifecycle
+
+GOSU_FFI_API Gosu_Window* Gosu_Window_create(int width, int height, unsigned window_flags,
+                                             double update_interval)
+{
+    return Gosu_translate_exceptions([=] {
+        return new Gosu_Window{width, height, window_flags, update_interval};
+    });
+};
+
+GOSU_FFI_API void Gosu_Window_destroy(Gosu_Window* window)
+{
+    delete window;
+}
+
+// Callbacks
+
+GOSU_FFI_API void Gosu_Window_set_update(Gosu_Window* window, void function(void*), void* data)
+{
+    Gosu_translate_exceptions([=] {
+        window->update_callback = [=] { function(data); };
+    });
+}
+
+GOSU_FFI_API void Gosu_Window_set_draw(Gosu_Window* window, void function(void*), void* data)
+{
+    Gosu_translate_exceptions([=] {
+        window->draw_callback = [=] { function(data); };
+    });
+}
+
+GOSU_FFI_API void Gosu_Window_set_button_down(Gosu_Window* window, void function(void*, unsigned),
+                                              void* data)
+{
+    Gosu_translate_exceptions([=] {
+        window->button_down_callback = [=](unsigned btn) { function(data, btn); };
+    });
+}
+
+GOSU_FFI_API void Gosu_Window_set_button_up(Gosu_Window* window, void function(void*, unsigned),
+                                            void* data)
+{
+    Gosu_translate_exceptions([=] {
+        window->button_up_callback = [=](unsigned btn) { function(data, btn); };
+    });
+}
+
+GOSU_FFI_API void Gosu_Window_set_gamepad_connected(Gosu_Window* window, void function(void*, int),
+                                                    void* data)
+{
+    Gosu_translate_exceptions([=] {
+        window->gamepad_connected_callback = [=](int id) { function(data, id); };
+    });
+}
+
+GOSU_FFI_API void Gosu_Window_set_gamepad_disconnected(Gosu_Window* window,
+                                                       void function(void*, int), void* data)
+{
+    Gosu_translate_exceptions([=] {
+        window->gamepad_disconnected_callback = [=](int id) { function(data, id); };
+    });
+}
+
+GOSU_FFI_API void Gosu_Window_set_drop(Gosu_Window* window, void function(void*, const char*),
+                                       void* data)
+{
+    Gosu_translate_exceptions([=] {
+        window->drop_callback = [=](const char* filename) { function(data, filename); };
+    });
+}
+
+GOSU_FFI_API void Gosu_Window_set_needs_redraw(Gosu_Window* window, bool function(void*),
+                                               void* data)
+{
+    Gosu_translate_exceptions([=] {
+        window->needs_redraw_callback = [=] { return function(data); };
+    });
+}
+
+GOSU_FFI_API void Gosu_Window_set_needs_cursor(Gosu_Window* window, bool function(void*),
+                                               void* data)
+{
+    Gosu_translate_exceptions([=] {
+        window->needs_cursor_callback = [=] { return function(data); };
+    });
+}
+
+GOSU_FFI_API void Gosu_Window_set_close(Gosu_Window* window, void function(void*), void* data)
+{
+    Gosu_translate_exceptions([=] {
+        window->close_callback = [=] { function(data); };
+    });
+}
+
+GOSU_FFI_API void Gosu_Window_set_gain_focus(Gosu_Window* window, void function(void*), void* data)
+{
+    Gosu_translate_exceptions([=] {
+        window->gain_focus_callback = [=] { function(data); };
+    });
+}
+
+GOSU_FFI_API void Gosu_Window_set_lose_focus(Gosu_Window* window, void function(void*), void* data)
+{
+    Gosu_translate_exceptions([=] {
+        window->lose_focus_callback = [=] { function(data); };
+    });
+}
+
+GOSU_FFI_API void Gosu_Window_default_button_down(Gosu_Window* window, unsigned id)
+{
+    Gosu_translate_exceptions([=] {
+        window->Gosu::Window::button_down(static_cast<Gosu::Button>(id));
+    });
+}
+
+// Properties
+
+GOSU_FFI_API int Gosu_Window_width(Gosu_Window* window)
+{
+    return Gosu_translate_exceptions([=] {
+        return window->width();
+    });
+}
+
+GOSU_FFI_API void Gosu_Window_set_width(Gosu_Window* window, int width)
+{
+    Gosu_translate_exceptions([=] {
+        window->resize(width, window->height(), window->fullscreen());
+    });
+}
+
+GOSU_FFI_API int Gosu_Window_height(Gosu_Window* window)
+{
+    return Gosu_translate_exceptions([=] {
+        return window->height();
+    });
+}
+
+GOSU_FFI_API void Gosu_Window_set_height(Gosu_Window* window, int height)
+{
+    Gosu_translate_exceptions([=] {
+        window->resize(window->width(), height, window->fullscreen());
+    });
+}
+
+GOSU_FFI_API bool Gosu_Window_is_fullscreen(Gosu_Window* window)
+{
+    return Gosu_translate_exceptions([=] {
+        return window->fullscreen();
+    });
+}
+
+GOSU_FFI_API void Gosu_Window_set_fullscreen(Gosu_Window* window, bool fullscreen)
+{
+    Gosu_translate_exceptions([=] {
+        window->resize(window->width(), window->height(), fullscreen);
+    });
+}
+
+GOSU_FFI_API void Gosu_Window_resize(Gosu_Window* window, int width, int height, bool fullscreen)
+{
+    Gosu_translate_exceptions([=] {
+        window->resize(width, height, fullscreen);
+    });
+}
+
+GOSU_FFI_API bool Gosu_Window_is_resizable(Gosu_Window* window)
+{
+    return Gosu_translate_exceptions([=] {
+        return window->resizable();
+    });
+}
+
+GOSU_FFI_API void Gosu_Window_set_resizable(Gosu_Window* window, bool resizable)
+{
+    Gosu_translate_exceptions([=] {
+        window->set_resizable(resizable);
+    });
+}
+
+GOSU_FFI_API bool Gosu_Window_is_borderless(Gosu_Window* window)
+{
+    return Gosu_translate_exceptions([=] {
+        return window->borderless();
+    });
+}
+
+GOSU_FFI_API void Gosu_Window_set_borderless(Gosu_Window* window, bool borderless)
+{
+    Gosu_translate_exceptions([=] {
+        window->set_borderless(borderless);
+    });
+}
+
+GOSU_FFI_API double Gosu_Window_update_interval(Gosu_Window* window)
+{
+    return Gosu_translate_exceptions([=] {
+        return window->update_interval();
+    });
+}
+
+GOSU_FFI_API void Gosu_Window_set_update_interval(Gosu_Window* window, double update_interval)
+{
+    Gosu_translate_exceptions([=] {
+        window->set_update_interval(update_interval);
+    });
+}
+
+GOSU_FFI_API const char* Gosu_Window_caption(Gosu_Window* window)
+{
+    static thread_local std::string caption;
+
+    return Gosu_translate_exceptions([=] {
+        caption = window->caption();
+        return caption.c_str();
+    });
+}
+
+GOSU_FFI_API void Gosu_Window_set_caption(Gosu_Window* window, const char* caption)
+{
+    Gosu_translate_exceptions([=] {
+        window->set_caption(caption);
+    });
+}
+
+GOSU_FFI_API void* Gosu_Window_sdl_window(Gosu_Window* window)
+{
+    return Gosu_translate_exceptions([=] {
+        return window->sdl_window();
+    });
+}
+
+// Input Properties
+
+GOSU_FFI_API Gosu_TextInput* Gosu_Window_text_input(Gosu_Window* window)
+{
+    return Gosu_translate_exceptions([=] {
+        return dynamic_cast<Gosu_TextInput*>(window->input().text_input());
+    });
+}
+
+GOSU_FFI_API void Gosu_Window_set_text_input(Gosu_Window* window, Gosu_TextInput* text_input)
+{
+    Gosu_translate_exceptions([=] {
+        window->input().set_text_input(text_input);
+    });
+}
+
+GOSU_FFI_API double Gosu_Window_mouse_x(Gosu_Window* window)
+{
+    return Gosu_translate_exceptions([=] {
+        return window->input().mouse_x();
+    });
+}
+
+GOSU_FFI_API void Gosu_Window_set_mouse_x(Gosu_Window* window, double x)
+{
+    Gosu_translate_exceptions([=] {
+        window->input().set_mouse_position(x, window->input().mouse_x());
+    });
+}
+
+GOSU_FFI_API double Gosu_Window_mouse_y(Gosu_Window* window)
+{
+    return Gosu_translate_exceptions([=] {
+        return window->input().mouse_y();
+    });
+}
+
+GOSU_FFI_API void Gosu_Window_set_mouse_y(Gosu_Window* window, double y)
+{
+    Gosu_translate_exceptions([=] {
+        window->input().set_mouse_position(window->input().mouse_x(), y);
+    });
+}
+
+GOSU_FFI_API void Gosu_Window_gain_focus(Gosu_Window* window)
+{
+    Gosu_translate_exceptions([=] {
+        window->gain_focus();
+    });
+}
+
+GOSU_FFI_API void Gosu_Window_lose_focus(Gosu_Window* window)
+{
+    Gosu_translate_exceptions([=] {
+        window->lose_focus();
+    });
+}
+
+// Main Loop
+
+GOSU_FFI_API void Gosu_Window_show(Gosu_Window* window)
+{
+    Gosu_translate_exceptions([=] {
+        window->show();
+    });
+}
+
+GOSU_FFI_API bool Gosu_Window_tick(Gosu_Window* window)
+{
+    return Gosu_translate_exceptions([=] {
+        return window->tick();
+    });
+}
+
+GOSU_FFI_API void Gosu_Window_close_immediately(Gosu_Window* window)
+{
+    Gosu_translate_exceptions([=] {
+        window->Gosu::Window::close();
+    });
+}

data/ffi/Gosu_Window.h

@@ -0,0 +1,78 @@
+#pragma once
+
+#include "Gosu_FFI.h"
+#include "Gosu_TextInput.h"
+#include <stdbool.h>
+
+typedef struct Gosu_Window Gosu_Window;
+
+// Lifecycle
+
+GOSU_FFI_API Gosu_Window* Gosu_Window_create(int width, int height, unsigned window_flags,
+                                             double update_interval);
+GOSU_FFI_API void Gosu_Window_destroy(Gosu_Window* window);
+
+// Callbacks
+
+GOSU_FFI_API void Gosu_Window_set_update(Gosu_Window* window, void function(void* data),
+                                         void* data);
+GOSU_FFI_API void Gosu_Window_set_draw(Gosu_Window* window, void function(void* data), void* data);
+GOSU_FFI_API void Gosu_Window_set_button_down(Gosu_Window* window,
+                                              void function(void* data, unsigned id), void* data);
+GOSU_FFI_API void Gosu_Window_set_button_up(Gosu_Window* window,
+                                            void function(void* data, unsigned id), void* data);
+GOSU_FFI_API void Gosu_Window_set_gamepad_connected(Gosu_Window* window,
+                                                    void function(void* data, int index),
+                                                    void* data);
+GOSU_FFI_API void Gosu_Window_set_gamepad_disconnected(Gosu_Window* window,
+                                                       void function(void* data, int index),
+                                                       void* data);
+GOSU_FFI_API void Gosu_Window_set_drop(Gosu_Window* window,
+                                       void function(void* data, const char* filename), void* data);
+GOSU_FFI_API void Gosu_Window_set_needs_redraw(Gosu_Window* window, bool function(void* data),
+                                               void* data);
+GOSU_FFI_API void Gosu_Window_set_needs_cursor(Gosu_Window* window, bool function(void* data),
+                                               void* data);
+GOSU_FFI_API void Gosu_Window_set_gain_focus(Gosu_Window* window, void function(void* data), void* data);
+GOSU_FFI_API void Gosu_Window_set_lose_focus(Gosu_Window* window, void function(void* data), void* data);
+GOSU_FFI_API void Gosu_Window_set_close(Gosu_Window* window, void function(void* data), void* data);
+
+GOSU_FFI_API void Gosu_Window_default_button_down(Gosu_Window* window, unsigned id);
+
+// Properties
+
+GOSU_FFI_API int Gosu_Window_width(Gosu_Window* window);
+GOSU_FFI_API void Gosu_Window_set_width(Gosu_Window* window, int width);
+GOSU_FFI_API int Gosu_Window_height(Gosu_Window* window);
+GOSU_FFI_API void Gosu_Window_set_height(Gosu_Window* window, int height);
+GOSU_FFI_API bool Gosu_Window_is_fullscreen(Gosu_Window* window);
+GOSU_FFI_API void Gosu_Window_set_fullscreen(Gosu_Window* window, bool fullscreen);
+GOSU_FFI_API void Gosu_Window_resize(Gosu_Window* window, int width, int height, bool fullscreen);
+
+GOSU_FFI_API bool Gosu_Window_is_resizable(Gosu_Window* window);
+GOSU_FFI_API void Gosu_Window_set_resizable(Gosu_Window* window, bool resizable);
+GOSU_FFI_API bool Gosu_Window_is_borderless(Gosu_Window* window);
+GOSU_FFI_API void Gosu_Window_set_borderless(Gosu_Window* window, bool borderless);
+
+GOSU_FFI_API double Gosu_Window_update_interval(Gosu_Window* window);
+GOSU_FFI_API void Gosu_Window_set_update_interval(Gosu_Window* window, double update_interval);
+
+GOSU_FFI_API const char* Gosu_Window_caption(Gosu_Window* window);
+GOSU_FFI_API void Gosu_Window_set_caption(Gosu_Window* window, const char* caption);
+
+GOSU_FFI_API void* Gosu_Window_sdl_window(Gosu_Window* window);
+
+// Input Properties
+
+GOSU_FFI_API Gosu_TextInput* Gosu_Window_text_input(Gosu_Window* window);
+GOSU_FFI_API void Gosu_Window_set_text_input(Gosu_Window* window, Gosu_TextInput* text_input);
+GOSU_FFI_API double Gosu_Window_mouse_x(Gosu_Window* window);
+GOSU_FFI_API void Gosu_Window_set_mouse_x(Gosu_Window* window, double width);
+GOSU_FFI_API double Gosu_Window_mouse_y(Gosu_Window* window);
+GOSU_FFI_API void Gosu_Window_set_mouse_y(Gosu_Window* window, double height);
+
+// Main Loop
+
+GOSU_FFI_API void Gosu_Window_show(Gosu_Window* window);
+GOSU_FFI_API bool Gosu_Window_tick(Gosu_Window* window);
+GOSU_FFI_API void Gosu_Window_close_immediately(Gosu_Window* window);

data/include/Gosu/Audio.hpp

@@ -1,7 +1,6 @@
 #pragma once
 
 #include <Gosu/Fwd.hpp>
-#include <Gosu/IO.hpp>
 #include <Gosu/Platform.hpp>
 #include <Gosu/Utility.hpp>
 #include <memory>
@@ -55,13 +54,11 @@ namespace Gosu
         /// Constructs an empty sample that is inaudible when played.
         Sample();
 
-        /// Constructs a sample that can be played on the specified audio
-        /// system and loads the sample from a file.
+        /// Loads a sample from a file.
         explicit Sample(const std::string& filename);
 
-        /// Constructs a sample that can be played on the specified audio
-        /// system and loads the sample data from a stream.
-        explicit Sample(Reader reader);
+        /// Loads a sample from memory.
+        explicit Sample(Buffer buffer);
 
         /// Plays the sample without panning.
         /// @param volume Can be anything from 0.0 (silence) to 1.0 (full volume).
@@ -88,13 +85,11 @@ namespace Gosu
         std::unique_ptr<Impl> m_impl;
 
     public:
-        /// Constructs a song that can be played on the provided audio system and loads the song
-        /// from a file. The file type is determined by the filename.
+        /// Loads or streams a song from a file.
         explicit Song(const std::string& filename);
 
-        /// Constructs a song of the specified type that can be played on the
-        /// provided audio system and loads the song data from a stream.
-        explicit Song(Reader reader);
+        /// Loads or streams a song from memory.
+        explicit Song(Buffer buffer);
 
         ~Song();
 

data/include/Gosu/Bitmap.hpp

@@ -1,100 +1,85 @@
 #pragma once
 
+#include <Gosu/Buffer.hpp>
 #include <Gosu/Color.hpp>
-#include <Gosu/IO.hpp>
+#include <Gosu/Utility.hpp>
 #include <string>
-#include <vector>
+#include <string_view>
 
 namespace Gosu
 {
-    /// A two-dimensional array area of pixels, each represented by a Color value.
+    /// A two-dimensional area of pixels, each represented by a Color value.
+    /// Internally, it is stored as a contiguous array of Gosu::Color, row by row.
+    ///
     /// Bitmaps are typically created only as an intermediate step between loading image files, and
     /// creating Gosu::Image objects from them (i.e. transferring the image into video RAM).
-    /// Has (expensive) value semantics.
+    ///
+    /// Bitmaps have (expensive) value semantics.
     class Bitmap
     {
         int m_width = 0, m_height = 0;
-        std::vector<Color> m_pixels;
+        Buffer m_pixels;
 
     public:
         Bitmap() = default;
 
         Bitmap(int width, int height, Color c = Color::NONE);
 
-        int width() const
-        {
-            return m_width;
-        }
+        /// Takes ownership of the given memory buffer.
+        /// @throw std::length_error if the buffer does not contain (width * height * 4) bytes.
+        Bitmap(int width, int height, Gosu::Buffer&& buffer);
 
-        int height() const
-        {
-            return m_height;
-        }
+        int width() const { return m_width; }
 
-        void swap(Bitmap& other);
+        int height() const { return m_height; }
 
         void resize(int width, int height, Color c = Color::NONE);
 
-        /// Returns the color at the specified position without any bounds checking.
-        Color get_pixel(int x, int y) const
-        {
-            return m_pixels[y * m_width + x];
-        }
+        /// Returns a reference to the pixel at the specified position without any bounds checking.
+        /// This can be a two-argument operator[] once we require C++23.
+        const Color& pixel(int x, int y) const { return data()[y * m_width + x]; }
 
-        /// Sets the pixel at the specified position without any bounds checking.
-        void set_pixel(int x, int y, Color c)
-        {
-            m_pixels[y * m_width + x] = c;
-        }
+        /// Returns a reference to the pixel at the specified position without any bounds checking.
+        /// This can be a two-argument operator[] once we require C++23.
+        Color& pixel(int x, int y) { return data()[y * m_width + x]; }
 
         /// This updates a pixel using the "over" alpha compositing operator, see:
         /// https://en.wikipedia.org/wiki/Alpha_compositing
+        /// Like pixel(), it does not perform any bounds checking.
         void blend_pixel(int x, int y, Color c);
 
         /// Inserts a bitmap at the given position. Parts of the inserted bitmap that would be
         /// outside of the target bitmap will be clipped away.
-        void insert(int x, int y, const Bitmap& source);
+        void insert(const Bitmap& source, int x, int y);
 
         /// Inserts a portion of a bitmap at the given position. Parts of the inserted bitmap that
         /// would be outside of the target bitmap will be clipped away.
-        void insert(int x, int y, const Bitmap& source,
-                    int src_x, int src_y, int src_width, int src_height);
+        /// Parts of the source_rect that are outside of the source image will be skipped.
+        void insert(const Bitmap& source, int x, int y, Rect source_rect);
+
+        /// Set the alpha value of all pixels which are equal to the color key to zero.
+        /// To reduce interpolation artifacts when stretching or rotating the resulting image, the
+        /// RGB values of transparent pixels will be adjusted to the average of their neighbors.
+        void apply_color_key(Color key);
 
         /// Direct access to the array of color values.
-        /// The return value is undefined if this bitmap is empty.
-        const Color* data() const
-        {
-            return &m_pixels[0];
-        }
+        const Color* data() const { return reinterpret_cast<const Color*>(m_pixels.data()); }
 
         /// Direct access to the array of color values.
-        /// The return value is undefined if this bitmap is empty.
-        Color* data()
-        {
-            return &m_pixels[0];
-        }
-
-        #ifdef FRIEND_TEST
-        FRIEND_TEST(BitmapTests, MemoryManagement);
-        #endif
+        Color* data() { return reinterpret_cast<Color*>(m_pixels.data()); }
+
+        bool operator==(const Bitmap&) const;
     };
 
-    /// Loads any supported image into a Bitmap.
+    /// Loads an image file, in any supported format.
     Bitmap load_image_file(const std::string& filename);
-    /// Loads any supported image into a Bitmap.
-    Bitmap load_image_file(Reader input);
+    /// Loads an image from memory, in any supported format.
+    Bitmap load_image(const Buffer& buffer);
 
     /// Saves a Bitmap to a file.
     void save_image_file(const Bitmap& bitmap, const std::string& filename);
     /// Saves a Bitmap to an arbitrary resource.
-    void save_image_file(const Bitmap& bitmap, Writer writer,
-                         const std::string_view& format_hint = "png");
-
-    /// Set the alpha value of all pixels which are equal to the color key to zero.
-    /// To reduce interpolation artefacts when stretching or rotating the resulting image, the color
-    /// value of these pixels will also be adjusted to the average of their surrounding pixels.
-    void apply_color_key(Bitmap& bitmap, Color key);
+    Gosu::Buffer save_image(const Bitmap& bitmap, std::string_view format_hint = "png");
 
-    Bitmap apply_border_flags(unsigned image_flags, const Bitmap& source,
-                              int src_x, int src_y, int src_width, int src_height);
+    Bitmap apply_border_flags(unsigned image_flags, const Bitmap& source, Rect source_rect);
 }

data/include/Gosu/Buffer.hpp

@@ -0,0 +1,54 @@
+#pragma once
+
+#include <cstdint>
+#include <functional>
+#include <string>
+#include <vector>
+
+namespace Gosu
+{
+    /// In many places, Gosu also accepts memory buffers in place of filenames to enable
+    /// interoperability with other storage systems, such as creating images from downloaded files
+    /// or loading sounds from PhysFS resources.
+    ///
+    /// Instead of using a vector<byte> or a similar standard container, this class consists of a
+    /// pointer and a deleter. This makes it easy to create Buffers from methods in other libraries
+    /// that return a pointer, but require that a specific functions is used for freeing the
+    /// pointer, such as std::free or SDL_free.
+    class Buffer
+    {
+        void* m_buffer;
+        std::size_t m_size ;
+        std::function<void(void*)> m_deleter;
+
+    public:
+        Buffer() = default;
+        /// Creates a Buffer that refers to a given portion of memory. The deleter will be called
+        /// when the Buffer is freed or re-assigned.
+        /// @param deleter Can be nullptr to create a non-owning view. Must not throw.
+        Buffer(void* buffer, std::size_t size, std::function<void(void*)> deleter);
+        Buffer(Buffer&& other) noexcept;
+        Buffer& operator=(Buffer&& other) noexcept;
+        ~Buffer();
+
+        /// Creates a new buffer by allocating memory. Does not initialize this memory.
+        explicit Buffer(std::size_t size);
+        /// Takes ownership of the given vector.
+        explicit Buffer(std::vector<std::uint8_t>&& vector) noexcept;
+
+        /// Makes a copy of the given buffer. Avoid this if possible.
+        Buffer(const Buffer& other);
+        /// Makes a copy of the given buffer. Avoid this if possible.
+        Buffer& operator=(const Buffer& other);
+
+        const std::uint8_t* data() const { return static_cast<const std::uint8_t*>(m_buffer); }
+        std::uint8_t* data() { return static_cast<std::uint8_t*>(m_buffer); }
+        std::size_t size() const { return m_size; }
+    };
+
+    /// Loads a whole file into a buffer.
+    Buffer load_file(const std::string& filename);
+
+    /// Creates or overwrites a file with the contents of a buffer.
+    void save_file(const Buffer& buffer, const std::string& filename);
+}