gosu 0.14.5 → 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/Graphics.cpp

@@ -68,7 +68,7 @@ struct Gosu::Graphics::Impl
     {
         glPushAttrib(GL_ALL_ATTRIB_BITS);
         glDisable(GL_BLEND);
-        // Reset the colour to white to avoid surprises.
+        // Reset the color to white to avoid surprises.
         // https://www.libgosu.org/cgi-bin/mwf/topic_show.pl?pid=9115#pid9115
         glColor4ubv(reinterpret_cast<const GLubyte*>(&Color::WHITE));
         while (glGetError() != GL_NO_ERROR);
@@ -287,13 +287,16 @@ 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([&] {
+        glPushAttrib(GL_ALL_ATTRIB_BITS);
         glClearColor(0, 0, 0, 0);
         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+        glEnable(GL_BLEND);
         queues.emplace_back(QM_RENDER_TO_TEXTURE);
         f();
         queues.back().perform_draw_ops_and_code();
         queues.pop_back();
         glFlush();
+        glPopAttrib();
     });
     
     // Restore previous matrix and glViewport.

data/src/GraphicsImpl.hpp

@@ -110,7 +110,6 @@ namespace Gosu
     void ensure_current_context();
     
     inline std::string escape_markup(const std::string& text) {
-        // Escape all markup and delegate to layout_markup.
         auto markup = text;
         for (std::string::size_type pos = 0; pos < markup.length(); ++pos) {
             if (markup[pos] == '&') {

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/MarkupParser.cpp

@@ -119,17 +119,25 @@ bool Gosu::MarkupParser::parse_markup()
 
 bool Gosu::MarkupParser::parse_escape_entity()
 {
+    auto translate_to = [this](char ch) {
+        if (word_state == ADDING_WHITESPACE) {
+            flush_to_consumer();
+            word_state = ADDING_WORD;
+        }
+        add_composed_substring(u32string(1, ch));
+    };
+    
     // These are not entities (images) but escapes for markup characters.
     if (match_and_skip("<")) {
-        add_composed_substring(u32string(1, '<'));
+        translate_to('<');
         return true;
     }
     if (match_and_skip("&gt;")) {
-        add_composed_substring(u32string(1, '>'));
+        translate_to('>');
         return true;
     }
     if (match_and_skip("&amp;")) {
-        add_composed_substring(u32string(1, '&'));
+        translate_to('&');
         return true;
     }