sfml3-rb 0.3.0 → 0.3.1

data/ext/graphics/circle.c

@@ -61,6 +61,27 @@ static VALUE Circle_wrap(VALUE klass, sfCircleShape* shape) {
     return TypedData_Wrap_Struct(klass, &Circle_data_type, ptr);
 }
 
+static VALUE Circle_alloc(VALUE klass) {
+    Circle* ptr = malloc(sizeof(Circle));
+    sfCircleShape* shape;
+
+    if (ptr == NULL) {
+        rb_raise(rb_eNoMemError, "failed to allocate circle shape");
+    }
+
+    shape = sfCircleShape_create();
+
+    if (shape == NULL) {
+        free(ptr);
+        rb_raise(rb_eRuntimeError, "failed to create circle shape");
+    }
+
+    ptr->shape = shape;
+    ptr->rb_texture = Qnil;
+
+    return TypedData_Wrap_Struct(klass, &Circle_data_type, ptr);
+}
+
 /* call-seq:
  *   Circle.new(radius = 0) -> Circle
  *
@@ -68,19 +89,16 @@ static VALUE Circle_wrap(VALUE klass, sfCircleShape* shape) {
  *
  * @return [Circle]
  */
-static VALUE Circle_new(int argc, VALUE* argv, VALUE klass) {
+static VALUE Circle_initialize(int argc, VALUE* argv, VALUE self) {
     VALUE rb_radius;
-    sfCircleShape* shape;
 
     rb_scan_args(argc, argv, "01", &rb_radius);
 
-    shape = sfCircleShape_create();
-
     if (!NIL_P(rb_radius)) {
-        sfCircleShape_setRadius(shape, NUM2DBL(rb_radius));
+        sfCircleShape_setRadius(Get_Circle_Shape(self), NUM2DBL(rb_radius));
     }
 
-    return Circle_wrap(klass, shape);
+    return self;
 }
 
 /* call-seq: copy -> Circle
@@ -465,17 +483,14 @@ static VALUE Circle_get_global_bounds(VALUE self) {
  * @return [nil]
  */
 static VALUE Circle_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());
-    }
+    TargetView view = Get_RenderTarget_View(rb_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_drawCircleShape,
-                sfRenderTexture_drawCircleShape, Get_Circle_Shape(self),
-                Get_RenderState_Struct(rb_state));
+    TARGET_DRAW(view, sfRenderWindow_drawCircleShape, sfRenderTexture_drawCircleShape,
+                Get_Circle_Shape(self), Get_RenderState_Struct(rb_state));
 
     return Qnil;
 }
@@ -532,9 +547,11 @@ static VALUE Circle_draw(VALUE self, VALUE rb_target, VALUE rb_state) {
 void Init_Circle(VALUE rb_mSFML) {
     rb_cCircle = rb_define_class_under(rb_mSFML, "Circle", rb_cObject);
 
+    rb_define_alloc_func(rb_cCircle, Circle_alloc);
+
     rb_include_module(rb_cCircle, Get_Module_Drawable());
 
-    rb_define_singleton_method(rb_cCircle, "new", Circle_new, -1);
+    rb_define_method(rb_cCircle, "initialize", Circle_initialize, -1);
 
     // methods
     rb_define_method(rb_cCircle, "copy", Circle_copy, 0);

data/ext/graphics/color.c

@@ -54,6 +54,18 @@ static sfColor Color_from_integer(VALUE rb_integer) {
                      (unsigned char)((value >> 8) & 0xFF), (unsigned char)(value & 0xFF)};
 }
 
+static VALUE Color_alloc(VALUE klass) {
+    Color* ptr = malloc(sizeof(Color));
+
+    if (ptr == NULL) {
+        rb_raise(rb_eNoMemError, "failed to allocate color");
+    }
+
+    ptr->color = (sfColor){0, 0, 0, 255};
+
+    return TypedData_Wrap_Struct(klass, &Color_data_type, ptr);
+}
+
 /* call-seq:
  *   Color.new                    -> Color(0, 0, 0, 255)
  *   Color.new(r, g, b, a=255)    -> Color(r, g, b, a)
@@ -70,9 +82,7 @@ static sfColor Color_from_integer(VALUE rb_integer) {
  * @raise [ArgumentError] if given an Array shorter than 3 elements, or an
  *   argument count other than 0, 1, 3 or 4
  */
-static VALUE Color_new(int argc, VALUE* argv, VALUE klass) {
-    VALUE self;
-    Color* ptr;
+static VALUE Color_initialize(int argc, VALUE* argv, VALUE self) {
     sfColor color = {0, 0, 0, 255};
 
     if (argc == 1 && rb_obj_is_kind_of(argv[0], rb_cColor)) {
@@ -90,10 +100,7 @@ static VALUE Color_new(int argc, VALUE* argv, VALUE klass) {
         raise_invalid_arguments_excepted(4, argc);
     }
 
-    ptr = malloc(sizeof(Color));
-    ptr->color = color;
-
-    self = TypedData_Wrap_Struct(klass, &Color_data_type, ptr);
+    ((Color*)Get_Color_Struct(self))->color = color;
 
     return self;
 }
@@ -344,7 +351,9 @@ static VALUE Color_to_s(VALUE self) {
 void Init_Color(VALUE rb_mSFML) {
     rb_cColor = rb_define_class_under(rb_mSFML, "Color", rb_cObject);
 
-    rb_define_singleton_method(rb_cColor, "new", Color_new, -1);
+    rb_define_alloc_func(rb_cColor, Color_alloc);
+    rb_define_method(rb_cColor, "initialize", Color_initialize, -1);
+
     rb_define_singleton_method(rb_cColor, "from_rgb", Color_from_rgb, 1);
     rb_define_singleton_method(rb_cColor, "from_rgba", Color_from_rgba, 1);
 

data/ext/graphics/drawable.c

@@ -36,8 +36,9 @@ static VALUE Drawable_draw(VALUE self, VALUE rb_target, VALUE rb_state) {
 }
 
 /* Document-module: SFML::Drawable
- * A mixin for anything that can be drawn to a render target (Window,
- * RenderTexture) via #draw(target, state).
+ * A mixin for anything that can be drawn to a render target (RenderWindow,
+ * RenderTexture -- both include RenderTarget -- or a legacy Target) via
+ * #draw(target, state).
  */
 void Init_Drawable(VALUE rb_mSFML) {
     rb_mDrawable = rb_define_module_under(rb_mSFML, "Drawable");

data/ext/graphics/font.c

@@ -225,12 +225,18 @@ static VALUE Font_get_info(VALUE self) {
     return rb_str_new_cstr(info.family != NULL ? info.family : "");
 }
 
+static VALUE Font_alloc(VALUE klass) {
+    (void)klass;
+    rb_raise(rb_eNotImpError, "use Font.from_file, Font.from_memory or Font.from_stream");
+}
+
 /* Document-class: SFML::Font
  * A font face used to render text, loaded from a file, memory buffer or
  * stream. Glyphs are rasterized and cached lazily per character size.
  */
 void Init_Font(VALUE rb_mSFML) {
     rb_cFont = rb_define_class_under(rb_mSFML, "Font", rb_cObject);
+    rb_define_alloc_func(rb_cFont, Font_alloc);
 
     rb_define_singleton_method(rb_cFont, "from_file", Font_from_file, 1);
     rb_define_singleton_method(rb_cFont, "from_memory", Font_from_memory, 1);

data/ext/graphics/glyph.c

@@ -66,12 +66,19 @@ static VALUE Glyph_get_texture_rect(VALUE self) {
     return int_rect_to_rb(Get_Glyph(self)->glyph.textureRect);
 }
 
+static VALUE Glyph_alloc(VALUE klass) {
+    (void)klass;
+    rb_raise(rb_eNotImpError,
+             "glyph objects are returned by Font#glyph and cannot be constructed directly");
+}
+
 /* Document-class: SFML::Glyph
  * A single character's rendering metrics and texture location, as returned
  * by Font#glyph. Read-only.
  */
 void Init_Glyph(VALUE rb_mSFML) {
     rb_cGlyph = rb_define_class_under(rb_mSFML, "Glyph", rb_cObject);
+    rb_define_alloc_func(rb_cGlyph, Glyph_alloc);
 
     rb_define_method(rb_cGlyph, "advance", Glyph_get_advance, 0);
     rb_define_method(rb_cGlyph, "bounds", Glyph_get_bounds, 0);

data/ext/graphics/image.c

@@ -15,7 +15,9 @@
 static VALUE rb_cImage;
 
 static void Image_free(void* ptr) {
-    sfImage_destroy(ptr);
+    if (ptr != NULL) {
+        sfImage_destroy(ptr);
+    }
 }
 
 static const rb_data_type_t Image_data_type = {
@@ -31,6 +33,15 @@ static VALUE Image_wrap(VALUE klass, sfImage* image) {
     return TypedData_Wrap_Struct(klass, &Image_data_type, image);
 }
 
+static VALUE Image_initialize_copy(VALUE self, VALUE other) {
+    (void)other;
+    rb_raise(rb_eTypeError, "can't copy a %s", rb_obj_classname(self));
+}
+
+static VALUE Image_alloc(VALUE klass) {
+    return TypedData_Wrap_Struct(klass, &Image_data_type, NULL);
+}
+
 /* call-seq:
  *   Image.new(size) -> Image
  *
@@ -40,8 +51,16 @@ static VALUE Image_wrap(VALUE klass, sfImage* image) {
  * @return [Image]
  * @raise [RuntimeError] if the image cannot be created
  */
-static VALUE Image_new(VALUE klass, VALUE rb_size) {
-    return Image_wrap(klass, sfImage_create(vec2u_from_rb(rb_size)));
+static VALUE Image_initialize(VALUE self, VALUE rb_size) {
+    sfImage* image = sfImage_create(vec2u_from_rb(rb_size));
+
+    if (image == NULL) {
+        rb_raise(rb_eRuntimeError, "failed to create image");
+    }
+
+    DATA_PTR(self) = image;
+
+    return self;
 }
 
 /* call-seq:
@@ -313,7 +332,9 @@ static VALUE Image_flip_vertically(VALUE self) {
 void Init_Image(VALUE rb_mSFML) {
     rb_cImage = rb_define_class_under(rb_mSFML, "Image", rb_cObject);
 
-    rb_define_singleton_method(rb_cImage, "new", Image_new, 1);
+    rb_define_alloc_func(rb_cImage, Image_alloc);
+    rb_define_method(rb_cImage, "initialize", Image_initialize, 1);
+    rb_define_private_method(rb_cImage, "initialize_copy", Image_initialize_copy, 1);
     rb_define_singleton_method(rb_cImage, "from_color", Image_from_color, 2);
     rb_define_singleton_method(rb_cImage, "from_pixels", Image_from_pixels, 2);
     rb_define_singleton_method(rb_cImage, "from_file", Image_from_file, 1);

data/ext/graphics/polygon.c

@@ -59,6 +59,27 @@ static VALUE ConvexShape_wrap(VALUE klass, sfConvexShape* shape) {
     return TypedData_Wrap_Struct(klass, &ConvexShape_data_type, ptr);
 }
 
+static VALUE ConvexShape_alloc(VALUE klass) {
+    ConvexShape* ptr = malloc(sizeof(ConvexShape));
+    sfConvexShape* shape;
+
+    if (ptr == NULL) {
+        rb_raise(rb_eNoMemError, "failed to allocate convex shape");
+    }
+
+    shape = sfConvexShape_create();
+
+    if (shape == NULL) {
+        free(ptr);
+        rb_raise(rb_eRuntimeError, "failed to create convex shape");
+    }
+
+    ptr->shape = shape;
+    ptr->rb_texture = Qnil;
+
+    return TypedData_Wrap_Struct(klass, &ConvexShape_data_type, ptr);
+}
+
 /* call-seq:
  *   ConvexShape.new(point_count = 0) -> ConvexShape
  *
@@ -66,17 +87,17 @@ static VALUE ConvexShape_wrap(VALUE klass, sfConvexShape* shape) {
  *
  * @return [ConvexShape]
  */
-static VALUE ConvexShape_new(int argc, VALUE* argv, VALUE klass) {
-    sfConvexShape* shape = sfConvexShape_create();
+static VALUE ConvexShape_initialize(int argc, VALUE* argv, VALUE self) {
     VALUE rb_point_count;
 
     rb_scan_args(argc, argv, "01", &rb_point_count);
 
     if (!NIL_P(rb_point_count)) {
-        sfConvexShape_setPointCount(shape, (size_t)NUM2SIZET(rb_point_count));
+        sfConvexShape_setPointCount(Get_ConvexShape_Struct(self),
+                                    (size_t)NUM2SIZET(rb_point_count));
     }
 
-    return ConvexShape_wrap(klass, shape);
+    return self;
 }
 
 /* call-seq: copy -> ConvexShape
@@ -463,17 +484,14 @@ static VALUE ConvexShape_get_global_bounds(VALUE self) {
  * @return [nil]
  */
 static VALUE ConvexShape_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());
-    }
+    TargetView view = Get_RenderTarget_View(rb_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_drawConvexShape,
-                sfRenderTexture_drawConvexShape, Get_ConvexShape_Struct(self),
-                Get_RenderState_Struct(rb_state));
+    TARGET_DRAW(view, sfRenderWindow_drawConvexShape, sfRenderTexture_drawConvexShape,
+                Get_ConvexShape_Struct(self), Get_RenderState_Struct(rb_state));
 
     return Qnil;
 }
@@ -520,9 +538,11 @@ static VALUE ConvexShape_draw(VALUE self, VALUE rb_target, VALUE rb_state) {
 void Init_ConvexShape(VALUE rb_mSFML) {
     rb_cConvexShape = rb_define_class_under(rb_mSFML, "ConvexShape", rb_cObject);
 
+    rb_define_alloc_func(rb_cConvexShape, ConvexShape_alloc);
+
     rb_include_module(rb_cConvexShape, Get_Module_Drawable());
 
-    rb_define_singleton_method(rb_cConvexShape, "new", ConvexShape_new, -1);
+    rb_define_method(rb_cConvexShape, "initialize", ConvexShape_initialize, -1);
 
     rb_define_method(rb_cConvexShape, "copy", ConvexShape_copy, 0);
 

data/ext/graphics/rect.c

@@ -30,6 +30,18 @@ static VALUE Rect_wrap(sfFloatRect rect) {
     return TypedData_Wrap_Struct(rb_cRect, &Rect_data_type, ptr);
 }
 
+static VALUE Rect_alloc(VALUE klass) {
+    Rect* ptr = malloc(sizeof(Rect));
+
+    if (ptr == NULL) {
+        rb_raise(rb_eNoMemError, "failed to allocate rect");
+    }
+
+    ptr->rect = (sfFloatRect){{0, 0}, {0, 0}};
+
+    return TypedData_Wrap_Struct(klass, &Rect_data_type, ptr);
+}
+
 /* call-seq:
  *   Rect.new                        -> Rect(0, 0, 0, 0)
  *   Rect.new(left, top)             -> Rect(left, top, 0, 0)
@@ -44,9 +56,7 @@ static VALUE Rect_wrap(sfFloatRect rect) {
  * @raise [ArgumentError] if given an Array shorter than 4 elements, or an
  *   argument count other than 0, 1, 2 or 4
  */
-static VALUE Rect_new(int argc, VALUE* argv, VALUE klass) {
-    VALUE self;
-    Rect* ptr;
+static VALUE Rect_initialize(int argc, VALUE* argv, VALUE self) {
     sfFloatRect rect = {{0, 0}, {0, 0}};
 
     if (argc == 1 && rb_obj_is_kind_of(argv[0], rb_cRect)) {
@@ -62,10 +72,7 @@ static VALUE Rect_new(int argc, VALUE* argv, VALUE klass) {
         raise_invalid_arguments_excepted(4, argc);
     }
 
-    ptr = malloc(sizeof(Rect));
-    ptr->rect = rect;
-
-    self = TypedData_Wrap_Struct(klass, &Rect_data_type, ptr);
+    ((Rect*)Get_Rect_Struct(self))->rect = rect;
 
     return self;
 }
@@ -362,7 +369,8 @@ void Init_Rect(VALUE rb_mSFML) {
 
     rb_include_module(rb_cRect, rb_mEnumerable);
 
-    rb_define_singleton_method(rb_cRect, "new", Rect_new, -1);
+    rb_define_alloc_func(rb_cRect, Rect_alloc);
+    rb_define_method(rb_cRect, "initialize", Rect_initialize, -1);
 
     rb_define_method(rb_cRect, "left", Rect_get_left, 0);
     rb_define_method(rb_cRect, "top", Rect_get_top, 0);

data/ext/graphics/rectangle.c

@@ -60,6 +60,27 @@ static VALUE RectangleShape_wrap(VALUE klass, sfRectangleShape* shape) {
     return TypedData_Wrap_Struct(klass, &RectangleShape_data_type, ptr);
 }
 
+static VALUE RectangleShape_alloc(VALUE klass) {
+    RectangleShape* ptr = malloc(sizeof(RectangleShape));
+    sfRectangleShape* shape;
+
+    if (ptr == NULL) {
+        rb_raise(rb_eNoMemError, "failed to allocate rectangle shape");
+    }
+
+    shape = sfRectangleShape_create();
+
+    if (shape == NULL) {
+        free(ptr);
+        rb_raise(rb_eRuntimeError, "failed to create rectangle shape");
+    }
+
+    ptr->shape = shape;
+    ptr->rb_texture = Qnil;
+
+    return TypedData_Wrap_Struct(klass, &RectangleShape_data_type, ptr);
+}
+
 /* call-seq:
  *   RectangleShape.new(size = Vector2.new(0, 0)) -> RectangleShape
  *
@@ -67,17 +88,16 @@ static VALUE RectangleShape_wrap(VALUE klass, sfRectangleShape* shape) {
  *
  * @return [RectangleShape]
  */
-static VALUE RectangleShape_new(int argc, VALUE* argv, VALUE klass) {
-    sfRectangleShape* shape = sfRectangleShape_create();
+static VALUE RectangleShape_initialize(int argc, VALUE* argv, VALUE self) {
     VALUE rb_size;
 
     rb_scan_args(argc, argv, "01", &rb_size);
 
     if (!NIL_P(rb_size)) {
-        sfRectangleShape_setSize(shape, vec2f_from_rb(rb_size));
+        sfRectangleShape_setSize(Get_RectangleShape_Struct(self), vec2f_from_rb(rb_size));
     }
 
-    return RectangleShape_wrap(klass, shape);
+    return self;
 }
 
 /* call-seq: copy -> RectangleShape
@@ -451,17 +471,14 @@ static VALUE RectangleShape_get_global_bounds(VALUE self) {
  * @return [nil]
  */
 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());
-    }
+    TargetView view = Get_RenderTarget_View(rb_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));
+    TARGET_DRAW(view, sfRenderWindow_drawRectangleShape, sfRenderTexture_drawRectangleShape,
+                Get_RectangleShape_Struct(self), Get_RenderState_Struct(rb_state));
 
     return Qnil;
 }
@@ -504,9 +521,11 @@ static VALUE RectangleShape_draw(VALUE self, VALUE rb_target, VALUE rb_state) {
 void Init_RectangleShape(VALUE rb_mSFML) {
     rb_cRectangleShape = rb_define_class_under(rb_mSFML, "RectangleShape", rb_cObject);
 
+    rb_define_alloc_func(rb_cRectangleShape, RectangleShape_alloc);
+
     rb_include_module(rb_cRectangleShape, Get_Module_Drawable());
 
-    rb_define_singleton_method(rb_cRectangleShape, "new", RectangleShape_new, -1);
+    rb_define_method(rb_cRectangleShape, "initialize", RectangleShape_initialize, -1);
 
     rb_define_method(rb_cRectangleShape, "copy", RectangleShape_copy, 0);
 

data/ext/graphics/render_state.c

@@ -56,6 +56,10 @@ static VALUE RenderStates_wrap(VALUE klass, RenderStates* states) {
     return TypedData_Wrap_Struct(klass, &RenderStates_data_type, states);
 }
 
+static VALUE RenderStates_alloc(VALUE klass) {
+    return RenderStates_wrap(klass, RenderStates_create());
+}
+
 /* call-seq:
  *   RenderState.new         -> RenderState
  *   RenderState.new(matrix) -> RenderState
@@ -67,22 +71,15 @@ static VALUE RenderStates_wrap(VALUE klass, RenderStates* states) {
  * @return [RenderState]
  * @raise [ArgumentError] if given more than one argument
  */
-static VALUE RenderStates_new(int argc, VALUE* argv, VALUE klass) {
-    RenderStates* states;
-    VALUE self;
-
+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;
 }
 
@@ -282,7 +279,8 @@ static VALUE RenderStates_set_shader(VALUE self, VALUE rb_shader) {
 void Init_RenderState(VALUE rb_mSFML) {
     rb_cRenderState = rb_define_class_under(rb_mSFML, "RenderState", rb_cObject);
 
-    rb_define_singleton_method(rb_cRenderState, "new", RenderStates_new, -1);
+    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,12 +31,13 @@ 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);
 }
 
 /* call-seq:
@@ -46,14 +49,23 @@ static VALUE RenderTexture_wrap(VALUE klass, sfRenderTexture* render_texture) {
  * @return [RenderTexture]
  * @raise [RuntimeError] if creation fails
  */
-static VALUE RenderTexture_new(int argc, VALUE* argv, VALUE klass) {
+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
@@ -239,8 +251,7 @@ 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;
 }
@@ -314,7 +325,12 @@ static VALUE RenderTexture_maximum_antialiasing_level(VALUE klass) {
 void Init_RenderTexture(VALUE rb_mSFML) {
     rb_cRenderTexture = rb_define_class_under(rb_mSFML, "RenderTexture", rb_cObject);
 
-    rb_define_singleton_method(rb_cRenderTexture, "new", RenderTexture_new, -1);
+    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

data/ext/graphics/shader.c

@@ -728,6 +728,11 @@ static VALUE Shader_set_uniform(VALUE self, VALUE rb_name, VALUE rb_value) {
     return self;
 }
 
+static VALUE Shader_alloc(VALUE klass) {
+    (void)klass;
+    rb_raise(rb_eNotImpError, "use Shader.from_file, Shader.from_memory or Shader.from_stream");
+}
+
 /* Document-class: SFML::Shader
  * A GLSL vertex/geometry/fragment shader program, uploaded to the GPU and
  * carried on RenderState#shader.
@@ -757,6 +762,7 @@ static VALUE Shader_set_uniform(VALUE self, VALUE rb_name, VALUE rb_value) {
  */
 void Init_Shader(VALUE rb_mSFML) {
     rb_cShader = rb_define_class_under(rb_mSFML, "Shader", rb_cObject);
+    rb_define_alloc_func(rb_cShader, Shader_alloc);
 
     rb_define_singleton_method(rb_cShader, "from_file", Shader_from_file, -1);
     rb_define_singleton_method(rb_cShader, "from_memory", Shader_from_memory, -1);