sfml3-rb 0.0.1 → 0.2.2

data/ext/graphics/stencil_mode.c

@@ -0,0 +1,211 @@
+#include "graphics/stencil_mode.h"
+
+#include <ruby.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "core/exceptions.h"
+#include "core/macros.h"
+
+typedef struct {
+    sfStencilMode mode;
+} StencilMode;
+
+static VALUE rb_cStencilMode;
+
+static const char *comparison_names[] = {
+    "never", "less", "less_equal", "greater", "greater_equal", "equal", "not_equal", "always"
+};
+
+static const char *operation_names[] = {
+    "keep", "zero", "replace", "increment", "decrement", "invert"
+};
+
+static void StencilMode_free(void *ptr) {
+    free(ptr);
+}
+
+static const rb_data_type_t StencilMode_data_type = {
+    .wrap_struct_name = "SFML::StencilMode",
+    .function = {.dmark = NULL, .dfree = StencilMode_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE StencilMode_wrap(sfStencilMode mode) {
+    StencilMode *ptr = malloc(sizeof(StencilMode));
+
+    ptr->mode = mode;
+
+    return TypedData_Wrap_Struct(rb_cStencilMode, &StencilMode_data_type, ptr);
+}
+
+static sfStencilComparison comparison_from_rb(VALUE rb_value) {
+    size_t i;
+
+    if (RB_INTEGER_TYPE_P(rb_value)) {
+        return (sfStencilComparison) NUM2INT(rb_value);
+    }
+
+    if (SYMBOL_P(rb_value)) {
+        const char *name = rb_id2name(SYM2ID(rb_value));
+
+        for (i = 0; i < sizeof(comparison_names) / sizeof(comparison_names[0]); i++) {
+            if (strcmp(name, comparison_names[i]) == 0) {
+                return (sfStencilComparison) i;
+            }
+        }
+    }
+
+    rb_raise(rb_eArgError, "unknown stencil comparison");
+    return sfStencilComparisonAlways;
+}
+
+static sfStencilUpdateOperation operation_from_rb(VALUE rb_value) {
+    size_t i;
+
+    if (RB_INTEGER_TYPE_P(rb_value)) {
+        return (sfStencilUpdateOperation) NUM2INT(rb_value);
+    }
+
+    if (SYMBOL_P(rb_value)) {
+        const char *name = rb_id2name(SYM2ID(rb_value));
+
+        for (i = 0; i < sizeof(operation_names) / sizeof(operation_names[0]); i++) {
+            if (strcmp(name, operation_names[i]) == 0) {
+                return (sfStencilUpdateOperation) i;
+            }
+        }
+    }
+
+    rb_raise(rb_eArgError, "unknown stencil update operation");
+    return sfStencilUpdateOperationKeep;
+}
+
+static VALUE StencilMode_new(int argc, VALUE *argv, VALUE klass) {
+    VALUE self;
+    StencilMode *ptr;
+    sfStencilMode mode = sfStencilMode_default;
+
+    if (argc == 5) {
+        mode.stencilComparison = comparison_from_rb(argv[0]);
+        mode.stencilUpdateOperation = operation_from_rb(argv[1]);
+        mode.stencilReference.value = (unsigned int) NUM2UINT(argv[2]);
+        mode.stencilMask.value = (unsigned int) NUM2UINT(argv[3]);
+        mode.stencilOnly = RTEST(argv[4]);
+    } else if (argc != 0) {
+        raise_invalid_arguments_excepted(5, argc);
+    }
+
+    ptr = malloc(sizeof(StencilMode));
+    ptr->mode = mode;
+
+    self = TypedData_Wrap_Struct(klass, &StencilMode_data_type, ptr);
+
+    return self;
+}
+
+static VALUE StencilMode_get_comparison(VALUE self) {
+    return ID2SYM(rb_intern(comparison_names[((StencilMode *) Get_StencilMode_Struct(self))->mode.stencilComparison]));
+}
+
+static VALUE StencilMode_get_operation(VALUE self) {
+    sfStencilMode mode = ((StencilMode *) Get_StencilMode_Struct(self))->mode;
+
+    return ID2SYM(rb_intern(operation_names[mode.stencilUpdateOperation]));
+}
+
+static VALUE StencilMode_get_reference(VALUE self) {
+    return UINT2NUM(((StencilMode *) Get_StencilMode_Struct(self))->mode.stencilReference.value);
+}
+
+static VALUE StencilMode_get_mask(VALUE self) {
+    return UINT2NUM(((StencilMode *) Get_StencilMode_Struct(self))->mode.stencilMask.value);
+}
+
+static VALUE StencilMode_get_only(VALUE self) {
+    return BOOL2RB(((StencilMode *) Get_StencilMode_Struct(self))->mode.stencilOnly);
+}
+
+static VALUE StencilMode_set_comparison(VALUE self, VALUE rb_value) {
+    ((StencilMode *) Get_StencilMode_Struct(self))->mode.stencilComparison = comparison_from_rb(rb_value);
+    return rb_value;
+}
+
+static VALUE StencilMode_set_operation(VALUE self, VALUE rb_value) {
+    ((StencilMode *) Get_StencilMode_Struct(self))->mode.stencilUpdateOperation = operation_from_rb(rb_value);
+    return rb_value;
+}
+
+static VALUE StencilMode_set_reference(VALUE self, VALUE rb_value) {
+    ((StencilMode *) Get_StencilMode_Struct(self))->mode.stencilReference.value = (unsigned int) NUM2UINT(rb_value);
+    return rb_value;
+}
+
+static VALUE StencilMode_set_mask(VALUE self, VALUE rb_value) {
+    ((StencilMode *) Get_StencilMode_Struct(self))->mode.stencilMask.value = (unsigned int) NUM2UINT(rb_value);
+    return rb_value;
+}
+
+static VALUE StencilMode_set_only(VALUE self, VALUE rb_value) {
+    ((StencilMode *) Get_StencilMode_Struct(self))->mode.stencilOnly = RTEST(rb_value);
+    return rb_value;
+}
+
+static VALUE StencilMode_eql(VALUE self, VALUE rb_other) {
+    sfStencilMode a = ((StencilMode *) Get_StencilMode_Struct(self))->mode;
+    sfStencilMode b;
+
+    if (!rb_obj_is_kind_of(rb_other, rb_cStencilMode)) {
+        return Qfalse;
+    }
+
+    b = ((StencilMode *) Get_StencilMode_Struct(rb_other))->mode;
+
+    return BOOL2RB(a.stencilComparison == b.stencilComparison &&
+                   a.stencilUpdateOperation == b.stencilUpdateOperation &&
+                   a.stencilReference.value == b.stencilReference.value &&
+                   a.stencilMask.value == b.stencilMask.value &&
+                   a.stencilOnly == b.stencilOnly);
+}
+
+void Init_StencilMode(VALUE rb_module) {
+    rb_cStencilMode = rb_define_class_under(rb_module, "StencilMode", rb_cObject);
+
+    rb_define_singleton_method(rb_cStencilMode, "new", StencilMode_new, -1);
+
+    rb_define_method(rb_cStencilMode, "comparison", StencilMode_get_comparison, 0);
+    rb_define_method(rb_cStencilMode, "update_operation", StencilMode_get_operation, 0);
+    rb_define_method(rb_cStencilMode, "reference", StencilMode_get_reference, 0);
+    rb_define_method(rb_cStencilMode, "mask", StencilMode_get_mask, 0);
+    rb_define_method(rb_cStencilMode, "stencil_only", StencilMode_get_only, 0);
+
+    rb_define_method(rb_cStencilMode, "comparison=", StencilMode_set_comparison, 1);
+    rb_define_method(rb_cStencilMode, "update_operation=", StencilMode_set_operation, 1);
+    rb_define_method(rb_cStencilMode, "reference=", StencilMode_set_reference, 1);
+    rb_define_method(rb_cStencilMode, "mask=", StencilMode_set_mask, 1);
+    rb_define_method(rb_cStencilMode, "stencil_only=", StencilMode_set_only, 1);
+
+    rb_define_method(rb_cStencilMode, "==", StencilMode_eql, 1);
+}
+
+VALUE Get_Klass_StencilMode(void) {
+    return rb_cStencilMode;
+}
+
+void *Get_StencilMode_Struct(VALUE self) {
+    StencilMode *ptr;
+    TypedData_Get_Struct(self, StencilMode, &StencilMode_data_type, ptr);
+    return ptr;
+}
+
+sfStencilMode stencil_mode_from_rb(VALUE rb_mode) {
+    if (rb_obj_is_kind_of(rb_mode, rb_cStencilMode)) {
+        return ((StencilMode *) Get_StencilMode_Struct(rb_mode))->mode;
+    }
+
+    return sfStencilMode_default;
+}
+
+VALUE stencil_mode_to_rb(sfStencilMode mode) {
+    return StencilMode_wrap(mode);
+}

data/ext/graphics/stencil_mode.h

@@ -0,0 +1,18 @@
+#ifndef SFML_RB_GRAPHICS_STENCIL_MODE_H
+#define SFML_RB_GRAPHICS_STENCIL_MODE_H
+
+#include <ruby.h>
+
+#include "core/sfml.h"
+
+void Init_StencilMode(VALUE rb_module);
+
+VALUE Get_Klass_StencilMode(void);
+
+void *Get_StencilMode_Struct(VALUE self);
+
+sfStencilMode stencil_mode_from_rb(VALUE rb_mode);
+
+VALUE stencil_mode_to_rb(sfStencilMode mode);
+
+#endif //SFML_RB_GRAPHICS_STENCIL_MODE_H

data/ext/graphics/target.c

@@ -0,0 +1,133 @@
+#include "graphics/target.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "graphics/render_state.h"
+#include "graphics/render_texture.h"
+#include "graphics/view.h"
+#include "window/window.h"
+#include "core/exceptions.h"
+#include "core/macros.h"
+
+static VALUE rb_cTarget;
+
+static Target *Target_create(TargetType type, void *handle) {
+    Target *target = malloc(sizeof(Target));
+
+    target->type = type;
+    target->handle = handle;
+
+    return target;
+}
+
+static void RenderTarget_free(void *ptr) {
+    free(ptr);
+}
+
+static const rb_data_type_t RenderTarget_data_type = {
+    .wrap_struct_name = "SFML::Target",
+    .function = {.dmark = NULL, .dfree = RenderTarget_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE RenderTarget_new(VALUE klass, VALUE rb_window) {
+    VALUE self;
+    Target *target;
+
+    if (!rb_obj_is_kind_of(rb_window, Get_Klass_Window())) {
+        raise_invalid_argument_class(Get_Klass_Window());
+    }
+
+    target = Target_create(SFML_TARGET_WINDOW, Get_Window_Struct(rb_window));
+    self = TypedData_Wrap_Struct(klass, &RenderTarget_data_type, target);
+
+    rb_obj_call_init(self, 0, NULL);
+
+    return self;
+}
+
+static VALUE RenderTarget_init(VALUE self) {
+    return self;
+}
+
+static VALUE RenderTarget_draw(VALUE self, VALUE rb_drawable, VALUE rb_state) {
+    if (!rb_obj_is_kind_of(rb_state, Get_Klass_RenderState())) {
+        raise_invalid_argument_class(Get_Klass_RenderState());
+    }
+
+    return rb_funcall(rb_drawable, rb_intern("draw"), 2, self, rb_state);
+}
+
+static VALUE RenderTarget_set_view(VALUE self, VALUE rb_view) {
+    Target *target = Get_Target_Struct(self);
+
+    if (!rb_obj_is_kind_of(rb_view, Get_Klass_View())) {
+        raise_invalid_argument_class(Get_Klass_View());
+    }
+
+    if (target->type == SFML_TARGET_WINDOW) {
+        sfRenderWindow_setView((sfRenderWindow *) target->handle, Get_View_Struct(rb_view));
+    } else {
+        sfRenderTexture_setView((sfRenderTexture *) target->handle, Get_View_Struct(rb_view));
+    }
+
+    return Qnil;
+}
+
+static VALUE RenderTarget_get_view(VALUE self) {
+    Target *target = Get_Target_Struct(self);
+    sfView *view;
+
+    if (target->type == SFML_TARGET_WINDOW) {
+        view = sfView_copy(sfRenderWindow_getView((sfRenderWindow *) target->handle));
+    } else {
+        view = sfView_copy(sfRenderTexture_getView((sfRenderTexture *) target->handle));
+    }
+
+    return Get_Casting_View(view);
+}
+
+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, 0);
+    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;
+}
+
+Target *Get_Target_Struct(VALUE self) {
+    Target *ptr;
+    TypedData_Get_Struct(self, Target, &RenderTarget_data_type, ptr);
+    return ptr;
+}
+
+VALUE Get_New_Target(VALUE rb_window) {
+    return RenderTarget_new(Get_Klass_Target(), rb_window);
+}
+
+VALUE Get_New_Target_From_RenderTexture(VALUE rb_render_texture) {
+    VALUE self;
+    Target *target;
+
+    if (!rb_obj_is_kind_of(rb_render_texture, Get_Klass_RenderTexture())) {
+        raise_invalid_argument_class(Get_Klass_RenderTexture());
+    }
+
+    target = Target_create(SFML_TARGET_TEXTURE, Get_RenderTexture_Struct(rb_render_texture));
+    self = TypedData_Wrap_Struct(rb_cTarget, &RenderTarget_data_type, target);
+
+    return self;
+}

data/ext/graphics/target.h

@@ -0,0 +1,40 @@
+#ifndef SFML_RB_GRAPHICS_TARGET_H
+#define SFML_RB_GRAPHICS_TARGET_H
+
+#include <ruby.h>
+
+#include "core/sfml.h"
+
+typedef enum {
+    SFML_TARGET_WINDOW,
+    SFML_TARGET_TEXTURE
+} TargetType;
+
+typedef struct {
+    TargetType type;
+    void *handle;
+} Target;
+
+/* Dispatch a draw call to whichever underlying render surface this target
+   wraps. Pass NULL states to use the defaults; never hand CSFML a NULL. */
+#define TARGET_DRAW(target, window_fn, texture_fn, object, states)                        \
+    do {                                                                                  \
+        const sfRenderStates *sfml_states = (states) ? (states) : &sfRenderStates_default; \
+        if ((target)->type == SFML_TARGET_WINDOW) {                                       \
+            window_fn((sfRenderWindow *) (target)->handle, (object), sfml_states);        \
+        } else {                                                                          \
+            texture_fn((sfRenderTexture *) (target)->handle, (object), sfml_states);      \
+        }                                                                                 \
+    } while (0)
+
+void Init_Target(VALUE rb_module);
+
+VALUE Get_Klass_Target(void);
+
+Target *Get_Target_Struct(VALUE self);
+
+VALUE Get_New_Target(VALUE rb_window);
+
+VALUE Get_New_Target_From_RenderTexture(VALUE rb_render_texture);
+
+#endif //SFML_RB_GRAPHICS_TARGET_H