ruby-sdl2 0.3.5 → 0.3.7

data/video.c.m4

@@ -65,7 +65,20 @@ typedef struct Surface {
     int need_to_free_pixels;
 } Surface;
 
+static void Window_free(Window*);
 static void Renderer_free(Renderer*);
+static void Texture_free(Texture*);
+static void Surface_free(Surface*);
+
+/* Forward-declare TypedData types (need free function declarations above) */
+DEFINE_DATA_TYPE(Window, Window_free);
+DEFINE_DATA_TYPE(SDL_DisplayMode, free);
+DEFINE_DATA_TYPE(Renderer, Renderer_free);
+DEFINE_DATA_TYPE(Texture, Texture_free);
+DEFINE_DATA_TYPE(Surface, Surface_free);
+DEFINE_DATA_TYPE(SDL_Rect, free);
+DEFINE_DATA_TYPE(SDL_Point, free);
+
 static void Window_destroy_internal(Window* w)
 {
     int i;
@@ -89,12 +102,13 @@ static void Window_free(Window* w)
 
 static VALUE Window_new(SDL_Window* window)
 {
-    Window* w = ALLOC(Window);
+    Window* w;
+    VALUE obj = TypedData_Make_Struct(cWindow, Window, &Window_data_type, w);
     w->window = window;
     w->num_renderers = 0;
     w->max_renderers = 4;
     w->renderers = ALLOC_N(struct Renderer*, 4);
-    return Data_Wrap_Struct(cWindow, 0, Window_free, w);
+    return obj;
 }
 
 DEFINE_GETTER(static, Window, cWindow, "SDL2::Window");
@@ -111,24 +125,24 @@ static VALUE Display_new(int index)
 
 static VALUE DisplayMode_s_allocate(VALUE klass)
 {
-    SDL_DisplayMode* mode = ALLOC(SDL_DisplayMode);
+    SDL_DisplayMode* mode;
+    VALUE obj = TypedData_Make_Struct(klass, SDL_DisplayMode, &SDL_DisplayMode_data_type, mode);
     mode->format = mode->w = mode->h = mode->refresh_rate = 0;
     mode->driverdata = NULL;
-    return Data_Wrap_Struct(klass, 0, free, mode);
+    return obj;
 }
 
 static VALUE DisplayMode_new(SDL_DisplayMode* mode)
 {
     VALUE display_mode = DisplayMode_s_allocate(cDisplayMode);
     SDL_DisplayMode* m;
-    Data_Get_Struct(display_mode, SDL_DisplayMode, m);
+    TypedData_Get_Struct(display_mode, SDL_DisplayMode, &SDL_DisplayMode_data_type, m);
     *m = *mode;
     return display_mode;
 }
 
 DEFINE_GETTER(static, SDL_DisplayMode, cDisplayMode, "SDL2::Display::Mode");
 
-static void Texture_free(Texture*);
 static void Renderer_destroy_internal(Renderer* r)
 {
     int i;
@@ -167,14 +181,15 @@ static void Window_attach_renderer(Window* w, Renderer* r)
 
 static VALUE Renderer_new(SDL_Renderer* renderer, Window* w)
 {
-    Renderer* r = ALLOC(Renderer);
+    Renderer* r;
+    VALUE obj = TypedData_Make_Struct(cRenderer, Renderer, &Renderer_data_type, r);
     r->renderer = renderer;
     r->num_textures = 0;
     r->max_textures = 16;
     r->textures = ALLOC_N(Texture*, 16);
     r->refcount = 1;
     Window_attach_renderer(w, r);
-    return Data_Wrap_Struct(cRenderer, 0, Renderer_free, r);
+    return obj;
 }
 
 DEFINE_WRAPPER(SDL_Renderer, Renderer, renderer, cRenderer, "SDL2::Renderer");
@@ -209,11 +224,12 @@ static void Renderer_attach_texture(Renderer* r, Texture* t)
 
 static VALUE Texture_new(SDL_Texture* texture, Renderer* r)
 {
-    Texture* t = ALLOC(Texture);
+    Texture* t;
+    VALUE obj = TypedData_Make_Struct(cTexture, Texture, &Texture_data_type, t);
     t->texture = texture;
     t->refcount = 1;
     Renderer_attach_texture(r, t);
-    return Data_Wrap_Struct(cTexture, 0, Texture_free, t);
+    return obj;
 }
 
 DEFINE_WRAPPER(SDL_Texture, Texture, texture, cTexture, "SDL2::Texture");
@@ -231,10 +247,11 @@ static void Surface_free(Surface* s)
 
 VALUE Surface_new(SDL_Surface* surface)
 {
-    Surface* s = ALLOC(Surface);
+    Surface* s;
+    VALUE obj = TypedData_Make_Struct(cSurface, Surface, &Surface_data_type, s);
     s->surface = surface;
     s->need_to_free_pixels = 0;
-    return Data_Wrap_Struct(cSurface, 0, Surface_free, s);
+    return obj;
 }
 
 DEFINE_WRAPPER(SDL_Surface, Surface, surface, cSurface, "SDL2::Surface");
@@ -352,13 +369,14 @@ static VALUE SDL2_s_video_init(VALUE self, VALUE driver_name)
  *
  *
  * @!method destroy?
- *   Return true if the window is already destroyed.
+ *   @return [Boolean] true if the window is already destroyed.
  */
 
 /*
  * @overload create(title, x, y, w, h, flags)
  *   Create a window with the specified position (x,y), dimensions (w,h) and flags.
  *
+ *   @param [String] title title of the created window
  *   @param [Integer] x the x position of the left-top of the window
  *   @param [Integer] y the y position of the left-top of the window
  *   @param [Integer] w the width of the window
@@ -482,7 +500,7 @@ static VALUE Window_window_id(VALUE self)
 /*
  * Get information about the window.
  *
- * @return [SDL2::Window::Mode]
+ * @return [SDL2::Display::Mode]
  */
 static VALUE Window_display_mode(VALUE self)
 {
@@ -519,7 +537,7 @@ static VALUE Window_brightness(VALUE self)
  *
  *   @param brightness [Float] the brightness, 0.0 means complete dark and 1.0 means
  *     normal brightness.
- *   @return [brightness]
+ *   @return [void]
  *
  *   @see #brightness
  */
@@ -573,7 +591,7 @@ static VALUE Window_gamma_ramp(VALUE self)
  *   Set the window icon.
  *
  *   @param icon [SDL2::Surface] the icon for the window
- *   @return [icon]
+ *   @return [void]
  */
 static VALUE Window_set_icon(VALUE self, VALUE icon)
 {
@@ -596,7 +614,7 @@ static VALUE Window_input_is_grabbed_p(VALUE self)
  *   Set the window's input grab mode.
  *
  *   @param grabbed [Boolean] true to grub input, and false to release input
- *   @return [grabbed]
+ *   @return [void]
  *
  *   @see #input_is_grabbed?
  */
@@ -625,7 +643,7 @@ static VALUE Window_set_int_int(void (*func)(SDL_Window*, int, int), VALUE windo
 /*
  * Get the maximum size of the window's client area.
  *
- * @return [Integer,Integer] maximum width and maximum height.
+ * @return [Array(Integer,Integer)] maximum width and maximum height.
  *
  * @see #maximum_size=
  */
@@ -638,10 +656,10 @@ static VALUE Window_maximum_size(VALUE self)
  * @overload maximum_size=(size)
  *   Set the maximum size of the window's client area.
  *
- *   @param size [[Integer, Integer]] maximum width and maximum height,
+ *   @param size [Array(Integer, Integer)] maximum width and maximum height,
  *     the both must be positive.
  *
- *   @return [size]
+ *   @return [void]
  *
  *   @see #maximum_size
  */
@@ -653,7 +671,7 @@ static VALUE Window_set_maximum_size(VALUE self, VALUE max_size)
 /*
  * Get the minimum size of the window's client area.
  *
- * @return [Integer,Integer] minimum width and minimum height.
+ * @return [Array(Integer,Integer)] minimum width and minimum height.
  *
  * @see #minimum_size=
  */
@@ -666,10 +684,10 @@ static VALUE Window_minimum_size(VALUE self)
  * @overload minimum_size=(size)
  *   Set the minimum size of the window's client area.
  *
- *   @param size [[Integer, Integer]] minimum width and minimum height,
+ *   @param size [Array(Integer, Integer)] minimum width and minimum height,
  *     the both must be positive.
  *
- *   @return [size]
+ *   @return [void]
  *
  *   @see #minimum_size
  */
@@ -681,7 +699,7 @@ static VALUE Window_set_minimum_size(VALUE self, VALUE min_size)
 /*
  * Get the position of the window.
  *
- * @return [Integer,Integer] the x position and the y position
+ * @return [Array(Integer,Integer)] the x position and the y position
  *
  * @see #position=
  */
@@ -694,11 +712,11 @@ static VALUE Window_position(VALUE self)
  * @overload position=(xy)
  *   Set the position of the window
  *
- *   @param xy [[Integer, Integer]] the x position and the y position,
+ *   @param xy [Array(Integer, Integer)] the x position and the y position,
  *     {SDL2::Window::POS_CENTERED} and {SDL2::Window::POS_UNDEFINED}
  *     are available.
  *
- *   @return [size]
+ *   @return [void]
  *
  *   @see #position
  */
@@ -710,7 +728,7 @@ static VALUE Window_set_position(VALUE self, VALUE xy)
 /*
  * Get the size of the window.
  *
- * @return [[Integer, Integer]] the width and the height
+ * @return [Array(Integer, Integer)] the width and the height
  *
  * @see size=
  */
@@ -723,9 +741,9 @@ static VALUE Window_size(VALUE self)
  * @overload size=(size)
  *   Set the size of the window.
  *
- *   @param wh [[Integer, Integer]] new width and new height
+ *   @param size [Array(Integer, Integer)] new width and new height
  *
- *   @return [size]
+ *   @return [void]
  *
  *   @see #size
  */
@@ -765,7 +783,7 @@ static VALUE Window_bordered(VALUE self)
  *   @param bordered [Boolean] true for bordered window, anad false for
  *     borderless window
  *
- *   @return [bordered]
+ *   @return [void]
  *
  *   @see #bordered
  */
@@ -780,7 +798,7 @@ static VALUE Window_set_bordered(VALUE self, VALUE bordered)
  *   Set the title of the window.
  *
  *   @param title [String] the title
- *   @return [title]
+ *   @return [void]
  *
  *   @see #title
  */
@@ -870,7 +888,7 @@ static VALUE Window_fullscreen_mode(VALUE self)
  *   @param flag [Integer] 0 for window mode, {SDL2::Window::Flags::FULLSCREEN} for
  *     fullscreen mode, and {SDL2::Flags::Window::FULLSCREEN_DESKTOP} for fullscreen
  *     at the current desktop resolution.
- *   @return [flag]
+ *   @return [void]
  *
  *   @see #fullscreen_mode
  */
@@ -884,7 +902,7 @@ static VALUE Window_set_fullscreen_mode(VALUE self, VALUE flags)
 /*
  * Get the size of the drawable region.
  *
- * @return [[Integer, Integer]] the width and height of the region
+ * @return [Array(Integer, Integer)] the width and height of the region
  */
 static VALUE Window_gl_drawable_size(VALUE self)
 {
@@ -962,7 +980,7 @@ static VALUE Window_debug_info(VALUE self)
  *
  * @!attribute [r] name
  *   The name of the display
- *   @return [Stirng]
+ *   @return [String]
  *
  */
 
@@ -1322,6 +1340,54 @@ static VALUE Renderer_present(VALUE self)
     return Qnil;
 }
 
+/*
+ * @overload read_pixels(rect, format)
+ *   Read pixels from the current rendering target.
+ *
+ *   ## Remarks
+ *
+ *   **WARNING**: This is a very slow operation, and should not be used frequently.
+ *   If you're using this on the main rendering target, it should be called after
+ *   rendering and before {#present}.
+ *
+ *   @param [SDL2::Rect,nil] rect the area to read, or nil for the entire target
+ *   @param [SDL2::PixelFormat,Integer] format the desired pixel format
+ *     (0 to use the format of the rendering target)
+ *   @return [String] raw pixel data as a binary string
+ */
+static VALUE Renderer_read_pixels(VALUE self, VALUE rect, VALUE format)
+{
+    SDL_Renderer* renderer = Get_SDL_Renderer(self);
+    SDL_Rect sdl_rect;
+    SDL_Rect* rect_ptr = NULL;
+    Uint32 fmt = uint32_for_format(format);
+    int w, h, pitch;
+    void* pixels;
+
+    if (rect != Qnil) {
+        sdl_rect = *Get_SDL_Rect(rect);
+        rect_ptr = &sdl_rect;
+        w = sdl_rect.w;
+        h = sdl_rect.h;
+    } else {
+        HANDLE_ERROR(SDL_GetRendererOutputSize(renderer, &w, &h));
+    }
+
+    if (fmt == 0) {
+        SDL_RendererInfo info;
+        HANDLE_ERROR(SDL_GetRendererInfo(renderer, &info));
+        pitch = w * SDL_BYTESPERPIXEL(info.texture_formats[0]);
+    } else {
+        pitch = w * SDL_BYTESPERPIXEL(fmt);
+    }
+
+    pixels = ALLOCA_N(char, pitch * h);
+
+    HANDLE_ERROR(SDL_RenderReadPixels(renderer, rect_ptr, fmt, pixels, pitch));
+    
+    return rb_str_new(pixels, pitch * h);
+}
+
 /*
  * Crear the rendering target with the drawing color.
  * @return [nil]
@@ -1336,7 +1402,7 @@ static VALUE Renderer_clear(VALUE self)
 
 /*
  * Get the color used for drawing operations
- * @return [[Integer,Integer,Integer,Integer]]
+ * @return [Array(Integer,Integer,Integer,Integer)]
  *   red, green, blue, and alpha components of the drawing color
  *   (all components are more than or equal to 0 and less than and equal to 255)
  *
@@ -1364,12 +1430,10 @@ static VALUE Renderer_draw_color(VALUE self)
  *   * {#fill_rect}
  *   * {#clear}
  *
- *   @param [[Integer, Integer, Integer]] color
- *     red, green, and blue components used for drawing
- *   @param [[Integer, Integer, Integer, Integer]] color
- *     red, green, blue, and alpha components used for drawing
+ *   @param [Array<Integer>] color
+ *     red, green, blue, and optionally alpha components used for drawing
  *
- *   @return [color]
+ *   @return [Array<Integer>]
  *
  *   @see #draw_color
  */
@@ -1514,7 +1578,8 @@ static VALUE Renderer_clip_rect(VALUE self)
  *
  *   Set the clip rectangle for the current target.
  *
- *   @return [rect]
+ *   @param rect [SDL2::Rect]
+ *   @return [void]
  *   @see #clip_rect
  */
 static VALUE Renderer_set_clip_rect(VALUE self, VALUE rect)
@@ -1538,7 +1603,7 @@ static VALUE Render_clip_enabled_p(VALUE self)
 /*
  * Get device indepndent resolution for rendering.
  *
- * @return [[Integer, Integer]] the logical width and height
+ * @return [Array(Integer, Integer)] the logical width and height
  * @see #logical_size=
  */
 static VALUE Renderer_logical_size(VALUE self)
@@ -1553,8 +1618,8 @@ static VALUE Renderer_logical_size(VALUE self)
  *
  *   Set a device indepndent resolution for rendering.
  *
- *   @param w_and_h [[Integer, Integer]] the width and height of the logical resolution
- *   @return [w_and_h]
+ *   @param w_and_h [Array(Integer, Integer)] the width and height of the logical resolution
+ *   @return [void]
  *   @see #logical_size
  */
 static VALUE Renderer_set_logical_size(VALUE self, VALUE wh)
@@ -1568,7 +1633,7 @@ static VALUE Renderer_set_logical_size(VALUE self, VALUE wh)
 /*
  * Get the drawing scale for the current target.
  *
- * @return [[Integer, Integer]] horizontal and vertical scale factor
+ * @return [Array(Integer, Integer)] horizontal and vertical scale factor
  * @see #scale=
  */
 static VALUE Renderer_scale(VALUE self)
@@ -1590,8 +1655,8 @@ static VALUE Renderer_scale(VALUE self)
  *   it will be handled using the appropriate
  *   quality hints. For best results use integer scaling factors.
  *
- *   @param scaleX_and_scaleY [[Float, Float]] the horizontal and vertical scaling factors
- *   @return [scaleX_and_scaleY]
+ *   @param scaleX_and_scaleY [Array(Float, Float)] the horizontal and vertical scaling factors
+ *   @return [void]
  *   @see #scale
  */
 static VALUE Renderer_set_scale(VALUE self, VALUE xy)
@@ -1621,7 +1686,7 @@ static VALUE Renderer_viewport(VALUE self)
  *   Set the drawing area for rendering on the current target.
  *
  *   @param area [SDL2::Rect,nil] the drawing area, or nil to set the viewport to the entire target
- *   @return [area]
+ *   @return [void]
  *   @see #viewport
  */
 static VALUE Renderer_set_viewport(VALUE self, VALUE rect)
@@ -1643,7 +1708,7 @@ static VALUE Renderer_support_render_target_p(VALUE self)
 /*
  * Get the output size of a rendering context.
  *
- * @return [[Integer, Integer]] the width and the height
+ * @return [Array(Integer, Integer)] the width and the height
  */
 static VALUE Renderer_output_size(VALUE self)
 {
@@ -1666,7 +1731,7 @@ static VALUE Renderer_output_size(VALUE self)
  *  @param [SDL2::Texture,nil] target the targeted texture, or nil
  *    for the default render target(i.e. screen)
  *
- *  @return [target]
+ *  @return [void]
  *
  *  @see #render_target
  */
@@ -1776,6 +1841,8 @@ static VALUE Renderer_debug_info(VALUE self)
 /*
  * Destroy the texture and deallocate memory.
  *
+ * @return [void]
+ *
  * @see #destroy?
  */
 static VALUE Texture_destroy(VALUE self)
@@ -1803,7 +1870,7 @@ static VALUE Texture_blend_mode(VALUE self)
  *   Set the blending model of the texture.
  *
  *   @param mode [Integer] blending mode
- *   @return [mode]
+ *   @return [void]
  *
  *   @see #blend_mode
  */
@@ -1833,7 +1900,7 @@ static VALUE Texture_alpha_mod(VALUE self)
  *
  *   @param alpha [Integer] the alpha value multiplied into copy operation,
  *     from 0 to 255
- *   @return [alpha]
+ *   @return [void]
  *
  *   @see #alpha_mod
  */
@@ -1846,7 +1913,7 @@ static VALUE Texture_set_alpha_mod(VALUE self, VALUE alpha)
 /*
  * Get an additional color value used in render copy operations.
  *
- * @return [[Integer, Integer, Integer]] the current red, green, and blue
+ * @return [Array(Integer, Integer, Integer)] the current red, green, and blue
  *   color value.
  */
 static VALUE Texture_color_mod(VALUE self)
@@ -1860,9 +1927,9 @@ static VALUE Texture_color_mod(VALUE self)
  * @overload color_mod=(rgb)
  *   Set an additional color value used in render copy operations.
  *
- *   @param rgb [[Integer, Integer, Integer]] the red, green, and blue
+ *   @param rgb [Array(Integer, Integer, Integer)] the red, green, and blue
  *     color value multiplied into copy operations.
- *   @return [rgb]
+ *   @return [void]
  */
 static VALUE Texture_set_color_mod(VALUE self, VALUE rgb)
 {
@@ -2018,7 +2085,7 @@ static VALUE Surface_s_save_bmp(VALUE self, VALUE src, VALUE fname)
 }
 
 /*
- * @overload from_string(string, width, heigth, depth, pitch=nil, rmask=nil, gmask=nil, bmask=nil, amask=nil)
+ * @overload from_string(string, width, height, depth, pitch=nil, rmask=nil, gmask=nil, bmask=nil, amask=nil)
  *
  *   Create a RGB surface from pixel data as String object.
  *
@@ -2046,6 +2113,7 @@ static VALUE Surface_s_from_string(int argc, VALUE* argv, VALUE self)
     SDL_Surface* surface;
     void* pixels;
     Surface* s;
+    VALUE obj;
 
     rb_scan_args(argc, argv, "45", &string, &width, &height, &depth,
                  &pitch, &Rmask, &Gmask, &Bmask, &Amask);
@@ -2072,10 +2140,10 @@ static VALUE Surface_s_from_string(int argc, VALUE* argv, VALUE self)
 
     RB_GC_GUARD(string);
 
-    s = ALLOC(Surface);
+    obj = TypedData_Make_Struct(cSurface, Surface, &Surface_data_type, s);
     s->surface = surface;
     s->need_to_free_pixels = 1;
-    return Data_Wrap_Struct(cSurface, 0, Surface_free, s);
+    return obj;
 }
 
 /*
@@ -2114,7 +2182,7 @@ static VALUE Surface_blend_mode(VALUE self)
  *   Set the blending mode of the surface used for blit operations.
  *
  *   @param mode [Integer] the blending mode
- *   @return [mode]
+ *   @return [void]
  *   @see #blend_mode
  */
 static VALUE Surface_set_blend_mode(VALUE self, VALUE mode)
@@ -2241,7 +2309,7 @@ static VALUE Surface_bytes_per_pixel(VALUE self)
  *
  *   @param x [Integer] the x coordinate
  *   @param y [Integer] the y coordinate
- *   @return [[Integer, Integer, Integer, Integer]]
+ *   @return [Array(Integer, Integer, Integer, Integer)]
  *     the red, green, blue, and alpha component of the specified pixel.
  *
  */
@@ -2301,7 +2369,7 @@ static VALUE Surface_unset_color_key(VALUE self)
  *     the color key, pixel value (see {#pixel}) or pixel color (array of
  *     three or four integer elements).
  *
- *   @return [key]
+ *   @return [Integer, Array<Integer>] value
  *
  *   @see #color_key
  *   @see #unset_color_key
@@ -2429,12 +2497,14 @@ static VALUE Surface_s_new(int argc, VALUE* argv, VALUE self)
 #define FIELD_ACCESSOR(classname, typename, field)              \
     static VALUE classname##_##field(VALUE self)                \
     {                                                           \
-        typename* r; Data_Get_Struct(self, typename, r);        \
+        typename* r;                                            \
+        TypedData_Get_Struct(self, typename, &typename##_data_type, r); \
         return INT2NUM(r->field);                               \
     }                                                           \
     static VALUE classname##_set_##field(VALUE self, VALUE val) \
     {                                                           \
-        typename* r; Data_Get_Struct(self, typename, r);        \
+        typename* r;                                            \
+        TypedData_Get_Struct(self, typename, &typename##_data_type, r); \
         r->field = NUM2INT(val); return val;                    \
     }
 
@@ -2462,16 +2532,21 @@ static VALUE Surface_s_new(int argc, VALUE* argv, VALUE self)
  *   Height of the rectangle
  *   @return [Integer]
  *
- * @!method self.[](*args)
+ * @!method self.[](x, y, w, h)
  *   Alias of new. See {#initialize}.
+ *
+ *   @param x [Integer] X coordiante of the left-top point of the rectangle
+ *   @param y [Integer] Y coordiante of the left-top point of the rectangle
+ *   @param w [Integer] Width of the rectangle
+ *   @param h [Integer] Height of the rectangle
  *   @return [SDL2::Rect]
  */
 static VALUE Rect_s_allocate(VALUE klass)
 {
-    SDL_Rect* rect = ALLOC(SDL_Rect);
+    SDL_Rect* rect;
+    VALUE obj = TypedData_Make_Struct(klass, SDL_Rect, &SDL_Rect_data_type, rect);
     rect->x = rect->y = rect->w = rect->h = 0;
-
-    return Data_Wrap_Struct(cRect, 0, free, rect);
+    return obj;
 }
 
 /*
@@ -2499,7 +2574,7 @@ static VALUE Rect_initialize(int argc, VALUE* argv, VALUE self)
         /* do nothing*/
     } else if (argc == 4) {
         SDL_Rect* rect;
-        Data_Get_Struct(self, SDL_Rect, rect);
+        TypedData_Get_Struct(self, SDL_Rect, &SDL_Rect_data_type, rect);
         rect->x = NUM2INT(x); rect->y = NUM2INT(y);
         rect->w = NUM2INT(w); rect->h = NUM2INT(h);
     } else {
@@ -2574,7 +2649,7 @@ static VALUE Rect_union(VALUE self, VALUE other)
 static VALUE Point_s_allocate(VALUE klass)
 {
     SDL_Point* point;
-    return Data_Make_Struct(klass, SDL_Point, 0, free, point);
+    return TypedData_Make_Struct(klass, SDL_Point, &SDL_Point_data_type, point);
 }
 
 /*
@@ -2714,6 +2789,8 @@ PIXELFORMAT_ATTR_READER(fourcc_p,  SDL_ISPIXELFORMAT_FOURCC, INT2BOOL);
  * @overload ==(other)
  *   Return true if two pixel format is the same format.
  *
+ * @param other [SDL2::PixelFormat] other PixelFormat object
+ *
  * @return [Boolean]
  */
 static VALUE PixelFormat_eq(VALUE self, VALUE other)
@@ -2833,45 +2910,45 @@ void rubysdl2_init_video(void)
 #endif
     rb_define_method(cWindow, "gl_swap", Window_gl_swap, 0);
 
-    /* Indicate that you don't care what the window position is */
+    /* @return [Integer] Indicate that you don't care what the window position is */
     rb_define_const(cWindow, "POS_CENTERED", INT2NUM(SDL_WINDOWPOS_CENTERED));
-    /* Indicate that the window position should be centered */
+    /* @return [Integer] Indicate that the window position should be centered */
     rb_define_const(cWindow, "POS_UNDEFINED", INT2NUM(SDL_WINDOWPOS_UNDEFINED));
 
     mWindowFlags = rb_define_module_under(cWindow, "Flags");
     /* define(`DEFINE_WINDOW_FLAGS_CONST',`rb_define_const(mWindowFlags, "$1", UINT2NUM(SDL_WINDOW_$1))') */
-    /* fullscreen window */
+    /* @return [Integer] fullscreen window */
     DEFINE_WINDOW_FLAGS_CONST(FULLSCREEN);
-    /* fullscreen window at the current desktop resolution */
+    /* @return [Integer] fullscreen window at the current desktop resolution */
     DEFINE_WINDOW_FLAGS_CONST(FULLSCREEN_DESKTOP);
-    /* window usable with OpenGL context */
+    /* @return [Integer] window usable with OpenGL context */
     DEFINE_WINDOW_FLAGS_CONST(OPENGL);
-    /* window is visible */
+    /* @return [Integer] window is visible */
     DEFINE_WINDOW_FLAGS_CONST(SHOWN);
-    /* window is not visible */
+    /* @return [Integer] window is not visible */
     DEFINE_WINDOW_FLAGS_CONST(HIDDEN);
-    /* no window decoration */
+    /* @return [Integer] no window decoration */
     DEFINE_WINDOW_FLAGS_CONST(BORDERLESS);
-    /* window is resizable */
+    /* @return [Integer] window is resizable */
     DEFINE_WINDOW_FLAGS_CONST(RESIZABLE);
-    /* window is minimized */
+    /* @return [Integer] window is minimized */
     DEFINE_WINDOW_FLAGS_CONST(MINIMIZED);
-    /* window is maximized */
+    /* @return [Integer] window is maximized */
     DEFINE_WINDOW_FLAGS_CONST(MAXIMIZED);
-    /* window has grabbed input focus */
+    /* @return [Integer] window has grabbed input focus */
     DEFINE_WINDOW_FLAGS_CONST(INPUT_GRABBED);
-    /* window has input focus */
+    /* @return [Integer] window has input focus */
     DEFINE_WINDOW_FLAGS_CONST(INPUT_FOCUS);
-    /* window has mouse focus */
+    /* @return [Integer] window has mouse focus */
     DEFINE_WINDOW_FLAGS_CONST(MOUSE_FOCUS);
-    /* window is not created by SDL */
+    /* @return [Integer] window is not created by SDL */
     DEFINE_WINDOW_FLAGS_CONST(FOREIGN);
 #ifdef HAVE_CONST_SDL_WINDOW_ALLOW_HIGHDPI
-    /* window should be created in high-DPI mode if supported (>= SDL 2.0.1)*/
+    /* @return [Integer] window should be created in high-DPI mode if supported (>= SDL 2.0.1)*/
     DEFINE_WINDOW_FLAGS_CONST(ALLOW_HIGHDPI);
 #endif
 #ifdef HAVE_CONST_SDL_WINDOW_MOUSE_CAPTURE
-    /* window has mouse caputred (>= SDL 2.0.4) */
+    /* @return [Integer] window has mouse caputred (>= SDL 2.0.4) */
     DEFINE_WINDOW_FLAGS_CONST(MOUSE_CAPTURE);
 #endif
 
@@ -2910,6 +2987,7 @@ void rubysdl2_init_video(void)
     rb_define_method(cRenderer, "copy", Renderer_copy, 3);
     rb_define_method(cRenderer, "copy_ex", Renderer_copy_ex, 6);
     rb_define_method(cRenderer, "present", Renderer_present, 0);
+    rb_define_method(cRenderer, "read_pixels", Renderer_read_pixels, 2);
     rb_define_method(cRenderer, "draw_color",Renderer_draw_color, 0);
     rb_define_method(cRenderer, "draw_color=",Renderer_set_draw_color, 1);
     rb_define_method(cRenderer, "clear", Renderer_clear, 0);
@@ -2941,33 +3019,33 @@ void rubysdl2_init_video(void)
     mRendererFlags = rb_define_module_under(cRenderer, "Flags");
 
     /* define(`DEFINE_RENDERER_FLAGS_CONST',`rb_define_const(mRendererFlags, "$1", UINT2NUM(SDL_RENDERER_$1))') */
-    /* the renderer is a software fallback */
+    /* @return [Integer] the renderer is a software fallback */
     DEFINE_RENDERER_FLAGS_CONST(SOFTWARE);
-    /* the renderer uses hardware acceleration */
+    /* @return [Integer] the renderer uses hardware acceleration */
     DEFINE_RENDERER_FLAGS_CONST(ACCELERATED);
 #ifdef HAVE_CONST_SDL_RENDERER_PRESENTVSYNC
-    /* present is synchronized with the refresh rate */
+    /* @return [Integer] present is synchronized with the refresh rate */
     DEFINE_RENDERER_FLAGS_CONST(PRESENTVSYNC);
 #endif
-    /* the renderer supports rendering to texture */
+    /* @return [Integer] the renderer supports rendering to texture */
     DEFINE_RENDERER_FLAGS_CONST(TARGETTEXTURE);
     /* define(`DEFINE_SDL_FLIP_CONST',`rb_define_const(cRenderer, "FLIP_$1", INT2FIX(SDL_FLIP_$1))') */
-    /* Do not flip, used in {Renderer#copy_ex} */
+    /* @return [Integer] Do not flip, used in {Renderer#copy_ex} */
     DEFINE_SDL_FLIP_CONST(NONE);
-    /* Flip horizontally, used in {Renderer#copy_ex} */
+    /* @return [Integer] Flip horizontally, used in {Renderer#copy_ex} */
     DEFINE_SDL_FLIP_CONST(HORIZONTAL);
-    /* Flip vertically, used in {Renderer#copy_ex} */
+    /* @return [Integer] Flip vertically, used in {Renderer#copy_ex} */
     DEFINE_SDL_FLIP_CONST(VERTICAL);
 
     mBlendMode = rb_define_module_under(mSDL2, "BlendMode");
     /* define(`DEFINE_BLENDMODE_CONST',`rb_define_const(mBlendMode, "$1", INT2FIX(SDL_BLENDMODE_$1))') */
-    /* no blending (dstRGBA = srcRGBA) */
+    /* @return [Integer] no blending (dstRGBA = srcRGBA) */
     DEFINE_BLENDMODE_CONST(NONE);
-    /* alpha blending (dstRGB = (srcRGB * srcA) + (dstRGB * (1-srcA), dstA = srcA + (dstA * (1-srcA)))*/
+    /* @return [Integer] alpha blending (dstRGB = (srcRGB * srcA) + (dstRGB * (1-srcA), dstA = srcA + (dstA * (1-srcA)))*/
     DEFINE_BLENDMODE_CONST(BLEND);
-    /* additive blending (dstRGB = (srcRGB * srcA) + dstRGB, dstA = dstA) */
+    /* @return [Integer] additive blending (dstRGB = (srcRGB * srcA) + dstRGB, dstA = dstA) */
     DEFINE_BLENDMODE_CONST(ADD);
-    /* color modulate (multiplicative) (dstRGB = srcRGB * dstRGB, dstA = dstA) */
+    /* @return [Integer] color modulate (multiplicative) (dstRGB = srcRGB * dstRGB, dstA = dstA) */
     DEFINE_BLENDMODE_CONST(MOD);
 
     cTexture = rb_define_class_under(mSDL2, "Texture", rb_cObject);
@@ -2985,11 +3063,11 @@ void rubysdl2_init_video(void)
     rb_define_method(cTexture, "inspect", Texture_inspect, 0);
     rb_define_method(cTexture, "debug_info", Texture_debug_info, 0);
     /* define(`DEFINE_TEXTUREAH_ACCESS_CONST', `rb_define_const(cTexture, "ACCESS_$1", INT2NUM(SDL_TEXTUREACCESS_$1))') */
-    /* texture access pattern - changes rarely, not lockable */
+    /* @return [Integer] texture access pattern code - changes rarely, not lockable */
     DEFINE_TEXTUREAH_ACCESS_CONST(STATIC);
-    /* texture access pattern - changes frequently, lockable */
+    /* @return [Integer] texture access pattern code - changes frequently, lockable */
     DEFINE_TEXTUREAH_ACCESS_CONST(STREAMING);
-    /* texture access pattern - can be used as a render target */
+    /* @return [Integer] texture access pattern code - can be used as a render target */
     DEFINE_TEXTUREAH_ACCESS_CONST(TARGET);
 
 
@@ -3013,7 +3091,7 @@ void rubysdl2_init_video(void)
     rb_define_method(cSurface, "pixel_color", Surface_pixel_color, 2);
     rb_define_method(cSurface, "color_key", Surface_color_key, 0);
     rb_define_method(cSurface, "color_key=", Surface_set_color_key, 1);
-    rb_define_method(cSurface, "unset_color_key", Surface_set_color_key, 0);
+    rb_define_method(cSurface, "unset_color_key", Surface_unset_color_key, 0);
     rb_define_method(cSurface, "pixels", Surface_pixels, 0);
     rb_define_method(cSurface, "pitch", Surface_pitch, 0);
     rb_define_method(cSurface, "bits_per_pixel", Surface_bits_per_pixel, 0);
@@ -3065,7 +3143,8 @@ void rubysdl2_init_video(void)
     rb_define_method(cPixelFormat, "==", PixelFormat_eq, 1);
 
     mPixelType = rb_define_module_under(cPixelFormat, "Type");
-    /* define(`DEFINE_PIXELTYPE_CONST',`rb_define_const(mPixelType, "$1", UINT2NUM(SDL_PIXELTYPE_$1))') */
+    /* define(`DEFINE_PIXELTYPE_CONST',`/$8* @return [Integer] *$8/
+    rb_define_const(mPixelType, "$1", UINT2NUM(SDL_PIXELTYPE_$1))') */
     DEFINE_PIXELTYPE_CONST(UNKNOWN);
     DEFINE_PIXELTYPE_CONST(INDEX1);
     DEFINE_PIXELTYPE_CONST(INDEX4);
@@ -3080,12 +3159,17 @@ void rubysdl2_init_video(void)
     DEFINE_PIXELTYPE_CONST(ARRAYF32);
 
     mBitmapOrder = rb_define_module_under(cPixelFormat, "BitmapOrder");
+    /* @return [Integer] */
     rb_define_const(mBitmapOrder, "NONE", UINT2NUM(SDL_BITMAPORDER_NONE));
+    /* @return [Integer] */
     rb_define_const(mBitmapOrder, "O_1234", UINT2NUM(SDL_BITMAPORDER_1234));
+    /* @return [Integer] */
     rb_define_const(mBitmapOrder, "O_4321", UINT2NUM(SDL_BITMAPORDER_4321));
 
     mPackedOrder = rb_define_module_under(cPixelFormat, "PackedOrder");
-    /* define(`DEFINE_PACKEDORDER_CONST',`rb_define_const(mPackedOrder, "$1", UINT2NUM(SDL_PACKEDORDER_$1))') */
+    /*
+      define(`DEFINE_PACKEDORDER_CONST',`/$8* @return [Integer] *$8/
+    rb_define_const(mPackedOrder, "$1", UINT2NUM(SDL_PACKEDORDER_$1))') */
     DEFINE_PACKEDORDER_CONST(NONE);
     DEFINE_PACKEDORDER_CONST(XRGB);
     DEFINE_PACKEDORDER_CONST(RGBX);
@@ -3097,7 +3181,8 @@ void rubysdl2_init_video(void)
     DEFINE_PACKEDORDER_CONST(BGRA);
 
     mArrayOrder = rb_define_module_under(cPixelFormat, "ArrayOrder");
-    /* define(`DEFINE_ARRAYORDER_CONST',`rb_define_const(mArrayOrder, "$1", UINT2NUM(SDL_ARRAYORDER_$1))') */
+    /* define(`DEFINE_ARRAYORDER_CONST',`/$8* @return [Integer] *$8/
+    rb_define_const(mArrayOrder, "$1", UINT2NUM(SDL_ARRAYORDER_$1))') */
     DEFINE_ARRAYORDER_CONST(NONE);
     DEFINE_ARRAYORDER_CONST(RGB);
     DEFINE_ARRAYORDER_CONST(RGBA);
@@ -3107,7 +3192,9 @@ void rubysdl2_init_video(void)
     DEFINE_ARRAYORDER_CONST(ABGR);
 
     mPackedLayout = rb_define_module_under(cPixelFormat, "PackedLayout");
-    /* define(`DEFINE_PACKEDLAYOUT_CONST',`rb_define_const(mPackedLayout, "L_$1", UINT2NUM(SDL_PACKEDLAYOUT_$1))') */
+    /* define(`DEFINE_PACKEDLAYOUT_CONST',`/$8* @return [Integer] *$8/
+    rb_define_const(mPackedLayout, "L_$1", UINT2NUM(SDL_PACKEDLAYOUT_$1))') */
+    /* @return [Integer] */
     rb_define_const(mPackedLayout, "NONE", UINT2NUM(SDL_PACKEDLAYOUT_NONE));
     DEFINE_PACKEDLAYOUT_CONST(332);
     DEFINE_PACKEDLAYOUT_CONST(4444);
@@ -3120,17 +3207,17 @@ void rubysdl2_init_video(void)
 
     {
         VALUE formats = rb_ary_new();
-        /* -: Array of all available formats */
+        /* -: @return [Array<SDL2::PixelFormat>] array of all available formats */
         rb_define_const(cPixelFormat, "FORMATS", formats);
         /* define(`DEFINE_PIXELFORMAT_CONST',`do {
             VALUE format = PixelFormat_new(SDL_PIXELFORMAT_$1);
-            $2
+            /$8* -: @return [SDL2::PixelFormat] $2 *$8/
             rb_define_const(cPixelFormat, "$1", format);
             rb_ary_push(formats, format);
         } while (0)')
          */
 
-        DEFINE_PIXELFORMAT_CONST(UNKNOWN, /* -: PixelFormat: Unused - reserved by SDL */);
+        DEFINE_PIXELFORMAT_CONST(UNKNOWN, Unused - reserved by SDL);
         DEFINE_PIXELFORMAT_CONST(INDEX1LSB);
         DEFINE_PIXELFORMAT_CONST(INDEX1MSB);
         DEFINE_PIXELFORMAT_CONST(INDEX4LSB);
@@ -3285,13 +3372,13 @@ void rubysdl2_init_image(void)
     rb_define_method(cRenderer, "load_texture", Renderer_load_texture, 1);
 
 
-    /* Initialize the JPEG loader */
+    /* @return [Integer] Initialize the JPEG loader */
     rb_define_const(mIMG, "INIT_JPG", INT2NUM(IMG_INIT_JPG));
-    /* Initialize the PNG loader */
+    /* @return [Integer] Initialize the PNG loader */
     rb_define_const(mIMG, "INIT_PNG", INT2NUM(IMG_INIT_PNG));
-    /* Initialize the TIF loader */
+    /* @return [Integer] Initialize the TIF loader */
     rb_define_const(mIMG, "INIT_TIF", INT2NUM(IMG_INIT_TIF));
-    /* Initialize the WEBP loader */
+    /* @return [Integer] Initialize the WEBP loader */
     rb_define_const(mIMG, "INIT_WEBP", INT2NUM(IMG_INIT_WEBP));
 }