gosu 0.15.0 → 1.0.0

data/src/Font.cpp

@@ -6,10 +6,13 @@
 #include <Gosu/Math.hpp>
 #include <Gosu/Text.hpp>
 #include <Gosu/Utility.hpp>
-#include "utf8proc.h"
+
+#include <utf8proc.h>
+
 #include <array>
 #include <cassert>
 #include <map>
+#include <stdexcept>
 using namespace std;
 
 static const int FONT_RENDER_SCALE = 2;

data/src/FontWrapper.cpp

@@ -0,0 +1,74 @@
+#include <Gosu/Gosu.hpp>
+
+extern "C" {
+#include <Gosu/Image.h>
+#include <Gosu/Font.h>
+
+Gosu_Font *Gosu_Font_create(int height, const char *name, unsigned flags)
+{
+    return reinterpret_cast<Gosu_Font *>(new Gosu::Font(height, name, flags));
+}
+
+const char *Gosu_Font_name(Gosu_Font *font)
+{
+    return reinterpret_cast<Gosu::Font *>(font)->name().c_str();
+}
+
+int Gosu_Font_height(Gosu_Font *font)
+{
+    return reinterpret_cast<Gosu::Font *>(font)->height();
+}
+
+unsigned Gosu_Font_flags(Gosu_Font *font)
+{
+    return reinterpret_cast<Gosu::Font *>(font)->flags();
+}
+
+double Gosu_Font_text_width(Gosu_Font *font, const char *text)
+{
+    return reinterpret_cast<Gosu::Font *>(font)->text_width(text);
+}
+
+double Gosu_Font_markup_width(Gosu_Font *font, const char *text)
+{
+    return reinterpret_cast<Gosu::Font *>(font)->markup_width(text);
+}
+
+void Gosu_Font_draw_text(Gosu_Font *font, const char *text, double x, double y, double z,
+                            double scale_x, double scale_y, unsigned c, unsigned mode)
+{
+    reinterpret_cast<Gosu::Font *>(font)->draw_text(text, x, y, z, scale_x, scale_y, c, (Gosu::AlphaMode)mode);
+}
+
+void Gosu_Font_draw_markup(Gosu_Font *font, const char *text, double x, double y, double z,
+                            double scale_x, double scale_y, unsigned c, unsigned mode)
+{
+    reinterpret_cast<Gosu::Font *>(font)->draw_markup(text, x, y, z, scale_x, scale_y, c, (Gosu::AlphaMode)mode);
+}
+
+void Gosu_Font_draw_text_rel(Gosu_Font *font, const char *text, double x, double y, double z,
+                                double rel_x, double rel_y, double scale_x, double scale_y,
+                                unsigned c, unsigned mode)
+{
+    reinterpret_cast<Gosu::Font *>(font)->draw_text_rel(text, x, y, z, rel_x, rel_y, scale_x, scale_y, c, (Gosu::AlphaMode)mode);
+}
+
+void Gosu_Font_draw_markup_rel(Gosu_Font *font, const char *text, double x, double y, double z,
+                                double rel_x, double rel_y, double scale_x, double scale_y,
+                                unsigned c, unsigned mode)
+{
+    reinterpret_cast<Gosu::Font *>(font)->draw_markup_rel(text, x, y, z, rel_x, rel_y, scale_x, scale_y, c, (Gosu::AlphaMode)mode);
+}
+
+void Gosu_Font_set_image(Gosu_Font *font, const char *codepoint, unsigned font_flags, Gosu_Image *image)
+{
+
+    const Gosu::Image *gosu_image = reinterpret_cast<Gosu::Image *>(image);
+    reinterpret_cast<Gosu::Font *>(font)->set_image(codepoint, font_flags, *gosu_image);
+}
+
+void Gosu_Font_destroy(Gosu_Font *font)
+{
+    delete (reinterpret_cast<Gosu::Font *>(font));
+}
+}

data/src/GosuWrapper.cpp

@@ -0,0 +1,251 @@
+#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::Button)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);
+}
+
+const char *Gosu_button_name(int btn)
+{
+    static thread_local std::string name;
+    name = Gosu::Input::button_name((Gosu::Button)btn);
+    return name.empty() ? nullptr : name.c_str();
+}
+
+const char *Gosu_gamepad_name(int id)
+{
+    static thread_local std::string name;
+    name = Gosu::Input::gamepad_name(id);
+    return name.empty() ? nullptr : name.c_str();
+}
+
+double Gosu_axis(int btn)
+{
+    return Gosu::Input::axis((Gosu::Button)btn);
+}
+
+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/Graphics.cpp

@@ -287,7 +287,9 @@ Gosu::Image Gosu::Graphics::render(int width, int height, const function<void ()
 
     // This is the actual render-to-texture step.
     Image result = OffScreenTarget(width, height, image_flags).render([&] {
+#ifndef GOSU_IS_OPENGLES
         glPushAttrib(GL_ALL_ATTRIB_BITS);
+#endif
         glClearColor(0, 0, 0, 0);
         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
         glEnable(GL_BLEND);
@@ -296,7 +298,9 @@ Gosu::Image Gosu::Graphics::render(int width, int height, const function<void ()
         queues.back().perform_draw_ops_and_code();
         queues.pop_back();
         glFlush();
+#ifndef GOSU_IS_OPENGLES
         glPopAttrib();
+#endif
     });
     
     // Restore previous matrix and glViewport.
@@ -434,7 +438,7 @@ unique_ptr<Gosu::ImageData> Gosu::Graphics::create_image(const Bitmap& src,
         }
         else {
             Bitmap bmp(src_width, src_height);
-            bmp.insert(src, 0, 0, src_x, src_y, src_width, src_height);
+            bmp.insert(0, 0, src, src_x, src_y, src_width, src_height);
             data = texture->try_alloc(bmp, 0);
         }
         
@@ -445,14 +449,13 @@ unique_ptr<Gosu::ImageData> Gosu::Graphics::create_image(const Bitmap& src,
     // Too large to fit on a single texture.
     if (src_width > max_size - 2 || src_height > max_size - 2) {
         Bitmap bmp(src_width, src_height);
-        bmp.insert(src, 0, 0, src_x, src_y, src_width, src_height);
+        bmp.insert(0, 0, src, src_x, src_y, src_width, src_height);
         unique_ptr<ImageData> lidi;
         lidi.reset(new LargeImageData(bmp, max_size - 2, max_size - 2, flags));
         return lidi;
     }
     
-    Bitmap bmp;
-    apply_border_flags(bmp, src, src_x, src_y, src_width, src_height, flags);
+    Bitmap bmp = apply_border_flags(flags, src, src_x, src_y, src_width, src_height);
 
     // Try to put the bitmap into one of the already allocated textures.
     for (const auto& texture : textures) {

data/src/Image.cpp

@@ -13,32 +13,30 @@ Gosu::Image::Image()
 {
 }
 
-Gosu::Image::Image(const string& filename, unsigned flags)
+Gosu::Image::Image(const string& filename, unsigned image_flags)
 {
     // Forward.
-    Bitmap bmp;
-    load_image_file(bmp, filename);
-    Image(bmp, flags).data_.swap(data_);
+    Bitmap bitmap = load_image_file(filename);
+    Image{bitmap, image_flags}.data_.swap(data_);
 }
 
-Gosu::Image::Image(const string& filename, unsigned src_x, unsigned src_y,
-                   unsigned src_width, unsigned src_height, unsigned flags)
+Gosu::Image::Image(const string& filename, int src_x, int src_y, int src_width, int src_height,
+                   unsigned image_flags)
 {
     // Forward.
-    Bitmap bmp;
-    load_image_file(bmp, filename);
-    Image(bmp, src_x, src_y, src_width, src_height, flags).data_.swap(data_);
+    Bitmap bitmap = load_image_file(filename);
+    Image{bitmap, src_x, src_y, src_width, src_height, image_flags}.data_.swap(data_);
 }
 
-Gosu::Image::Image(const Bitmap& source, unsigned flags)
+Gosu::Image::Image(const Bitmap& source, unsigned image_flags)
 {
     // Forward.
-    Image(source, 0, 0, source.width(), source.height(), flags).data_.swap(data_);
+    Image{source, 0, 0, source.width(), source.height(), image_flags}.data_.swap(data_);
 }
 
-Gosu::Image::Image(const Bitmap& source, unsigned src_x, unsigned src_y,
-                   unsigned src_width, unsigned src_height, unsigned flags)
-: data_(Graphics::create_image(source, src_x, src_y, src_width, src_height, flags))
+Gosu::Image::Image(const Bitmap& source, int src_x, int src_y, int src_width, int src_height,
+                   unsigned image_flags)
+: data_(Graphics::create_image(source, src_x, src_y, src_width, src_height, image_flags))
 {
 }
 
@@ -141,7 +139,6 @@ vector<Gosu::Image> Gosu::load_tiles(const Bitmap& bmp, int tile_width, int tile
 vector<Gosu::Image> Gosu::load_tiles(const string& filename, int tile_width, int tile_height,
                                      unsigned flags)
 {
-    Bitmap bmp;
-    load_image_file(bmp, filename);
+    Bitmap bmp = load_image_file(filename);
     return load_tiles(bmp, tile_width, tile_height, flags);
 }

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