gosu 0.15.1 → 0.15.2

data/src/GosuWrapper.cpp

@@ -0,0 +1,232 @@
+#include <Gosu/Gosu.hpp>
+
+extern "C" {
+#include <Gosu/Gosu.h>
+
+void Gosu_gl_z(double z, void function(void *data), void *data)
+{
+    std::function<void ()> callback;
+    callback = [=]() { function(data); };
+
+    Gosu::Graphics::gl(z, callback);
+}
+
+void Gosu_gl(void function(void *data), void *data)
+{
+    std::function<void ()> callback;
+    callback = [=]() { function(data); };
+
+    Gosu::Graphics::gl(callback);
+}
+
+Gosu_Image *Gosu_render(int width, int height, void function(void *data), void *data, unsigned image_flags)
+{
+    std::function<void ()> callback;
+    callback = [=]() { function(data); };
+
+    return reinterpret_cast<Gosu_Image *>(new Gosu::Image(Gosu::Graphics::render(width, height, callback, image_flags)));
+}
+
+Gosu_Image *Gosu_record(int width, int height, void function(void *data), void *data)
+{
+    std::function<void ()> callback;
+    callback = [=]() { function(data); };
+    return reinterpret_cast<Gosu_Image *>(new Gosu::Image(Gosu::Graphics::record(width, height, callback)));
+}
+
+void Gosu_flush()
+{
+    Gosu::Graphics::flush();
+}
+
+void Gosu_transform(double m0, double m1, double m2, double m3, double m4, double m5, double m6,
+                    double m7, double m8, double m9, double m10, double m11, double m12, double m13,
+                    double m14, double m15, void function(void *data), void *data)
+{
+    Gosu::Transform transform = {
+        m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15};
+    std::function<void ()> callback;
+    callback = [=]() { function(data); };
+
+    Gosu::Graphics::transform(transform, callback);
+}
+
+void Gosu_translate(double x, double y, void function(void *data), void *data)
+{
+    std::function<void ()> callback;
+    callback = [=]() { function(data); };
+
+    Gosu::Graphics::transform(Gosu::translate(x, y), callback);
+}
+
+void Gosu_scale(double scale_x, double scale_y, double around_x, double around_y, void function(void *data), void *data)
+{
+    std::function<void ()> callback;
+    callback = [=]() { function(data); };
+
+    Gosu::Graphics::transform(Gosu::scale(scale_x, scale_y, around_x, around_y), callback);
+}
+
+void Gosu_rotate(double angle, double around_x, double around_y, void function(void *data), void *data)
+{
+    std::function<void ()> callback;
+    callback = [=]() { function(data); };
+
+    Gosu::Graphics::transform(Gosu::rotate(angle, around_x, around_y), callback);
+}
+
+void Gosu_clip_to(double x, double y, double width, double height, void function(void *data), void *data)
+{
+    std::function<void ()> callback;
+    callback = [=]() { function(data); };
+
+    Gosu::Graphics::clip_to(x, y, width, height, callback);
+}
+
+void Gosu_draw_line(double x1, double y1, unsigned c1,
+                    double x2, double y2, unsigned c2,
+                    double z, unsigned mode)
+{
+    Gosu::Graphics::draw_line(x1, y1, c1, x2, y2, c2, z, (Gosu::AlphaMode)mode);
+}
+
+void Gosu_draw_triangle(double x1, double y1, unsigned c1,
+                        double x2, double y2, unsigned c2,
+                        double x3, double y3, unsigned c3,
+                        double z, unsigned mode)
+{
+    Gosu::Graphics::draw_triangle(x1, y1, c1,
+                                    x2, y2, c2,
+                                    x3, y3, c3,
+                                    z, (Gosu::AlphaMode)mode);
+}
+
+void Gosu_draw_rect(double x, double y, double width, double height, unsigned c, double z, unsigned mode)
+{
+    Gosu::Graphics::draw_rect(x, y, width, height, c, z, (Gosu::AlphaMode)mode);
+}
+
+void Gosu_draw_quad(double x1, double y1, unsigned c1,
+                    double x2, double y2, unsigned c2,
+                    double x3, double y3, unsigned c3,
+                    double x4, double y4, unsigned c4,
+                    double z, unsigned mode)
+{
+    Gosu::Graphics::draw_quad(x1, y1, c1,
+                                x2, y2, c2,
+                                x3, y3, c3,
+                                x4, y4, c4,
+                                z, (Gosu::AlphaMode)mode);
+}
+
+double Gosu_distance(double x1, double y1, double x2, double y2)
+{
+    return Gosu::distance(x1, y1, x2, y2);
+}
+
+double Gosu_angle(double from_x, double from_y, double to_x, double to_y)
+{
+    return Gosu::angle(from_x, from_y, to_x, to_y);
+}
+
+double Gosu_angle_diff(double from, double to)
+{
+    return Gosu::angle_diff(from, to);
+}
+
+double Gosu_offset_x(double angle, double radius)
+{
+    return Gosu::offset_x(angle, radius);
+}
+
+double Gosu_offset_y(double angle, double radius)
+{
+    return Gosu::offset_y(angle, radius);
+}
+
+double Gosu_random(double min, double max)
+{
+    return Gosu::random(min, max);
+}
+
+unsigned Gosu_available_width(Gosu_Window *window)
+{
+    Gosu::Window *gosu_window = nullptr;
+    if (window != nullptr) {
+        gosu_window = reinterpret_cast<Gosu::Window *>(window);
+    }
+    return Gosu::available_width(gosu_window);
+}
+
+unsigned Gosu_available_height(Gosu_Window *window)
+{
+    Gosu::Window *gosu_window = nullptr;
+    if (window != nullptr) {
+        gosu_window = reinterpret_cast<Gosu::Window *>(window);
+    }
+    return Gosu::available_height(gosu_window);
+}
+
+unsigned Gosu_screen_width(Gosu_Window *window)
+{
+    Gosu::Window *gosu_window = nullptr;
+    if (window != nullptr) {
+        gosu_window = reinterpret_cast<Gosu::Window *>(window);
+    }
+    return Gosu::screen_width(gosu_window);
+}
+
+unsigned Gosu_screen_height(Gosu_Window *window)
+{
+    Gosu::Window *gosu_window = nullptr;
+    if (window != nullptr) {
+        gosu_window = reinterpret_cast<Gosu::Window *>(window);
+    }
+    return Gosu::screen_height(gosu_window);
+}
+
+int Gosu_button_down(int btn)
+{
+    return Gosu::Input::down((Gosu::ButtonName)btn);
+}
+
+const char *Gosu_button_id_to_char(int id)
+{
+    static thread_local std::string button;
+    button = Gosu::Input::id_to_char((Gosu::Button)id);
+
+    return button.c_str();
+}
+
+unsigned Gosu_button_char_to_id(const char *btn)
+{
+    return Gosu::Input::char_to_id(btn).id();
+}
+
+int Gosu_fps()
+{
+    return Gosu::fps();
+}
+
+const char *Gosu_language()
+{
+    static thread_local std::string language;
+    language = Gosu::language();
+
+    return language.c_str();
+}
+
+long Gosu_milliseconds()
+{
+    return Gosu::milliseconds();
+}
+
+const char *Gosu_default_font_name()
+{
+    static thread_local std::string name;
+    name = Gosu::default_font_name();
+
+    return name.c_str();
+}
+
+}

data/src/ImageWrapper.cpp

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

@@ -3,6 +3,7 @@
 #include <Gosu/Graphics.hpp>
 #include <Gosu/Math.hpp>
 #include <cmath>
+#include <stdexcept>
 using namespace std;
 
 Gosu::LargeImageData::LargeImageData(const Bitmap& source, int tile_width, int tile_height,

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());
+  }
+}