sfml3-rb 0.0.1 → 0.2.2

data/ext/graphics/rectangle.c

@@ -0,0 +1,302 @@
+#include "graphics/rectangle.h"
+
+#include <ruby.h>
+#include <stdlib.h>
+
+#include "graphics/circle.h"
+#include "graphics/drawable.h"
+#include "graphics/target.h"
+#include "graphics/render_state.h"
+#include "graphics/transform.h"
+#include "graphics/color.h"
+#include "graphics/rect.h"
+#include "graphics/texture.h"
+#include "system/vec2.h"
+#include "core/exceptions.h"
+#include "core/macros.h"
+
+typedef struct {
+    sfRectangleShape *shape;
+    VALUE rb_texture;
+} RectangleShape;
+
+static VALUE rb_cRectangleShape;
+
+static void RectangleShape_mark(void *ptr) {
+    rb_gc_mark(((RectangleShape *) ptr)->rb_texture);
+}
+
+static void RectangleShape_free(void *ptr) {
+    sfRectangleShape_destroy(((RectangleShape *) ptr)->shape);
+    free(ptr);
+}
+
+static const rb_data_type_t RectangleShape_data_type = {
+    .wrap_struct_name = "SFML::RectangleShape",
+    .function = {.dmark = RectangleShape_mark, .dfree = RectangleShape_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static RectangleShape *Get_RectangleShape(VALUE self) {
+    RectangleShape *ptr;
+    TypedData_Get_Struct(self, RectangleShape, &RectangleShape_data_type, ptr);
+    return ptr;
+}
+
+static sfRectangleShape *Get_RectangleShape_Struct(VALUE self) {
+    return Get_RectangleShape(self)->shape;
+}
+
+static VALUE RectangleShape_wrap(VALUE klass, sfRectangleShape *shape) {
+    RectangleShape *ptr;
+
+    if (shape == NULL) {
+        rb_raise(rb_eRuntimeError, "failed to create rectangle shape");
+    }
+
+    ptr = malloc(sizeof(RectangleShape));
+    ptr->shape = shape;
+    ptr->rb_texture = Qnil;
+
+    return TypedData_Wrap_Struct(klass, &RectangleShape_data_type, ptr);
+}
+
+static VALUE RectangleShape_new(int argc, VALUE *argv, VALUE klass) {
+    sfRectangleShape *shape = sfRectangleShape_create();
+    VALUE rb_size;
+
+    rb_scan_args(argc, argv, "01", &rb_size);
+
+    if (!NIL_P(rb_size)) {
+        sfRectangleShape_setSize(shape, vec2f_from_rb(rb_size));
+    }
+
+    return RectangleShape_wrap(klass, shape);
+}
+
+static VALUE RectangleShape_copy(VALUE self) {
+    RectangleShape *ptr = Get_RectangleShape(self);
+    VALUE copy = RectangleShape_wrap(Get_Klass_RectangleShape(), sfRectangleShape_copy(ptr->shape));
+
+    if (!NIL_P(ptr->rb_texture)) {
+        RectangleShape *copy_ptr = Get_RectangleShape(copy);
+
+        copy_ptr->rb_texture = ptr->rb_texture;
+        sfRectangleShape_setTexture(copy_ptr->shape, Get_Texture_Struct(ptr->rb_texture), false);
+    }
+
+    return copy;
+}
+
+static VALUE RectangleShape_get_size(VALUE self) {
+    return vec2f_to_rb(sfRectangleShape_getSize(Get_RectangleShape_Struct(self)));
+}
+
+static VALUE RectangleShape_set_size(VALUE self, VALUE rb_size) {
+    sfRectangleShape_setSize(Get_RectangleShape_Struct(self), vec2f_from_rb(rb_size));
+    return rb_size;
+}
+
+static VALUE RectangleShape_get_position(VALUE self) {
+    return vec2f_to_rb(sfRectangleShape_getPosition(Get_RectangleShape_Struct(self)));
+}
+
+static VALUE RectangleShape_set_position(VALUE self, VALUE rb_position) {
+    sfRectangleShape_setPosition(Get_RectangleShape_Struct(self), vec2f_from_rb(rb_position));
+    return rb_position;
+}
+
+static VALUE RectangleShape_get_rotation(VALUE self) {
+    return DBL2NUM(sfRectangleShape_getRotation(Get_RectangleShape_Struct(self)));
+}
+
+static VALUE RectangleShape_set_rotation(VALUE self, VALUE rb_rotation) {
+    sfRectangleShape_setRotation(Get_RectangleShape_Struct(self), NUM2DBL(rb_rotation));
+    return rb_rotation;
+}
+
+static VALUE RectangleShape_get_scale(VALUE self) {
+    return vec2f_to_rb(sfRectangleShape_getScale(Get_RectangleShape_Struct(self)));
+}
+
+static VALUE RectangleShape_set_scale(VALUE self, VALUE rb_scale) {
+    sfRectangleShape_setScale(Get_RectangleShape_Struct(self), vec2f_from_rb(rb_scale));
+    return rb_scale;
+}
+
+static VALUE RectangleShape_get_origin(VALUE self) {
+    return vec2f_to_rb(sfRectangleShape_getOrigin(Get_RectangleShape_Struct(self)));
+}
+
+static VALUE RectangleShape_set_origin(VALUE self, VALUE rb_origin) {
+    sfRectangleShape_setOrigin(Get_RectangleShape_Struct(self), vec2f_from_rb(rb_origin));
+    return rb_origin;
+}
+
+static VALUE RectangleShape_move(VALUE self, VALUE rb_offset) {
+    sfRectangleShape_move(Get_RectangleShape_Struct(self), vec2f_from_rb(rb_offset));
+    return self;
+}
+
+static VALUE RectangleShape_rotate(VALUE self, VALUE rb_angle) {
+    sfRectangleShape_rotate(Get_RectangleShape_Struct(self), NUM2DBL(rb_angle));
+    return self;
+}
+
+static VALUE RectangleShape_scale(VALUE self, VALUE rb_factors) {
+    sfRectangleShape_scale(Get_RectangleShape_Struct(self), vec2f_from_rb(rb_factors));
+    return self;
+}
+
+static VALUE RectangleShape_get_transform(VALUE self) {
+    return Transform_MatrixToArray(sfRectangleShape_getTransform(Get_RectangleShape_Struct(self)).matrix);
+}
+
+static VALUE RectangleShape_get_inverse_transform(VALUE self) {
+    return Transform_MatrixToArray(sfRectangleShape_getInverseTransform(Get_RectangleShape_Struct(self)).matrix);
+}
+
+static VALUE RectangleShape_get_fill_color(VALUE self) {
+    return color_to_rb(sfRectangleShape_getFillColor(Get_RectangleShape_Struct(self)));
+}
+
+static VALUE RectangleShape_set_fill_color(VALUE self, VALUE rb_color) {
+    sfRectangleShape_setFillColor(Get_RectangleShape_Struct(self), color_from_rb(rb_color));
+    return rb_color;
+}
+
+static VALUE RectangleShape_get_outline_color(VALUE self) {
+    return color_to_rb(sfRectangleShape_getOutlineColor(Get_RectangleShape_Struct(self)));
+}
+
+static VALUE RectangleShape_set_outline_color(VALUE self, VALUE rb_color) {
+    sfRectangleShape_setOutlineColor(Get_RectangleShape_Struct(self), color_from_rb(rb_color));
+    return rb_color;
+}
+
+static VALUE RectangleShape_get_outline_thickness(VALUE self) {
+    return DBL2NUM(sfRectangleShape_getOutlineThickness(Get_RectangleShape_Struct(self)));
+}
+
+static VALUE RectangleShape_set_outline_thickness(VALUE self, VALUE rb_thickness) {
+    sfRectangleShape_setOutlineThickness(Get_RectangleShape_Struct(self), NUM2DBL(rb_thickness));
+    return rb_thickness;
+}
+
+static VALUE RectangleShape_set_texture(VALUE self, VALUE rb_texture) {
+    RectangleShape *ptr = Get_RectangleShape(self);
+    bool reset_rect = false;
+
+    if (NIL_P(rb_texture)) {
+        ptr->rb_texture = Qnil;
+        sfRectangleShape_setTexture(ptr->shape, NULL, reset_rect);
+        return rb_texture;
+    }
+
+    if (!rb_obj_is_kind_of(rb_texture, Get_Klass_Texture())) {
+        raise_invalid_argument_class(Get_Klass_Texture());
+    }
+
+    ptr->rb_texture = rb_texture;
+    sfRectangleShape_setTexture(ptr->shape, Get_Texture_Struct(rb_texture), reset_rect);
+
+    return rb_texture;
+}
+
+static VALUE RectangleShape_get_texture(VALUE self) {
+    return Get_RectangleShape(self)->rb_texture;
+}
+
+static VALUE RectangleShape_get_texture_rect(VALUE self) {
+    return int_rect_to_rb(sfRectangleShape_getTextureRect(Get_RectangleShape_Struct(self)));
+}
+
+static VALUE RectangleShape_set_texture_rect(VALUE self, VALUE rb_rect) {
+    sfRectangleShape_setTextureRect(Get_RectangleShape_Struct(self), int_rect_from_rb(rb_rect));
+    return rb_rect;
+}
+
+static VALUE RectangleShape_get_point_count(VALUE self) {
+    return SIZET2NUM(sfRectangleShape_getPointCount(Get_RectangleShape_Struct(self)));
+}
+
+static VALUE RectangleShape_get_point(VALUE self, VALUE rb_index) {
+    return vec2f_to_rb(sfRectangleShape_getPoint(Get_RectangleShape_Struct(self), (size_t) NUM2SIZET(rb_index)));
+}
+
+static VALUE RectangleShape_get_geometric_center(VALUE self) {
+    return vec2f_to_rb(sfRectangleShape_getGeometricCenter(Get_RectangleShape_Struct(self)));
+}
+
+static VALUE RectangleShape_get_local_bounds(VALUE self) {
+    return rect_to_rb(sfRectangleShape_getLocalBounds(Get_RectangleShape_Struct(self)));
+}
+
+static VALUE RectangleShape_get_global_bounds(VALUE self) {
+    return rect_to_rb(sfRectangleShape_getGlobalBounds(Get_RectangleShape_Struct(self)));
+}
+
+static VALUE RectangleShape_draw(VALUE self, VALUE rb_target, VALUE rb_state) {
+    if (!rb_obj_is_kind_of(rb_target, Get_Klass_Target())) {
+        raise_invalid_argument_class(Get_Klass_Target());
+    }
+
+    if (!rb_obj_is_kind_of(rb_state, Get_Klass_RenderState())) {
+        raise_invalid_argument_class(Get_Klass_RenderState());
+    }
+
+    TARGET_DRAW(Get_Target_Struct(rb_target), sfRenderWindow_drawRectangleShape,
+                sfRenderTexture_drawRectangleShape, Get_RectangleShape_Struct(self),
+                Get_RenderState_Struct(rb_state));
+
+    return Qnil;
+}
+
+void Init_RectangleShape(VALUE rb_module) {
+    rb_cRectangleShape = rb_define_class_under(rb_module, "RectangleShape", rb_cObject);
+
+    rb_include_module(rb_cRectangleShape, Get_Module_Drawable());
+
+    rb_define_singleton_method(rb_cRectangleShape, "new", RectangleShape_new, -1);
+
+    rb_define_method(rb_cRectangleShape, "copy", RectangleShape_copy, 0);
+
+    rb_define_method(rb_cRectangleShape, "size", RectangleShape_get_size, 0);
+    rb_define_method(rb_cRectangleShape, "position", RectangleShape_get_position, 0);
+    rb_define_method(rb_cRectangleShape, "rotation", RectangleShape_get_rotation, 0);
+    rb_define_method(rb_cRectangleShape, "scale", RectangleShape_get_scale, 0);
+    rb_define_method(rb_cRectangleShape, "origin", RectangleShape_get_origin, 0);
+    rb_define_method(rb_cRectangleShape, "fill_color", RectangleShape_get_fill_color, 0);
+    rb_define_method(rb_cRectangleShape, "outline_color", RectangleShape_get_outline_color, 0);
+    rb_define_method(rb_cRectangleShape, "outline_thickness", RectangleShape_get_outline_thickness, 0);
+    rb_define_method(rb_cRectangleShape, "texture", RectangleShape_get_texture, 0);
+    rb_define_method(rb_cRectangleShape, "texture_rect", RectangleShape_get_texture_rect, 0);
+    rb_define_method(rb_cRectangleShape, "point_count", RectangleShape_get_point_count, 0);
+    rb_define_method(rb_cRectangleShape, "point", RectangleShape_get_point, 1);
+    rb_define_method(rb_cRectangleShape, "geometric_center", RectangleShape_get_geometric_center, 0);
+    rb_define_method(rb_cRectangleShape, "local_bounds", RectangleShape_get_local_bounds, 0);
+    rb_define_method(rb_cRectangleShape, "global_bounds", RectangleShape_get_global_bounds, 0);
+    rb_define_method(rb_cRectangleShape, "transform", RectangleShape_get_transform, 0);
+    rb_define_method(rb_cRectangleShape, "inverse_transform", RectangleShape_get_inverse_transform, 0);
+    rb_define_method(rb_cRectangleShape, "matrix", RectangleShape_get_transform, 0);
+
+    rb_define_method(rb_cRectangleShape, "size=", RectangleShape_set_size, 1);
+    rb_define_method(rb_cRectangleShape, "position=", RectangleShape_set_position, 1);
+    rb_define_method(rb_cRectangleShape, "rotation=", RectangleShape_set_rotation, 1);
+    rb_define_method(rb_cRectangleShape, "scale=", RectangleShape_set_scale, 1);
+    rb_define_method(rb_cRectangleShape, "origin=", RectangleShape_set_origin, 1);
+    rb_define_method(rb_cRectangleShape, "fill_color=", RectangleShape_set_fill_color, 1);
+    rb_define_method(rb_cRectangleShape, "outline_color=", RectangleShape_set_outline_color, 1);
+    rb_define_method(rb_cRectangleShape, "outline_thickness=", RectangleShape_set_outline_thickness, 1);
+    rb_define_method(rb_cRectangleShape, "texture=", RectangleShape_set_texture, 1);
+    rb_define_method(rb_cRectangleShape, "texture_rect=", RectangleShape_set_texture_rect, 1);
+
+    rb_define_method(rb_cRectangleShape, "move", RectangleShape_move, 1);
+    rb_define_method(rb_cRectangleShape, "rotate", RectangleShape_rotate, 1);
+    rb_define_method(rb_cRectangleShape, "scale!", RectangleShape_scale, 1);
+    rb_define_method(rb_cRectangleShape, "draw", RectangleShape_draw, 2);
+}
+
+VALUE Get_Klass_RectangleShape(void) {
+    return rb_cRectangleShape;
+}

data/ext/graphics/rectangle.h

@@ -0,0 +1,10 @@
+#ifndef SFML_RB_GRAPHICS_RECTANGLE_H
+#define SFML_RB_GRAPHICS_RECTANGLE_H
+
+#include <ruby.h>
+
+void Init_RectangleShape(VALUE rb_module);
+
+VALUE Get_Klass_RectangleShape(void);
+
+#endif //SFML_RB_GRAPHICS_RECTANGLE_H

data/ext/graphics/render_state.c

@@ -0,0 +1,204 @@
+#include "graphics/render_state.h"
+
+#include <ruby.h>
+#include <stdlib.h>
+
+#include "graphics/transform.h"
+#include "graphics/blend_mode.h"
+#include "graphics/stencil_mode.h"
+#include "graphics/enums.h"
+#include "graphics/texture.h"
+#include "graphics/shader.h"
+#include "core/exceptions.h"
+#include "core/macros.h"
+
+/* The wrapped struct holds Ruby references (texture, shader) alongside the C
+   states, so the data type needs a dmark. The C struct is a member rather than
+   the whole allocation so those references have somewhere to live. */
+typedef struct {
+    sfRenderStates c;
+    VALUE rb_texture;
+    VALUE rb_shader;
+} RenderStates;
+
+static VALUE rb_cRenderState;
+
+static void RenderStates_mark(void* ptr) {
+    RenderStates* states = ptr;
+
+    rb_gc_mark(states->rb_texture);
+    rb_gc_mark(states->rb_shader);
+}
+
+static void RenderStates_free(void* ptr) {
+    free(ptr);
+}
+
+static const rb_data_type_t RenderStates_data_type = {
+    .wrap_struct_name = "SFML::RenderState",
+    .function = {.dmark = RenderStates_mark, .dfree = RenderStates_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY};
+
+static RenderStates* RenderStates_create(void) {
+    RenderStates* states = malloc(sizeof(RenderStates));
+
+    /* Copy the defaults rather than filling fields by hand: CSFML 2 left the
+       struct smaller, and spelling fields out is how stencilMode and
+       coordinateType ended up uninitialised under CSFML 3. */
+    states->c = sfRenderStates_default;
+    states->rb_texture = Qnil;
+    states->rb_shader = Qnil;
+
+    return states;
+}
+
+static VALUE RenderStates_wrap(VALUE klass, RenderStates* states) {
+    return TypedData_Wrap_Struct(klass, &RenderStates_data_type, states);
+}
+
+static VALUE RenderStates_new(int argc, VALUE* argv, VALUE klass) {
+    RenderStates* states;
+    VALUE self;
+
+    if (argc > 1) {
+        raise_invalid_arguments_excepted(1, argc);
+    }
+
+    states = RenderStates_create();
+
+    if (argc == 1) {
+        states->c.transform = Transform_ArrayToTransform(argv[0]);
+    }
+
+    self = RenderStates_wrap(klass, states);
+
+    return self;
+}
+
+static VALUE RenderStates_set_transform(VALUE self, VALUE rb_matrix) {
+    sfRenderStates* states = Get_RenderState_Struct(self);
+
+    states->transform = Transform_ArrayToTransform(rb_matrix);
+
+    return self;
+}
+
+static VALUE RenderStates_get_transform(VALUE self) {
+    return Transform_MatrixToArray(Get_RenderState_Struct(self)->transform.matrix);
+}
+
+static VALUE RenderStates_get_blend_mode(VALUE self) {
+    return blend_mode_to_rb(Get_RenderState_Struct(self)->blendMode);
+}
+
+static VALUE RenderStates_set_blend_mode(VALUE self, VALUE rb_mode) {
+    Get_RenderState_Struct(self)->blendMode = blend_mode_from_rb(rb_mode);
+    return rb_mode;
+}
+
+static VALUE RenderStates_get_stencil_mode(VALUE self) {
+    return stencil_mode_to_rb(Get_RenderState_Struct(self)->stencilMode);
+}
+
+static VALUE RenderStates_set_stencil_mode(VALUE self, VALUE rb_mode) {
+    Get_RenderState_Struct(self)->stencilMode = stencil_mode_from_rb(rb_mode);
+    return rb_mode;
+}
+
+static VALUE RenderStates_get_coordinate_type(VALUE self) {
+    return ID2SYM(rb_intern(coordinate_type_name(Get_RenderState_Struct(self)->coordinateType)));
+}
+
+static VALUE RenderStates_set_coordinate_type(VALUE self, VALUE rb_type) {
+    Get_RenderState_Struct(self)->coordinateType = coordinate_type_from_rb(rb_type);
+    return rb_type;
+}
+
+/* sfRenderStates is the first member, so its address is the wrapper's. */
+static RenderStates* Get_RenderStates_Wrapper(VALUE self) {
+    return (RenderStates*)Get_RenderState_Struct(self);
+}
+
+static VALUE RenderStates_get_texture(VALUE self) {
+    return Get_RenderStates_Wrapper(self)->rb_texture;
+}
+
+static VALUE RenderStates_set_texture(VALUE self, VALUE rb_texture) {
+    RenderStates* states = Get_RenderStates_Wrapper(self);
+
+    if (NIL_P(rb_texture)) {
+        states->rb_texture = Qnil;
+        states->c.texture = NULL;
+        return rb_texture;
+    }
+
+    if (!rb_obj_is_kind_of(rb_texture, Get_Klass_Texture())) {
+        raise_invalid_argument_class(Get_Klass_Texture());
+    }
+
+    states->rb_texture = rb_texture;
+    states->c.texture = Get_Texture_Struct(rb_texture);
+
+    return rb_texture;
+}
+
+static VALUE RenderStates_get_shader(VALUE self) {
+    return Get_RenderStates_Wrapper(self)->rb_shader;
+}
+
+static VALUE RenderStates_set_shader(VALUE self, VALUE rb_shader) {
+    RenderStates* states = Get_RenderStates_Wrapper(self);
+
+    if (NIL_P(rb_shader)) {
+        states->rb_shader = Qnil;
+        states->c.shader = NULL;
+        return rb_shader;
+    }
+
+    if (!rb_obj_is_kind_of(rb_shader, Get_Klass_Shader())) {
+        raise_invalid_argument_class(Get_Klass_Shader());
+    }
+
+    states->rb_shader = rb_shader;
+    states->c.shader = Get_Shader_Struct(rb_shader);
+
+    return rb_shader;
+}
+
+void Init_RenderState(VALUE rb_module) {
+    rb_cRenderState = rb_define_class_under(rb_module, "RenderState", rb_cObject);
+
+    rb_define_singleton_method(rb_cRenderState, "new", RenderStates_new, -1);
+
+    // setters
+    rb_define_method(rb_cRenderState, "transform=", RenderStates_set_transform, 1);
+    rb_define_method(rb_cRenderState, "matrix=", RenderStates_set_transform, 1);
+    rb_define_method(rb_cRenderState, "blend_mode=", RenderStates_set_blend_mode, 1);
+    rb_define_method(rb_cRenderState, "stencil_mode=", RenderStates_set_stencil_mode, 1);
+    rb_define_method(rb_cRenderState, "coordinate_type=", RenderStates_set_coordinate_type, 1);
+    rb_define_method(rb_cRenderState, "texture=", RenderStates_set_texture, 1);
+    rb_define_method(rb_cRenderState, "shader=", RenderStates_set_shader, 1);
+
+    // getters
+    rb_define_method(rb_cRenderState, "transform", RenderStates_get_transform, 0);
+    rb_define_method(rb_cRenderState, "matrix", RenderStates_get_transform, 0);
+    rb_define_method(rb_cRenderState, "blend_mode", RenderStates_get_blend_mode, 0);
+    rb_define_method(rb_cRenderState, "stencil_mode", RenderStates_get_stencil_mode, 0);
+    rb_define_method(rb_cRenderState, "coordinate_type", RenderStates_get_coordinate_type, 0);
+    rb_define_method(rb_cRenderState, "texture", RenderStates_get_texture, 0);
+    rb_define_method(rb_cRenderState, "shader", RenderStates_get_shader, 0);
+}
+
+sfRenderStates* Get_RenderState_Struct(VALUE self) {
+    RenderStates* states;
+    TypedData_Get_Struct(self, RenderStates, &RenderStates_data_type, states);
+    return &states->c;
+}
+
+VALUE Get_Klass_RenderState(void) {
+    return rb_cRenderState;
+}
+
+VALUE Get_New_RenderState(void) {
+    return RenderStates_wrap(Get_Klass_RenderState(), RenderStates_create());
+}

data/ext/graphics/render_state.h

@@ -0,0 +1,18 @@
+#ifndef SFML_RB_GRAPHICS_RENDER_STATE_H
+#define SFML_RB_GRAPHICS_RENDER_STATE_H
+
+#include <ruby.h>
+
+#include "core/sfml.h"
+
+#define DefaultMatrix3x3() {1, 0, 0, 0, 1, 0, 0, 0, 1}
+
+void Init_RenderState(VALUE rb_module);
+
+sfRenderStates *Get_RenderState_Struct(VALUE self);
+
+VALUE Get_Klass_RenderState(void);
+
+VALUE Get_New_RenderState(void);
+
+#endif //SFML_RB_GRAPHICS_RENDER_STATE_H