sfml3-rb 0.2.2 → 0.3.1

data/ext/graphics/render_state.c

@@ -56,25 +56,41 @@ 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;
+static VALUE RenderStates_alloc(VALUE klass) {
+    return RenderStates_wrap(klass, RenderStates_create());
+}
 
+/* call-seq:
+ *   RenderState.new         -> RenderState
+ *   RenderState.new(matrix) -> RenderState
+ *
+ * Creates a render state with SFML's default blend mode, stencil mode and
+ * coordinate type, and identity transform unless +matrix+ (a 3x3
+ * row-major Array, see Transform) is given.
+ *
+ * @return [RenderState]
+ * @raise [ArgumentError] if given more than one argument
+ */
+static VALUE RenderStates_initialize(int argc, VALUE* argv, VALUE self) {
     if (argc > 1) {
         raise_invalid_arguments_excepted(1, argc);
     }
 
-    states = RenderStates_create();
-
     if (argc == 1) {
-        states->c.transform = Transform_ArrayToTransform(argv[0]);
+        Get_RenderState_Struct(self)->transform = Transform_ArrayToTransform(argv[0]);
     }
 
-    self = RenderStates_wrap(klass, states);
-
     return self;
 }
 
+/* call-seq:
+ *   transform=(matrix) -> self
+ *   matrix=(matrix) -> self
+ *
+ * +matrix+ is a 3x3 row-major Array, see Transform.
+ *
+ * @return [self]
+ */
 static VALUE RenderStates_set_transform(VALUE self, VALUE rb_matrix) {
     sfRenderStates* states = Get_RenderState_Struct(self);
 
@@ -83,32 +99,77 @@ static VALUE RenderStates_set_transform(VALUE self, VALUE rb_matrix) {
     return self;
 }
 
+/* call-seq: transform -> Array
+ *
+ * Also available as #matrix.
+ *
+ * @return [Array] the 3x3 row-major transform matrix
+ */
 static VALUE RenderStates_get_transform(VALUE self) {
     return Transform_MatrixToArray(Get_RenderState_Struct(self)->transform.matrix);
 }
 
+/* call-seq: blend_mode -> BlendMode
+ *
+ * Returns the state's blend mode.
+ *
+ * @return [BlendMode]
+ */
 static VALUE RenderStates_get_blend_mode(VALUE self) {
     return blend_mode_to_rb(Get_RenderState_Struct(self)->blendMode);
 }
 
+/* call-seq:
+ *   blend_mode=(value) -> BlendMode
+ *
+ * Sets the state's blend mode.
+ *
+ * @return [BlendMode] +value+
+ */
 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;
 }
 
+/* call-seq: stencil_mode -> StencilMode
+ *
+ * Returns the state's stencil mode.
+ *
+ * @return [StencilMode]
+ */
 static VALUE RenderStates_get_stencil_mode(VALUE self) {
     return stencil_mode_to_rb(Get_RenderState_Struct(self)->stencilMode);
 }
 
+/* call-seq:
+ *   stencil_mode=(value) -> StencilMode
+ *
+ * Sets the state's stencil mode.
+ *
+ * @return [StencilMode] +value+
+ */
 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;
 }
 
+/* call-seq: coordinate_type -> Symbol
+ *
+ * Returns the state's texture coordinate type.
+ *
+ * @return [Symbol] either +:pixels+ or +:normalized+
+ */
 static VALUE RenderStates_get_coordinate_type(VALUE self) {
     return ID2SYM(rb_intern(coordinate_type_name(Get_RenderState_Struct(self)->coordinateType)));
 }
 
+/* call-seq:
+ *   coordinate_type=(value) -> Symbol
+ *
+ * +value+ is +:pixels+ or +:normalized+.
+ *
+ * @return [Symbol] +value+
+ */
 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;
@@ -119,10 +180,23 @@ static RenderStates* Get_RenderStates_Wrapper(VALUE self) {
     return (RenderStates*)Get_RenderState_Struct(self);
 }
 
+/* call-seq: texture -> Texture or nil
+ *
+ * Returns the object's texture, or +nil+ if it has none.
+ *
+ * @return [Texture, nil]
+ */
 static VALUE RenderStates_get_texture(VALUE self) {
     return Get_RenderStates_Wrapper(self)->rb_texture;
 }
 
+/* call-seq:
+ *   texture=(value) -> Texture or nil
+ *
+ * Sets the object's texture.
+ *
+ * @return [Texture, nil] +value+
+ */
 static VALUE RenderStates_set_texture(VALUE self, VALUE rb_texture) {
     RenderStates* states = Get_RenderStates_Wrapper(self);
 
@@ -142,10 +216,23 @@ static VALUE RenderStates_set_texture(VALUE self, VALUE rb_texture) {
     return rb_texture;
 }
 
+/* call-seq: shader -> Shader or nil
+ *
+ * Returns the state's shader, or +nil+ if it has none.
+ *
+ * @return [Shader, nil]
+ */
 static VALUE RenderStates_get_shader(VALUE self) {
     return Get_RenderStates_Wrapper(self)->rb_shader;
 }
 
+/* call-seq:
+ *   shader=(value) -> Shader or nil
+ *
+ * Sets the state's shader.
+ *
+ * @return [Shader, nil] +value+
+ */
 static VALUE RenderStates_set_shader(VALUE self, VALUE rb_shader) {
     RenderStates* states = Get_RenderStates_Wrapper(self);
 
@@ -165,10 +252,35 @@ static VALUE RenderStates_set_shader(VALUE self, VALUE 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);
+/* Document-class: SFML::RenderState
+ * The set of render states (transform, blend mode, stencil mode,
+ * coordinate type, texture, shader) applied when drawing a Drawable to a
+ * render target.
+ *
+ * @!attribute transform
+ *   The object's transform matrix.
+ *   @return [Array] the 3x3 row-major transform matrix
+ * @!attribute blend_mode
+ *   The blend mode applied to the draw.
+ *   @return [BlendMode]
+ * @!attribute stencil_mode
+ *   The stencil mode applied to the draw.
+ *   @return [StencilMode]
+ * @!attribute coordinate_type
+ *   The type of texture coordinates used.
+ *   @return [Symbol] either +:pixels+ or +:normalized+
+ * @!attribute texture
+ *   The object's texture, or +nil+ if it has none.
+ *   @return [Texture, nil]
+ * @!attribute shader
+ *   The shader applied to the draw, or +nil+ if none.
+ *   @return [Shader, nil]
+ */
+void Init_RenderState(VALUE rb_mSFML) {
+    rb_cRenderState = rb_define_class_under(rb_mSFML, "RenderState", rb_cObject);
+
+    rb_define_alloc_func(rb_cRenderState, RenderStates_alloc);
+    rb_define_method(rb_cRenderState, "initialize", RenderStates_initialize, -1);
 
     // setters
     rb_define_method(rb_cRenderState, "transform=", RenderStates_set_transform, 1);

data/ext/graphics/render_texture.c

@@ -15,7 +15,9 @@
 static VALUE rb_cRenderTexture;
 
 static void RenderTexture_free(void* ptr) {
-    sfRenderTexture_destroy(ptr);
+    if (ptr != NULL) {
+        sfRenderTexture_destroy(ptr);
+    }
 }
 
 static const rb_data_type_t RenderTexture_data_type = {
@@ -29,39 +31,87 @@ sfRenderTexture* Get_RenderTexture_Struct(VALUE self) {
     return ptr;
 }
 
-static VALUE RenderTexture_wrap(VALUE klass, sfRenderTexture* render_texture) {
-    if (render_texture == NULL) {
-        rb_raise(rb_eRuntimeError, "failed to create render texture");
-    }
+static VALUE RenderTexture_initialize_copy(VALUE self, VALUE other) {
+    (void)other;
+    rb_raise(rb_eTypeError, "can't copy a %s", rb_obj_classname(self));
+}
 
-    return TypedData_Wrap_Struct(klass, &RenderTexture_data_type, render_texture);
+static VALUE RenderTexture_alloc(VALUE klass) {
+    return TypedData_Wrap_Struct(klass, &RenderTexture_data_type, NULL);
 }
 
-static VALUE RenderTexture_new(int argc, VALUE* argv, VALUE klass) {
+/* call-seq:
+ *   RenderTexture.new(size)           -> RenderTexture
+ *   RenderTexture.new(size, settings) -> RenderTexture
+ *
+ * +settings+ is currently accepted but ignored.
+ *
+ * @return [RenderTexture]
+ * @raise [RuntimeError] if creation fails
+ */
+static VALUE RenderTexture_initialize(int argc, VALUE* argv, VALUE self) {
     VALUE rb_size, rb_settings;
+    sfRenderTexture* render_texture;
 
     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));
+    render_texture = sfRenderTexture_create(vec2u_from_rb(rb_size), NULL);
+
+    if (render_texture == NULL) {
+        rb_raise(rb_eRuntimeError, "failed to create render texture");
+    }
+
+    DATA_PTR(self) = render_texture;
+
+    return self;
 }
 
+/* call-seq: size -> Vector2
+ *
+ * Returns the object's size.
+ *
+ * @return [Vector2]
+ */
 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});
 }
 
+/* call-seq:
+ *   active=(value) -> true or false
+ *
+ * Activates or deactivates this render texture as the current OpenGL
+ * rendering target on the calling thread.
+ *
+ * @return [Boolean] whether the operation succeeded
+ */
 static VALUE RenderTexture_set_active(VALUE self, VALUE rb_active) {
     return BOOL2RB(sfRenderTexture_setActive(Get_RenderTexture_Struct(self), RTEST(rb_active)));
 }
 
+/* call-seq: display -> self
+ *
+ * Updates the target texture with everything drawn so far. Call this after
+ * drawing and before reading #texture.
+ *
+ * @return [self]
+ */
 static VALUE RenderTexture_display(VALUE self) {
     sfRenderTexture_display(Get_RenderTexture_Struct(self));
     return self;
 }
 
+/* call-seq:
+ *   clear             -> self
+ *   clear(color)       -> self
+ *
+ * Clears the render texture to +color+ (a Color, default black).
+ *
+ * @return [self]
+ */
 static VALUE RenderTexture_clear(int argc, VALUE* argv, VALUE self) {
     VALUE rb_color;
     sfColor color = sfBlack;
@@ -77,6 +127,14 @@ static VALUE RenderTexture_clear(int argc, VALUE* argv, VALUE self) {
     return self;
 }
 
+/* call-seq:
+ *   view=(value) -> self
+ *
+ * Sets the target's current view.
+ *
+ * @return [self]
+ * @raise [TypeError] if +value+ is not a View
+ */
 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());
@@ -87,41 +145,102 @@ static VALUE RenderTexture_set_view(VALUE self, VALUE rb_view) {
     return self;
 }
 
+/* call-seq: view -> View
+ *
+ * Returns the target's current view.
+ *
+ * @return [View] a copy of the current view
+ */
 static VALUE RenderTexture_get_view(VALUE self) {
     return Get_Casting_View(sfView_copy(sfRenderTexture_getView(Get_RenderTexture_Struct(self))));
 }
 
+/* call-seq: default_view -> View
+ *
+ * Returns the view covering the whole render target.
+ *
+ * @return [View] a copy of the view covering the render texture's full area
+ */
 static VALUE RenderTexture_get_default_view(VALUE self) {
     return Get_Casting_View(
         sfView_copy(sfRenderTexture_getDefaultView(Get_RenderTexture_Struct(self))));
 }
 
+/* call-seq: texture -> Texture
+ *
+ * Returns the target texture, whose contents update after each #display.
+ *
+ * @return [Texture] the target texture, borrowed -- its contents update
+ *   after each #display
+ */
 static VALUE RenderTexture_get_texture(VALUE self) {
     return texture_from_borrowed(sfRenderTexture_getTexture(Get_RenderTexture_Struct(self)));
 }
 
+/* call-seq:
+ *   smooth=(value) -> true or false
+ *
+ * Enables or disables smooth rendering.
+ *
+ * @return [Boolean] +value+
+ */
 static VALUE RenderTexture_set_smooth(VALUE self, VALUE rb_smooth) {
     sfRenderTexture_setSmooth(Get_RenderTexture_Struct(self), RTEST(rb_smooth));
     return rb_smooth;
 }
 
+/* call-seq: smooth? -> true or false
+ *
+ * Returns +true+ if smooth rendering is enabled.
+ *
+ * @return [Boolean]
+ */
 static VALUE RenderTexture_is_smooth(VALUE self) {
     return BOOL2RB(sfRenderTexture_isSmooth(Get_RenderTexture_Struct(self)));
 }
 
+/* call-seq:
+ *   repeated=(value) -> true or false
+ *
+ * Enables or disables texture repeating.
+ *
+ * @return [Boolean] +value+
+ */
 static VALUE RenderTexture_set_repeated(VALUE self, VALUE rb_repeated) {
     sfRenderTexture_setRepeated(Get_RenderTexture_Struct(self), RTEST(rb_repeated));
     return rb_repeated;
 }
 
+/* call-seq: repeated? -> true or false
+ *
+ * Returns +true+ if texture repeating is enabled.
+ *
+ * @return [Boolean]
+ */
 static VALUE RenderTexture_is_repeated(VALUE self) {
     return BOOL2RB(sfRenderTexture_isRepeated(Get_RenderTexture_Struct(self)));
 }
 
+/* call-seq: generate_mipmap -> true or false
+ *
+ * Generates the mipmap pyramid for the texture.
+ *
+ * @return [Boolean] whether mipmap generation succeeded
+ */
 static VALUE RenderTexture_generate_mipmap(VALUE self) {
     return BOOL2RB(sfRenderTexture_generateMipmap(Get_RenderTexture_Struct(self)));
 }
 
+/* call-seq:
+ *   draw(drawable)         -> self
+ *   draw(drawable, state)  -> self
+ *
+ * Draws +drawable+ (anything responding to +#draw+, i.e. including
+ * Drawable) using +state+ (a RenderState, default the identity state).
+ *
+ * @return [self]
+ * @raise [ArgumentError] if given no arguments or more than 2
+ */
 static VALUE RenderTexture_draw(int argc, VALUE* argv, VALUE self) {
     VALUE rb_drawable, rb_state;
 
@@ -132,12 +251,18 @@ static VALUE RenderTexture_draw(int argc, VALUE* argv, VALUE self) {
     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);
+    rb_funcall(rb_drawable, rb_intern("draw"), 2, self, rb_state);
 
     return self;
 }
 
+/* call-seq:
+ *   RenderTexture.maximum_antialiasing_level -> Integer
+ *
+ * Returns the maximum supported antialiasing level.
+ *
+ * @return [Integer]
+ */
 static VALUE RenderTexture_maximum_antialiasing_level(VALUE klass) {
     return UINT2NUM(sfRenderTexture_getMaximumAntiAliasingLevel());
 }
@@ -150,10 +275,62 @@ static VALUE RenderTexture_maximum_antialiasing_level(VALUE klass) {
 #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);
+/* Document-class: SFML::RenderTexture
+ * An off-screen render target backed by a Texture: anything drawable can be
+ * drawn onto it, then read back via #texture (after #display).
+ *
+ * The methods below are shared with Window via the render_target.inc
+ * fragment (see ext/graphics/render_target.inc) and documented here
+ * directly since the fragment hides their function bodies from the
+ * doc-comment scanner. Window's own docs restate the same list.
+ *
+ * @!method srgb?
+ *   Returns +true+ if the render texture uses an sRGB format.
+ *   @return [Boolean]
+ * @!method clear_stencil(value)
+ *   Clears the stencil buffer with the given value.
+ *   @return [self]
+ * @!method clear_color_and_stencil(color, stencil)
+ *   Clears the color and stencil buffers in one pass.
+ *   @return [self]
+ * @!method viewport(view = nil)
+ *   Returns the current viewport in pixels; +view+ defaults to the target's current view.
+ *   @return [Rect] the current viewport in pixels; +view+ defaults to the target's current view
+ * @!method scissor(view = nil)
+ *   Returns the current scissor rectangle in pixels; +view+ defaults to the target's current view.
+ *   @return [Rect] the current scissor rectangle in pixels; +view+ defaults to the target's current
+ * view
+ * @!method map_pixel_to_coords(point, view = nil)
+ *   Converts a pixel position to world coordinates, using the inverse of the view transform.
+ *   @return [Vector2]
+ * @!method map_coords_to_pixel(point, view = nil)
+ *   Converts a world position to pixel coordinates.
+ *   @return [Vector2]
+ * @!method push_gl_states
+ *   Saves the current OpenGL states before custom drawing.
+ *   @return [self]
+ * @!method pop_gl_states
+ *   Restores the OpenGL states saved by #push_gl_states.
+ *   @return [self]
+ * @!method reset_gl_states
+ *   Resets the OpenGL states to those SFML expects.
+ *   @return [self]
+ * @!method draw_primitives(vertices, primitive, state = nil)
+ *   Draws raw vertex primitives using the given primitive type and render state.
+ *   @return [self]
+ * @!method draw_vertex_buffer_range(buffer, first, count, state = nil)
+ *   Draws a range of vertices from a VertexBuffer.
+ *   @return [self]
+ */
+void Init_RenderTexture(VALUE rb_mSFML) {
+    rb_cRenderTexture = rb_define_class_under(rb_mSFML, "RenderTexture", rb_cObject);
+
+    rb_include_module(rb_cRenderTexture, Get_Module_RenderTarget());
+
+    rb_define_alloc_func(rb_cRenderTexture, RenderTexture_alloc);
+    rb_define_method(rb_cRenderTexture, "initialize", RenderTexture_initialize, -1);
+    rb_define_private_method(rb_cRenderTexture, "initialize_copy", RenderTexture_initialize_copy,
+                             1);
     rb_define_singleton_method(rb_cRenderTexture, "maximum_antialiasing_level",
                                RenderTexture_maximum_antialiasing_level, 0);
 

data/ext/graphics/render_window.c

@@ -0,0 +1,55 @@
+#include "graphics/render_window.h"
+
+#include <ruby.h>
+
+#include "graphics/render_state.h"
+#include "graphics/target.h"
+#include "window/window.h"
+#include "window/window_base.h"
+#include "core/exceptions.h"
+#include "core/macros.h"
+
+static VALUE rb_cRenderWindow;
+
+/* call-seq:
+ *   draw(drawable, state = nil) -> self
+ *
+ * Draws +drawable+ into the window. Unlike Window#draw this hands +self+ to the
+ * drawable, because a RenderWindow is a RenderTarget.
+ *
+ * @return [self]
+ * @raise [ArgumentError] if given no arguments or more than 2
+ */
+static VALUE RenderWindow_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(rb_drawable, rb_intern("draw"), 2, self, rb_state);
+
+    return self;
+}
+
+/* Document-class: SFML::RenderWindow
+ * A SFML::Window that is also a SFML::RenderTarget, so it can be handed
+ * directly to a drawable's #draw as well as drawn into with #draw. Creation,
+ * events and every window method come from Window (and WindowBase); the
+ * render-target surface is listed on SFML::RenderTarget.
+ */
+void Init_RenderWindow(VALUE rb_mSFML) {
+    rb_cRenderWindow = rb_define_class_under(rb_mSFML, "RenderWindow", Get_Klass_Window());
+
+    rb_define_alloc_func(rb_cRenderWindow, Window_alloc);
+    rb_define_method(rb_cRenderWindow, "draw", RenderWindow_draw, -1);
+
+    rb_include_module(rb_cRenderWindow, Get_Module_RenderTarget());
+}
+
+VALUE Get_Klass_RenderWindow(void) {
+    return rb_cRenderWindow;
+}

data/ext/graphics/render_window.h

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