sfml3-rb 0.0.1 → 0.2.2

data/ext/graphics/vertex_buffer.c

@@ -0,0 +1,211 @@
+#include "graphics/vertex_buffer.h"
+
+#include <ruby.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "graphics/drawable.h"
+#include "graphics/target.h"
+#include "graphics/render_state.h"
+#include "graphics/vertex.h"
+#include "graphics/enums.h"
+#include "core/exceptions.h"
+#include "core/macros.h"
+
+static VALUE rb_cVertexBuffer;
+
+static const char* usage_names[] = {"stream", "dynamic", "static"};
+
+static void VertexBuffer_free(void* ptr) {
+    sfVertexBuffer_destroy(ptr);
+}
+
+static const rb_data_type_t VertexBuffer_data_type = {
+    .wrap_struct_name = "SFML::VertexBuffer",
+    .function = {.dmark = NULL, .dfree = VertexBuffer_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY};
+
+static VALUE VertexBuffer_wrap(VALUE klass, sfVertexBuffer* buffer) {
+    if (buffer == NULL) {
+        rb_raise(rb_eRuntimeError, "failed to create vertex buffer");
+    }
+
+    return TypedData_Wrap_Struct(klass, &VertexBuffer_data_type, buffer);
+}
+
+sfVertexBuffer* Get_VertexBuffer_Struct(VALUE self) {
+    sfVertexBuffer* ptr;
+    TypedData_Get_Struct(self, sfVertexBuffer, &VertexBuffer_data_type, ptr);
+    return ptr;
+}
+
+static sfVertexBufferUsage usage_from_rb(VALUE rb_usage) {
+    size_t i;
+
+    if (RB_INTEGER_TYPE_P(rb_usage)) {
+        return (sfVertexBufferUsage)NUM2INT(rb_usage);
+    }
+
+    if (SYMBOL_P(rb_usage)) {
+        const char* name = rb_id2name(SYM2ID(rb_usage));
+
+        for (i = 0; i < 3; i++) {
+            if (strcmp(name, usage_names[i]) == 0) {
+                return (sfVertexBufferUsage)i;
+            }
+        }
+    }
+
+    rb_raise(rb_eArgError, "unknown vertex buffer usage");
+    return sfVertexBufferStatic;
+}
+
+static VALUE VertexBuffer_new(int argc, VALUE* argv, VALUE klass) {
+    VALUE rb_count, rb_primitive, rb_usage;
+    size_t count = 0;
+    sfPrimitiveType primitive = sfPoints;
+    sfVertexBufferUsage usage = sfVertexBufferStatic;
+
+    rb_scan_args(argc, argv, "03", &rb_count, &rb_primitive, &rb_usage);
+
+    if (!NIL_P(rb_count)) {
+        count = (size_t)NUM2SIZET(rb_count);
+    }
+
+    if (!NIL_P(rb_primitive)) {
+        primitive = primitive_type_from_rb(rb_primitive);
+    }
+
+    if (!NIL_P(rb_usage)) {
+        usage = usage_from_rb(rb_usage);
+    }
+
+    return VertexBuffer_wrap(klass, sfVertexBuffer_create(count, primitive, usage));
+}
+
+static VALUE VertexBuffer_copy(VALUE self) {
+    return VertexBuffer_wrap(Get_Klass_VertexBuffer(),
+                             sfVertexBuffer_copy(Get_VertexBuffer_Struct(self)));
+}
+
+static VALUE VertexBuffer_get_vertex_count(VALUE self) {
+    return SIZET2NUM(sfVertexBuffer_getVertexCount(Get_VertexBuffer_Struct(self)));
+}
+
+static VALUE VertexBuffer_update(int argc, VALUE* argv, VALUE self) {
+    VALUE rb_vertices, rb_offset;
+    unsigned int offset = 0;
+    size_t count;
+    sfVertex* vertices;
+    bool result;
+
+    rb_scan_args(argc, argv, "11", &rb_vertices, &rb_offset);
+
+    if (!NIL_P(rb_offset)) {
+        offset = (unsigned int)NUM2UINT(rb_offset);
+    }
+
+    vertices = vertices_from_rb(rb_vertices, &count);
+
+    result =
+        sfVertexBuffer_update(Get_VertexBuffer_Struct(self), vertices, (unsigned int)count, offset);
+
+    xfree(vertices);
+
+    return BOOL2RB(result);
+}
+
+static VALUE VertexBuffer_update_from(VALUE self, VALUE rb_other) {
+    if (!rb_obj_is_kind_of(rb_other, rb_cVertexBuffer)) {
+        raise_invalid_argument_class(rb_cVertexBuffer);
+    }
+
+    return BOOL2RB(sfVertexBuffer_updateFromVertexBuffer(Get_VertexBuffer_Struct(self),
+                                                         Get_VertexBuffer_Struct(rb_other)));
+}
+
+/* Exchanges the two buffers' contents in place, so anything already holding
+   either object sees the swap. */
+static VALUE VertexBuffer_swap(VALUE self, VALUE rb_other) {
+    if (!rb_obj_is_kind_of(rb_other, rb_cVertexBuffer)) {
+        raise_invalid_argument_class(rb_cVertexBuffer);
+    }
+
+    sfVertexBuffer_swap(Get_VertexBuffer_Struct(self), Get_VertexBuffer_Struct(rb_other));
+
+    return self;
+}
+
+static VALUE VertexBuffer_get_primitive_type(VALUE self) {
+    return ID2SYM(rb_intern(
+        primitive_type_name(sfVertexBuffer_getPrimitiveType(Get_VertexBuffer_Struct(self)))));
+}
+
+static VALUE VertexBuffer_set_primitive_type(VALUE self, VALUE rb_type) {
+    sfVertexBuffer_setPrimitiveType(Get_VertexBuffer_Struct(self), primitive_type_from_rb(rb_type));
+    return rb_type;
+}
+
+static VALUE VertexBuffer_get_usage(VALUE self) {
+    return ID2SYM(rb_intern(usage_names[sfVertexBuffer_getUsage(Get_VertexBuffer_Struct(self))]));
+}
+
+static VALUE VertexBuffer_set_usage(VALUE self, VALUE rb_usage) {
+    sfVertexBuffer_setUsage(Get_VertexBuffer_Struct(self), usage_from_rb(rb_usage));
+    return rb_usage;
+}
+
+static VALUE VertexBuffer_get_native_handle(VALUE self) {
+    return UINT2NUM(sfVertexBuffer_getNativeHandle(Get_VertexBuffer_Struct(self)));
+}
+
+static VALUE VertexBuffer_bind(VALUE self) {
+    sfVertexBuffer_bind(Get_VertexBuffer_Struct(self));
+    return self;
+}
+
+static VALUE VertexBuffer_is_available(VALUE klass) {
+    return BOOL2RB(sfVertexBuffer_isAvailable());
+}
+
+static VALUE VertexBuffer_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_drawVertexBuffer,
+                sfRenderTexture_drawVertexBuffer, Get_VertexBuffer_Struct(self),
+                Get_RenderState_Struct(rb_state));
+
+    return Qnil;
+}
+
+void Init_VertexBuffer(VALUE rb_module) {
+    rb_cVertexBuffer = rb_define_class_under(rb_module, "VertexBuffer", rb_cObject);
+
+    rb_include_module(rb_cVertexBuffer, Get_Module_Drawable());
+
+    rb_define_singleton_method(rb_cVertexBuffer, "new", VertexBuffer_new, -1);
+    rb_define_singleton_method(rb_cVertexBuffer, "available?", VertexBuffer_is_available, 0);
+
+    rb_define_method(rb_cVertexBuffer, "copy", VertexBuffer_copy, 0);
+    rb_define_method(rb_cVertexBuffer, "vertex_count", VertexBuffer_get_vertex_count, 0);
+    rb_define_method(rb_cVertexBuffer, "update", VertexBuffer_update, -1);
+    rb_define_method(rb_cVertexBuffer, "update_from", VertexBuffer_update_from, 1);
+    rb_define_method(rb_cVertexBuffer, "swap", VertexBuffer_swap, 1);
+    rb_define_method(rb_cVertexBuffer, "primitive", VertexBuffer_get_primitive_type, 0);
+    rb_define_method(rb_cVertexBuffer, "primitive=", VertexBuffer_set_primitive_type, 1);
+    rb_define_method(rb_cVertexBuffer, "usage", VertexBuffer_get_usage, 0);
+    rb_define_method(rb_cVertexBuffer, "usage=", VertexBuffer_set_usage, 1);
+    rb_define_method(rb_cVertexBuffer, "native_handle", VertexBuffer_get_native_handle, 0);
+    rb_define_method(rb_cVertexBuffer, "bind", VertexBuffer_bind, 0);
+    rb_define_method(rb_cVertexBuffer, "draw", VertexBuffer_draw, 2);
+}
+
+VALUE Get_Klass_VertexBuffer(void) {
+    return rb_cVertexBuffer;
+}

data/ext/graphics/vertex_buffer.h

@@ -0,0 +1,14 @@
+#ifndef SFML_RB_GRAPHICS_VERTEX_BUFFER_H
+#define SFML_RB_GRAPHICS_VERTEX_BUFFER_H
+
+#include <ruby.h>
+
+#include "core/sfml.h"
+
+void Init_VertexBuffer(VALUE rb_module);
+
+VALUE Get_Klass_VertexBuffer(void);
+
+sfVertexBuffer* Get_VertexBuffer_Struct(VALUE self);
+
+#endif // SFML_RB_GRAPHICS_VERTEX_BUFFER_H

data/ext/{view.c → graphics/view.c}

@@ -1,170 +1,169 @@
-#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);
+#include "graphics/view.h"
+
+#include <stdio.h>
+
+#include "graphics/transform.h"
+#include "graphics/transformable.h"
+#include "graphics/color.h"
+#include "system/vec2.h"
+#include "graphics/rect.h"
+#include "core/macros.h"
+#include "core/sfml.h"
+
+static VALUE rb_cView;
+
+static sfView* View_create() {
+    return sfView_create();
+}
+
+static void View_free(void* ptr) {
+    sfView_destroy(ptr);
+}
+
+static const rb_data_type_t View_data_type = {
+    .wrap_struct_name = "SFML::View",
+    .function = {.dmark = NULL, .dfree = View_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY};
+
+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 = TypedData_Wrap_Struct(klass, &View_data_type, view);
+
+    rb_obj_call_init(self, 0, NULL);
+
+    return self;
+}
+
+static VALUE View_new(VALUE klass) {
+    return View_new_from(klass, NULL);
+}
+
+/* The rect is the visible area: position is the top-left corner, not the
+   centre, which is what distinguishes this from new + center=/size=. */
+static VALUE View_s_from_rect(VALUE klass, VALUE rb_rect) {
+    return View_new_from(klass, sfView_createFromRect(rect_from_rb(rb_rect)));
+}
+
+static VALUE View_init(VALUE self) {
+    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_from_rb(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_rotation(VALUE self) {
+    return DBL2NUM(sfView_getRotation(Get_View_Struct(self)));
+}
+
+static VALUE View_get_size(VALUE self) {
+    return vec2f_to_rb(sfView_getSize(Get_View_Struct(self)));
+}
+
+static VALUE View_get_center(VALUE self) {
+    return vec2f_to_rb(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_set_scissor(VALUE self, VALUE rb_scissor) {
+    sfView_setScissor(Get_View_Struct(self), RECT_RB2C(rb_scissor));
+
+    return self;
+}
+
+static VALUE View_get_scissor(VALUE self) {
+    return RECT_C2RB(sfView_getScissor(Get_View_Struct(self)));
+}
+
+static VALUE View_move(VALUE self, VALUE rb_move) {
+    sfView_move(Get_View_Struct(self), vec2f_from_rb(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);
+    rb_define_singleton_method(rb_cView, "from_rect", View_s_from_rect, 1);
+
+    // 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, "rotation=", 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);
+    rb_define_method(rb_cView, "scissor=", View_set_scissor, 1);
+
+    // getters
+    rb_define_method(rb_cView, "rotation", 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);
+    rb_define_method(rb_cView, "scissor", View_get_scissor, 0);
+}
+
+void* Get_View_Struct(VALUE self) {
+    sfView* ptr;
+    TypedData_Get_Struct(self, sfView, &View_data_type, ptr);
+    return ptr;
+}
+
+VALUE Get_Klass_View() {
+    return rb_cView;
+}
+
+VALUE Get_Casting_View(void* ptr) {
+    return View_new_from(Get_Klass_View(), ptr);
 }

data/ext/{ext/klass → graphics}/view.h

@@ -1,5 +1,5 @@
-#ifndef CANDY2D_EXT_VIEW_H
-#define CANDY2D_EXT_VIEW_H
+#ifndef SFML_RB_GRAPHICS_VIEW_H
+#define SFML_RB_GRAPHICS_VIEW_H
 
 #include <ruby.h>
 
@@ -11,4 +11,4 @@ VALUE Get_Klass_View();
 
 VALUE Get_Casting_View(void *ptr);
 
-#endif //CANDY2D_EXT_VIEW_H
+#endif //SFML_RB_GRAPHICS_VIEW_H