sfml3-rb 0.0.1 → 0.2.2

data/ext/graphics/render_target.inc

@@ -0,0 +1,181 @@
+/* Shared method bodies for every render target (Window, RenderTexture).
+   Included from two translation units; each defines RT_FN, RT_METHOD and
+   RT_HANDLE before including this file, then undefines them after. Generating
+   concrete methods per class keeps the compiler's type checks on the handle and
+   on every sf* call, which a runtime dispatch through void* would not.
+
+   CSFML gives sfRenderWindow and sfRenderTexture identical render-target
+   surfaces under two name prefixes, so RT_FN is the only thing that differs.
+   SFML::Target still exists for the runtime-dispatch case (Drawable#draw); this
+   file is about the methods each concrete target owns directly. */
+
+#include "graphics/enums.h"
+#include "graphics/render_state.h"
+#include "graphics/vertex.h"
+#include "graphics/vertex_buffer.h"
+#include "graphics/view.h"
+#include "graphics/color.h"
+#include "graphics/rect.h"
+#include "system/vec2.h"
+#include "core/exceptions.h"
+#include "core/macros.h"
+
+/* A nil view means "the target's current view", which is what CSFML's NULL
+   means for every one of these. */
+static const sfView *RT_METHOD(view_arg)(VALUE rb_view) {
+    if (NIL_P(rb_view)) {
+        return NULL;
+    }
+
+    if (!rb_obj_is_kind_of(rb_view, Get_Klass_View())) {
+        raise_invalid_argument_class(Get_Klass_View());
+    }
+
+    return Get_View_Struct(rb_view);
+}
+
+static const sfRenderStates *RT_METHOD(state_arg)(VALUE rb_state) {
+    if (NIL_P(rb_state)) {
+        return NULL;
+    }
+
+    if (!rb_obj_is_kind_of(rb_state, Get_Klass_RenderState())) {
+        raise_invalid_argument_class(Get_Klass_RenderState());
+    }
+
+    return Get_RenderState_Struct(rb_state);
+}
+
+static VALUE RT_METHOD(is_srgb)(VALUE self) {
+    return BOOL2RB(RT_FN(isSrgb)(RT_HANDLE(self)));
+}
+
+static VALUE RT_METHOD(clear_stencil)(VALUE self, VALUE rb_value) {
+    sfStencilValue value = {.value = (unsigned int) NUM2UINT(rb_value)};
+
+    RT_FN(clearStencil)(RT_HANDLE(self), value);
+
+    return self;
+}
+
+static VALUE RT_METHOD(clear_color_and_stencil)(VALUE self, VALUE rb_color, VALUE rb_stencil) {
+    sfStencilValue value = {.value = (unsigned int) NUM2UINT(rb_stencil)};
+
+    RT_FN(clearColorAndStencil)(RT_HANDLE(self), color_from_rb(rb_color), value);
+
+    return self;
+}
+
+static VALUE RT_METHOD(get_viewport)(int argc, VALUE *argv, VALUE self) {
+    VALUE rb_view;
+
+    rb_scan_args(argc, argv, "01", &rb_view);
+
+    return int_rect_to_rb(RT_FN(getViewport)(RT_HANDLE(self), RT_METHOD(view_arg)(rb_view)));
+}
+
+static VALUE RT_METHOD(get_scissor)(int argc, VALUE *argv, VALUE self) {
+    VALUE rb_view;
+
+    rb_scan_args(argc, argv, "01", &rb_view);
+
+    return int_rect_to_rb(RT_FN(getScissor)(RT_HANDLE(self), RT_METHOD(view_arg)(rb_view)));
+}
+
+/* Pixel -> world. The inverse of the view transform, so a zoomed, rotated or
+   viewport-shifted view still turns a mouse position into scene coordinates. */
+static VALUE RT_METHOD(map_pixel_to_coords)(int argc, VALUE *argv, VALUE self) {
+    VALUE rb_point, rb_view;
+
+    rb_scan_args(argc, argv, "11", &rb_point, &rb_view);
+
+    return vec2f_to_rb(RT_FN(mapPixelToCoords)(RT_HANDLE(self),
+                                               vec2i_from_rb(rb_point),
+                                               RT_METHOD(view_arg)(rb_view)));
+}
+
+/* World -> pixel. Returns integer pixel coordinates. */
+static VALUE RT_METHOD(map_coords_to_pixel)(int argc, VALUE *argv, VALUE self) {
+    VALUE rb_point, rb_view;
+    sfVector2i pixel;
+
+    rb_scan_args(argc, argv, "11", &rb_point, &rb_view);
+
+    pixel = RT_FN(mapCoordsToPixel)(RT_HANDLE(self),
+                                    vec2f_from_rb(rb_point),
+                                    RT_METHOD(view_arg)(rb_view));
+
+    return VEC2_C2RB(pixel);
+}
+
+static VALUE RT_METHOD(push_gl_states)(VALUE self) {
+    RT_FN(pushGLStates)(RT_HANDLE(self));
+    return self;
+}
+
+static VALUE RT_METHOD(pop_gl_states)(VALUE self) {
+    RT_FN(popGLStates)(RT_HANDLE(self));
+    return self;
+}
+
+static VALUE RT_METHOD(reset_gl_states)(VALUE self) {
+    RT_FN(resetGLStates)(RT_HANDLE(self));
+    return self;
+}
+
+/* draw_primitives(vertices, primitive, state = nil) */
+static VALUE RT_METHOD(draw_primitives)(int argc, VALUE *argv, VALUE self) {
+    VALUE rb_vertices, rb_primitive, rb_state;
+    sfPrimitiveType type;
+    const sfRenderStates *states;
+    sfVertex *vertices;
+    size_t count;
+
+    rb_scan_args(argc, argv, "21", &rb_vertices, &rb_primitive, &rb_state);
+
+    /* Every argument is converted before the array is allocated, so a bad
+       vertex raises without leaking it. */
+    type = primitive_type_from_rb(rb_primitive);
+    states = RT_METHOD(state_arg)(rb_state);
+    vertices = vertices_from_rb(rb_vertices, &count);
+
+    RT_FN(drawPrimitives)(RT_HANDLE(self), vertices, count, type, states);
+
+    xfree(vertices);
+
+    return self;
+}
+
+/* draw_vertex_buffer_range(buffer, first, count, state = nil) */
+static VALUE RT_METHOD(draw_vertex_buffer_range)(int argc, VALUE *argv, VALUE self) {
+    VALUE rb_buffer, rb_first, rb_count, rb_state;
+
+    rb_scan_args(argc, argv, "31", &rb_buffer, &rb_first, &rb_count, &rb_state);
+
+    if (!rb_obj_is_kind_of(rb_buffer, Get_Klass_VertexBuffer())) {
+        raise_invalid_argument_class(Get_Klass_VertexBuffer());
+    }
+
+    RT_FN(drawVertexBufferRange)(RT_HANDLE(self),
+                                 Get_VertexBuffer_Struct(rb_buffer),
+                                 NUM2SIZET(rb_first),
+                                 NUM2SIZET(rb_count),
+                                 RT_METHOD(state_arg)(rb_state));
+
+    return self;
+}
+
+static void RT_METHOD(define_render_target_methods)(VALUE klass) {
+    rb_define_method(klass, "srgb?", RT_METHOD(is_srgb), 0);
+    rb_define_method(klass, "clear_stencil", RT_METHOD(clear_stencil), 1);
+    rb_define_method(klass, "clear_color_and_stencil", RT_METHOD(clear_color_and_stencil), 2);
+    rb_define_method(klass, "viewport", RT_METHOD(get_viewport), -1);
+    rb_define_method(klass, "scissor", RT_METHOD(get_scissor), -1);
+    rb_define_method(klass, "map_pixel_to_coords", RT_METHOD(map_pixel_to_coords), -1);
+    rb_define_method(klass, "map_coords_to_pixel", RT_METHOD(map_coords_to_pixel), -1);
+    rb_define_method(klass, "push_gl_states", RT_METHOD(push_gl_states), 0);
+    rb_define_method(klass, "pop_gl_states", RT_METHOD(pop_gl_states), 0);
+    rb_define_method(klass, "reset_gl_states", RT_METHOD(reset_gl_states), 0);
+    rb_define_method(klass, "draw_primitives", RT_METHOD(draw_primitives), -1);
+    rb_define_method(klass, "draw_vertex_buffer_range", RT_METHOD(draw_vertex_buffer_range), -1);
+}

data/ext/graphics/render_texture.c

@@ -0,0 +1,182 @@
+#include "graphics/render_texture.h"
+
+#include <ruby.h>
+
+#include "graphics/target.h"
+#include "graphics/render_state.h"
+#include "graphics/view.h"
+#include "graphics/texture.h"
+#include "graphics/color.h"
+#include "graphics/rect.h"
+#include "system/vec2.h"
+#include "core/exceptions.h"
+#include "core/macros.h"
+
+static VALUE rb_cRenderTexture;
+
+static void RenderTexture_free(void* ptr) {
+    sfRenderTexture_destroy(ptr);
+}
+
+static const rb_data_type_t RenderTexture_data_type = {
+    .wrap_struct_name = "SFML::RenderTexture",
+    .function = {.dmark = NULL, .dfree = RenderTexture_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY};
+
+sfRenderTexture* Get_RenderTexture_Struct(VALUE self) {
+    sfRenderTexture* ptr;
+    TypedData_Get_Struct(self, sfRenderTexture, &RenderTexture_data_type, ptr);
+    return ptr;
+}
+
+static VALUE RenderTexture_wrap(VALUE klass, sfRenderTexture* render_texture) {
+    if (render_texture == NULL) {
+        rb_raise(rb_eRuntimeError, "failed to create render texture");
+    }
+
+    return TypedData_Wrap_Struct(klass, &RenderTexture_data_type, render_texture);
+}
+
+static VALUE RenderTexture_new(int argc, VALUE* argv, VALUE klass) {
+    VALUE rb_size, rb_settings;
+
+    rb_scan_args(argc, argv, "11", &rb_size, &rb_settings);
+
+    (void)rb_settings;
+
+    return RenderTexture_wrap(klass, sfRenderTexture_create(vec2u_from_rb(rb_size), NULL));
+}
+
+static VALUE RenderTexture_get_size(VALUE self) {
+    sfVector2u size = sfRenderTexture_getSize(Get_RenderTexture_Struct(self));
+
+    return vec2f_to_rb((sfVector2f){(float)size.x, (float)size.y});
+}
+
+static VALUE RenderTexture_set_active(VALUE self, VALUE rb_active) {
+    return BOOL2RB(sfRenderTexture_setActive(Get_RenderTexture_Struct(self), RTEST(rb_active)));
+}
+
+static VALUE RenderTexture_display(VALUE self) {
+    sfRenderTexture_display(Get_RenderTexture_Struct(self));
+    return self;
+}
+
+static VALUE RenderTexture_clear(int argc, VALUE* argv, VALUE self) {
+    VALUE rb_color;
+    sfColor color = sfBlack;
+
+    rb_scan_args(argc, argv, "01", &rb_color);
+
+    if (!NIL_P(rb_color)) {
+        color = color_from_rb(rb_color);
+    }
+
+    sfRenderTexture_clear(Get_RenderTexture_Struct(self), color);
+
+    return self;
+}
+
+static VALUE RenderTexture_set_view(VALUE self, VALUE rb_view) {
+    if (!rb_obj_is_kind_of(rb_view, Get_Klass_View())) {
+        raise_invalid_argument_class(Get_Klass_View());
+    }
+
+    sfRenderTexture_setView(Get_RenderTexture_Struct(self), Get_View_Struct(rb_view));
+
+    return self;
+}
+
+static VALUE RenderTexture_get_view(VALUE self) {
+    return Get_Casting_View(sfView_copy(sfRenderTexture_getView(Get_RenderTexture_Struct(self))));
+}
+
+static VALUE RenderTexture_get_default_view(VALUE self) {
+    return Get_Casting_View(
+        sfView_copy(sfRenderTexture_getDefaultView(Get_RenderTexture_Struct(self))));
+}
+
+static VALUE RenderTexture_get_texture(VALUE self) {
+    return texture_from_borrowed(sfRenderTexture_getTexture(Get_RenderTexture_Struct(self)));
+}
+
+static VALUE RenderTexture_set_smooth(VALUE self, VALUE rb_smooth) {
+    sfRenderTexture_setSmooth(Get_RenderTexture_Struct(self), RTEST(rb_smooth));
+    return rb_smooth;
+}
+
+static VALUE RenderTexture_is_smooth(VALUE self) {
+    return BOOL2RB(sfRenderTexture_isSmooth(Get_RenderTexture_Struct(self)));
+}
+
+static VALUE RenderTexture_set_repeated(VALUE self, VALUE rb_repeated) {
+    sfRenderTexture_setRepeated(Get_RenderTexture_Struct(self), RTEST(rb_repeated));
+    return rb_repeated;
+}
+
+static VALUE RenderTexture_is_repeated(VALUE self) {
+    return BOOL2RB(sfRenderTexture_isRepeated(Get_RenderTexture_Struct(self)));
+}
+
+static VALUE RenderTexture_generate_mipmap(VALUE self) {
+    return BOOL2RB(sfRenderTexture_generateMipmap(Get_RenderTexture_Struct(self)));
+}
+
+static VALUE RenderTexture_draw(int argc, VALUE* argv, VALUE self) {
+    VALUE rb_drawable, rb_state;
+
+    if (argc == 0 || argc > 2) {
+        raise_invalid_arguments_excepted(-1, argc);
+    }
+
+    rb_drawable = argv[0];
+    rb_state = (argc == 2) ? argv[1] : Get_New_RenderState();
+
+    rb_funcall(Get_New_Target_From_RenderTexture(self), rb_intern("draw"), 2, rb_drawable,
+               rb_state);
+
+    return self;
+}
+
+static VALUE RenderTexture_maximum_antialiasing_level(VALUE klass) {
+    return UINT2NUM(sfRenderTexture_getMaximumAntiAliasingLevel());
+}
+
+#define RT_FN(name) sfRenderTexture_##name
+#define RT_METHOD(name) RenderTexture_##name
+#define RT_HANDLE(self) Get_RenderTexture_Struct(self)
+#include "graphics/render_target.inc"
+#undef RT_FN
+#undef RT_METHOD
+#undef RT_HANDLE
+
+void Init_RenderTexture(VALUE rb_module) {
+    rb_cRenderTexture = rb_define_class_under(rb_module, "RenderTexture", rb_cObject);
+
+    rb_define_singleton_method(rb_cRenderTexture, "new", RenderTexture_new, -1);
+    rb_define_singleton_method(rb_cRenderTexture, "maximum_antialiasing_level",
+                               RenderTexture_maximum_antialiasing_level, 0);
+
+    rb_define_method(rb_cRenderTexture, "size", RenderTexture_get_size, 0);
+    rb_define_method(rb_cRenderTexture, "display", RenderTexture_display, 0);
+    rb_define_method(rb_cRenderTexture, "clear", RenderTexture_clear, -1);
+    rb_define_method(rb_cRenderTexture, "view", RenderTexture_get_view, 0);
+    rb_define_method(rb_cRenderTexture, "default_view", RenderTexture_get_default_view, 0);
+    rb_define_method(rb_cRenderTexture, "texture", RenderTexture_get_texture, 0);
+    rb_define_method(rb_cRenderTexture, "smooth?", RenderTexture_is_smooth, 0);
+    rb_define_method(rb_cRenderTexture, "repeated?", RenderTexture_is_repeated, 0);
+    rb_define_method(rb_cRenderTexture, "generate_mipmap", RenderTexture_generate_mipmap, 0);
+
+    rb_define_method(rb_cRenderTexture, "view=", RenderTexture_set_view, 1);
+    rb_define_method(rb_cRenderTexture, "active=", RenderTexture_set_active, 1);
+    rb_define_method(rb_cRenderTexture, "smooth=", RenderTexture_set_smooth, 1);
+    rb_define_method(rb_cRenderTexture, "repeated=", RenderTexture_set_repeated, 1);
+
+    rb_define_method(rb_cRenderTexture, "draw", RenderTexture_draw, -1);
+
+    RenderTexture_define_render_target_methods(rb_cRenderTexture);
+}
+
+VALUE Get_Klass_RenderTexture(void) {
+    return rb_cRenderTexture;
+}

data/ext/graphics/render_texture.h

@@ -0,0 +1,14 @@
+#ifndef SFML_RB_GRAPHICS_RENDER_TEXTURE_H
+#define SFML_RB_GRAPHICS_RENDER_TEXTURE_H
+
+#include <ruby.h>
+
+#include "core/sfml.h"
+
+void Init_RenderTexture(VALUE rb_module);
+
+VALUE Get_Klass_RenderTexture(void);
+
+sfRenderTexture *Get_RenderTexture_Struct(VALUE self);
+
+#endif //SFML_RB_GRAPHICS_RENDER_TEXTURE_H