gosu 1.0.0 → 1.1.1.1

data/src/ImageWrapper.cpp

@@ -1,168 +0,0 @@
-#include <Gosu/Gosu.hpp>
-#include <stdio.h>
-#include <cstring>
-
-extern "C" {
-#include <Gosu/Image.h>
-
-// Constructors
-Gosu_Image *Gosu_Image_create(const char *filename, unsigned image_flags)
-{
-    return reinterpret_cast<Gosu_Image *>(new Gosu::Image(filename, image_flags));
-};
-
-Gosu_Image *Gosu_Image_create_from_markup(const char *markup, const char *font, double font_height,
-                                            int width, double spacing, unsigned align, unsigned font_flags, unsigned image_flags)
-{
-    Gosu::Bitmap bitmap = Gosu::layout_markup(markup, font, font_height, spacing, width,
-                                                (Gosu::Alignment)align, font_flags);
-    return reinterpret_cast<Gosu_Image *>(new Gosu::Image(bitmap, image_flags));
-}
-
-Gosu_Image *Gosu_Image_create_from_text(const char *text, const char *font, double font_height,
-                                        int width, double spacing, unsigned align, unsigned font_flags, unsigned image_flags)
-{
-    Gosu::Bitmap bitmap = Gosu::layout_text(text, font, font_height, spacing, width,
-                                            (Gosu::Alignment)align, font_flags);
-    return reinterpret_cast<Gosu_Image *>(new Gosu::Image(bitmap, image_flags));
-}
-
-Gosu_Image *Gosu_Image_create_from_blob(unsigned char *blob, int byte_count, int columns, int rows, unsigned image_flags)
-{
-    std::size_t size = columns * rows * 4;
-    Gosu::Bitmap bitmap(columns, rows, Gosu::Color::NONE);
-
-    if (byte_count == size) {
-        // 32 bit per pixel, assume R8G8B8A8
-        std::memcpy(bitmap.data(), blob, size);
-    }
-    else if (byte_count == size * sizeof(float)) {
-        // 128 bit per channel, assume float/float/float/float
-        const float *in = reinterpret_cast<const float *>(blob);
-        Gosu::Color::Channel *out = reinterpret_cast<Gosu::Color::Channel *>(bitmap.data());
-        for (int i = size; i > 0; --i) {
-            *(out++) = static_cast<Gosu::Color::Channel>(*(in++) * 255);
-        }
-    }
-    else {
-        return nullptr; // abort?
-    }
-
-    return reinterpret_cast<Gosu_Image *>(new Gosu::Image(bitmap, image_flags));
-}
-
-Gosu_Image *Gosu_Image_create_from_subimage(Gosu_Image *image, int left, int top, int width, int height)
-{
-    Gosu::Image *gosu_image = reinterpret_cast<Gosu::Image *>(image);
-    std::unique_ptr<Gosu::ImageData> image_data = gosu_image->data().subimage(left, top, width, height);
-
-    return reinterpret_cast<Gosu_Image *>(image_data.get() ? new Gosu::Image(std::move(image_data)) : nullptr);
-}
-
-void Gosu_Image_create_from_tiles(const char *source, int tile_width, int tile_height, void function(void *data, Gosu_Image *image), void *data, unsigned image_flags)
-{
-    std::vector<Gosu::Image> gosu_images = Gosu::load_tiles(source, tile_width, tile_height, image_flags);
-
-    for (Gosu::Image &img : gosu_images) {
-        function(data, reinterpret_cast<Gosu_Image *>(new Gosu::Image(img)));
-    }
-}
-
-void Gosu_Image_create_tiles_from_image(Gosu_Image *image, int tile_width, int tile_height, void function(void *data, Gosu_Image *image), void *data, unsigned image_flags)
-{
-    std::vector<Gosu::Image> gosu_images = Gosu::load_tiles(reinterpret_cast<Gosu::Image *>(image)->data().to_bitmap(), tile_width, tile_height, image_flags);
-
-    for (Gosu::Image &img : gosu_images) {
-        function(data, reinterpret_cast<Gosu_Image *>(new Gosu::Image(img)));
-    }
-}
-
-// Properties
-unsigned Gosu_Image_width(Gosu_Image *image)
-{
-    return reinterpret_cast<Gosu::Image *>(image)->width();
-}
-
-unsigned Gosu_Image_height(Gosu_Image *image)
-{
-    return reinterpret_cast<Gosu::Image *>(image)->height();
-}
-
-Gosu_GLTexInfo *Gosu_Image_gl_tex_info_create(Gosu_Image *image)
-{
-    Gosu::Image *gosu_image = reinterpret_cast<Gosu::Image *>(image);
-    Gosu::GLTexInfo *gosu_texture_info = new Gosu::GLTexInfo(*gosu_image->data().gl_tex_info());
-    if (gosu_texture_info) {
-        return reinterpret_cast<Gosu_GLTexInfo *>(gosu_texture_info);
-    }
-    else {
-        return nullptr;
-    }
-}
-
-void Gosu_Image_gl_tex_info_destroy(Gosu_GLTexInfo *gl_tex_info)
-{
-    delete (reinterpret_cast<Gosu::GLTexInfo *>(gl_tex_info));
-}
-
-// Rendering
-void Gosu_Image_draw(Gosu_Image *image, double x, double y, double z, double scale_x, double scale_y, unsigned color, unsigned mode)
-{
-    reinterpret_cast<Gosu::Image *>(image)->draw(x, y, z, scale_x, scale_y, color, (Gosu::AlphaMode)mode);
-}
-
-void Gosu_Image_draw_rot(Gosu_Image *image, double x, double y, double z,
-                            double angle, double center_x, double center_y,
-                            double scale_x, double scale_y, unsigned color, unsigned mode)
-{
-    reinterpret_cast<Gosu::Image *>(image)->draw_rot(x, y, z,
-                                                        angle, center_x, center_y,
-                                                        scale_x, scale_y,
-                                                        color, (Gosu::AlphaMode)mode);
-}
-
-void Gosu_Image_draw_as_quad(Gosu_Image *image,
-                                double x1, double y1, unsigned color1,
-                                double x2, double y2, unsigned color2,
-                                double x3, double y3, unsigned color3,
-                                double x4, double y4, unsigned color4,
-                                double z, unsigned mode)
-{
-    Gosu::Image *gosu_image = reinterpret_cast<Gosu::Image *>(image);
-    gosu_image->data().draw(
-        x1, y1, color1,
-        x2, y2, color2,
-        x3, y3, color3,
-        x4, y4, color4,
-        z, (Gosu::AlphaMode)mode);
-}
-
-// Image operations
-void Gosu_Image_insert(Gosu_Image *image, Gosu_Image *source, int x, int y)
-{
-    Gosu::Bitmap bmp;
-    bmp = reinterpret_cast<Gosu::Image *>(source)->data().to_bitmap();
-    reinterpret_cast<Gosu::Image *>(image)->data().insert(bmp, x, y);
-}
-
-unsigned char *Gosu_Image_to_blob(Gosu_Image *image)
-{
-    Gosu::Image *gosu_image = reinterpret_cast<Gosu::Image *>(image);
-    static thread_local Gosu::Bitmap bitmap;
-    bitmap = gosu_image->data().to_bitmap();
-
-    return reinterpret_cast<unsigned char *>(bitmap.data());
-}
-
-void Gosu_Image_save(Gosu_Image *image, const char *filename)
-{
-    Gosu::save_image_file(reinterpret_cast<Gosu::Image *>(image)->data().to_bitmap(), filename);
-}
-
-// Destructor
-void Gosu_Image_destroy(Gosu_Image *image)
-{
-    delete (reinterpret_cast<Gosu::Image *>(image));
-}
-
-}

data/src/MPEGFile.hpp

@@ -1,90 +0,0 @@
-#pragma once
-
-#include "AudioFile.hpp"
-#include <Gosu/IO.hpp>
-#include <algorithm>
-#include <stdexcept>
-#include <string>
-
-#include <mpg123.h>
-
-namespace Gosu
-{
-    class MPEGFile : public AudioFile
-    {
-        Gosu::Buffer contents_;
-        off_t position_ = 0;
-        mpg123_handle* handle_;
-        
-        enum {
-            SAMPLE_RATE = 44100,
-            INPUT_SIZE = 16384
-        };
-        
-    public:
-        MPEGFile(Gosu::Reader reader)
-        {
-            contents_.resize(reader.resource().size() - reader.position());
-            reader.read(contents_.data(), contents_.size());
-
-            static int init_error = mpg123_init();
-            if (init_error != MPG123_OK) {
-                throw std::runtime_error("Cannot initialize mpg123: " +
-                                         std::string(mpg123_plain_strerror(init_error)));
-            }
-
-            int new_error;
-            handle_ = mpg123_new(nullptr, &new_error);
-            if (handle_ == nullptr) {
-                throw std::runtime_error("Cannot initialize mpg123 decoder: " +
-                                         std::string(mpg123_plain_strerror(new_error)));
-            }
-            
-            mpg123_param(handle_, MPG123_FORCE_RATE, SAMPLE_RATE, 0);
-            mpg123_param(handle_, MPG123_FLAGS, MPG123_FORCE_STEREO, 0);
-            
-            mpg123_open_feed(handle_);
-        }
-        
-        ~MPEGFile() override
-        {
-            mpg123_delete(handle_);
-        }
-        
-        ALenum format() const override
-        {
-            return AL_FORMAT_STEREO16;
-        }
-        
-        ALuint sample_rate() const override
-        {
-            return SAMPLE_RATE;
-        }
-        
-        std::size_t read_data(void* dest, std::size_t length) override
-        {
-            std::size_t written = 0;
-            int error = 0;
-            
-            error = mpg123_read(handle_, static_cast<unsigned char*>(dest), length, &written);
-            while (written == 0
-                   && (error == MPG123_NEED_MORE || error == MPG123_NEW_FORMAT)
-                   && position_ != contents_.size()) {
-                auto bytes = std::min<std::size_t>(contents_.size() - position_, INPUT_SIZE);
-                // (Not sure what to do about the return value of mpg123_feed here.)
-                mpg123_feed(handle_, static_cast<unsigned char*>(contents_.data()) + position_,
-                            bytes);
-                position_ += bytes;
-                error = mpg123_read(handle_, static_cast<unsigned char*>(dest), length, &written);
-            }
-            
-            return written;
-        }
-        
-        void rewind() override
-        {
-            mpg123_feedseek(handle_, 0, SEEK_SET, &position_);
-            assert (position_ >= 0 && position_ <= contents_.size());
-        }
-    };
-}

data/src/SampleWrapper.cpp

@@ -1,30 +0,0 @@
-#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

@@ -1,52 +0,0 @@
-#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/TextInputWrapper.cpp

@@ -1,101 +0,0 @@
-#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/WindowWrapper.cpp

@@ -1,317 +0,0 @@
-#include <Gosu/Gosu.hpp>
-
-namespace Gosu
-{
-class WindowForWrapper : public Gosu::Window
-{
-public:
-    WindowForWrapper(int width, int height, bool fullscreen, double update_interval, bool resizable);
-    void update() override;
-    void draw() override;
-    void default_button_down(unsigned btn); // Enables fullscreen toggle
-    void button_down(Gosu::Button btn) override;
-    void button_up(Gosu::Button btn) override;
-    void gamepad_connected(int id) override;
-    void gamepad_disconnected(int id) override;
-    void drop(const std::string &filename) override;
-    bool needs_redraw() const override;
-    bool needs_cursor() const override;
-    void close() override;
-
-    void close_immediately();
-
-    std::function<void ()> update_callback;
-    std::function<void ()> draw_callback;
-    std::function<void (unsigned btn)> button_down_callback;
-    std::function<void (unsigned btn)> button_up_callback;
-    std::function<void (int id)> gamepad_connected_callback;
-    std::function<void (int id)> gamepad_disconnected_callback;
-    std::function<void (const char *filename)> drop_callback;
-    std::function<bool ()> needs_redraw_callback;
-    std::function<bool ()> needs_cursor_callback;
-    std::function<void ()> close_callback;
-};
-} // namespace Gosu
-
-Gosu::WindowForWrapper::WindowForWrapper(int width, int height, bool fullscreen,
-                                         double update_interval, bool resizable)
-    : Gosu::Window(width, height, fullscreen, update_interval, resizable)
-{
-}
-
-void Gosu::WindowForWrapper::update()
-{
-    if (update_callback != nullptr) {
-        update_callback();
-    }
-}
-
-void Gosu::WindowForWrapper::draw()
-{
-    if (draw_callback != nullptr) {
-        draw_callback();
-    }
-}
-
-void Gosu::WindowForWrapper::default_button_down(unsigned btn)
-{
-    Gosu::Window::button_down(Gosu::Button(btn));
-}
-
-void Gosu::WindowForWrapper::button_down(Gosu::Button btn)
-{
-    if (button_down_callback != nullptr) {
-        button_down_callback(btn);
-    }
-}
-
-void Gosu::WindowForWrapper::button_up(Gosu::Button btn)
-{
-    if (button_up_callback != nullptr) {
-        button_up_callback(btn);
-    }
-}
-
-void Gosu::WindowForWrapper::gamepad_connected(int id)
-{
-    if (gamepad_connected_callback != nullptr) {
-        gamepad_connected_callback(id);
-    }
-}
-
-void Gosu::WindowForWrapper::gamepad_disconnected(int id)
-{
-    if (gamepad_disconnected_callback != nullptr) {
-        gamepad_disconnected_callback(id);
-    }
-}
-
-void Gosu::WindowForWrapper::drop(const std::string &filename)
-{
-    if (drop_callback != nullptr) {
-        drop_callback(filename.c_str());
-    }
-}
-
-bool Gosu::WindowForWrapper::needs_redraw() const
-{
-    if (needs_redraw_callback != nullptr) {
-        return needs_redraw_callback();
-    }
-    else {
-        return true;
-    }
-}
-
-bool Gosu::WindowForWrapper::needs_cursor() const
-{
-    if (needs_cursor_callback != nullptr) {
-        return needs_cursor_callback();
-    }
-    else {
-        return false;
-    }
-}
-
-void Gosu::WindowForWrapper::close()
-{
-    if (close_callback != nullptr) {
-        close_callback();
-    }
-    else {
-        Gosu::Window::close();
-    }
-}
-
-void Gosu::WindowForWrapper::close_immediately()
-{
-    Gosu::Window::close();
-}
-
-extern "C" {
-#include <Gosu/Window.h>
-#include <Gosu/TextInput.h>
-
-// Constructor
-Gosu_Window *Gosu_Window_create(int width, int height, bool fullscreen, double update_interval, bool resizable)
-{
-    return reinterpret_cast<Gosu_Window *>(new Gosu::WindowForWrapper(width, height, fullscreen, update_interval, resizable));
-};
-
-// Callbacks
-void Gosu_Window_set_draw(Gosu_Window *window, void function(void *data), void *data)
-{
-    reinterpret_cast<Gosu::WindowForWrapper *>(window)->draw_callback = [=]() { function(data); };
-}
-
-void Gosu_Window_set_update(Gosu_Window *window, void function(void *data), void *data)
-{
-    reinterpret_cast<Gosu::WindowForWrapper *>(window)->update_callback = [=]() { function(data); };
-}
-
-void Gosu_Window_set_button_down(Gosu_Window *window, void function(void *data, unsigned btn), void *data)
-{
-    reinterpret_cast<Gosu::WindowForWrapper *>(window)->button_down_callback = [=](unsigned btn) { function(data, btn); };
-}
-
-void Gosu_Window_default_button_down(Gosu_Window *window, unsigned btn)
-{
-    reinterpret_cast<Gosu::WindowForWrapper *>(window)->default_button_down(btn);
-}
-
-void Gosu_Window_set_button_up(Gosu_Window *window, void function(void *data, unsigned btn), void *data)
-{
-    reinterpret_cast<Gosu::WindowForWrapper *>(window)->button_up_callback = [=](unsigned btn) { function(data, btn); };
-}
-
-void Gosu_Window_set_gamepad_connected(Gosu_Window *window, void function(void *data, int id), void *data)
-{
-    reinterpret_cast<Gosu::WindowForWrapper *>(window)->gamepad_connected_callback = [=](int id) { function(data, id); };
-}
-
-void Gosu_Window_set_gamepad_disconnected(Gosu_Window *window, void function(void *data, int id), void *data)
-{
-    reinterpret_cast<Gosu::WindowForWrapper *>(window)->gamepad_disconnected_callback = [=](int id) { function(data, id); };
-}
-
-void Gosu_Window_set_drop(Gosu_Window *window, void function(void *data, const char *filename), void *data)
-{
-    reinterpret_cast<Gosu::WindowForWrapper *>(window)->drop_callback = [=](const char *filename) { function(data, filename); };
-}
-
-void Gosu_Window_set_needs_redraw(Gosu_Window *window, bool function(void *data), void *data)
-{
-    reinterpret_cast<Gosu::WindowForWrapper *>(window)->needs_redraw_callback = [=]() -> bool { return function(data); };
-}
-
-void Gosu_Window_set_needs_cursor(Gosu_Window *window, bool function(void *data), void *data)
-{
-    reinterpret_cast<Gosu::WindowForWrapper *>(window)->needs_cursor_callback = [=]() -> bool { return function(data); };
-}
-
-void Gosu_Window_set_close(Gosu_Window *window, void function(void *data), void *data)
-{
-    reinterpret_cast<Gosu::WindowForWrapper *>(window)->close_callback = [=]() { function(data); };
-}
-
-Gosu_TextInput *Gosu_Window_text_input(Gosu_Window *window)
-{
-    Gosu::Window *gosu_window = reinterpret_cast<Gosu::WindowForWrapper *>(window);
-    return reinterpret_cast<Gosu_TextInput *>(gosu_window->input().text_input());
-}
-
-void Gosu_Window_set_text_input(Gosu_Window *window, Gosu_TextInput *text_input)
-{
-    Gosu::Window *gosu_window = reinterpret_cast<Gosu::WindowForWrapper *>(window);
-    gosu_window->input().set_text_input(reinterpret_cast<Gosu::TextInput *>(text_input));
-}
-
-void Gosu_Window_show(Gosu_Window *window)
-{
-    reinterpret_cast<Gosu::WindowForWrapper *>(window)->show();
-}
-
-bool Gosu_Window_tick(Gosu_Window *window)
-{
-    return reinterpret_cast<Gosu::WindowForWrapper *>(window)->tick();
-}
-
-void Gosu_Window_close_immediately(Gosu_Window *window)
-{
-    reinterpret_cast<Gosu::WindowForWrapper *>(window)->close_immediately();
-}
-
-bool Gosu_Window_is_fullscreen(Gosu_Window *window)
-{
-    return reinterpret_cast<Gosu::WindowForWrapper *>(window)->fullscreen();
-}
-
-bool Gosu_Window_is_resizable(Gosu_Window *window)
-{
-    return reinterpret_cast<Gosu::WindowForWrapper *>(window)->resizable();
-}
-
-const char *Gosu_Window_caption(Gosu_Window *window)
-{
-    static thread_local std::string caption;
-    caption = reinterpret_cast<Gosu::WindowForWrapper *>(window)->caption();
-
-    return caption.c_str();
-}
-
-void Gosu_Window_set_caption(Gosu_Window *window, const char *caption)
-{
-    reinterpret_cast<Gosu::WindowForWrapper *>(window)->set_caption(caption);
-}
-
-double Gosu_Window_update_interval(Gosu_Window *window)
-{
-    return reinterpret_cast<Gosu::WindowForWrapper *>(window)->update_interval();
-}
-
-void Gosu_Window_set_update_interval(Gosu_Window *window, double update_interval)
-{
-    reinterpret_cast<Gosu::WindowForWrapper *>(window)->set_update_interval(update_interval);
-}
-
-void Gosu_Window_set_mouse_x(Gosu_Window *window, double x)
-{
-    Gosu::Window *gosu_window = reinterpret_cast<Gosu::WindowForWrapper *>(window);
-    gosu_window->input().set_mouse_position(x, gosu_window->input().mouse_x());
-}
-
-void Gosu_Window_set_mouse_y(Gosu_Window *window, double y)
-{
-    Gosu::Window *gosu_window = reinterpret_cast<Gosu::WindowForWrapper *>(window);
-    gosu_window->input().set_mouse_position(gosu_window->input().mouse_x(), y);
-}
-
-double Gosu_Window_mouse_x(Gosu_Window *window)
-{
-    return reinterpret_cast<Gosu::WindowForWrapper *>(window)->input().mouse_x();
-}
-
-double Gosu_Window_mouse_y(Gosu_Window *window)
-{
-    return reinterpret_cast<Gosu::WindowForWrapper *>(window)->input().mouse_y();
-}
-
-int Gosu_Window_width(Gosu_Window *window)
-{
-    return reinterpret_cast<Gosu::WindowForWrapper *>(window)->width();
-}
-
-void Gosu_Window_set_width(Gosu_Window *window, int width)
-{
-    Gosu::Window *gosu_window = reinterpret_cast<Gosu::WindowForWrapper *>(window);
-    gosu_window->resize(width, gosu_window->height(), gosu_window->fullscreen());
-}
-
-int Gosu_Window_height(Gosu_Window *window)
-{
-    return reinterpret_cast<Gosu::WindowForWrapper *>(window)->height();
-}
-
-void Gosu_Window_set_height(Gosu_Window *window, int height)
-{
-    Gosu::Window *gosu_window = reinterpret_cast<Gosu::WindowForWrapper *>(window);
-    gosu_window->resize(gosu_window->width(), height, gosu_window->fullscreen());
-}
-
-void Gosu_Window_resize(Gosu_Window *window, int width, int height, bool fullscreen)
-{
-    reinterpret_cast<Gosu::WindowForWrapper *>(window)->resize(width, height, fullscreen);
-}
-
-int Gosu_Window_is_button_down(Gosu_Window *window, unsigned btn)
-{
-    return reinterpret_cast<Gosu::WindowForWrapper *>(window)->input().down(Gosu::Button(btn));
-}
-
-// Destructor
-void Gosu_Window_destroy(Gosu_Window *window)
-{
-    delete (reinterpret_cast<Gosu::WindowForWrapper *>(window));
-}
-
-}