gosu 1.4.6 → 2.0.0.pre6

data/ffi/Gosu_Image.cpp

@@ -0,0 +1,206 @@
+#include "Gosu_FFI_internal.h"
+#include <cstring> // for std::memcpy
+
+GOSU_FFI_API Gosu_Image* Gosu_Image_create(const char* filename, unsigned image_flags)
+{
+    return Gosu_translate_exceptions([=] {
+        return new Gosu_Image{Gosu::Image{filename, image_flags}};
+    });
+}
+
+GOSU_FFI_API 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)
+{
+    return Gosu_translate_exceptions([=] {
+        Gosu::Bitmap bitmap = Gosu::layout_markup(markup, font, font_height, spacing, width,
+                                                  static_cast<Gosu::Alignment>(align), font_flags);
+        return new Gosu_Image{Gosu::Image{bitmap, image_flags}};
+    });
+}
+
+GOSU_FFI_API 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)
+{
+    return Gosu_translate_exceptions([=] {
+        Gosu::Bitmap bitmap = Gosu::layout_text(text, font, font_height, spacing, width,
+                                                static_cast<Gosu::Alignment>(align), font_flags);
+        return new Gosu_Image{Gosu::Image{bitmap, image_flags}};
+    });
+}
+
+GOSU_FFI_API Gosu_Image* Gosu_Image_create_from_blob(void* blob, int byte_count, int columns,
+                                                     int rows, unsigned image_flags)
+{
+    return Gosu_translate_exceptions([=] {
+        std::size_t size = columns * rows * 4;
+        Gosu::Bitmap bitmap{columns, rows};
+
+        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 - for Texplay compatibility.
+            const float* in = static_cast<const float*>(blob);
+            Gosu::Color::Channel* out = reinterpret_cast<Gosu::Color::Channel*>(bitmap.data());
+            for (std::size_t i = 0; i < size; ++i) {
+                out[i] = static_cast<Gosu::Color::Channel>(in[i] * 255);
+            }
+        }
+        else {
+            throw std::invalid_argument{"Invalid byte_count " + std::to_string(byte_count) +
+                                        "for image of size " + std::to_string(columns) + "x" +
+                                        std::to_string(rows)};
+        }
+
+        return new Gosu_Image{Gosu::Image{bitmap, image_flags}};
+    });
+}
+
+GOSU_FFI_API Gosu_Image* Gosu_Image_create_from_subimage(Gosu_Image* image, int left, int top,
+                                                         int width, int height)
+{
+    return Gosu_translate_exceptions([=]() -> Gosu_Image* {
+        std::unique_ptr<Gosu::Drawable> drawable
+            = image->image.drawable().subimage(Gosu::Rect { left, top, width, height });
+
+        if (! drawable) return nullptr;
+
+        return new Gosu_Image{Gosu::Image{std::move(drawable)}};
+    });
+}
+
+GOSU_FFI_API void Gosu_Image_create_from_tiles(const char* source, int tile_width, int tile_height,
+                                               void function(void*, Gosu_Image*), void* data,
+                                               unsigned image_flags)
+{
+    Gosu_translate_exceptions([=] {
+        std::vector<Gosu::Image> gosu_images =
+            Gosu::load_tiles(source, tile_width, tile_height, image_flags);
+
+        for (Gosu::Image& img : gosu_images) {
+            function(data, new Gosu_Image{img});
+        }
+    });
+}
+
+GOSU_FFI_API void Gosu_Image_create_tiles_from_image(Gosu_Image* image, int tile_width,
+                                                     int tile_height,
+                                                     void function(void*, Gosu_Image*), void* data,
+                                                     unsigned image_flags)
+{
+    Gosu_translate_exceptions([=] {
+        std::vector<Gosu::Image> gosu_images = Gosu::load_tiles(
+            image->image.drawable().to_bitmap(), tile_width, tile_height, image_flags);
+
+        for (Gosu::Image& img : gosu_images) {
+            function(data, new Gosu_Image{img});
+        }
+    });
+}
+
+GOSU_FFI_API void Gosu_Image_destroy(Gosu_Image* image)
+{
+    delete image;
+}
+
+// Properties
+
+GOSU_FFI_API unsigned Gosu_Image_width(Gosu_Image* image)
+{
+    return Gosu_translate_exceptions([=] {
+        return image->image.width();
+    });
+}
+
+GOSU_FFI_API unsigned Gosu_Image_height(Gosu_Image* image)
+{
+    return Gosu_translate_exceptions([=] {
+        return image->image.height();
+    });
+}
+
+GOSU_FFI_API Gosu_GLTexInfo* Gosu_Image_gl_tex_info_create(Gosu_Image* image)
+{
+    return Gosu_translate_exceptions([=]() -> Gosu_GLTexInfo* {
+        const Gosu::GLTexInfo* info = image->image.drawable().gl_tex_info();
+        if (!info) {
+            return nullptr;
+        }
+        return new Gosu_GLTexInfo {
+            .tex_name = info->tex_name,
+            .left = info->left,
+            .right = info->right,
+            .top = info->top,
+            .bottom = info->bottom,
+        };
+    });
+}
+
+GOSU_FFI_API void Gosu_Image_gl_tex_info_destroy(Gosu_GLTexInfo* gl_tex_info)
+{
+    Gosu_translate_exceptions([=] {
+        delete reinterpret_cast<Gosu::GLTexInfo*>(gl_tex_info);
+    });
+}
+
+// Rendering
+
+GOSU_FFI_API void Gosu_Image_draw(Gosu_Image* image, double x, double y, double z, double scale_x,
+                                  double scale_y, unsigned color, unsigned mode)
+{
+    Gosu_translate_exceptions([=] {
+        image->image.draw(x, y, z, scale_x, scale_y, color, static_cast<Gosu::BlendMode>(mode));
+    });
+}
+
+GOSU_FFI_API 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)
+{
+    Gosu_translate_exceptions([=] {
+        image->image.draw_rot(x, y, z, angle, center_x, center_y, scale_x, scale_y, color,
+                              static_cast<Gosu::BlendMode>(mode));
+    });
+}
+
+GOSU_FFI_API 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_translate_exceptions([=] {
+        image->image.drawable().draw(x1, y1, color1, x2, y2, color2, x3, y3, color3, x4, y4, color4, z,
+                                 static_cast<Gosu::BlendMode>(mode));
+    });
+}
+
+// Image operations
+
+GOSU_FFI_API void Gosu_Image_insert(Gosu_Image* image, Gosu_Image* source, int x, int y)
+{
+    Gosu_translate_exceptions([=] {
+        Gosu::Bitmap bitmap = source->image.drawable().to_bitmap();
+        image->image.drawable().insert(bitmap, x, y);
+    });
+}
+
+GOSU_FFI_API uint8_t* Gosu_Image_to_blob(Gosu_Image* image)
+{
+    static thread_local Gosu::Bitmap bitmap;
+    return Gosu_translate_exceptions([=] {
+        bitmap = image->image.drawable().to_bitmap();
+        return reinterpret_cast<uint8_t*>(bitmap.data());
+    });
+}
+
+GOSU_FFI_API void Gosu_Image_save(Gosu_Image* image, const char* filename)
+{
+    Gosu_translate_exceptions([=] {
+        Gosu::save_image_file(image->image.drawable().to_bitmap(), filename);
+    });
+}

data/ffi/Gosu_Image.h

@@ -0,0 +1,60 @@
+#pragma once
+
+#include "Gosu_FFI.h"
+#include <stdint.h>
+
+typedef struct Gosu_Image Gosu_Image;
+
+typedef struct Gosu_GLTexInfo
+{
+    uint32_t tex_name;
+    double left, right, top, bottom;
+} Gosu_GLTexInfo;
+
+// Constructor
+GOSU_FFI_API Gosu_Image* Gosu_Image_create(const char* filename, unsigned image_flags);
+GOSU_FFI_API Gosu_Image* Gosu_Image_create_from_blob(void* blob, int byte_count, int width,
+                                                     int height, unsigned image_flags);
+GOSU_FFI_API 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_FFI_API 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_FFI_API Gosu_Image* Gosu_Image_create_from_subimage(Gosu_Image* source, int left, int top,
+                                                         int width, int height);
+
+GOSU_FFI_API 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);
+GOSU_FFI_API 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);
+
+// Destructor
+GOSU_FFI_API void Gosu_Image_destroy(Gosu_Image* image);
+
+// Image properties
+GOSU_FFI_API unsigned Gosu_Image_width(Gosu_Image* image);
+GOSU_FFI_API unsigned Gosu_Image_height(Gosu_Image* image);
+
+// Rendering
+GOSU_FFI_API void Gosu_Image_draw(Gosu_Image* image, double x, double y, double z, double scale_x,
+                                  double scale_y, unsigned color, unsigned mode);
+GOSU_FFI_API 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);
+GOSU_FFI_API 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);
+
+// Operations
+GOSU_FFI_API void Gosu_Image_insert(Gosu_Image* image, Gosu_Image* source, int x, int y);
+GOSU_FFI_API void Gosu_Image_save(Gosu_Image* image, const char* filename);
+GOSU_FFI_API uint8_t* Gosu_Image_to_blob(Gosu_Image* image);
+GOSU_FFI_API Gosu_GLTexInfo* Gosu_Image_gl_tex_info_create(Gosu_Image* image);
+GOSU_FFI_API void Gosu_Image_gl_tex_info_destroy(Gosu_GLTexInfo* tex_info);

data/ffi/Gosu_Sample.cpp

@@ -0,0 +1,29 @@
+#include "Gosu_FFI_internal.h"
+
+GOSU_FFI_API Gosu_Sample* Gosu_Sample_create(const char* filename)
+{
+    return Gosu_translate_exceptions([=] {
+        return new Gosu_Sample{Gosu::Sample{filename}};
+    });
+}
+
+GOSU_FFI_API void Gosu_Sample_destroy(Gosu_Sample* sample)
+{
+    delete sample;
+}
+
+GOSU_FFI_API Gosu_Channel* Gosu_Sample_play(Gosu_Sample* sample, double volume, double speed,
+                                            bool looping)
+{
+    return Gosu_translate_exceptions([=] {
+        return new Gosu_Channel{sample->sample.play(volume, speed, looping)};
+    });
+}
+
+GOSU_FFI_API Gosu_Channel* Gosu_Sample_play_pan(Gosu_Sample* sample, double pan, double volume,
+                                                double speed, bool looping)
+{
+    return Gosu_translate_exceptions([=] {
+        return new Gosu_Channel{sample->sample.play_pan(pan, volume, speed, looping)};
+    });
+}

data/ffi/Gosu_Sample.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "Gosu_Channel.h"
+#include "Gosu_FFI.h"
+
+typedef struct Gosu_Sample Gosu_Sample;
+
+GOSU_FFI_API Gosu_Sample* Gosu_Sample_create(const char* filename);
+GOSU_FFI_API void Gosu_Sample_destroy(Gosu_Sample* sample);
+
+GOSU_FFI_API Gosu_Channel* Gosu_Sample_play(Gosu_Sample* sample, double volume, double speed,
+                                            bool looping);
+GOSU_FFI_API Gosu_Channel* Gosu_Sample_play_pan(Gosu_Sample* sample, double pan, double volume,
+                                                double speed, bool looping);

data/ffi/Gosu_Song.cpp

@@ -0,0 +1,69 @@
+#include "Gosu_FFI_internal.h"
+
+GOSU_FFI_API Gosu_Song* Gosu_Song_create(const char* filename)
+{
+    return Gosu_translate_exceptions([=] {
+        return new Gosu_Song{filename};
+    });
+}
+
+GOSU_FFI_API void Gosu_Song_destroy(Gosu_Song* song)
+{
+    delete song;
+}
+
+GOSU_FFI_API void Gosu_Song_play(Gosu_Song* song, bool looping)
+{
+    Gosu_translate_exceptions([=] {
+        song->play(looping);
+    });
+}
+
+GOSU_FFI_API bool Gosu_Song_playing(Gosu_Song* song)
+{
+    return Gosu_translate_exceptions([=] {
+        return song->playing();
+    });
+}
+
+GOSU_FFI_API void Gosu_Song_pause(Gosu_Song* song)
+{
+    Gosu_translate_exceptions([=] {
+        song->pause();
+    });
+}
+
+GOSU_FFI_API bool Gosu_Song_paused(Gosu_Song* song)
+{
+    return Gosu_translate_exceptions([=] {
+        return song->paused();
+    });
+}
+
+GOSU_FFI_API void Gosu_Song_stop(Gosu_Song* song)
+{
+    Gosu_translate_exceptions([=] {
+        song->stop();
+    });
+}
+
+GOSU_FFI_API double Gosu_Song_volume(Gosu_Song* song)
+{
+    return Gosu_translate_exceptions([=] {
+        return song->volume();
+    });
+}
+
+GOSU_FFI_API void Gosu_Song_set_volume(Gosu_Song* song, double volume)
+{
+    Gosu_translate_exceptions([=] {
+        return song->set_volume(volume);
+    });
+}
+
+GOSU_FFI_API Gosu_Song* Gosu_Song_current_song(void)
+{
+    return Gosu_translate_exceptions([=] {
+        return reinterpret_cast<Gosu_Song*>(Gosu::Song::current_song());
+    });
+}

data/ffi/Gosu_Song.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "Gosu_FFI.h"
+
+typedef struct Gosu_Song Gosu_Song;
+
+GOSU_FFI_API Gosu_Song* Gosu_Song_create(const char* filename);
+GOSU_FFI_API void Gosu_Song_destroy(Gosu_Song* song);
+
+GOSU_FFI_API void Gosu_Song_pause(Gosu_Song* song);
+GOSU_FFI_API bool Gosu_Song_paused(Gosu_Song* song);
+GOSU_FFI_API void Gosu_Song_play(Gosu_Song* song, bool looping);
+GOSU_FFI_API bool Gosu_Song_playing(Gosu_Song* song);
+GOSU_FFI_API void Gosu_Song_stop(Gosu_Song* song);
+GOSU_FFI_API double Gosu_Song_volume(Gosu_Song* song);
+GOSU_FFI_API void Gosu_Song_set_volume(Gosu_Song* song, double volume);
+
+GOSU_FFI_API Gosu_Song* Gosu_Song_current_song(void);

data/ffi/Gosu_TextInput.cpp

@@ -0,0 +1,94 @@
+#include "Gosu_FFI_internal.h"
+
+GOSU_FFI_API Gosu_TextInput* Gosu_TextInput_create()
+{
+    return Gosu_translate_exceptions([=] {
+        return new Gosu_TextInput{};
+    });
+}
+
+GOSU_FFI_API void Gosu_TextInput_destroy(Gosu_TextInput* text_input)
+{
+    delete text_input;
+}
+
+GOSU_FFI_API const char* Gosu_TextInput_text(Gosu_TextInput* text_input)
+{
+    static thread_local std::string text;
+
+    return Gosu_translate_exceptions([=] {
+        text = text_input->text();
+        return text.c_str();
+    });
+}
+
+GOSU_FFI_API void Gosu_TextInput_set_text(Gosu_TextInput* text_input, const char* text)
+{
+    Gosu_translate_exceptions([=] {
+        text_input->set_text(text);
+    });
+}
+
+GOSU_FFI_API int Gosu_TextInput_caret_pos(Gosu_TextInput* text_input)
+{
+    return Gosu_translate_exceptions([=] {
+        return text_input->caret_pos();
+    });
+}
+
+GOSU_FFI_API void Gosu_TextInput_set_caret_pos(Gosu_TextInput* text_input, int pos)
+{
+    Gosu_translate_exceptions([=] {
+        text_input->set_caret_pos(pos);
+    });
+}
+
+GOSU_FFI_API int Gosu_TextInput_selection_start(Gosu_TextInput* text_input)
+{
+    return Gosu_translate_exceptions([=] {
+        return text_input->selection_start();
+    });
+}
+
+GOSU_FFI_API void Gosu_TextInput_set_selection_start(Gosu_TextInput* text_input, int pos)
+{
+    Gosu_translate_exceptions([=] {
+        text_input->set_selection_start(pos);
+    });
+}
+
+GOSU_FFI_API void Gosu_TextInput_set_filter(Gosu_TextInput* text_input,
+                                            void function(void*, const char*), void* data)
+{
+    Gosu_translate_exceptions([=] {
+        text_input->filter_callback = [=](const char* text) { function(data, text); };
+    });
+}
+
+GOSU_FFI_API void Gosu_TextInput_set_filter_result(Gosu_TextInput* text_input, const char* result)
+{
+    Gosu_translate_exceptions([=] {
+        text_input->filter_result = result;
+    });
+}
+
+GOSU_FFI_API void Gosu_TextInput_insert_text(Gosu_TextInput* text_input, const char* text)
+{
+    Gosu_translate_exceptions([=] {
+        text_input->insert_text(text);
+    });
+}
+
+GOSU_FFI_API void Gosu_TextInput_delete_backward(Gosu_TextInput* text_input)
+{
+    Gosu_translate_exceptions([=] {
+        text_input->delete_backward();
+    });
+}
+
+GOSU_FFI_API void Gosu_TextInput_delete_forward(Gosu_TextInput* text_input)
+{
+    Gosu_translate_exceptions([=] {
+        text_input->delete_forward();
+    });
+}

data/ffi/Gosu_TextInput.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "Gosu_FFI.h"
+
+typedef struct Gosu_TextInput Gosu_TextInput;
+
+GOSU_FFI_API Gosu_TextInput* Gosu_TextInput_create(void);
+GOSU_FFI_API void Gosu_TextInput_destroy(Gosu_TextInput* text_input);
+
+GOSU_FFI_API const char* Gosu_TextInput_text(Gosu_TextInput* text_input);
+GOSU_FFI_API void Gosu_TextInput_set_text(Gosu_TextInput* text_input, const char* text);
+
+GOSU_FFI_API int Gosu_TextInput_caret_pos(Gosu_TextInput* text_input);
+GOSU_FFI_API void Gosu_TextInput_set_caret_pos(Gosu_TextInput* text_input, int pos);
+
+GOSU_FFI_API int Gosu_TextInput_selection_start(Gosu_TextInput* text_input);
+GOSU_FFI_API void Gosu_TextInput_set_selection_start(Gosu_TextInput* text_input, int pos);
+
+GOSU_FFI_API void Gosu_TextInput_set_filter(Gosu_TextInput* text_input,
+                                            void function(void* data, const char* text),
+                                            void* data);
+GOSU_FFI_API void Gosu_TextInput_set_filter_result(Gosu_TextInput* text_input, const char* result);
+GOSU_FFI_API void Gosu_TextInput_insert_text(Gosu_TextInput* text_input, const char* text);
+GOSU_FFI_API void Gosu_TextInput_delete_backward(Gosu_TextInput* text_input);
+GOSU_FFI_API void Gosu_TextInput_delete_forward(Gosu_TextInput* text_input);