ruby-sdl2 0.3.5 → 0.3.7

data/video.c

@@ -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
  */
@@ -885,7 +903,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
  */
@@ -899,7 +917,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)
 {
@@ -977,7 +995,7 @@ static VALUE Window_debug_info(VALUE self)
  *
  * @!attribute [r] name
  *   The name of the display
- *   @return [Stirng]
+ *   @return [String]
  *
  */
 
@@ -1337,6 +1355,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]
@@ -1351,7 +1417,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)
  *
@@ -1379,12 +1445,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
  */
@@ -1529,7 +1593,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)
@@ -1553,7 +1618,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)
@@ -1568,8 +1633,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)
@@ -1583,7 +1648,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)
@@ -1605,8 +1670,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)
@@ -1636,7 +1701,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)
@@ -1658,7 +1723,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)
 {
@@ -1681,7 +1746,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
  */
@@ -1791,6 +1856,8 @@ static VALUE Renderer_debug_info(VALUE self)
 /*
  * Destroy the texture and deallocate memory.
  *
+ * @return [void]
+ *
  * @see #destroy?
  */
 static VALUE Texture_destroy(VALUE self)
@@ -1818,7 +1885,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
  */
@@ -1848,7 +1915,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
  */
@@ -1861,7 +1928,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)
@@ -1875,9 +1942,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)
 {
@@ -2033,7 +2100,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.
  *
@@ -2061,6 +2128,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);
@@ -2087,10 +2155,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;
 }
 
 /*
@@ -2129,7 +2197,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)
@@ -2256,7 +2324,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.
  *
  */
@@ -2316,7 +2384,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
@@ -2444,12 +2512,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;                    \
     }
 
@@ -2477,16 +2547,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;
 }
 
 /*
@@ -2514,7 +2589,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 {
@@ -2589,7 +2664,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);
 }
 
 /*
@@ -2749,6 +2824,8 @@ static VALUE PixelFormat_fourcc_p(VALUE self)
  * @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)
@@ -2874,45 +2951,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");
     /*  */
-    /* fullscreen window */
+    /* @return [Integer] fullscreen window */
     rb_define_const(mWindowFlags, "FULLSCREEN", UINT2NUM(SDL_WINDOW_FULLSCREEN));
-    /* fullscreen window at the current desktop resolution */
+    /* @return [Integer] fullscreen window at the current desktop resolution */
     rb_define_const(mWindowFlags, "FULLSCREEN_DESKTOP", UINT2NUM(SDL_WINDOW_FULLSCREEN_DESKTOP));
-    /* window usable with OpenGL context */
+    /* @return [Integer] window usable with OpenGL context */
     rb_define_const(mWindowFlags, "OPENGL", UINT2NUM(SDL_WINDOW_OPENGL));
-    /* window is visible */
+    /* @return [Integer] window is visible */
     rb_define_const(mWindowFlags, "SHOWN", UINT2NUM(SDL_WINDOW_SHOWN));
-    /* window is not visible */
+    /* @return [Integer] window is not visible */
     rb_define_const(mWindowFlags, "HIDDEN", UINT2NUM(SDL_WINDOW_HIDDEN));
-    /* no window decoration */
+    /* @return [Integer] no window decoration */
     rb_define_const(mWindowFlags, "BORDERLESS", UINT2NUM(SDL_WINDOW_BORDERLESS));
-    /* window is resizable */
+    /* @return [Integer] window is resizable */
     rb_define_const(mWindowFlags, "RESIZABLE", UINT2NUM(SDL_WINDOW_RESIZABLE));
-    /* window is minimized */
+    /* @return [Integer] window is minimized */
     rb_define_const(mWindowFlags, "MINIMIZED", UINT2NUM(SDL_WINDOW_MINIMIZED));
-    /* window is maximized */
+    /* @return [Integer] window is maximized */
     rb_define_const(mWindowFlags, "MAXIMIZED", UINT2NUM(SDL_WINDOW_MAXIMIZED));
-    /* window has grabbed input focus */
+    /* @return [Integer] window has grabbed input focus */
     rb_define_const(mWindowFlags, "INPUT_GRABBED", UINT2NUM(SDL_WINDOW_INPUT_GRABBED));
-    /* window has input focus */
+    /* @return [Integer] window has input focus */
     rb_define_const(mWindowFlags, "INPUT_FOCUS", UINT2NUM(SDL_WINDOW_INPUT_FOCUS));
-    /* window has mouse focus */
+    /* @return [Integer] window has mouse focus */
     rb_define_const(mWindowFlags, "MOUSE_FOCUS", UINT2NUM(SDL_WINDOW_MOUSE_FOCUS));
-    /* window is not created by SDL */
+    /* @return [Integer] window is not created by SDL */
     rb_define_const(mWindowFlags, "FOREIGN", UINT2NUM(SDL_WINDOW_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)*/
     rb_define_const(mWindowFlags, "ALLOW_HIGHDPI", UINT2NUM(SDL_WINDOW_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) */
     rb_define_const(mWindowFlags, "MOUSE_CAPTURE", UINT2NUM(SDL_WINDOW_MOUSE_CAPTURE));
 #endif
 
@@ -2951,6 +3028,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);
@@ -2982,33 +3060,33 @@ void rubysdl2_init_video(void)
     mRendererFlags = rb_define_module_under(cRenderer, "Flags");
 
     /*  */
-    /* the renderer is a software fallback */
+    /* @return [Integer] the renderer is a software fallback */
     rb_define_const(mRendererFlags, "SOFTWARE", UINT2NUM(SDL_RENDERER_SOFTWARE));
-    /* the renderer uses hardware acceleration */
+    /* @return [Integer] the renderer uses hardware acceleration */
     rb_define_const(mRendererFlags, "ACCELERATED", UINT2NUM(SDL_RENDERER_ACCELERATED));
 #ifdef HAVE_CONST_SDL_RENDERER_PRESENTVSYNC
-    /* present is synchronized with the refresh rate */
+    /* @return [Integer] present is synchronized with the refresh rate */
     rb_define_const(mRendererFlags, "PRESENTVSYNC", UINT2NUM(SDL_RENDERER_PRESENTVSYNC));
 #endif
-    /* the renderer supports rendering to texture */
+    /* @return [Integer] the renderer supports rendering to texture */
     rb_define_const(mRendererFlags, "TARGETTEXTURE", UINT2NUM(SDL_RENDERER_TARGETTEXTURE));
     /*  */
-    /* Do not flip, used in {Renderer#copy_ex} */
+    /* @return [Integer] Do not flip, used in {Renderer#copy_ex} */
     rb_define_const(cRenderer, "FLIP_NONE", INT2FIX(SDL_FLIP_NONE));
-    /* Flip horizontally, used in {Renderer#copy_ex} */
+    /* @return [Integer] Flip horizontally, used in {Renderer#copy_ex} */
     rb_define_const(cRenderer, "FLIP_HORIZONTAL", INT2FIX(SDL_FLIP_HORIZONTAL));
-    /* Flip vertically, used in {Renderer#copy_ex} */
+    /* @return [Integer] Flip vertically, used in {Renderer#copy_ex} */
     rb_define_const(cRenderer, "FLIP_VERTICAL", INT2FIX(SDL_FLIP_VERTICAL));
 
     mBlendMode = rb_define_module_under(mSDL2, "BlendMode");
     /*  */
-    /* no blending (dstRGBA = srcRGBA) */
+    /* @return [Integer] no blending (dstRGBA = srcRGBA) */
     rb_define_const(mBlendMode, "NONE", INT2FIX(SDL_BLENDMODE_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)))*/
     rb_define_const(mBlendMode, "BLEND", INT2FIX(SDL_BLENDMODE_BLEND));
-    /* additive blending (dstRGB = (srcRGB * srcA) + dstRGB, dstA = dstA) */
+    /* @return [Integer] additive blending (dstRGB = (srcRGB * srcA) + dstRGB, dstA = dstA) */
     rb_define_const(mBlendMode, "ADD", INT2FIX(SDL_BLENDMODE_ADD));
-    /* color modulate (multiplicative) (dstRGB = srcRGB * dstRGB, dstA = dstA) */
+    /* @return [Integer] color modulate (multiplicative) (dstRGB = srcRGB * dstRGB, dstA = dstA) */
     rb_define_const(mBlendMode, "MOD", INT2FIX(SDL_BLENDMODE_MOD));
 
     cTexture = rb_define_class_under(mSDL2, "Texture", rb_cObject);
@@ -3029,11 +3107,11 @@ void rubysdl2_init_video(void)
     rb_define_method(cTexture, "inspect", Texture_inspect, 0);
     rb_define_method(cTexture, "debug_info", Texture_debug_info, 0);
     /*  */
-    /* texture access pattern - changes rarely, not lockable */
+    /* @return [Integer] texture access pattern code - changes rarely, not lockable */
     rb_define_const(cTexture, "ACCESS_STATIC", INT2NUM(SDL_TEXTUREACCESS_STATIC));
-    /* texture access pattern - changes frequently, lockable */
+    /* @return [Integer] texture access pattern code - changes frequently, lockable */
     rb_define_const(cTexture, "ACCESS_STREAMING", INT2NUM(SDL_TEXTUREACCESS_STREAMING));
-    /* texture access pattern - can be used as a render target */
+    /* @return [Integer] texture access pattern code - can be used as a render target */
     rb_define_const(cTexture, "ACCESS_TARGET", INT2NUM(SDL_TEXTUREACCESS_TARGET));
 
 
@@ -3058,7 +3136,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);
@@ -3117,278 +3195,319 @@ void rubysdl2_init_video(void)
 
     mPixelType = rb_define_module_under(cPixelFormat, "Type");
     /*  */
+    /* @return [Integer] */
     rb_define_const(mPixelType, "UNKNOWN", UINT2NUM(SDL_PIXELTYPE_UNKNOWN));
+    /* @return [Integer] */
     rb_define_const(mPixelType, "INDEX1", UINT2NUM(SDL_PIXELTYPE_INDEX1));
+    /* @return [Integer] */
     rb_define_const(mPixelType, "INDEX4", UINT2NUM(SDL_PIXELTYPE_INDEX4));
+    /* @return [Integer] */
     rb_define_const(mPixelType, "INDEX8", UINT2NUM(SDL_PIXELTYPE_INDEX8));
+    /* @return [Integer] */
     rb_define_const(mPixelType, "PACKED8", UINT2NUM(SDL_PIXELTYPE_PACKED8));
+    /* @return [Integer] */
     rb_define_const(mPixelType, "PACKED16", UINT2NUM(SDL_PIXELTYPE_PACKED16));
+    /* @return [Integer] */
     rb_define_const(mPixelType, "PACKED32", UINT2NUM(SDL_PIXELTYPE_PACKED32));
+    /* @return [Integer] */
     rb_define_const(mPixelType, "ARRAYU8", UINT2NUM(SDL_PIXELTYPE_ARRAYU8));
+    /* @return [Integer] */
     rb_define_const(mPixelType, "ARRAYU16", UINT2NUM(SDL_PIXELTYPE_ARRAYU16));
+    /* @return [Integer] */
     rb_define_const(mPixelType, "ARRAYU32", UINT2NUM(SDL_PIXELTYPE_ARRAYU32));
+    /* @return [Integer] */
     rb_define_const(mPixelType, "ARRAYF16", UINT2NUM(SDL_PIXELTYPE_ARRAYF16));
+    /* @return [Integer] */
     rb_define_const(mPixelType, "ARRAYF32", UINT2NUM(SDL_PIXELTYPE_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");
-    /*  */
+    /*
+       */
+    /* @return [Integer] */
     rb_define_const(mPackedOrder, "NONE", UINT2NUM(SDL_PACKEDORDER_NONE));
+    /* @return [Integer] */
     rb_define_const(mPackedOrder, "XRGB", UINT2NUM(SDL_PACKEDORDER_XRGB));
+    /* @return [Integer] */
     rb_define_const(mPackedOrder, "RGBX", UINT2NUM(SDL_PACKEDORDER_RGBX));
+    /* @return [Integer] */
     rb_define_const(mPackedOrder, "ARGB", UINT2NUM(SDL_PACKEDORDER_ARGB));
+    /* @return [Integer] */
     rb_define_const(mPackedOrder, "RGBA", UINT2NUM(SDL_PACKEDORDER_RGBA));
+    /* @return [Integer] */
     rb_define_const(mPackedOrder, "XBGR", UINT2NUM(SDL_PACKEDORDER_XBGR));
+    /* @return [Integer] */
     rb_define_const(mPackedOrder, "BGRX", UINT2NUM(SDL_PACKEDORDER_BGRX));
+    /* @return [Integer] */
     rb_define_const(mPackedOrder, "ABGR", UINT2NUM(SDL_PACKEDORDER_ABGR));
+    /* @return [Integer] */
     rb_define_const(mPackedOrder, "BGRA", UINT2NUM(SDL_PACKEDORDER_BGRA));
 
     mArrayOrder = rb_define_module_under(cPixelFormat, "ArrayOrder");
     /*  */
+    /* @return [Integer] */
     rb_define_const(mArrayOrder, "NONE", UINT2NUM(SDL_ARRAYORDER_NONE));
+    /* @return [Integer] */
     rb_define_const(mArrayOrder, "RGB", UINT2NUM(SDL_ARRAYORDER_RGB));
+    /* @return [Integer] */
     rb_define_const(mArrayOrder, "RGBA", UINT2NUM(SDL_ARRAYORDER_RGBA));
+    /* @return [Integer] */
     rb_define_const(mArrayOrder, "ARGB", UINT2NUM(SDL_ARRAYORDER_ARGB));
+    /* @return [Integer] */
     rb_define_const(mArrayOrder, "BGR", UINT2NUM(SDL_ARRAYORDER_BGR));
+    /* @return [Integer] */
     rb_define_const(mArrayOrder, "BGRA", UINT2NUM(SDL_ARRAYORDER_BGRA));
+    /* @return [Integer] */
     rb_define_const(mArrayOrder, "ABGR", UINT2NUM(SDL_ARRAYORDER_ABGR));
 
     mPackedLayout = rb_define_module_under(cPixelFormat, "PackedLayout");
     /*  */
+    /* @return [Integer] */
     rb_define_const(mPackedLayout, "NONE", UINT2NUM(SDL_PACKEDLAYOUT_NONE));
+    /* @return [Integer] */
     rb_define_const(mPackedLayout, "L_332", UINT2NUM(SDL_PACKEDLAYOUT_332));
+    /* @return [Integer] */
     rb_define_const(mPackedLayout, "L_4444", UINT2NUM(SDL_PACKEDLAYOUT_4444));
+    /* @return [Integer] */
     rb_define_const(mPackedLayout, "L_1555", UINT2NUM(SDL_PACKEDLAYOUT_1555));
+    /* @return [Integer] */
     rb_define_const(mPackedLayout, "L_5551", UINT2NUM(SDL_PACKEDLAYOUT_5551));
+    /* @return [Integer] */
     rb_define_const(mPackedLayout, "L_565", UINT2NUM(SDL_PACKEDLAYOUT_565));
+    /* @return [Integer] */
     rb_define_const(mPackedLayout, "L_8888", UINT2NUM(SDL_PACKEDLAYOUT_8888));
+    /* @return [Integer] */
     rb_define_const(mPackedLayout, "L_2101010", UINT2NUM(SDL_PACKEDLAYOUT_2101010));
+    /* @return [Integer] */
     rb_define_const(mPackedLayout, "L_1010102", UINT2NUM(SDL_PACKEDLAYOUT_1010102));
 
     {
         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);
         /* 
          */
 
         do {
             VALUE format = PixelFormat_new(SDL_PIXELFORMAT_UNKNOWN);
-            /* -: PixelFormat: Unused - reserved by SDL */
+            /* -: @return [SDL2::PixelFormat] Unused - reserved by SDL */
             rb_define_const(cPixelFormat, "UNKNOWN", format);
             rb_ary_push(formats, format);
         } while (0);
         do {
             VALUE format = PixelFormat_new(SDL_PIXELFORMAT_INDEX1LSB);
-            
+            /* -: @return [SDL2::PixelFormat]  */
             rb_define_const(cPixelFormat, "INDEX1LSB", format);
             rb_ary_push(formats, format);
         } while (0);
         do {
             VALUE format = PixelFormat_new(SDL_PIXELFORMAT_INDEX1MSB);
-            
+            /* -: @return [SDL2::PixelFormat]  */
             rb_define_const(cPixelFormat, "INDEX1MSB", format);
             rb_ary_push(formats, format);
         } while (0);
         do {
             VALUE format = PixelFormat_new(SDL_PIXELFORMAT_INDEX4LSB);
-            
+            /* -: @return [SDL2::PixelFormat]  */
             rb_define_const(cPixelFormat, "INDEX4LSB", format);
             rb_ary_push(formats, format);
         } while (0);
         do {
             VALUE format = PixelFormat_new(SDL_PIXELFORMAT_INDEX4MSB);
-            
+            /* -: @return [SDL2::PixelFormat]  */
             rb_define_const(cPixelFormat, "INDEX4MSB", format);
             rb_ary_push(formats, format);
         } while (0);
         do {
             VALUE format = PixelFormat_new(SDL_PIXELFORMAT_INDEX8);
-            
+            /* -: @return [SDL2::PixelFormat]  */
             rb_define_const(cPixelFormat, "INDEX8", format);
             rb_ary_push(formats, format);
         } while (0);
         do {
             VALUE format = PixelFormat_new(SDL_PIXELFORMAT_RGB332);
-            
+            /* -: @return [SDL2::PixelFormat]  */
             rb_define_const(cPixelFormat, "RGB332", format);
             rb_ary_push(formats, format);
         } while (0);
         do {
             VALUE format = PixelFormat_new(SDL_PIXELFORMAT_RGB444);
-            
+            /* -: @return [SDL2::PixelFormat]  */
             rb_define_const(cPixelFormat, "RGB444", format);
             rb_ary_push(formats, format);
         } while (0);
         do {
             VALUE format = PixelFormat_new(SDL_PIXELFORMAT_RGB555);
-            
+            /* -: @return [SDL2::PixelFormat]  */
             rb_define_const(cPixelFormat, "RGB555", format);
             rb_ary_push(formats, format);
         } while (0);
         do {
             VALUE format = PixelFormat_new(SDL_PIXELFORMAT_BGR555);
-            
+            /* -: @return [SDL2::PixelFormat]  */
             rb_define_const(cPixelFormat, "BGR555", format);
             rb_ary_push(formats, format);
         } while (0);
         do {
             VALUE format = PixelFormat_new(SDL_PIXELFORMAT_ARGB4444);
-            
+            /* -: @return [SDL2::PixelFormat]  */
             rb_define_const(cPixelFormat, "ARGB4444", format);
             rb_ary_push(formats, format);
         } while (0);
         do {
             VALUE format = PixelFormat_new(SDL_PIXELFORMAT_RGBA4444);
-            
+            /* -: @return [SDL2::PixelFormat]  */
             rb_define_const(cPixelFormat, "RGBA4444", format);
             rb_ary_push(formats, format);
         } while (0);
         do {
             VALUE format = PixelFormat_new(SDL_PIXELFORMAT_ABGR4444);
-            
+            /* -: @return [SDL2::PixelFormat]  */
             rb_define_const(cPixelFormat, "ABGR4444", format);
             rb_ary_push(formats, format);
         } while (0);
         do {
             VALUE format = PixelFormat_new(SDL_PIXELFORMAT_BGRA4444);
-            
+            /* -: @return [SDL2::PixelFormat]  */
             rb_define_const(cPixelFormat, "BGRA4444", format);
             rb_ary_push(formats, format);
         } while (0);
         do {
             VALUE format = PixelFormat_new(SDL_PIXELFORMAT_ARGB1555);
-            
+            /* -: @return [SDL2::PixelFormat]  */
             rb_define_const(cPixelFormat, "ARGB1555", format);
             rb_ary_push(formats, format);
         } while (0);
         do {
             VALUE format = PixelFormat_new(SDL_PIXELFORMAT_RGBA5551);
-            
+            /* -: @return [SDL2::PixelFormat]  */
             rb_define_const(cPixelFormat, "RGBA5551", format);
             rb_ary_push(formats, format);
         } while (0);
         do {
             VALUE format = PixelFormat_new(SDL_PIXELFORMAT_ABGR1555);
-            
+            /* -: @return [SDL2::PixelFormat]  */
             rb_define_const(cPixelFormat, "ABGR1555", format);
             rb_ary_push(formats, format);
         } while (0);
         do {
             VALUE format = PixelFormat_new(SDL_PIXELFORMAT_BGRA5551);
-            
+            /* -: @return [SDL2::PixelFormat]  */
             rb_define_const(cPixelFormat, "BGRA5551", format);
             rb_ary_push(formats, format);
         } while (0);
         do {
             VALUE format = PixelFormat_new(SDL_PIXELFORMAT_RGB565);
-            
+            /* -: @return [SDL2::PixelFormat]  */
             rb_define_const(cPixelFormat, "RGB565", format);
             rb_ary_push(formats, format);
         } while (0);
         do {
             VALUE format = PixelFormat_new(SDL_PIXELFORMAT_BGR565);
-            
+            /* -: @return [SDL2::PixelFormat]  */
             rb_define_const(cPixelFormat, "BGR565", format);
             rb_ary_push(formats, format);
         } while (0);
         do {
             VALUE format = PixelFormat_new(SDL_PIXELFORMAT_RGB24);
-            
+            /* -: @return [SDL2::PixelFormat]  */
             rb_define_const(cPixelFormat, "RGB24", format);
             rb_ary_push(formats, format);
         } while (0);
         do {
             VALUE format = PixelFormat_new(SDL_PIXELFORMAT_BGR24);
-            
+            /* -: @return [SDL2::PixelFormat]  */
             rb_define_const(cPixelFormat, "BGR24", format);
             rb_ary_push(formats, format);
         } while (0);
         do {
             VALUE format = PixelFormat_new(SDL_PIXELFORMAT_RGB888);
-            
+            /* -: @return [SDL2::PixelFormat]  */
             rb_define_const(cPixelFormat, "RGB888", format);
             rb_ary_push(formats, format);
         } while (0);
         do {
             VALUE format = PixelFormat_new(SDL_PIXELFORMAT_RGBX8888);
-            
+            /* -: @return [SDL2::PixelFormat]  */
             rb_define_const(cPixelFormat, "RGBX8888", format);
             rb_ary_push(formats, format);
         } while (0);
         do {
             VALUE format = PixelFormat_new(SDL_PIXELFORMAT_BGR888);
-            
+            /* -: @return [SDL2::PixelFormat]  */
             rb_define_const(cPixelFormat, "BGR888", format);
             rb_ary_push(formats, format);
         } while (0);
         do {
             VALUE format = PixelFormat_new(SDL_PIXELFORMAT_BGRX8888);
-            
+            /* -: @return [SDL2::PixelFormat]  */
             rb_define_const(cPixelFormat, "BGRX8888", format);
             rb_ary_push(formats, format);
         } while (0);
         do {
             VALUE format = PixelFormat_new(SDL_PIXELFORMAT_ARGB8888);
-            
+            /* -: @return [SDL2::PixelFormat]  */
             rb_define_const(cPixelFormat, "ARGB8888", format);
             rb_ary_push(formats, format);
         } while (0);
         do {
             VALUE format = PixelFormat_new(SDL_PIXELFORMAT_RGBA8888);
-            
+            /* -: @return [SDL2::PixelFormat]  */
             rb_define_const(cPixelFormat, "RGBA8888", format);
             rb_ary_push(formats, format);
         } while (0);
         do {
             VALUE format = PixelFormat_new(SDL_PIXELFORMAT_ABGR8888);
-            
+            /* -: @return [SDL2::PixelFormat]  */
             rb_define_const(cPixelFormat, "ABGR8888", format);
             rb_ary_push(formats, format);
         } while (0);
         do {
             VALUE format = PixelFormat_new(SDL_PIXELFORMAT_BGRA8888);
-            
+            /* -: @return [SDL2::PixelFormat]  */
             rb_define_const(cPixelFormat, "BGRA8888", format);
             rb_ary_push(formats, format);
         } while (0);
         do {
             VALUE format = PixelFormat_new(SDL_PIXELFORMAT_ARGB2101010);
-            
+            /* -: @return [SDL2::PixelFormat]  */
             rb_define_const(cPixelFormat, "ARGB2101010", format);
             rb_ary_push(formats, format);
         } while (0);
         do {
             VALUE format = PixelFormat_new(SDL_PIXELFORMAT_YV12);
-            
+            /* -: @return [SDL2::PixelFormat]  */
             rb_define_const(cPixelFormat, "YV12", format);
             rb_ary_push(formats, format);
         } while (0);
         do {
             VALUE format = PixelFormat_new(SDL_PIXELFORMAT_IYUV);
-            
+            /* -: @return [SDL2::PixelFormat]  */
             rb_define_const(cPixelFormat, "IYUV", format);
             rb_ary_push(formats, format);
         } while (0);
         do {
             VALUE format = PixelFormat_new(SDL_PIXELFORMAT_YUY2);
-            
+            /* -: @return [SDL2::PixelFormat]  */
             rb_define_const(cPixelFormat, "YUY2", format);
             rb_ary_push(formats, format);
         } while (0);
         do {
             VALUE format = PixelFormat_new(SDL_PIXELFORMAT_UYVY);
-            
+            /* -: @return [SDL2::PixelFormat]  */
             rb_define_const(cPixelFormat, "UYVY", format);
             rb_ary_push(formats, format);
         } while (0);
         do {
             VALUE format = PixelFormat_new(SDL_PIXELFORMAT_YVYU);
-            
+            /* -: @return [SDL2::PixelFormat]  */
             rb_define_const(cPixelFormat, "YVYU", format);
             rb_ary_push(formats, format);
         } while (0);
@@ -3511,13 +3630,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));
 }