sfml3-rb 0.0.1 → 0.2.2

data/ext/ext.c

@@ -1,20 +1,72 @@
 #include <ruby.h>
 #include <stdio.h>
 
-#include "ext/module.h"
-#include "ext/module/transform.h"
-#include "ext/module/drawable/drawable.h"
-#include "ext/klass/color.h"
-#include "ext/klass/transformable.h"
-#include <ext/klass/clock.h>
-#include <ext/klass/target.h>
-#include "ext/klass/render_state.h"
-#include "ext/klass/event.h"
-#include "ext/klass/window.h"
-#include "ext/klass/view.h"
-#include "ext/klass/video_mode.h"
-#include "ext/klass/drawable/circle.h"
-
+#include "core/macros.h"
+#include "core/foreign_thread.h"
+#include "system/vec2.h"
+#include "system/vec3.h"
+#include "system/time.h"
+#include "graphics/transform.h"
+#include "graphics/drawable.h"
+#include "graphics/color.h"
+#include "graphics/rect.h"
+#include "graphics/blend_mode.h"
+#include "graphics/stencil_mode.h"
+#include "graphics/image.h"
+#include "graphics/texture.h"
+#include "graphics/transformable.h"
+#include "system/clock.h"
+#include "system/sleep.h"
+#include "system/buffer.h"
+#include "system/input_stream.h"
+#include "graphics/target.h"
+#include "graphics/render_state.h"
+#include "window/event.h"
+#include "window/window.h"
+#include "window/keyboard.h"
+#include "window/mouse.h"
+#include "window/joystick.h"
+#include "window/touch.h"
+#include "window/sensor.h"
+#include "window/clipboard.h"
+#include "window/cursor.h"
+#include "window/context_settings.h"
+#include "window/context.h"
+#include "window/vulkan.h"
+#include "graphics/view.h"
+#include "window/video_mode.h"
+#include "graphics/circle.h"
+#include "graphics/rectangle.h"
+#include "graphics/polygon.h"
+#include "graphics/shape.h"
+#include "graphics/sprite.h"
+#include "graphics/vertex.h"
+#include "graphics/vertex_array.h"
+#include "graphics/vertex_buffer.h"
+#include "graphics/glyph.h"
+#include "graphics/font.h"
+#include "graphics/text.h"
+#include "graphics/render_texture.h"
+#include "graphics/shader.h"
+#include "audio/effect_processor.h"
+#include "audio/audio_enums.h"
+#include "audio/sound_source_cone.h"
+#include "audio/listener.h"
+#include "audio/sound_buffer.h"
+#include "audio/sound.h"
+#include "audio/music.h"
+#include "audio/sound_stream.h"
+#include "audio/sound_buffer_recorder.h"
+#include "audio/sound_recorder.h"
+#include "network/network_enums.h"
+#include "network/ip_address.h"
+#include "network/packet.h"
+#include "network/tcp_socket.h"
+#include "network/tcp_listener.h"
+#include "network/udp_socket.h"
+#include "network/socket_selector.h"
+#include "network/http.h"
+#include "network/ftp.h"
 
 //  C Naming Convention:
 //
@@ -30,9 +82,25 @@
 //    Local variables     lower_case or lowerCase
 //    Global variables    g_lowerCase or g_lower_case (searchable by g_ prefix)
 
+static VALUE rb_mExt;
+
 void Init_sfml_ext(void) {
     rb_mExt = rb_define_module("SFML");
 
+    Init_ForeignThread();
+
+    Init_Vector2(rb_mExt);
+    Init_Vector3(rb_mExt);
+    Init_Time(rb_mExt);
+    Init_Sleep(rb_mExt);
+    Init_Buffer(rb_mExt);
+    Init_InputStream(rb_mExt);
+    Init_Color(rb_mExt);
+    Init_Rect(rb_mExt);
+    Init_BlendMode(rb_mExt);
+    Init_StencilMode(rb_mExt);
+    Init_Image(rb_mExt);
+    Init_Texture(rb_mExt);
     Init_Drawable(rb_mExt);
     Init_Transform(rb_mExt);
     Init_Transformable(rb_mExt);
@@ -40,8 +108,51 @@ void Init_sfml_ext(void) {
     Init_Target(rb_mExt);
     Init_RenderState(rb_mExt);
     Init_Circle(rb_mExt);
+    Init_RectangleShape(rb_mExt);
+    Init_ConvexShape(rb_mExt);
+    Init_Shape(rb_mExt);
+    Init_Sprite(rb_mExt);
+    Init_Vertex(rb_mExt);
+    Init_VertexArray(rb_mExt);
+    Init_VertexBuffer(rb_mExt);
+    Init_Glyph(rb_mExt);
+    Init_Font(rb_mExt);
+    Init_Text(rb_mExt);
+    Init_RenderTexture(rb_mExt);
+    Init_Shader(rb_mExt);
     Init_Event(rb_mExt);
     Init_VideoMode(rb_mExt);
     Init_View(rb_mExt);
     Init_Window(rb_mExt);
+    Init_Keyboard(rb_mExt);
+    Init_Mouse(rb_mExt);
+    Init_Joystick(rb_mExt);
+    Init_Touch(rb_mExt);
+    Init_Sensor(rb_mExt);
+    Init_Clipboard(rb_mExt);
+    Init_Cursor(rb_mExt);
+    Init_ContextSettings(rb_mExt);
+    Init_Context(rb_mExt);
+    Init_Vulkan(rb_mExt);
+
+    Init_EffectProcessor();
+    Init_AudioEnums(rb_mExt);
+    Init_SoundSourceCone(rb_mExt);
+    Init_Listener(rb_mExt);
+    Init_SoundBuffer(rb_mExt);
+    Init_Sound(rb_mExt);
+    Init_Music(rb_mExt);
+    Init_SoundStream(rb_mExt);
+    Init_SoundBufferRecorder(rb_mExt);
+    Init_SoundRecorder(rb_mExt);
+
+    Init_NetworkEnums(rb_mExt);
+    Init_IpAddress(rb_mExt);
+    Init_Packet(rb_mExt);
+    Init_TcpSocket(rb_mExt);
+    Init_TcpListener(rb_mExt);
+    Init_UdpSocket(rb_mExt);
+    Init_SocketSelector(rb_mExt);
+    Init_Http(rb_mExt);
+    Init_Ftp(rb_mExt);
 }

data/ext/extconf.rb

@@ -1,16 +1,42 @@
+# frozen_string_literal: true
+
 require 'mkmf'
 require_relative 'ports'
 
+# Warnings are on everywhere: a user's build log is the only diagnostic anyone
+# gets when an install fails on a platform we never tested.
+$CFLAGS = "#{$CFLAGS} -Wall -Wextra -Wno-unused-parameter"
+
+# Promoting them to errors is opt-in, and CI is the only caller. An unfamiliar
+# compiler at `gem install` time will warn about things this code cannot
+# predict, and a warning must never be what stops someone installing the gem.
+# SFML_STRICT=1 is what keeps the TypedData migration from regressing: going
+# back to Data_Wrap_Struct would reintroduce a deprecation warning and fail.
+$CFLAGS = "#{$CFLAGS} -Werror=deprecated-declarations" if ENV['SFML_STRICT']
+
 # Link order matters for static archives: CSFML depends on SFML, SFML depends
-# on FreeType, and all of them depend on the target's OS libraries. This
-# mirrors the INTERFACE_LINK_LIBRARIES that SFML's own CMake config exports.
+# on FreeType and the Ogg/Vorbis/FLAC codecs, and all of them depend on the
+# target's OS libraries. This mirrors the INTERFACE_LINK_LIBRARIES that SFML's
+# own CMake config exports. Within the codecs, vorbisfile/vorbisenc depend on
+# vorbis, which depends on ogg, and FLAC stands alone; all of them must follow
+# sfml-audio so the linker has already seen the references.
+#
+# These are named by full path rather than -l. mkmf puts the host's -L/usr/lib64
+# ahead of the ports prefix, so a plain -lfreetype resolves to the host's shared
+# library and the built extension silently gains a runtime dependency on it. A
+# full path to the .a is used as-is by every linker (GNU ld, mingw, ld64) and
+# cannot be shadowed.
 VENDORED_LIBS = %w[
-  csfml-graphics-s csfml-window-s csfml-system-s
-  sfml-graphics-s sfml-window-s sfml-system-s
+  csfml-graphics-s csfml-window-s csfml-system-s csfml-audio-s csfml-network-s
+  sfml-graphics-s sfml-window-s sfml-system-s sfml-audio-s sfml-network-s
   freetype
+  vorbisfile vorbisenc vorbis ogg
+  FLAC
 ].freeze
 
-SYSTEM_CSFML_LIBS = %w[csfml-graphics csfml-window csfml-system].freeze
+SYSTEM_CSFML_LIBS = %w[
+  csfml-graphics csfml-window csfml-system csfml-audio csfml-network
+].freeze
 
 def use_vendored_ports
   $INCFLAGS = "-I#{Ports.prefix}/include #{$INCFLAGS}"
@@ -27,7 +53,8 @@ def use_vendored_ports
   # static SFML archives ahead of it.
   $libs = [
     $libs,
-    *(VENDORED_LIBS + Ports.libs).map { |l| "-l#{l}" },
+    *VENDORED_LIBS.map { |l| File.join(Ports.prefix, 'lib', "lib#{l}.a") },
+    *Ports.libs.map { |l| "-l#{l}" },
     *Ports.cxx_runtime
   ].join(' ')
 end
@@ -81,4 +108,22 @@ C
   MSG
 end
 
+# The sources live in per-subsystem directories (core/, system/, window/,
+# graphics/) but mkmf only globs the top level of $srcdir, so the list has to be
+# handed to it. Objects still land flat in the build directory: mkmf derives
+# $objs from File.basename, and make finds each source through VPATH -- which is
+# why no mkdir rules are needed for the object tree.
+#
+# That flattening also means every .c basename must be unique across the whole
+# tree. mkmf enforces it, aborting with "source files duplication", so a
+# collision fails the build loudly rather than dropping a file.
+sources = Dir.glob("#{$srcdir}/**/*.c")
+$srcs = sources
+$VPATH.concat(
+  sources.map { |file| File.dirname(file) }
+         .uniq
+         .reject { |dir| dir == $srcdir }
+         .map { |dir| dir.sub(/\A#{Regexp.escape($srcdir)}/, '$(srcdir)') }
+)
+
 create_makefile 'sfml/sfml_ext'

data/ext/graphics/blend_mode.c

@@ -0,0 +1,261 @@
+#include "graphics/blend_mode.h"
+
+#include <ruby.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "core/exceptions.h"
+#include "core/macros.h"
+
+typedef struct {
+    sfBlendMode mode;
+} BlendMode;
+
+static VALUE rb_cBlendMode;
+
+static const char *factor_names[] = {
+    "zero", "one", "src_color", "one_minus_src_color", "dst_color",
+    "one_minus_dst_color", "src_alpha", "one_minus_src_alpha", "dst_alpha", "one_minus_dst_alpha"
+};
+
+static const char *equation_names[] = {
+    "add", "subtract", "reverse_subtract", "min", "max"
+};
+
+static void BlendMode_free(void *ptr) {
+    free(ptr);
+}
+
+static const rb_data_type_t BlendMode_data_type = {
+    .wrap_struct_name = "SFML::BlendMode",
+    .function = {.dmark = NULL, .dfree = BlendMode_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE BlendMode_wrap(sfBlendMode mode) {
+    BlendMode *ptr = malloc(sizeof(BlendMode));
+
+    ptr->mode = mode;
+
+    return TypedData_Wrap_Struct(rb_cBlendMode, &BlendMode_data_type, ptr);
+}
+
+static sfBlendFactor factor_from_rb(VALUE rb_factor) {
+    size_t i;
+
+    if (RB_INTEGER_TYPE_P(rb_factor)) {
+        return (sfBlendFactor) NUM2INT(rb_factor);
+    }
+
+    if (SYMBOL_P(rb_factor)) {
+        const char *name = rb_id2name(SYM2ID(rb_factor));
+
+        for (i = 0; i < sizeof(factor_names) / sizeof(factor_names[0]); i++) {
+            if (strcmp(name, factor_names[i]) == 0) {
+                return (sfBlendFactor) i;
+            }
+        }
+    }
+
+    rb_raise(rb_eArgError, "unknown blend factor");
+    return sfBlendFactorZero;
+}
+
+static sfBlendEquation equation_from_rb(VALUE rb_equation) {
+    size_t i;
+
+    if (RB_INTEGER_TYPE_P(rb_equation)) {
+        return (sfBlendEquation) NUM2INT(rb_equation);
+    }
+
+    if (SYMBOL_P(rb_equation)) {
+        const char *name = rb_id2name(SYM2ID(rb_equation));
+
+        for (i = 0; i < sizeof(equation_names) / sizeof(equation_names[0]); i++) {
+            if (strcmp(name, equation_names[i]) == 0) {
+                return (sfBlendEquation) i;
+            }
+        }
+    }
+
+    rb_raise(rb_eArgError, "unknown blend equation");
+    return sfBlendEquationAdd;
+}
+
+static VALUE BlendMode_new(int argc, VALUE *argv, VALUE klass) {
+    VALUE self;
+    BlendMode *ptr;
+    sfBlendMode mode = sfBlendAlpha;
+
+    if (argc == 6) {
+        mode = (sfBlendMode) {
+            factor_from_rb(argv[0]), factor_from_rb(argv[1]), equation_from_rb(argv[2]),
+            factor_from_rb(argv[3]), factor_from_rb(argv[4]), equation_from_rb(argv[5])
+        };
+    } else if (argc != 0) {
+        raise_invalid_arguments_excepted(6, argc);
+    }
+
+    ptr = malloc(sizeof(BlendMode));
+    ptr->mode = mode;
+
+    self = TypedData_Wrap_Struct(klass, &BlendMode_data_type, ptr);
+
+    return self;
+}
+
+static VALUE BlendMode_get_color_src_factor(VALUE self) {
+    return ID2SYM(rb_intern(factor_names[((BlendMode *) Get_BlendMode_Struct(self))->mode.colorSrcFactor]));
+}
+
+static VALUE BlendMode_get_color_dst_factor(VALUE self) {
+    return ID2SYM(rb_intern(factor_names[((BlendMode *) Get_BlendMode_Struct(self))->mode.colorDstFactor]));
+}
+
+static VALUE BlendMode_get_color_equation(VALUE self) {
+    return ID2SYM(rb_intern(equation_names[((BlendMode *) Get_BlendMode_Struct(self))->mode.colorEquation]));
+}
+
+static VALUE BlendMode_get_alpha_src_factor(VALUE self) {
+    return ID2SYM(rb_intern(factor_names[((BlendMode *) Get_BlendMode_Struct(self))->mode.alphaSrcFactor]));
+}
+
+static VALUE BlendMode_get_alpha_dst_factor(VALUE self) {
+    return ID2SYM(rb_intern(factor_names[((BlendMode *) Get_BlendMode_Struct(self))->mode.alphaDstFactor]));
+}
+
+static VALUE BlendMode_get_alpha_equation(VALUE self) {
+    return ID2SYM(rb_intern(equation_names[((BlendMode *) Get_BlendMode_Struct(self))->mode.alphaEquation]));
+}
+
+static VALUE BlendMode_set_color_src_factor(VALUE self, VALUE rb_value) {
+    ((BlendMode *) Get_BlendMode_Struct(self))->mode.colorSrcFactor = factor_from_rb(rb_value);
+    return rb_value;
+}
+
+static VALUE BlendMode_set_color_dst_factor(VALUE self, VALUE rb_value) {
+    ((BlendMode *) Get_BlendMode_Struct(self))->mode.colorDstFactor = factor_from_rb(rb_value);
+    return rb_value;
+}
+
+static VALUE BlendMode_set_color_equation(VALUE self, VALUE rb_value) {
+    ((BlendMode *) Get_BlendMode_Struct(self))->mode.colorEquation = equation_from_rb(rb_value);
+    return rb_value;
+}
+
+static VALUE BlendMode_set_alpha_src_factor(VALUE self, VALUE rb_value) {
+    ((BlendMode *) Get_BlendMode_Struct(self))->mode.alphaSrcFactor = factor_from_rb(rb_value);
+    return rb_value;
+}
+
+static VALUE BlendMode_set_alpha_dst_factor(VALUE self, VALUE rb_value) {
+    ((BlendMode *) Get_BlendMode_Struct(self))->mode.alphaDstFactor = factor_from_rb(rb_value);
+    return rb_value;
+}
+
+static VALUE BlendMode_set_alpha_equation(VALUE self, VALUE rb_value) {
+    ((BlendMode *) Get_BlendMode_Struct(self))->mode.alphaEquation = equation_from_rb(rb_value);
+    return rb_value;
+}
+
+static VALUE BlendMode_eql(VALUE self, VALUE rb_other) {
+    sfBlendMode a = ((BlendMode *) Get_BlendMode_Struct(self))->mode;
+    sfBlendMode b;
+
+    if (!rb_obj_is_kind_of(rb_other, rb_cBlendMode)) {
+        return Qfalse;
+    }
+
+    b = ((BlendMode *) Get_BlendMode_Struct(rb_other))->mode;
+
+    return BOOL2RB(a.colorSrcFactor == b.colorSrcFactor && a.colorDstFactor == b.colorDstFactor &&
+                   a.colorEquation == b.colorEquation && a.alphaSrcFactor == b.alphaSrcFactor &&
+                   a.alphaDstFactor == b.alphaDstFactor && a.alphaEquation == b.alphaEquation);
+}
+
+static void BlendMode_define_const(VALUE klass, const char *name, sfBlendMode mode) {
+    rb_define_const(klass, name, BlendMode_wrap(mode));
+}
+
+void Init_BlendMode(VALUE rb_module) {
+    rb_cBlendMode = rb_define_class_under(rb_module, "BlendMode", rb_cObject);
+
+    rb_define_singleton_method(rb_cBlendMode, "new", BlendMode_new, -1);
+
+    rb_define_method(rb_cBlendMode, "color_src_factor", BlendMode_get_color_src_factor, 0);
+    rb_define_method(rb_cBlendMode, "color_dst_factor", BlendMode_get_color_dst_factor, 0);
+    rb_define_method(rb_cBlendMode, "color_equation", BlendMode_get_color_equation, 0);
+    rb_define_method(rb_cBlendMode, "alpha_src_factor", BlendMode_get_alpha_src_factor, 0);
+    rb_define_method(rb_cBlendMode, "alpha_dst_factor", BlendMode_get_alpha_dst_factor, 0);
+    rb_define_method(rb_cBlendMode, "alpha_equation", BlendMode_get_alpha_equation, 0);
+
+    rb_define_method(rb_cBlendMode, "color_src_factor=", BlendMode_set_color_src_factor, 1);
+    rb_define_method(rb_cBlendMode, "color_dst_factor=", BlendMode_set_color_dst_factor, 1);
+    rb_define_method(rb_cBlendMode, "color_equation=", BlendMode_set_color_equation, 1);
+    rb_define_method(rb_cBlendMode, "alpha_src_factor=", BlendMode_set_alpha_src_factor, 1);
+    rb_define_method(rb_cBlendMode, "alpha_dst_factor=", BlendMode_set_alpha_dst_factor, 1);
+    rb_define_method(rb_cBlendMode, "alpha_equation=", BlendMode_set_alpha_equation, 1);
+
+    rb_define_method(rb_cBlendMode, "==", BlendMode_eql, 1);
+
+    BlendMode_define_const(rb_cBlendMode, "NONE", sfBlendNone);
+    BlendMode_define_const(rb_cBlendMode, "ALPHA", sfBlendAlpha);
+    BlendMode_define_const(rb_cBlendMode, "ADD", sfBlendAdd);
+    BlendMode_define_const(rb_cBlendMode, "MULTIPLY", sfBlendMultiply);
+    BlendMode_define_const(rb_cBlendMode, "MIN", sfBlendMin);
+    BlendMode_define_const(rb_cBlendMode, "MAX", sfBlendMax);
+}
+
+VALUE Get_Klass_BlendMode(void) {
+    return rb_cBlendMode;
+}
+
+void *Get_BlendMode_Struct(VALUE self) {
+    BlendMode *ptr;
+    TypedData_Get_Struct(self, BlendMode, &BlendMode_data_type, ptr);
+    return ptr;
+}
+
+sfBlendMode blend_mode_from_rb(VALUE rb_mode) {
+    if (rb_obj_is_kind_of(rb_mode, rb_cBlendMode)) {
+        return ((BlendMode *) Get_BlendMode_Struct(rb_mode))->mode;
+    }
+
+    if (RB_INTEGER_TYPE_P(rb_mode) == 0 && !SYMBOL_P(rb_mode)) {
+        raise_invalid_argument_class(rb_cBlendMode);
+    }
+
+    if (SYMBOL_P(rb_mode)) {
+        const char *name = rb_id2name(SYM2ID(rb_mode));
+
+        if (strcmp(name, "none") == 0) {
+            return sfBlendNone;
+        }
+
+        if (strcmp(name, "alpha") == 0) {
+            return sfBlendAlpha;
+        }
+
+        if (strcmp(name, "add") == 0) {
+            return sfBlendAdd;
+        }
+
+        if (strcmp(name, "multiply") == 0) {
+            return sfBlendMultiply;
+        }
+
+        if (strcmp(name, "min") == 0) {
+            return sfBlendMin;
+        }
+
+        if (strcmp(name, "max") == 0) {
+            return sfBlendMax;
+        }
+    }
+
+    return sfBlendAlpha;
+}
+
+VALUE blend_mode_to_rb(sfBlendMode mode) {
+    return BlendMode_wrap(mode);
+}

data/ext/graphics/blend_mode.h

@@ -0,0 +1,18 @@
+#ifndef SFML_RB_GRAPHICS_BLEND_MODE_H
+#define SFML_RB_GRAPHICS_BLEND_MODE_H
+
+#include <ruby.h>
+
+#include "core/sfml.h"
+
+void Init_BlendMode(VALUE rb_module);
+
+VALUE Get_Klass_BlendMode(void);
+
+void *Get_BlendMode_Struct(VALUE self);
+
+sfBlendMode blend_mode_from_rb(VALUE rb_mode);
+
+VALUE blend_mode_to_rb(sfBlendMode mode);
+
+#endif //SFML_RB_GRAPHICS_BLEND_MODE_H