sfml3-rb 0.0.1 → 0.2.2

data/ext/network/tcp_socket.h

@@ -0,0 +1,17 @@
+#ifndef SFML_RB_NETWORK_TCP_SOCKET_H
+#define SFML_RB_NETWORK_TCP_SOCKET_H
+
+#include <ruby.h>
+
+#include "core/sfml.h"
+
+void Init_TcpSocket(VALUE rb_module);
+
+VALUE Get_Klass_TcpSocket(void);
+
+void *Get_TcpSocket_Struct(VALUE self);
+
+/* Wraps a socket returned by sfTcpListener_accept, taking ownership. */
+VALUE tcp_socket_from_handle(sfTcpSocket *socket);
+
+#endif //SFML_RB_NETWORK_TCP_SOCKET_H

data/ext/network/udp_socket.c

@@ -0,0 +1,190 @@
+#include "network/udp_socket.h"
+
+#include <ruby.h>
+#include <stdlib.h>
+
+#include "core/macros.h"
+#include "network/ip_address.h"
+#include "network/network_enums.h"
+#include "network/packet.h"
+
+typedef struct {
+    sfUdpSocket *handle;
+} UdpSocket;
+
+static VALUE rb_cUdpSocket;
+
+static void UdpSocket_free(void *ptr) {
+    UdpSocket *socket = ptr;
+
+    if (socket->handle != NULL) {
+        sfUdpSocket_destroy(socket->handle);
+    }
+
+    free(socket);
+}
+
+static const rb_data_type_t UdpSocket_data_type = {
+    .wrap_struct_name = "SFML::UdpSocket",
+    .function = {.dmark = NULL, .dfree = UdpSocket_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE UdpSocket_wrap(VALUE klass, sfUdpSocket *handle) {
+    UdpSocket *ptr;
+
+    if (handle == NULL) {
+        rb_raise(rb_eRuntimeError, "failed to create UDP socket");
+    }
+
+    ptr = malloc(sizeof(UdpSocket));
+    ptr->handle = handle;
+
+    return TypedData_Wrap_Struct(klass, &UdpSocket_data_type, ptr);
+}
+
+static VALUE UdpSocket_new(VALUE klass) {
+    return UdpSocket_wrap(klass, sfUdpSocket_create());
+}
+
+static VALUE UdpSocket_any_port(VALUE klass) {
+    return UINT2NUM(sfUdpSocket_anyPort());
+}
+
+static VALUE UdpSocket_max_datagram_size(VALUE klass) {
+    return UINT2NUM(sfUdpSocket_maxDatagramSize());
+}
+
+static VALUE UdpSocket_blocking(VALUE self) {
+    return BOOL2RB(sfUdpSocket_isBlocking(Get_UdpSocket_Struct(self)));
+}
+
+static VALUE UdpSocket_set_blocking(VALUE self, VALUE rb_value) {
+    sfUdpSocket_setBlocking(Get_UdpSocket_Struct(self), RTEST(rb_value));
+    return rb_value;
+}
+
+static VALUE UdpSocket_local_port(VALUE self) {
+    return UINT2NUM(sfUdpSocket_getLocalPort(Get_UdpSocket_Struct(self)));
+}
+
+static VALUE UdpSocket_bind(int argc, VALUE *argv, VALUE self) {
+    VALUE rb_port, rb_address;
+
+    rb_scan_args(argc, argv, "11", &rb_port, &rb_address);
+
+    return ID2SYM(rb_intern(socket_status_name(sfUdpSocket_bind(
+        Get_UdpSocket_Struct(self), (unsigned short) NUM2INT(rb_port),
+        ip_address_from_rb(rb_address, sfIpAddress_Any)))));
+}
+
+static VALUE UdpSocket_unbind(VALUE self) {
+    sfUdpSocket_unbind(Get_UdpSocket_Struct(self));
+    return self;
+}
+
+static VALUE UdpSocket_send(VALUE self, VALUE rb_data, VALUE rb_address, VALUE rb_port) {
+    StringValue(rb_data);
+
+    return ID2SYM(rb_intern(socket_status_name(sfUdpSocket_send(
+        Get_UdpSocket_Struct(self), RSTRING_PTR(rb_data), (size_t) RSTRING_LEN(rb_data),
+        ip_address_from_rb(rb_address, sfIpAddress_None), (unsigned short) NUM2INT(rb_port)))));
+}
+
+/* Returns [data, IpAddress, port, status]; the address and port are those of
+   the sender. */
+static VALUE UdpSocket_receive(int argc, VALUE *argv, VALUE self) {
+    VALUE rb_max_length;
+    long max_length = 1024;
+    char *buffer;
+    size_t received = 0;
+    sfIpAddress remote_address = sfIpAddress_None;
+    unsigned short remote_port = 0;
+    sfSocketStatus status;
+    VALUE rb_result;
+
+    rb_scan_args(argc, argv, "01", &rb_max_length);
+
+    if (!NIL_P(rb_max_length)) {
+        max_length = NUM2LONG(rb_max_length);
+    }
+
+    if (max_length <= 0) {
+        rb_raise(rb_eArgError, "maximum length must be positive");
+    }
+
+    buffer = malloc((size_t) max_length);
+
+    status = sfUdpSocket_receive(Get_UdpSocket_Struct(self), buffer, (size_t) max_length, &received,
+                                 &remote_address, &remote_port);
+
+    rb_result = rb_ary_new_capa(4);
+    rb_ary_push(rb_result, rb_str_new(buffer, (long) received));
+    rb_ary_push(rb_result, ip_address_to_rb(remote_address));
+    rb_ary_push(rb_result, UINT2NUM(remote_port));
+    rb_ary_push(rb_result, ID2SYM(rb_intern(socket_status_name(status))));
+
+    free(buffer);
+
+    return rb_result;
+}
+
+static VALUE UdpSocket_send_packet(VALUE self, VALUE rb_packet, VALUE rb_address, VALUE rb_port) {
+    if (!rb_obj_is_kind_of(rb_packet, Get_Klass_Packet())) {
+        rb_raise(rb_eTypeError, "expected an SFML::Packet");
+    }
+
+    return ID2SYM(rb_intern(socket_status_name(sfUdpSocket_sendPacket(
+        Get_UdpSocket_Struct(self), Get_Packet_Struct(rb_packet),
+        ip_address_from_rb(rb_address, sfIpAddress_None), (unsigned short) NUM2INT(rb_port)))));
+}
+
+/* Returns [IpAddress, port, status]. */
+static VALUE UdpSocket_receive_packet(VALUE self, VALUE rb_packet) {
+    sfIpAddress remote_address = sfIpAddress_None;
+    unsigned short remote_port = 0;
+    sfSocketStatus status;
+    VALUE rb_result;
+
+    if (!rb_obj_is_kind_of(rb_packet, Get_Klass_Packet())) {
+        rb_raise(rb_eTypeError, "expected an SFML::Packet");
+    }
+
+    status = sfUdpSocket_receivePacket(Get_UdpSocket_Struct(self), Get_Packet_Struct(rb_packet),
+                                       &remote_address, &remote_port);
+
+    rb_result = rb_ary_new_capa(3);
+    rb_ary_push(rb_result, ip_address_to_rb(remote_address));
+    rb_ary_push(rb_result, UINT2NUM(remote_port));
+    rb_ary_push(rb_result, ID2SYM(rb_intern(socket_status_name(status))));
+
+    return rb_result;
+}
+
+void Init_UdpSocket(VALUE rb_module) {
+    rb_cUdpSocket = rb_define_class_under(rb_module, "UdpSocket", rb_cObject);
+
+    rb_define_singleton_method(rb_cUdpSocket, "new", UdpSocket_new, 0);
+    rb_define_singleton_method(rb_cUdpSocket, "any_port", UdpSocket_any_port, 0);
+    rb_define_singleton_method(rb_cUdpSocket, "max_datagram_size", UdpSocket_max_datagram_size, 0);
+
+    rb_define_method(rb_cUdpSocket, "blocking?", UdpSocket_blocking, 0);
+    rb_define_method(rb_cUdpSocket, "blocking=", UdpSocket_set_blocking, 1);
+    rb_define_method(rb_cUdpSocket, "local_port", UdpSocket_local_port, 0);
+    rb_define_method(rb_cUdpSocket, "bind", UdpSocket_bind, -1);
+    rb_define_method(rb_cUdpSocket, "unbind", UdpSocket_unbind, 0);
+    rb_define_method(rb_cUdpSocket, "send", UdpSocket_send, 3);
+    rb_define_method(rb_cUdpSocket, "receive", UdpSocket_receive, -1);
+    rb_define_method(rb_cUdpSocket, "send_packet", UdpSocket_send_packet, 3);
+    rb_define_method(rb_cUdpSocket, "receive_packet", UdpSocket_receive_packet, 1);
+}
+
+VALUE Get_Klass_UdpSocket(void) {
+    return rb_cUdpSocket;
+}
+
+void *Get_UdpSocket_Struct(VALUE self) {
+    UdpSocket *ptr;
+    TypedData_Get_Struct(self, UdpSocket, &UdpSocket_data_type, ptr);
+    return ptr->handle;
+}

data/ext/network/udp_socket.h

@@ -0,0 +1,14 @@
+#ifndef SFML_RB_NETWORK_UDP_SOCKET_H
+#define SFML_RB_NETWORK_UDP_SOCKET_H
+
+#include <ruby.h>
+
+#include "core/sfml.h"
+
+void Init_UdpSocket(VALUE rb_module);
+
+VALUE Get_Klass_UdpSocket(void);
+
+void *Get_UdpSocket_Struct(VALUE self);
+
+#endif //SFML_RB_NETWORK_UDP_SOCKET_H

data/ext/ports.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'digest'
 require 'etc'
 require 'fileutils'
@@ -23,11 +25,19 @@ module Ports
   # Cross targets, keyed by the RubyGems platform name that rake-compiler and
   # rake-compiler-dock use for them. `triple` is the GNU host triple whose
   # toolchain the matching rake-compiler-dock image installs as <triple>-gcc.
+  #
+  # `multiarch` is the Debian multiarch directory name, which is only sometimes
+  # the same string as the triple: i686 compiles with i686-linux-gnu-gcc but its
+  # libraries live in /usr/lib/i386-linux-gnu. Only set it where they differ.
   TARGETS = {
     'x86_64-linux-gnu' => { triple: 'x86_64-linux-gnu', os: :linux, cpu: 'x86_64' },
+    'x86-linux-gnu' => { triple: 'i686-linux-gnu', multiarch: 'i386-linux-gnu',
+                         os: :linux, cpu: 'i686' },
     'aarch64-linux-gnu' => { triple: 'aarch64-linux-gnu', os: :linux, cpu: 'aarch64' },
     'x86_64-linux-musl' => { triple: 'x86_64-unknown-linux-musl', os: :linux, cpu: 'x86_64' },
+    'x86-linux-musl' => { triple: 'i686-unknown-linux-musl', os: :linux, cpu: 'i686' },
     'x64-mingw-ucrt' => { triple: 'x86_64-w64-mingw32', os: :windows, cpu: 'x86_64' },
+    'x86-mingw32' => { triple: 'i686-w64-mingw32', os: :windows, cpu: 'i686' },
     'x86_64-darwin' => { triple: 'x86_64-apple-darwin', os: :darwin, cpu: 'x86_64' },
     'arm64-darwin' => { triple: 'aarch64-apple-darwin', os: :darwin, cpu: 'arm64' }
   }.freeze
@@ -41,32 +51,88 @@ module Ports
     windows: %w[gcc g++]
   }.freeze
 
-  # What the extension links on top of the static SFML/CSFML/FreeType archives.
-  # SFML resolves GL entry points through its own loader, so on Linux libGL is
-  # only needed for the handful of symbols SFML references directly.
+  # What the extension links on top of the static SFML/CSFML/FreeType/codec
+  # archives. SFML resolves GL entry points through its own loader, so on Linux
+  # libGL is only needed for the handful of symbols SFML references directly.
+  # Network links ws2_32 on Windows; audio needs no OpenAL, because SFML 3 uses
+  # the vendored miniaudio backend and resolves ALSA/Pulse at run time via dl.
   SYSTEM_LIBS = {
     linux: %w[GL X11 Xrandr Xcursor Xi udev pthread dl rt m],
-    windows: %w[opengl32 winmm gdi32 user32 advapi32 ole32],
+    windows: %w[opengl32 winmm gdi32 user32 advapi32 ole32 ws2_32],
     darwin: %w[]
   }.freeze
 
   # Clang wants -framework, not -l, and SFML's macOS backend is Objective-C++.
-  FRAMEWORKS = { darwin: %w[Cocoa OpenGL IOKit Carbon], linux: [], windows: [] }.freeze
+  # Audio reaches CoreAudio/CoreFoundation from miniaudio, and the network
+  # stack needs nothing beyond the system libc.
+  FRAMEWORKS = {
+    darwin: %w[Cocoa OpenGL IOKit Carbon CoreFoundation CoreAudio AudioToolbox],
+    linux: [], windows: []
+  }.freeze
 
-  # Order matters. CSFML does find_package(SFML 3 ... REQUIRED) and does not
-  # fetch SFML itself, and SFML does find_package(Freetype REQUIRED) once
-  # SFML_USE_SYSTEM_DEPS is on -- so each has to be installed into PREFIX
-  # before the next configures.
+  # Order matters. The Ogg/Vorbis/FLAC codecs and FreeType must be installed
+  # before SFML configures, because SFML's find_package(Vorbis)/find_package(FLAC)
+  # run with SFML_USE_SYSTEM_DEPS=ON and must find our static archives rather
+  # than the build host's shared ones. CSFML then does find_package(SFML 3 ...)
+  # and does not fetch SFML itself.
   #
   # FreeType is built here rather than left to SFML because SFML's own
   # FetchContent path clones it from git (no checksum, needs git at configure
   # time) and then does not install the resulting archive -- which leaves
   # libsfml-graphics-s.a with an undefined FT_Init_FreeType that only stays
-  # latent while nothing binds sf::Font. Pinning it as a port fixes both.
-  #
-  # Audio and network are off because the binding wraps neither, which also
-  # drops the FLAC/Ogg/Vorbis and mbedtls dependency families.
+  # latent while nothing binds sf::Font. Pinning it as a port fixes both. The
+  # same reasoning applies to the codecs: vendoring them keeps the binary gems
+  # free of libvorbis/libFLAC/libogg runtime dependencies and makes the audio
+  # module buildable on the mingw/darwin/musl images, which ship no codec
+  # development files at all.
   RECIPES = [
+    {
+      name: 'libogg',
+      version: '1.3.5',
+      sha256: '0eb4b4b9420a0f51db142ba3f9c64b333f826532dc0f48c6410ae51f4799b664',
+      url: 'https://downloads.xiph.org/releases/ogg/libogg-%<version>s.tar.gz',
+      flags: %w[
+        -DCMAKE_POLICY_VERSION_MINIMUM=3.5
+        -DBUILD_SHARED_LIBS=OFF
+        -DBUILD_TESTING=OFF
+        -DINSTALL_DOCS=OFF
+        -DINSTALL_CMAKE_PACKAGE_MODULE=ON
+        -DINSTALL_PKG_CONFIG_MODULE=OFF
+      ]
+    },
+    {
+      name: 'libvorbis',
+      version: '1.3.7',
+      sha256: '0e982409a9c3fc82ee06e08205b1355e5c6aa4c36bca58146ef399621b0ce5ab',
+      url: 'https://downloads.xiph.org/releases/vorbis/libvorbis-%<version>s.tar.gz',
+      flags: %w[
+        -DCMAKE_POLICY_VERSION_MINIMUM=3.5
+        -DBUILD_SHARED_LIBS=OFF
+        -DBUILD_TESTING=OFF
+        -DINSTALL_CMAKE_PACKAGE_MODULE=ON
+      ]
+    },
+    {
+      name: 'flac',
+      version: '1.4.3',
+      sha256: '6c58e69cd22348f441b861092b825e591d0b822e106de6eb0ee4d05d27205b70',
+      url: 'https://downloads.xiph.org/releases/flac/flac-%<version>s.tar.xz',
+      ext: 'tar.xz',
+      flags: %w[
+        -DBUILD_SHARED_LIBS=OFF
+        -DBUILD_CXXLIBS=OFF
+        -DBUILD_PROGRAMS=OFF
+        -DBUILD_EXAMPLES=OFF
+        -DBUILD_TESTING=OFF
+        -DBUILD_DOCS=OFF
+        -DWITH_OGG=OFF
+        -DWITH_FORTIFY_SOURCE=OFF
+        -DWITH_STACK_PROTECTOR=OFF
+        -DINSTALL_MANPAGES=OFF
+        -DINSTALL_CMAKE_CONFIG_MODULE=ON
+        -DINSTALL_PKGCONFIG_MODULES=ON
+      ]
+    },
     {
       name: 'freetype',
       version: '2.13.2',
@@ -89,8 +155,6 @@ module Ports
       sha256: '0034e05f95509e5d3fb81b1625713e06da7b068f210288ce3fd67106f8f46995',
       flags: %w[
         -DSFML_USE_SYSTEM_DEPS=ON
-        -DSFML_BUILD_AUDIO=OFF
-        -DSFML_BUILD_NETWORK=OFF
         -DSFML_BUILD_EXAMPLES=OFF
         -DSFML_BUILD_DOC=OFF
         -DSFML_BUILD_TEST_SUITE=OFF
@@ -101,15 +165,13 @@ module Ports
       version: '3.0.0',
       sha256: '903cd4a782fb0b233f732dc5b37861b552998e93ae8f268c40bd4ce50b2e88ca',
       flags: %w[
-        -DCSFML_BUILD_AUDIO=OFF
-        -DCSFML_BUILD_NETWORK=OFF
         -DCSFML_BUILD_EXAMPLES=OFF
         -DCSFML_LINK_SFML_STATICALLY=ON
       ]
     }
   ].freeze
 
-  TOOLCHAIN_HINT = <<~HINT.freeze
+  TOOLCHAIN_HINT = <<~HINT
     Building SFML from source needs CMake >= 3.22, a C++17 compiler, and the
     X11/udev/OpenGL development headers. SFML links those from the system and
     they cannot be bundled.
@@ -210,8 +272,11 @@ module Ports
     end
   end
 
+  # The local archive keeps a fixed <name>-<version>.<ext> name regardless of
+  # what the upstream release calls it, so recipes can point at libogg-1.3.5.tar.gz
+  # or flac-1.4.3.tar.xz without the rest of the code caring.
   def tarball(recipe)
-    File.join(ARCHIVES, "#{recipe[:name]}-#{recipe[:version]}.tar.gz")
+    File.join(ARCHIVES, "#{recipe[:name]}-#{recipe[:version]}.#{recipe[:ext] || 'tar.gz'}")
   end
 
   def source_dir(recipe)
@@ -273,6 +338,15 @@ module Ports
       -DCMAKE_INSTALL_LIBDIR=lib
     ]
     flags << "-DCMAKE_TOOLCHAIN_FILE=#{toolchain_file}" if cross?
+
+    # SFML 3.0.2 defaults CMAKE_OSX_DEPLOYMENT_TARGET to 13.0 in its own
+    # CMakeLists.txt, but the macOS SDK osxcross ships in the
+    # rake-compiler-dock image is 11.1, and osxcross refuses a target newer
+    # than its SDK ("targeted macOS version must be <= 11.1.0"). Pass it as a
+    # -D rather than writing it into the toolchain file because SFML's
+    # sfml_set_option() only supplies its default when the variable is not
+    # already defined -- a command-line cache entry always is.
+    flags << '-DCMAKE_OSX_DEPLOYMENT_TARGET=11.0' if os == :darwin
     flags
   end
 
@@ -328,7 +402,7 @@ module Ports
       else
         # Debian multiarch: without this CMake searches /usr/lib, finds the
         # container's own amd64 libraries and hands them to an aarch64 linker.
-        lines << "set(CMAKE_LIBRARY_ARCHITECTURE #{spec[:triple]})"
+        lines << "set(CMAKE_LIBRARY_ARCHITECTURE #{spec[:multiarch] || spec[:triple]})"
       end
     end
 
@@ -351,7 +425,9 @@ module Ports
 
     unless Dir.exist?(source)
       FileUtils.mkdir_p(build_root)
-      run('tar', 'xzf', tarball(recipe), '-C', build_root)
+      # Plain `xf`, not `xzf`: GNU tar, bsdtar and mingw's tar all sniff the
+      # compression, which is what lets gzip and xz recipes share this path.
+      run('tar', 'xf', tarball(recipe), '-C', build_root)
     end
 
     puts "Building #{recipe[:name]} #{recipe[:version]} for #{target}"

data/ext/system/buffer.c

@@ -0,0 +1,77 @@
+#include "system/buffer.h"
+
+#include <ruby.h>
+
+#include "core/exceptions.h"
+#include "core/macros.h"
+
+static VALUE rb_cBuffer;
+
+static void Buffer_free(void *ptr) {
+    sfBuffer_destroy(ptr);
+}
+
+static const rb_data_type_t Buffer_data_type = {
+    .wrap_struct_name = "SFML::Buffer",
+    .function = {.dmark = NULL, .dfree = Buffer_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE Buffer_wrap(VALUE klass, sfBuffer *buffer) {
+    return TypedData_Wrap_Struct(klass, &Buffer_data_type, buffer);
+}
+
+static VALUE Buffer_new(VALUE klass) {
+    VALUE self;
+    sfBuffer *buffer = sfBuffer_create();
+
+    if (buffer == NULL) {
+        rb_raise(rb_eNoMemError, "could not create buffer");
+    }
+
+    self = Buffer_wrap(klass, buffer);
+
+    return self;
+}
+
+static VALUE Buffer_get_size(VALUE self) {
+    return SIZET2NUM(sfBuffer_getSize(Get_Buffer_Struct(self)));
+}
+
+static VALUE Buffer_get_data(VALUE self) {
+    sfBuffer *buffer = Get_Buffer_Struct(self);
+    size_t size = sfBuffer_getSize(buffer);
+    const uint8_t *data = sfBuffer_getData(buffer);
+
+    if (data == NULL || size == 0) {
+        return rb_str_new("", 0);
+    }
+
+    return rb_str_new((const char *) data, (long) size);
+}
+
+static VALUE Buffer_is_empty(VALUE self) {
+    return BOOL2RB(sfBuffer_getSize(Get_Buffer_Struct(self)) == 0);
+}
+
+void Init_Buffer(VALUE rb_module) {
+    rb_cBuffer = rb_define_class_under(rb_module, "Buffer", rb_cObject);
+
+    rb_define_singleton_method(rb_cBuffer, "new", Buffer_new, 0);
+
+    rb_define_method(rb_cBuffer, "size", Buffer_get_size, 0);
+    rb_define_method(rb_cBuffer, "length", Buffer_get_size, 0);
+    rb_define_method(rb_cBuffer, "data", Buffer_get_data, 0);
+    rb_define_method(rb_cBuffer, "to_s", Buffer_get_data, 0);
+    rb_define_method(rb_cBuffer, "empty?", Buffer_is_empty, 0);
+}
+
+VALUE Get_Klass_Buffer(void) {
+    return rb_cBuffer;
+}
+
+void *Get_Buffer_Struct(VALUE self) {
+    sfBuffer *ptr;
+    TypedData_Get_Struct(self, sfBuffer, &Buffer_data_type, ptr);
+    return ptr;
+}

data/ext/system/buffer.h

@@ -0,0 +1,14 @@
+#ifndef SFML_RB_SYSTEM_BUFFER_H
+#define SFML_RB_SYSTEM_BUFFER_H
+
+#include <ruby.h>
+
+#include "core/sfml.h"
+
+void Init_Buffer(VALUE rb_module);
+
+VALUE Get_Klass_Buffer(void);
+
+void *Get_Buffer_Struct(VALUE self);
+
+#endif //SFML_RB_SYSTEM_BUFFER_H

data/ext/system/clock.c

@@ -0,0 +1,100 @@
+#include "system/clock.h"
+
+#include <stdio.h>
+
+#include "system/time.h"
+#include "system/vec2.h"
+#include "core/macros.h"
+#include "core/sfml.h"
+
+static VALUE rb_cClock;
+
+static sfClock *Clock_create() {
+    return sfClock_create();
+}
+
+static void Clock_free(void *ptr) {
+    sfClock_destroy(ptr);
+}
+
+static const rb_data_type_t Clock_data_type = {
+    .wrap_struct_name = "SFML::Clock",
+    .function = {.dmark = NULL, .dfree = Clock_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE Clock_new_from(VALUE klass, sfClock *clock) {
+    VALUE self;
+
+    self = TypedData_Wrap_Struct(klass, &Clock_data_type, clock);
+
+    rb_obj_call_init(self, 0, NULL);
+
+    return self;
+}
+
+static VALUE Clock_new(VALUE klass) {
+    return Clock_new_from(klass, Clock_create());
+}
+
+static VALUE Clock_init(VALUE self) {
+    return self;
+}
+
+static VALUE Clock_get_elapsed_time(VALUE self) {
+    return time_to_rb(sfClock_getElapsedTime(Get_Clock_Struct(self)));
+}
+
+static VALUE Clock_restart(VALUE self) {
+    return time_to_rb(sfClock_restart(Get_Clock_Struct(self)));
+}
+
+static VALUE Clock_reset(VALUE self) {
+    return time_to_rb(sfClock_reset(Get_Clock_Struct(self)));
+}
+
+static VALUE Clock_is_running(VALUE self) {
+    return BOOL2RB(sfClock_isRunning(Get_Clock_Struct(self)));
+}
+
+static VALUE Clock_start(VALUE self) {
+    sfClock_start(Get_Clock_Struct(self));
+    return self;
+}
+
+static VALUE Clock_stop(VALUE self) {
+    sfClock_stop(Get_Clock_Struct(self));
+    return self;
+}
+
+static VALUE Clock_copy(VALUE self) {
+    return Clock_new_from(Get_Klass_Clock(), sfClock_copy(Get_Clock_Struct(self)));
+}
+
+void Init_Clock(VALUE rb_module) {
+    rb_cClock = rb_define_class_under(rb_module, "Clock", rb_cObject);
+
+    rb_define_singleton_method(rb_cClock, "new", Clock_new, 0);
+
+    // methods
+    rb_define_method(rb_cClock, "initialize", Clock_init, 0);
+    rb_define_method(rb_cClock, "restart!", Clock_restart, 0);
+    rb_define_method(rb_cClock, "reset!", Clock_reset, 0);
+    rb_define_method(rb_cClock, "start!", Clock_start, 0);
+    rb_define_method(rb_cClock, "stop!", Clock_stop, 0);
+    rb_define_method(rb_cClock, "copy", Clock_copy, 0);
+
+    // getters
+    rb_define_method(rb_cClock, "elapsed_time", Clock_get_elapsed_time, 0);
+    rb_define_method(rb_cClock, "running?", Clock_is_running, 0);
+}
+
+void *Get_Clock_Struct(VALUE self) {
+    sfClock *clock;
+    TypedData_Get_Struct(self, sfClock, &Clock_data_type, clock);
+    return clock;
+}
+
+VALUE Get_Klass_Clock() {
+    return rb_cClock;
+}

data/ext/{ext/klass → system}/clock.h

@@ -1,5 +1,5 @@
-#ifndef SFML_RB_CLOCK_H
-#define SFML_RB_CLOCK_H
+#ifndef SFML_RB_SYSTEM_CLOCK_H
+#define SFML_RB_SYSTEM_CLOCK_H
 
 #include <ruby.h>
 
@@ -9,4 +9,4 @@ void *Get_Clock_Struct(VALUE self);
 
 VALUE Get_Klass_Clock();
 
-#endif //SFML_RB_CLOCK_H
+#endif //SFML_RB_SYSTEM_CLOCK_H