gosu 1.4.6 → 2.0.0.pre6

data/ffi/Gosu.cpp

@@ -0,0 +1,307 @@
+#include <Gosu/Transform.hpp>
+#include "Gosu_FFI_internal.h"
+
+GOSU_FFI_API void Init_gosu()
+{
+}
+
+std::string& Gosu_internal_error()
+{
+    static thread_local std::string error;
+    return error;
+}
+
+GOSU_FFI_API const char* Gosu_last_error(void)
+{
+    return Gosu_internal_error().empty() ? nullptr : Gosu_internal_error().c_str();
+}
+
+GOSU_FFI_API void Gosu_gl_z(double z, void function(void*), void* data)
+{
+    Gosu_translate_exceptions([=] {
+        Gosu::gl(z, [=] { function(data); });
+    });
+}
+
+GOSU_FFI_API void Gosu_gl(void function(void*), void* data)
+{
+    Gosu_translate_exceptions([=] {
+        Gosu::gl([=] { function(data); });
+    });
+}
+
+GOSU_FFI_API Gosu_Image* Gosu_render(int width, int height, void function(void*), void* data,
+                                     unsigned image_flags)
+{
+    return Gosu_translate_exceptions([=] {
+        Gosu::Image image = Gosu::render(width, height, [=] { function(data); }, image_flags);
+        return new Gosu_Image{image};
+    });
+}
+
+GOSU_FFI_API Gosu_Image* Gosu_record(int width, int height, void function(void*), void* data)
+{
+    return Gosu_translate_exceptions([=] {
+        Gosu::Image image = Gosu::record(width, height, [=] { function(data); });
+        return new Gosu_Image{image};
+    });
+}
+
+GOSU_FFI_API void Gosu_flush(void)
+{
+    Gosu_translate_exceptions([=] {
+        Gosu::flush();
+    });
+}
+
+GOSU_FFI_API 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*), void* data)
+{
+    Gosu_translate_exceptions([=] {
+        Gosu::Transform transform = {m0, m1, m2,  m3,  m4,  m5,  m6,  m7,
+                                     m8, m9, m10, m11, m12, m13, m14, m15};
+        Gosu::transform(transform, [=] { function(data); });
+    });
+}
+
+GOSU_FFI_API void Gosu_translate(double x, double y, void function(void*), void* data)
+{
+    Gosu_translate_exceptions([=] {
+        Gosu::transform(Gosu::Transform::translate(x, y), [=] { function(data); });
+    });
+}
+
+GOSU_FFI_API void Gosu_scale(double scale_x, double scale_y, double around_x, double around_y,
+                             void function(void*), void* data)
+{
+    Gosu_translate_exceptions([=] {
+        Gosu::transform(Gosu::Transform::scale(scale_x, scale_y).around(around_x, around_y),
+            [=] { function(data); });
+    });
+}
+
+GOSU_FFI_API void Gosu_rotate(double angle, double around_x, double around_y, void function(void*),
+                              void* data)
+{
+    Gosu_translate_exceptions([=] {
+        Gosu::transform(Gosu::Transform::rotate(angle).around(around_x, around_y),
+                        [=] { function(data); });
+    });
+}
+
+GOSU_FFI_API void Gosu_clip_to(double x, double y, double width, double height,
+                               void function(void*), void* data)
+{
+    Gosu_translate_exceptions([=] {
+        Gosu::clip_to(x, y, width, height, [=] { function(data); });
+    });
+}
+
+GOSU_FFI_API void Gosu_draw_line(double x1, double y1, unsigned c1, double x2, double y2,
+                                 unsigned c2, double z, unsigned mode)
+{
+    Gosu_translate_exceptions([=] {
+        Gosu::draw_line(x1, y1, c1, x2, y2, c2, z, static_cast<Gosu::BlendMode>(mode));
+    });
+}
+
+GOSU_FFI_API 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_translate_exceptions([=] {
+        Gosu::draw_triangle(x1, y1, c1, x2, y2, c2, x3, y3, c3, z,
+                            static_cast<Gosu::BlendMode>(mode));
+    });
+}
+
+GOSU_FFI_API void Gosu_draw_rect(double x, double y, double width, double height, unsigned c,
+                                 double z, unsigned mode)
+{
+    Gosu_translate_exceptions([=] {
+        Gosu::draw_rect(x, y, width, height, c, z, static_cast<Gosu::BlendMode>(mode));
+    });
+}
+
+GOSU_FFI_API 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_translate_exceptions([=] {
+        Gosu::draw_quad(x1, y1, c1, x2, y2, c2, x3, y3, c3, x4, y4, c4, z,
+                        static_cast<Gosu::BlendMode>(mode));
+    });
+}
+
+GOSU_FFI_API double Gosu_distance(double x1, double y1, double x2, double y2)
+{
+    return Gosu_translate_exceptions([=] {
+        return Gosu::distance(x1, y1, x2, y2);
+    });
+}
+
+GOSU_FFI_API double Gosu_angle(double from_x, double from_y, double to_x, double to_y)
+{
+    return Gosu_translate_exceptions([=] {
+        return Gosu::angle(from_x, from_y, to_x, to_y);
+    });
+}
+
+GOSU_FFI_API double Gosu_angle_diff(double from, double to)
+{
+    return Gosu_translate_exceptions([=] {
+        return Gosu::angle_diff(from, to);
+    });
+}
+
+GOSU_FFI_API double Gosu_offset_x(double angle, double radius)
+{
+    return Gosu_translate_exceptions([=] {
+        return Gosu::offset_x(angle, radius);
+    });
+}
+
+GOSU_FFI_API double Gosu_offset_y(double angle, double radius)
+{
+    return Gosu_translate_exceptions([=] {
+        return Gosu::offset_y(angle, radius);
+    });
+}
+
+GOSU_FFI_API double Gosu_random(double min, double max)
+{
+    return Gosu_translate_exceptions([=] {
+        return Gosu::random(min, max);
+    });
+}
+
+GOSU_FFI_API int Gosu_available_width(Gosu_Window* window)
+{
+    return Gosu_translate_exceptions([=] {
+        return Gosu::available_width(window);
+    });
+}
+
+GOSU_FFI_API int Gosu_available_height(Gosu_Window* window)
+{
+    return Gosu_translate_exceptions([=] {
+        return Gosu::available_height(window);
+    });
+}
+
+GOSU_FFI_API int Gosu_screen_width(Gosu_Window* window)
+{
+    return Gosu_translate_exceptions([=] {
+        return Gosu::screen_width(window);
+    });
+}
+
+GOSU_FFI_API int Gosu_screen_height(Gosu_Window* window)
+{
+    return Gosu_translate_exceptions([=] {
+        return Gosu::screen_height(window);
+    });
+}
+
+GOSU_FFI_API int Gosu_button_down(int id)
+{
+    return Gosu_translate_exceptions([=] {
+        return Gosu::Input::down(static_cast<Gosu::Button>(id));
+    });
+}
+
+GOSU_FFI_API const char* Gosu_button_id_to_char(int id)
+{
+    static thread_local std::string button;
+
+    return Gosu_translate_exceptions([=] {
+        button = Gosu::Input::id_to_char(static_cast<Gosu::Button>(id));
+        return button.c_str();
+    });
+}
+
+GOSU_FFI_API unsigned Gosu_button_char_to_id(const char* btn)
+{
+    return Gosu_translate_exceptions([=] {
+        return Gosu::Input::char_to_id(btn);
+    });
+}
+
+GOSU_FFI_API const char* Gosu_button_name(int id)
+{
+    static thread_local std::string name;
+
+    return Gosu_translate_exceptions([=] {
+        name = Gosu::Input::button_name(static_cast<Gosu::Button>(id));
+        return name.empty() ? nullptr : name.c_str();
+    });
+}
+
+GOSU_FFI_API const char* Gosu_gamepad_name(int id)
+{
+    static thread_local std::string name;
+
+    return Gosu_translate_exceptions([=] {
+        name = Gosu::Input::gamepad_name(id);
+        return name.empty() ? nullptr : name.c_str();
+    });
+}
+
+GOSU_FFI_API double Gosu_axis(int id)
+{
+    return Gosu_translate_exceptions([=] {
+        return Gosu::Input::axis(static_cast<Gosu::Button>(id));
+    });
+}
+
+GOSU_FFI_API const char* Gosu_clipboard()
+{
+    static thread_local std::string text;
+
+    return Gosu_translate_exceptions([=] {
+        text = Gosu::Input::clipboard();
+        return text.c_str();
+    });
+}
+
+GOSU_FFI_API void Gosu_set_clipboard(const char* text)
+{
+    Gosu_translate_exceptions([=] {
+        Gosu::Input::set_clipboard(text);
+    });
+}
+
+GOSU_FFI_API int Gosu_fps()
+{
+    return Gosu_translate_exceptions([=] {
+        return Gosu::fps();
+    });
+}
+
+GOSU_FFI_API void Gosu_user_languages(void function(void*, const char*), void* data)
+{
+    Gosu_translate_exceptions([=] {
+        for (const std::string& user_language : Gosu::user_languages()) {
+            function(data, user_language.c_str());
+        }
+    });
+}
+
+GOSU_FFI_API uint64_t Gosu_milliseconds()
+{
+    return Gosu_translate_exceptions([=] {
+        return Gosu::milliseconds();
+    });
+}
+
+GOSU_FFI_API const char* Gosu_default_font_name()
+{
+    static thread_local std::string name;
+
+    return Gosu_translate_exceptions([=] {
+        name = Gosu::default_font_name();
+        return name.c_str();
+    });
+}

data/ffi/Gosu.h

@@ -0,0 +1,84 @@
+#pragma once
+
+#include "Gosu_Channel.h"
+#include "Gosu_Color.h"
+#include "Gosu_FFI.h"
+#include "Gosu_Font.h"
+#include "Gosu_Image.h"
+#include "Gosu_Sample.h"
+#include "Gosu_Song.h"
+#include "Gosu_TextInput.h"
+#include "Gosu_Window.h"
+#include <stdint.h>
+
+// Error reporting
+GOSU_FFI_API const char* Gosu_last_error(void);
+
+// Graphics operations
+GOSU_FFI_API void Gosu_gl_z(double z, void function(void* data), void* data);
+GOSU_FFI_API void Gosu_gl(void function(void* data), void* data);
+GOSU_FFI_API void Gosu_flush(void);
+GOSU_FFI_API Gosu_Image* Gosu_render(int width, int height, void function(void* data), void* data,
+                                     unsigned image_flags);
+GOSU_FFI_API Gosu_Image* Gosu_record(int width, int height, void function(void* data), void* data);
+GOSU_FFI_API void Gosu_clip_to(double x, double y, double width, double height,
+                               void function(void* data), void* data);
+
+// Transformations
+GOSU_FFI_API 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_FFI_API void Gosu_translate(double x, double y, void function(void* data), void* data);
+GOSU_FFI_API void Gosu_scale(double scale_x, double scale_y, double around_x, double around_y,
+                             void function(void* data), void* data);
+GOSU_FFI_API void Gosu_rotate(double angle, double around_x, double around_y,
+                              void function(void* data), void* data);
+
+// Rendering
+GOSU_FFI_API void Gosu_draw_line(double x1, double y1, unsigned c1, double x2, double y2,
+                                 unsigned c2, double z, unsigned mode);
+GOSU_FFI_API 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_FFI_API void Gosu_draw_rect(double x, double y, double width, double height, unsigned c,
+                                 double z, unsigned mode);
+GOSU_FFI_API 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);
+
+// Math functions
+GOSU_FFI_API double Gosu_distance(double x1, double y1, double x2, double y2);
+
+GOSU_FFI_API double Gosu_angle(double from_x, double from_y, double to_x, double to_y);
+GOSU_FFI_API double Gosu_angle_diff(double from, double to);
+
+GOSU_FFI_API double Gosu_offset_x(double angle, double radius);
+GOSU_FFI_API double Gosu_offset_y(double angle, double radius);
+
+GOSU_FFI_API double Gosu_random(double min, double max);
+
+// Window/Screen information
+GOSU_FFI_API int Gosu_available_width(Gosu_Window* window);
+GOSU_FFI_API int Gosu_available_height(Gosu_Window* window);
+GOSU_FFI_API int Gosu_screen_width(Gosu_Window* window);
+GOSU_FFI_API int Gosu_screen_height(Gosu_Window* window);
+
+// Button querying
+GOSU_FFI_API int Gosu_button_down(int id);
+GOSU_FFI_API const char* Gosu_button_id_to_char(int id);
+GOSU_FFI_API unsigned Gosu_button_char_to_id(const char* character);
+GOSU_FFI_API const char* Gosu_button_name(int id);
+GOSU_FFI_API const char* Gosu_gamepad_name(int id);
+GOSU_FFI_API double Gosu_axis(int id);
+
+// Clipboard
+GOSU_FFI_API const char* Gosu_clipboard();
+GOSU_FFI_API void Gosu_set_clipboard(const char* text);
+
+// Misc
+GOSU_FFI_API int Gosu_fps(void);
+GOSU_FFI_API void Gosu_user_languages(void function(void* data, const char* language),
+                                      void* data);
+GOSU_FFI_API uint64_t Gosu_milliseconds(void);
+GOSU_FFI_API const char* Gosu_default_font_name(void);

data/ffi/Gosu_Channel.cpp

@@ -0,0 +1,62 @@
+#include "Gosu_FFI_internal.h"
+
+GOSU_FFI_API void Gosu_Channel_destroy(Gosu_Channel* channel)
+{
+    delete channel;
+}
+
+GOSU_FFI_API bool Gosu_Channel_playing(Gosu_Channel* channel)
+{
+    return Gosu_translate_exceptions([=] {
+        return channel->channel.playing();
+    });
+}
+
+GOSU_FFI_API void Gosu_Channel_pause(Gosu_Channel* channel)
+{
+    Gosu_translate_exceptions([=] {
+        channel->channel.pause();
+    });
+}
+
+GOSU_FFI_API bool Gosu_Channel_paused(Gosu_Channel* channel)
+{
+    return Gosu_translate_exceptions([=] {
+        return channel->channel.paused();
+    });
+}
+
+GOSU_FFI_API void Gosu_Channel_resume(Gosu_Channel* channel)
+{
+    Gosu_translate_exceptions([=] {
+        channel->channel.resume();
+    });
+}
+
+GOSU_FFI_API void Gosu_Channel_stop(Gosu_Channel* channel)
+{
+    Gosu_translate_exceptions([=] {
+        channel->channel.stop();
+    });
+}
+
+GOSU_FFI_API void Gosu_Channel_set_volume(Gosu_Channel* channel, double volume)
+{
+    Gosu_translate_exceptions([=] {
+        channel->channel.set_volume(volume);
+    });
+}
+
+GOSU_FFI_API void Gosu_Channel_set_speed(Gosu_Channel* channel, double speed)
+{
+    Gosu_translate_exceptions([=] {
+        channel->channel.set_speed(speed);
+    });
+}
+
+GOSU_FFI_API void Gosu_Channel_set_pan(Gosu_Channel* channel, double pan)
+{
+    Gosu_translate_exceptions([=] {
+        channel->channel.set_pan(pan);
+    });
+}

data/ffi/Gosu_Channel.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include "Gosu_FFI.h"
+
+typedef struct Gosu_Channel Gosu_Channel;
+
+GOSU_FFI_API void Gosu_Channel_destroy(Gosu_Channel* channel);
+
+GOSU_FFI_API bool Gosu_Channel_playing(Gosu_Channel* channel);
+GOSU_FFI_API void Gosu_Channel_pause(Gosu_Channel* channel);
+GOSU_FFI_API bool Gosu_Channel_paused(Gosu_Channel* channel);
+GOSU_FFI_API void Gosu_Channel_resume(Gosu_Channel* channel);
+GOSU_FFI_API void Gosu_Channel_stop(Gosu_Channel* channel);
+
+GOSU_FFI_API void Gosu_Channel_set_volume(Gosu_Channel* channel, double volume);
+GOSU_FFI_API void Gosu_Channel_set_speed(Gosu_Channel* channel, double speed);
+GOSU_FFI_API void Gosu_Channel_set_pan(Gosu_Channel* channel, double pan);

data/ffi/Gosu_Color.cpp

@@ -0,0 +1,132 @@
+#include "Gosu_FFI_internal.h"
+
+GOSU_FFI_API uint32_t Gosu_Color_create(uint32_t argb)
+{
+    return Gosu::Color{argb}.argb();
+}
+
+GOSU_FFI_API uint32_t Gosu_Color_create_argb(uint8_t a, uint8_t r, uint8_t g, uint8_t b)
+{
+    return Gosu::Color{r, g, b}.with_alpha(a).argb();
+}
+
+GOSU_FFI_API uint32_t Gosu_Color_create_from_hsv(double h, double s, double v)
+{
+    return Gosu::Color::from_hsv(h, s, v).argb();
+}
+
+GOSU_FFI_API uint32_t Gosu_Color_create_from_ahsv(uint8_t alpha, double h, double s, double v)
+{
+    return Gosu::Color::from_hsv(h, s, v).with_alpha(alpha).argb();
+}
+
+GOSU_FFI_API uint8_t Gosu_Color_alpha(uint32_t color)
+{
+    return Gosu::Color{color}.alpha;
+}
+
+GOSU_FFI_API uint8_t Gosu_Color_red(uint32_t color)
+{
+    return Gosu::Color{color}.red;
+}
+
+GOSU_FFI_API uint8_t Gosu_Color_green(uint32_t color)
+{
+    return Gosu::Color{color}.green;
+}
+
+GOSU_FFI_API uint8_t Gosu_Color_blue(uint32_t color)
+{
+    return Gosu::Color{color}.blue;
+}
+
+GOSU_FFI_API uint32_t Gosu_Color_set_alpha(uint32_t color, uint8_t value)
+{
+    Gosu::Color gosu_color{color};
+    gosu_color.alpha = value;
+
+    return gosu_color.argb();
+}
+
+GOSU_FFI_API uint32_t Gosu_Color_set_red(uint32_t color, uint8_t value)
+{
+    Gosu::Color gosu_color{color};
+    gosu_color.red = value;
+
+    return gosu_color.argb();
+}
+
+GOSU_FFI_API uint32_t Gosu_Color_set_green(uint32_t color, uint8_t value)
+{
+    Gosu::Color gosu_color{color};
+    gosu_color.green = value;
+
+    return gosu_color.argb();
+}
+
+GOSU_FFI_API uint32_t Gosu_Color_set_blue(uint32_t color, uint8_t value)
+{
+    Gosu::Color gosu_color{color};
+    gosu_color.blue = value;
+
+    return gosu_color.argb();
+}
+
+GOSU_FFI_API double Gosu_Color_hue(uint32_t color)
+{
+    return Gosu::Color{color}.hue();
+}
+
+GOSU_FFI_API double Gosu_Color_saturation(uint32_t color)
+{
+    return Gosu::Color{color}.saturation();
+}
+
+GOSU_FFI_API double Gosu_Color_value(uint32_t color)
+{
+    return Gosu::Color{color}.value();
+}
+
+GOSU_FFI_API uint32_t Gosu_Color_set_hue(uint32_t color, double value)
+{
+    Gosu::Color gosu_color{color};
+    gosu_color.set_hue(value);
+
+    return gosu_color.argb();
+}
+
+GOSU_FFI_API uint32_t Gosu_Color_set_saturation(uint32_t color, double value)
+{
+    Gosu::Color gosu_color{color};
+    gosu_color.set_saturation(value);
+
+    return gosu_color.argb();
+}
+
+GOSU_FFI_API uint32_t Gosu_Color_set_value(uint32_t color, double value)
+{
+    Gosu::Color gosu_color{color};
+    gosu_color.set_value(value);
+
+    return gosu_color.argb();
+}
+
+GOSU_FFI_API uint32_t Gosu_Color_argb(uint32_t color)
+{
+    return Gosu::Color{color}.argb();
+}
+
+GOSU_FFI_API uint32_t Gosu_Color_bgr(uint32_t color)
+{
+    return Gosu::Color{color}.bgr();
+}
+
+GOSU_FFI_API uint32_t Gosu_Color_abgr(uint32_t color)
+{
+    return Gosu::Color{color}.abgr();
+}
+
+GOSU_FFI_API uint32_t Gosu_Color_gl(uint32_t color)
+{
+    return color;
+}

data/ffi/Gosu_Color.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "Gosu_FFI.h"
+#include "stdint.h"
+
+GOSU_FFI_API uint32_t Gosu_Color_create(uint32_t argb);
+GOSU_FFI_API uint32_t Gosu_Color_create_argb(uint8_t a, uint8_t r, uint8_t g, uint8_t b);
+GOSU_FFI_API uint32_t Gosu_Color_create_from_hsv(double h, double s, double v);
+GOSU_FFI_API uint32_t Gosu_Color_create_from_ahsv(uint8_t alpha, double h, double s, double v);
+
+GOSU_FFI_API uint8_t Gosu_Color_alpha(uint32_t color);
+GOSU_FFI_API uint8_t Gosu_Color_red(uint32_t color);
+GOSU_FFI_API uint8_t Gosu_Color_green(uint32_t color);
+GOSU_FFI_API uint8_t Gosu_Color_blue(uint32_t color);
+GOSU_FFI_API uint32_t Gosu_Color_set_alpha(uint32_t color, uint8_t value);
+GOSU_FFI_API uint32_t Gosu_Color_set_red(uint32_t color, uint8_t value);
+GOSU_FFI_API uint32_t Gosu_Color_set_green(uint32_t color, uint8_t value);
+GOSU_FFI_API uint32_t Gosu_Color_set_blue(uint32_t color, uint8_t value);
+
+GOSU_FFI_API double Gosu_Color_hue(uint32_t color);
+GOSU_FFI_API double Gosu_Color_saturation(uint32_t color);
+GOSU_FFI_API double Gosu_Color_value(uint32_t color);
+GOSU_FFI_API uint32_t Gosu_Color_set_hue(uint32_t color, double value);
+GOSU_FFI_API uint32_t Gosu_Color_set_saturation(uint32_t color, double value);
+GOSU_FFI_API uint32_t Gosu_Color_set_value(uint32_t color, double value);
+
+GOSU_FFI_API uint32_t Gosu_Color_argb(uint32_t color);
+GOSU_FFI_API uint32_t Gosu_Color_bgr(uint32_t color);
+GOSU_FFI_API uint32_t Gosu_Color_abgr(uint32_t color);
+
+GOSU_FFI_API uint32_t Gosu_Color_gl(uint32_t color);