sfml3-rb 0.0.1

data/ext/target.c

@@ -0,0 +1,106 @@
+#include "ext/klass/target.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <ext/klass/drawable/circle.h>
+#include <ext/klass/render_state.h>
+
+#include "ext/module/transform.h"
+#include "ext/klass/transformable.h"
+#include "ext/klass/view.h"
+#include "ext/klass/window.h"
+#include "ext/vec2.h"
+#include "ext/rect.h"
+#include "ext/module.h"
+#include "ext/sfml.h"
+
+static VALUE rb_cTarget;
+
+static Target *RenderTarget_create(sfRenderWindow *c_window) {
+    Target *target = malloc(sizeof(Target));
+
+    target->window = c_window;
+
+    return target;
+}
+
+static void RenderTarget_free(void *ptr) {
+    free(ptr);
+}
+
+static VALUE RenderTarget_new(VALUE klass, VALUE rb_window) {
+    VALUE self;
+    Target *target;
+
+    if (!rb_obj_is_kind_of(rb_window, Get_Klass_Window())) {
+        rb_raise(rb_eArgError, "Expected a Window object");
+    }
+
+    target = RenderTarget_create(Get_Window_Struct(rb_window));
+    self = Data_Wrap_Struct(klass, 0, RenderTarget_free, target);
+
+    VALUE argv[1] = {rb_window};
+    rb_obj_call_init(self, 1, argv);
+
+    return self;
+}
+
+static VALUE RenderTarget_init(VALUE self, VALUE rb_window) {
+    return self;
+}
+
+static VALUE RenderTarget_draw(VALUE self, VALUE rb_drawable, VALUE rb_state) {
+    Target *target = Get_Target_Struct(self);
+
+    if (rb_obj_is_kind_of(rb_drawable, Get_Klass_Circle())) {
+        sfRenderWindow_drawCircleShape(target->window, Get_Circle_Struct(rb_drawable), Get_RenderState_Struct(rb_state));
+    } else {
+        rb_funcall(rb_drawable, rb_intern("draw"), 2, self, rb_state);
+    }
+
+    return self;
+}
+
+static VALUE RenderTarget_set_view(VALUE self, VALUE rb_view) {
+    if (!rb_obj_is_kind_of(rb_view, Get_Klass_View())) {
+        rb_raise(rb_eArgError, "Expected a View object");
+    }
+
+    sfRenderWindow_setView(((Target *) Get_Target_Struct(self))->window, Get_View_Struct(rb_view));
+
+    return Qnil;
+}
+
+static VALUE RenderTarget_get_view(VALUE self) {
+    return Get_Casting_View(sfView_copy(sfRenderWindow_getView(((Target *) Get_Target_Struct(self))->window)));
+}
+
+void Init_Target(VALUE rb_module) {
+    rb_cTarget = rb_define_class_under(rb_module, "Target", rb_cObject);
+
+    rb_define_singleton_method(rb_cTarget, "new", RenderTarget_new, 1);
+
+    // methods
+    rb_define_method(rb_cTarget, "initialize", RenderTarget_init, 1);
+    rb_define_method(rb_cTarget, "draw", RenderTarget_draw, 2);
+
+    // setters
+    rb_define_method(rb_cTarget, "view=", RenderTarget_set_view, 1);
+
+    // getters
+    rb_define_method(rb_cTarget, "view", RenderTarget_get_view, 0);
+}
+
+VALUE Get_Klass_Target(void) {
+    return rb_cTarget;
+}
+
+void *Get_Target_Struct(VALUE self) {
+    Target *ptr;
+    Data_Get_Struct(self, Target, ptr);
+    return ptr;
+}
+
+VALUE Get_New_Target(VALUE rb_window) {
+    return RenderTarget_new(Get_Klass_Target(), rb_window);
+}

data/ext/texture.c

@@ -0,0 +1,5 @@
+//
+// Created by Sealtiel on 03/06/2022.
+//
+
+#include "ext/klass/drawable/texture.h"

data/ext/transform.c

@@ -0,0 +1,107 @@
+#include "ext/module/transform.h"
+
+#include <ruby.h>
+#include <stdio.h>
+
+#include "ext/vec2.h"
+#include "ext/rect.h"
+#include "ext/module.h"
+#include "ext/sfml.h"
+
+
+static VALUE rb_mTransform;
+
+VALUE Transform_combine(VALUE self, VALUE rb_arr_a, VALUE rb_arr_b) {
+    sfTransform transform_a, transform_b;
+    float matrix_a[MATRIX_LENGTH], matrix_b[MATRIX_LENGTH];
+
+    Transform_ArrayToMatrix(rb_arr_a, matrix_a);
+    Transform_ArrayToMatrix(rb_arr_b, matrix_b);
+
+    Transform_SwapMatrix(matrix_a, transform_a.matrix);
+    Transform_SwapMatrix(matrix_b, transform_b.matrix);
+
+    sfTransform_combine(&transform_a, &transform_b);
+
+    return Transform_MatrixToArray(transform_a.matrix);
+}
+
+VALUE Transform_inverse(VALUE self, VALUE rb_matrix) {
+    sfTransform transform;
+    float matrix[MATRIX_LENGTH];
+
+    Transform_ArrayToMatrix(rb_matrix, matrix);
+    Transform_SwapMatrix(matrix, transform.matrix);
+
+    return Transform_MatrixToArray(sfTransform_getInverse(&transform).matrix);
+}
+
+void Init_Transform(VALUE rb_module) {
+    rb_mTransform = rb_define_module_under(rb_module, "Transform");
+
+    rb_define_module_function(rb_mTransform, "combine", Transform_combine, 2);
+    rb_define_module_function(rb_mTransform, "inverse", Transform_inverse, 1);
+}
+
+VALUE Transform_MatrixToArray(float *c_matrix) {
+    VALUE rb_arr;
+    size_t i;
+
+    if (c_matrix == NULL) {
+        return Qnil;
+    }
+
+    rb_arr = rb_ary_new();
+
+    for (i = 0; i < MATRIX_LENGTH; i++) {
+        rb_ary_push(rb_arr, DBL2NUM(c_matrix[i]));
+    }
+
+    return rb_arr;
+}
+
+void Transform_ArrayToMatrix(VALUE rb_matrix, float *c_matrix) {
+    size_t i;
+
+    if (c_matrix == NULL) {
+        return;
+    }
+
+    if (rb_array_len(rb_matrix) != MATRIX_LENGTH) {
+        return;
+    }
+
+    for (i = 0; i < MATRIX_LENGTH; i++) {
+        c_matrix[i] = NUM2DBL(rb_ary_entry(rb_matrix, (long) i));
+    }
+}
+
+void Transform_SwapMatrix(const float *c_matrix_a, float *c_matrix_b) {
+    size_t i;
+
+    if (c_matrix_a == NULL || c_matrix_b == NULL) {
+        return;
+    }
+
+    for (i = 0; i < MATRIX_LENGTH; i++) {
+        c_matrix_b[i] = c_matrix_a[i];
+    }
+}
+
+sfTransform Transform_ArrayToTransform(VALUE rb_matrix) {
+    float c_matrix[MATRIX_LENGTH];
+    sfTransform transform;
+
+    Transform_ArrayToMatrix(rb_matrix, c_matrix);
+    Transform_SwapMatrix(c_matrix, transform.matrix);
+
+    return transform;
+}
+
+VALUE Transform_TransformToArray(sfTransform c_transform) {
+    float c_matrix[MATRIX_LENGTH];
+
+    Transform_SwapMatrix(c_transform.matrix, c_matrix);
+
+    return Transform_MatrixToArray(c_matrix);
+}

data/ext/transformable.c

@@ -0,0 +1,145 @@
+#include "ext/klass/transformable.h"
+
+#include <ruby.h>
+#include <stdio.h>
+
+#include "ext/module/transform.h"
+#include "ext/vec2.h"
+#include "ext/rect.h"
+#include "ext/module.h"
+#include "ext/sfml.h"
+
+static VALUE rb_cTransformable;
+
+static sfTransformable *Transformable_create() {
+    return sfTransformable_create();
+}
+
+static void Transformable_free(void *ptr) {
+    sfTransformable_destroy((sfTransformable *) ptr);
+}
+
+static VALUE Transformable_new(VALUE klass) {
+    VALUE self;
+    sfTransformable *transformable;
+
+    transformable = Transformable_create();
+    self = Data_Wrap_Struct(klass, 0, Transformable_free, transformable);
+
+    rb_obj_call_init(self, 0, NULL);
+
+    return self;
+}
+
+static VALUE Transformable_init(VALUE self) {
+    return self;
+}
+
+static VALUE Transformable_set_position(VALUE self, VALUE rb_position) {
+    sfVector2f position = VEC2_RB2C(rb_position);
+    sfTransformable_setPosition(Get_Transformable_Struct(self), position);
+
+    return self;
+}
+
+static VALUE Transformable_set_rotation(VALUE self, VALUE rb_angle) {
+    sfTransformable_setRotation(Get_Transformable_Struct(self), NUM2DBL(rb_angle));
+
+    return self;
+}
+
+static VALUE Transformable_set_scale(VALUE self, VALUE rb_scale) {
+    sfVector2f scale = VEC2_RB2C(rb_scale);
+    sfTransformable_setScale(Get_Transformable_Struct(self), scale);
+
+    return self;
+}
+
+static VALUE Transformable_set_origin(VALUE self, VALUE rb_origin) {
+    sfVector2f origin = VEC2_RB2C(rb_origin);
+    sfTransformable_setOrigin(Get_Transformable_Struct(self), origin);
+
+    return self;
+}
+
+static VALUE Transformable_get_position(VALUE self) {
+    sfVector2f position = sfTransformable_getPosition(Get_Transformable_Struct(self));
+
+    return VEC2_C2RB(position);
+}
+
+static VALUE Transformable_get_rotation(VALUE self) {
+    return DBL2NUM(sfTransformable_getRotation(Get_Transformable_Struct(self)));
+}
+
+static VALUE Transformable_get_scale(VALUE self) {
+    sfVector2f scale = sfTransformable_getScale(Get_Transformable_Struct(self));
+
+    return VEC2_C2RB(scale);
+}
+
+static VALUE Transformable_get_origin(VALUE self) {
+    sfVector2f origin = sfTransformable_getOrigin(Get_Transformable_Struct(self));
+
+    return VEC2_C2RB(origin);
+}
+
+static VALUE Transformable_move(VALUE self, VALUE rb_move) {
+    sfVector2f move = VEC2_RB2C(rb_move);
+    sfTransformable_move(Get_Transformable_Struct(self), move);
+
+    return self;
+}
+
+static VALUE Transformable_rotate(VALUE self, VALUE rb_angle) {
+    sfTransformable_rotate(Get_Transformable_Struct(self), NUM2DBL(rb_angle));
+
+    return self;
+}
+
+static VALUE Transformable_scale(VALUE self, VALUE rb_scale) {
+    sfVector2f scale = VEC2_RB2C(rb_scale);
+    sfTransformable_scale(Get_Transformable_Struct(self), scale);
+
+    return self;
+}
+
+static VALUE Transformable_get_matrix(VALUE self) {
+    sfTransformable *transformable = Get_Transformable_Struct(self);
+    sfTransform transform = sfTransformable_getTransform(transformable);
+
+    return Transform_MatrixToArray(transform.matrix);
+}
+
+void Init_Transformable(VALUE rb_module) {
+    rb_cTransformable = rb_define_class_under(rb_module, "Transformable", rb_cObject);
+
+    rb_define_singleton_method(rb_cTransformable, "new", Transformable_new, 0);
+    rb_define_method(rb_cTransformable, "initialize", Transformable_init, 0);
+
+    rb_define_method(rb_cTransformable, "position=", Transformable_set_position, 1);
+    rb_define_method(rb_cTransformable, "angle=", Transformable_set_rotation, 1);
+    rb_define_method(rb_cTransformable, "scale=", Transformable_set_scale, 1);
+    rb_define_method(rb_cTransformable, "origin=", Transformable_set_origin, 1);
+
+    rb_define_method(rb_cTransformable, "position", Transformable_get_position, 0);
+    rb_define_method(rb_cTransformable, "angle", Transformable_get_rotation, 0);
+    rb_define_method(rb_cTransformable, "scale", Transformable_get_scale, 0);
+    rb_define_method(rb_cTransformable, "origin", Transformable_get_origin, 0);
+
+    rb_define_method(rb_cTransformable, "move", Transformable_move, 1);
+    rb_define_method(rb_cTransformable, "rotate", Transformable_rotate, 1);
+    rb_define_method(rb_cTransformable, "escalate", Transformable_scale, 1);
+
+    rb_define_method(rb_cTransformable, "matrix", Transformable_get_matrix, 0);
+}
+
+void *Get_Transformable_Struct(VALUE self) {
+    sfTransformable *transform;
+    Data_Get_Struct(self, sfTransformable, transform);
+    return transform;
+}
+
+VALUE Get_Klass_Transformable() {
+    return rb_cTransformable;
+}

data/ext/vec2.c

@@ -0,0 +1,42 @@
+#include "ext/vec2.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "ext/exceptions.h"
+
+VALUE vec2_new(float x, float y) {
+    VALUE rb_vec;
+
+    rb_vec = rb_ary_new();
+
+    rb_ary_store(rb_vec, 0, DBL2NUM(x));
+    rb_ary_store(rb_vec, 1, DBL2NUM(y));
+
+    return rb_vec;
+}
+
+void vec2_check(VALUE rb_arr) {
+    if (rb_array_len(rb_arr) != 2) {
+        raise_invalid_argument_class(rb_cArray);
+    }
+}
+
+VALUE vec2f_new_from_c(sfVector2f c_vec) {
+    return VEC2_C2RB(c_vec);
+}
+
+sfVector2i vec2i_new_from_ruby(VALUE rb_arr) {
+    sfVector2i vec = VEC2_RB2C_T(int, rb_arr);
+    return vec;
+}
+
+sfVector2u vec2u_new_from_ruby(VALUE rb_arr) {
+    sfVector2u vec = VEC2_RB2C_T(unsigned, rb_arr);
+    return vec;
+}
+
+sfVector2f vec2f_new_from_ruby(VALUE rb_arr) {
+    sfVector2f vec = VEC2_RB2C_T(float, rb_arr);
+    return vec;
+}

data/ext/video_mode.c

@@ -0,0 +1,78 @@
+#include "ext/klass/video_mode.h"
+
+#include <ruby.h>
+#include <stdio.h>
+
+#include "ext/sfml.h"
+#include "ext/module.h"
+
+static VALUE rb_cMode;
+
+static sfVideoMode *VideoMode_create(unsigned width, unsigned heigth, unsigned bitsPerPixel) {
+    sfVideoMode *mode = malloc(sizeof(sfVideoMode));
+
+    mode->size.x = width;
+    mode->size.y = heigth;
+    mode->bitsPerPixel = bitsPerPixel;
+
+    return mode;
+}
+
+static void VideoMode_free(void *ptr) {
+    free(ptr);
+}
+
+static VALUE VideoMode_new(VALUE klass, VALUE rb_width, VALUE rb_height, VALUE rb_bits) {
+    VALUE self;
+    sfVideoMode *ptr;
+
+    VALUE argv[] = {rb_width, rb_height, rb_bits};
+
+    ptr = VideoMode_create(NUM2INT(rb_width), NUM2INT(rb_height), NUM2INT(rb_bits));
+    self = Data_Wrap_Struct(klass, 0, VideoMode_free, ptr);
+
+    rb_obj_call_init(self, 3, argv);
+
+    return self;
+}
+
+static VALUE VideoMode_init(VALUE self, VALUE rb_width, VALUE rb_height, VALUE rb_bits) {
+    rb_iv_set(self, "@width", rb_width);
+    rb_iv_set(self, "@height", rb_height);
+    rb_iv_set(self, "@bits", rb_bits);
+
+    return self;
+}
+
+static VALUE VideoMode_is_available(VALUE self) {
+    sfVideoMode *ptr = Get_Mode_Struct(self);
+
+    if (sfVideoMode_isValid(*ptr)) {
+        return Qtrue;
+    }
+
+    return Qfalse;
+}
+
+void Init_VideoMode(VALUE rb_module) {
+    rb_cMode = rb_define_class_under(rb_module, "VideoMode", rb_cObject);
+
+    rb_define_singleton_method(rb_cMode, "new", VideoMode_new, 3);
+
+    // methods
+    rb_define_method(rb_cMode, "initialize", VideoMode_init, 3);
+    rb_define_method(rb_cMode, "available?", VideoMode_is_available, 0);
+    rb_define_attr(rb_cMode, "width", 1, 0);
+    rb_define_attr(rb_cMode, "height", 1, 0);
+    rb_define_attr(rb_cMode, "bits", 1, 0);
+}
+
+void *Get_Mode_Struct(VALUE self) {
+    sfVideoMode *ptr;
+    Data_Get_Struct(self, sfVideoMode, ptr);
+    return ptr;
+}
+
+VALUE Get_Klass_Mode() {
+    return rb_cMode;
+}

data/ext/view.c

@@ -0,0 +1,170 @@
+#include "ext/klass/view.h"
+
+#include <stdio.h>
+
+#include "ext/module/transform.h"
+#include "ext/klass/transformable.h"
+#include "ext/klass/color.h"
+#include "ext/vec2.h"
+#include "ext/rect.h"
+#include "ext/module.h"
+#include "ext/sfml.h"
+
+static VALUE rb_cView;
+
+static sfView *View_create() {
+    return sfView_create();
+}
+
+static void View_free(void *ptr) {
+    sfView_destroy(ptr);
+}
+
+static VALUE View_new_from(VALUE klass, sfView *c_view) {
+    VALUE self;
+    sfView *view;
+
+    if (c_view != NULL) {
+        view = c_view;
+    } else {
+        view = View_create();
+    }
+
+    self = Data_Wrap_Struct(klass, 0, View_free, view);
+
+    rb_obj_call_init(self, 0, NULL);
+
+    return self;
+}
+
+static VALUE View_new(VALUE klass) {
+    return View_new_from(klass, NULL);
+}
+
+static VALUE View_init(VALUE self) {
+    return self;
+}
+
+static VALUE View_set_position(VALUE self, VALUE rb_position) {
+    sfView *view = Get_View_Struct(self);
+    sfVector2f position = VEC2_RB2C(rb_position);
+    sfVector2f size = sfView_getSize(view);
+
+    sfFloatRect rect = {{position.x, position.y}, {size.x, size.y}};
+
+    sfView_setViewport(Get_View_Struct(self), rect);
+
+    return self;
+}
+
+
+static VALUE View_set_rotation(VALUE self, VALUE rb_rotation) {
+    sfView_setRotation(Get_View_Struct(self), NUM2DBL(rb_rotation));
+    return self;
+}
+
+
+static VALUE View_set_size(VALUE self, VALUE rb_scale) {
+    sfView_setSize(Get_View_Struct(self), vec2f_new_from_ruby(rb_scale));
+    return self;
+}
+
+
+static VALUE View_set_center(VALUE self, VALUE rb_origin) {
+    sfVector2f origin = VEC2_RB2C(rb_origin);
+    sfView_setCenter(Get_View_Struct(self), origin);
+    return self;
+}
+
+static VALUE View_set_viewport(VALUE self, VALUE rb_viewport) {
+    sfFloatRect viewport = RECT_RB2C(rb_viewport);
+    sfView_setViewport(Get_View_Struct(self), viewport);
+
+    return self;
+}
+
+static VALUE View_get_position(VALUE self) {
+    sfFloatRect viewport = sfView_getViewport(Get_View_Struct(self));
+    return vec2_new(viewport.position.x, viewport.position.y);
+}
+
+
+static VALUE View_get_rotation(VALUE self) {
+    return DBL2NUM(sfView_getRotation(Get_View_Struct(self)));
+}
+
+
+static VALUE View_get_size(VALUE self) {
+    return vec2f_new_from_c(sfView_getSize(Get_View_Struct(self)));
+}
+
+
+static VALUE View_get_center(VALUE self) {
+    return vec2f_new_from_c(sfView_getCenter(Get_View_Struct(self)));
+}
+
+static VALUE View_get_viewport(VALUE self) {
+    return RECT_C2RB(sfView_getViewport(Get_View_Struct(self)));
+}
+
+static VALUE View_move(VALUE self, VALUE rb_move) {
+    sfView_move(Get_View_Struct(self), vec2f_new_from_ruby(rb_move));
+    return self;
+}
+
+static VALUE View_rotate(VALUE self, VALUE rb_angle) {
+    sfView_rotate(Get_View_Struct(self), NUM2DBL(rb_angle));
+
+    return self;
+}
+
+static VALUE View_zoom(VALUE self, VALUE rb_zoom) {
+    sfView_zoom(Get_View_Struct(self), NUM2DBL(rb_zoom));
+
+    return self;
+}
+
+static VALUE View_copy(VALUE self) {
+    return Get_Casting_View(sfView_copy(Get_View_Struct(self)));
+}
+
+void Init_View(VALUE rb_module) {
+    rb_cView = rb_define_class_under(rb_module, "View", rb_cObject);
+
+    rb_define_singleton_method(rb_cView, "new", View_new, 0);
+
+    // methods
+    rb_define_method(rb_cView, "initialize", View_init, 0);
+    rb_define_method(rb_cView, "move", View_move, 1);
+    rb_define_method(rb_cView, "rotate", View_rotate, 1);
+    rb_define_method(rb_cView, "zoom", View_zoom, 1);
+    rb_define_method(rb_cView, "copy", View_copy, 0);
+
+    // setters
+    rb_define_method(rb_cView, "position=", View_set_position, 1);
+    rb_define_method(rb_cView, "angle=", View_set_rotation, 1);
+    rb_define_method(rb_cView, "size=", View_set_size, 1);
+    rb_define_method(rb_cView, "center=", View_set_center, 1);
+    rb_define_method(rb_cView, "viewport=", View_set_viewport, 1);
+
+    // getters
+    rb_define_method(rb_cView, "position", View_get_position, 0);
+    rb_define_method(rb_cView, "angle", View_get_rotation, 0);
+    rb_define_method(rb_cView, "size", View_get_size, 0);
+    rb_define_method(rb_cView, "center", View_get_center, 0);
+    rb_define_method(rb_cView, "viewport", View_get_viewport, 0);
+}
+
+void *Get_View_Struct(VALUE self) {
+    sfView *ptr;
+    Data_Get_Struct(self, sfView, ptr);
+    return ptr;
+}
+
+VALUE Get_Klass_View() {
+    return rb_cView;
+}
+
+VALUE Get_Casting_View(void *ptr) {
+    return View_new_from(Get_Klass_View(), ptr);
+}