ruby2d 0.11.2 → 0.12.0

data/ext/ruby2d/ruby2d.c

@@ -90,6 +90,7 @@
   #define r_ary_entry(ary, pos)  rb_ary_entry(ary, pos)
   #define r_ary_new()  rb_ary_new()
   #define r_ary_push(self, val)  rb_ary_push(self, val)
+  #define r_ary_len(self)  rb_ary_len(self)
   #define r_data_wrap_struct(name, data)  Data_Wrap_Struct(rb_cObject, NULL, (free_##name), data)
   #define r_data_get_struct(self, var, mrb_type, rb_type, data)  Data_Get_Struct(r_iv_get(self, var), rb_type, data)
   #define r_define_module(name)  rb_define_module(name)
@@ -132,11 +133,21 @@ static void free_surface(mrb_state *mrb, void *p_);
   static const struct mrb_data_type surface_data_type = {
     "surface", free_surface
   };
+static void free_sdl_texture(mrb_state *mrb, void *p_);
+  static const struct mrb_data_type sdl_texture_data_type = {
+    "sdl_texture", free_sdl_texture
+  };
+static void free_renderer(mrb_state *mrb, void *p_);
+  static const struct mrb_data_type renderer_data_type = {
+    "renderer", free_renderer
+  };
 #else
   static void free_sound(R2D_Sound *snd);
   static void free_music(R2D_Music *mus);
   static void free_font(TTF_Font *font);
   static void free_surface(SDL_Surface *surface);
+  static void free_sdl_texture(SDL_Texture *surface);
+  static void free_renderer(SDL_Renderer *renderer);
 #endif
 
 
@@ -371,31 +382,46 @@ static R_VAL ruby2d_circle_ext_draw(R_VAL self, R_VAL a) {
 
 
 /*
- * Ruby2D::Image#ext_load_image
- * Create an SDL surface from an image path, return the surface, width, and height
+ * Ruby2D::Pixmap#ext_load_pixmap
+ * Create an SDL surface from an image path, and ... 
+ * TODO: store the surface, width, and height in the object
  */
 #if MRUBY
-static R_VAL ruby2d_image_ext_load_image(mrb_state* mrb, R_VAL self) {
+static R_VAL ruby2d_pixmap_ext_load_pixmap(mrb_state* mrb, R_VAL self) {
   mrb_value path;
   mrb_get_args(mrb, "o", &path);
 #else
-static R_VAL ruby2d_image_ext_load_image(R_VAL self, R_VAL path) {
+static R_VAL ruby2d_pixmap_ext_load_pixmap(R_VAL self, R_VAL path) {
 #endif
   R2D_Init();
 
-  R_VAL result = r_ary_new();
-
   SDL_Surface *surface = R2D_CreateImageSurface(RSTRING_PTR(path));
-  R2D_ImageConvertToRGB(surface);
-
-  r_ary_push(result, r_data_wrap_struct(surface, surface));
-  r_ary_push(result, INT2NUM(surface->w));
-  r_ary_push(result, INT2NUM(surface->h));
+  // initialize for later use
+  r_iv_set(self, "@ext_sdl_texture", R_NIL);
+
+  if (surface != NULL) {
+#if GLES
+    // OpenGL ES doesn't support BGR color order, so applying the
+    // conversion to the pixels. This will however render incorrect colours
+    // for BGR images when using Canvas. 
+    // TODO: A better solution one day?
+    R2D_ImageConvertToRGB(surface);
+#endif
 
-  return result;
+    r_iv_set(self, "@ext_pixel_data", r_data_wrap_struct(surface, surface));
+    r_iv_set(self, "@width", INT2NUM(surface->w));
+    r_iv_set(self, "@height", INT2NUM(surface->h));
+  }
+  else {
+    // TODO: consider raising an exception?
+    //       for docs: https://silverhammermba.github.io/emberb/c/#raise
+    r_iv_set(self, "@ext_pixel_data", R_NIL);
+    r_iv_set(self, "@width", INT2NUM(0));
+    r_iv_set(self, "@height", INT2NUM(0));
+  }
+  return R_NIL;
 }
 
-
 /*
  * Ruby2D::Text#ext_load_text
  */
@@ -430,6 +456,69 @@ static R_VAL ruby2d_text_ext_load_text(R_VAL self, R_VAL font, R_VAL message) {
   return result;
 }
 
+/*
+ * Ruby2D::Canvas#ext_draw_pixmap
+ */
+#if MRUBY
+static R_VAL ruby2d_canvas_ext_draw_pixmap(mrb_state* mrb, R_VAL self) {
+  mrb_value pixmap, src_rect, x, y, w, h;
+  mrb_get_args(mrb, "oooooo", &pixmap, &src_rect, &x, &y, &w, &h);
+#else
+static R_VAL ruby2d_canvas_ext_draw_pixmap(R_VAL self, R_VAL pixmap, R_VAL src_rect, R_VAL x, R_VAL y, R_VAL w, R_VAL h) {
+#endif
+
+  if (r_test(pixmap)) {
+    // Retrieve pixmap's external pixel data (SDL_Surface)
+    SDL_Surface *pix_surface;
+    r_data_get_struct(pixmap, "@ext_pixel_data", &surface_data_type, SDL_Surface, pix_surface);
+
+    SDL_Texture *pix_sdl_tex = NULL;
+    R_VAL pix_ext_sdl_tex = r_iv_get(pixmap, "@ext_sdl_texture");
+    if (r_test(pix_ext_sdl_tex)) {
+      r_data_get_struct(pixmap, "@ext_sdl_texture", &sdl_texture_data_type, SDL_Texture, pix_sdl_tex);
+    }
+
+    SDL_Renderer *render;
+    r_data_get_struct(self, "@ext_renderer", &renderer_data_type, SDL_Renderer, render);
+
+    if (pix_sdl_tex == NULL) {
+      // create and cache an SDL_Texture for this Pixmap
+      pix_sdl_tex = SDL_CreateTextureFromSurface(render, pix_surface);
+      if (pix_sdl_tex != NULL) {
+        r_iv_set(pixmap, "@ext_sdl_texture", r_data_wrap_struct(sdl_texture, pix_sdl_tex));
+      }
+      else printf("*** Unable to create SDL_Texture: %s\n", SDL_GetError());
+    }
+
+    // Draw if we have an SDL_Texture
+    if (pix_sdl_tex != NULL) {
+      SDL_bool src_set = SDL_FALSE;
+      SDL_Rect src;
+      if (r_test(src_rect)) {
+        src_set = SDL_TRUE;
+        // portion of pixmap
+        src = (SDL_Rect) {
+          .x = NUM2INT(r_ary_entry(src_rect, 0)),
+          .y = NUM2INT(r_ary_entry(src_rect, 1)),
+          .w = NUM2INT(r_ary_entry(src_rect, 2)),
+          .h = NUM2INT(r_ary_entry(src_rect, 3))
+        };
+      }
+      else {
+        // whole pixmap
+        src = (SDL_Rect){ .x = 0, .y = 0, .w = pix_surface->w, .h = pix_surface->h }; 
+      }
+      // use incoming size or source size or fallback to pixmap size
+      int pix_w = r_test(w) ? NUM2INT(w) : (src_set ? src.w : NUM2INT(r_iv_get(pixmap, "@width")));
+      int pix_h = r_test(h) ? NUM2INT(h) : (src_set ? src.h : NUM2INT(r_iv_get(pixmap, "@height")));
+      
+      SDL_Rect dst = { .x = NUM2INT(x), .y = NUM2INT(y), .w = pix_w, .h = pix_h };
+      SDL_RenderCopy (render, pix_sdl_tex, &src, &dst);
+    }
+  }
+  return R_NIL;
+}
+
 
 /*
  * Ruby2D::Texture#ext_create
@@ -451,19 +540,47 @@ static R_VAL ruby2d_texture_ext_create(R_VAL self, R_VAL rubySurface, R_VAL widt
   #endif
 
   // Detect image mode
-  GLint format = GL_RGB;
-  if (surface->format->BytesPerPixel == 4) {
-    format = GL_RGBA;
-  }
+  GLint gl_internal_format, gl_format;
+  GLenum gl_type;  
 
-  R2D_GL_CreateTexture(&texture_id, format,
+  switch (surface->format->BytesPerPixel) {
+    case 4:
+#if GLES
+      gl_internal_format = gl_format = GL_RGBA; 
+#else
+      gl_internal_format = GL_RGBA; 
+      gl_format = (surface->format->Rmask == 0xff0000) ? GL_BGRA : GL_RGBA;
+#endif
+      gl_type = GL_UNSIGNED_BYTE;
+      break;
+    case 3:
+#if GLES
+      gl_internal_format = gl_format = GL_RGB; 
+#else
+      gl_internal_format = GL_RGB; 
+      gl_format = (surface->format->Rmask == 0xff0000) ? GL_BGR : GL_RGB;
+#endif
+      gl_type = GL_UNSIGNED_BYTE;
+      break;
+    case 2:
+      gl_internal_format = gl_format = GL_RGB;
+      gl_type = GL_UNSIGNED_SHORT_5_6_5;
+      break;
+    case 1:
+    default:
+      // this would be ideal for font glyphs which use luminance + alpha and colour
+      // is set when drawing
+      gl_internal_format = gl_format = GL_LUMINANCE_ALPHA;
+      gl_type = GL_UNSIGNED_BYTE;
+      break;
+  }
+  R2D_GL_CreateTexture(&texture_id, gl_internal_format, gl_format, gl_type,
                        NUM2INT(width), NUM2INT(height),
                        surface->pixels, GL_NEAREST);
 
   return INT2NUM(texture_id);
 }
 
-
 /*
  * Ruby2D::Texture#ext_delete
  */
@@ -482,6 +599,528 @@ static R_VAL ruby2d_texture_ext_delete(R_VAL self, R_VAL rubyTexture_id) {
 }
 
 
+/*
+ * Ruby2D::Canvas#ext_create
+ */
+#if MRUBY
+static R_VAL ruby2d_canvas_ext_create(mrb_state* mrb, R_VAL self) {
+  mrb_value a;
+  mrb_get_args(mrb, "o", &a);
+#else
+static R_VAL ruby2d_canvas_ext_create(R_VAL self, R_VAL a) {
+#endif
+  SDL_Surface *surf = SDL_CreateRGBSurface(
+    0, NUM2INT(r_ary_entry(a, 0)), NUM2INT(r_ary_entry(a, 1)),
+    32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000
+  );
+
+  SDL_Renderer *render = SDL_CreateSoftwareRenderer(surf);
+
+  SDL_SetRenderDrawColor(render,
+          NUM2DBL(r_ary_entry(a, 2)) * 255, // r
+          NUM2DBL(r_ary_entry(a, 3)) * 255, // g
+          NUM2DBL(r_ary_entry(a, 4)) * 255, // b
+          NUM2DBL(r_ary_entry(a, 5)) * 255  // a
+          );
+  SDL_SetRenderDrawBlendMode(render, SDL_BLENDMODE_NONE);
+  SDL_RenderClear(render);
+
+  SDL_SetSurfaceBlendMode(surf, SDL_BLENDMODE_BLEND);
+  SDL_SetRenderDrawBlendMode(render, SDL_BLENDMODE_BLEND);
+
+  r_iv_set(self, "@ext_pixel_data", r_data_wrap_struct(surface, surf));
+  r_iv_set(self, "@ext_renderer", r_data_wrap_struct(renderer, render));
+  return R_NIL;
+}
+
+/*
+ * Ruby2D::Canvas#ext_clear
+ */
+#if MRUBY
+static R_VAL ruby2d_canvas_ext_clear(mrb_state* mrb, R_VAL self) {
+  mrb_value a;
+  mrb_get_args(mrb, "o", &a);
+#else
+static R_VAL ruby2d_canvas_ext_clear(R_VAL self, R_VAL a) {
+#endif
+  // `a` is the array representing the colour values
+
+  SDL_Renderer *render;
+  r_data_get_struct(self, "@ext_renderer", &renderer_data_type, SDL_Renderer, render);
+
+  SDL_SetRenderDrawColor(render,
+          NUM2DBL(r_ary_entry(a, 0)) * 255, // r
+          NUM2DBL(r_ary_entry(a, 1)) * 255, // g
+          NUM2DBL(r_ary_entry(a, 2)) * 255, // b
+          NUM2DBL(r_ary_entry(a, 3)) * 255  // a
+          );
+  SDL_SetRenderDrawBlendMode(render, SDL_BLENDMODE_NONE);
+  SDL_RenderClear(render);
+  SDL_SetRenderDrawBlendMode(render, SDL_BLENDMODE_BLEND);
+
+  return R_NIL;
+}
+
+/*
+ * Ruby2D::Canvas#ext_fill_rectangle
+ */
+#if MRUBY
+static R_VAL ruby2d_canvas_ext_fill_rectangle(mrb_state* mrb, R_VAL self) {
+  mrb_value a;
+  mrb_get_args(mrb, "o", &a);
+#else
+static R_VAL ruby2d_canvas_ext_fill_rectangle(R_VAL self, R_VAL a) {
+#endif
+  // `a` is the array representing the rectangle
+
+  SDL_Renderer *render;
+  r_data_get_struct(self, "@ext_renderer", &renderer_data_type, SDL_Renderer, render);
+
+  SDL_SetRenderDrawBlendMode(render, SDL_BLENDMODE_BLEND);
+
+  SDL_Rect rect = { .x = NUM2INT(r_ary_entry(a, 0)),
+                    .y = NUM2INT(r_ary_entry(a, 1)),
+                    .w = NUM2INT(r_ary_entry(a, 2)),
+                    .h = NUM2INT(r_ary_entry(a, 3))
+                    };
+
+  SDL_SetRenderDrawColor(render,
+          NUM2DBL(r_ary_entry(a, 4)) * 255, // r
+          NUM2DBL(r_ary_entry(a, 5)) * 255, // g
+          NUM2DBL(r_ary_entry(a, 6)) * 255, // b
+          NUM2DBL(r_ary_entry(a, 7)) * 255  // a
+          );
+  SDL_RenderFillRect(render, &rect);
+
+  return R_NIL;
+}
+
+/*
+ * Ruby2D::Canvas#ext_draw_rectangle
+ */
+#if MRUBY
+static R_VAL ruby2d_canvas_ext_draw_rectangle(mrb_state* mrb, R_VAL self) {
+  mrb_value a;
+  mrb_get_args(mrb, "o", &a);
+#else
+static R_VAL ruby2d_canvas_ext_draw_rectangle(R_VAL self, R_VAL a) {
+#endif
+  // `a` is the array representing the rectangle
+  //   0, 1,   2,     3,       4,      5, 6, 7, 8
+  // [ x, y, width, height, thickness, r, g, b, a]
+
+  SDL_Renderer *render;
+  r_data_get_struct(self, "@ext_renderer", &renderer_data_type, SDL_Renderer, render);
+
+  int thickness = NUM2INT(r_ary_entry(a, 4)); 
+  if (thickness == 1) {
+    SDL_Rect rect = { .x = NUM2INT(r_ary_entry(a, 0)),
+                      .y = NUM2INT(r_ary_entry(a, 1)),
+                      .w = NUM2INT(r_ary_entry(a, 2)),
+                      .h = NUM2INT(r_ary_entry(a, 3))
+                      };
+
+    SDL_SetRenderDrawColor(render,
+            NUM2DBL(r_ary_entry(a, 5)) * 255, // r
+            NUM2DBL(r_ary_entry(a, 6)) * 255, // g
+            NUM2DBL(r_ary_entry(a, 7)) * 255, // b
+            NUM2DBL(r_ary_entry(a, 8)) * 255  // a
+            );
+    SDL_RenderDrawRect(render, &rect);
+  }
+  else if (thickness > 1) {
+    R2D_Canvas_DrawThickRect(render, 
+      NUM2INT(r_ary_entry(a, 0)), // x
+      NUM2INT(r_ary_entry(a, 1)), // y
+      NUM2INT(r_ary_entry(a, 2)), // width
+      NUM2INT(r_ary_entry(a, 3)), // height
+      thickness,
+      NUM2DBL(r_ary_entry(a, 5)) * 255, // r
+      NUM2DBL(r_ary_entry(a, 6)) * 255, // g
+      NUM2DBL(r_ary_entry(a, 7)) * 255, // b
+      NUM2DBL(r_ary_entry(a, 8)) * 255  // a
+    );
+  }
+  return R_NIL;
+}
+
+/*
+ * Ruby2D::Canvas#ext_draw_line
+ */
+#if MRUBY
+static R_VAL ruby2d_canvas_ext_draw_line(mrb_state* mrb, R_VAL self) {
+  mrb_value a;
+  mrb_get_args(mrb, "o", &a);
+#else
+static R_VAL ruby2d_canvas_ext_draw_line(R_VAL self, R_VAL a) {
+#endif
+  // `a` is the array representing the line
+
+  SDL_Renderer *render;
+  r_data_get_struct(self, "@ext_renderer", &renderer_data_type, SDL_Renderer, render);
+
+  int thickness = NUM2INT(r_ary_entry(a, 4)); 
+  if (thickness == 1) {
+    // use the SDL_Renderer's draw line for single pixel lines
+    SDL_SetRenderDrawColor(render,
+            NUM2DBL(r_ary_entry(a, 5)) * 255, // r
+            NUM2DBL(r_ary_entry(a, 6)) * 255, // g
+            NUM2DBL(r_ary_entry(a, 7)) * 255, // b
+            NUM2DBL(r_ary_entry(a, 8)) * 255  // a
+            );
+    SDL_RenderDrawLine(render, 
+      NUM2INT(r_ary_entry(a, 0)), // x1
+      NUM2INT(r_ary_entry(a, 1)), // y1
+      NUM2INT(r_ary_entry(a, 2)), // x2
+      NUM2INT(r_ary_entry(a, 3))  // y2
+    );
+  }
+  else if (thickness > 1) {
+    // use a custom handler to convert a thick line into a 
+    // quad and draw using SDL_Renderer's geometry renderer
+    R2D_Canvas_DrawThickLine(render, 
+      NUM2INT(r_ary_entry(a, 0)), // x1
+      NUM2INT(r_ary_entry(a, 1)), // y1
+      NUM2INT(r_ary_entry(a, 2)), // x2
+      NUM2INT(r_ary_entry(a, 3)), // y2
+      thickness,
+      NUM2DBL(r_ary_entry(a, 5)) * 255, // r
+      NUM2DBL(r_ary_entry(a, 6)) * 255, // g
+      NUM2DBL(r_ary_entry(a, 7)) * 255, // b
+      NUM2DBL(r_ary_entry(a, 8)) * 255  // a
+    );
+  }
+
+  return R_NIL;
+}
+
+#define MAX_POLY_POINTS 64
+
+/*
+ * Ruby2D::Canvas#ext_draw_polyline
+ */
+#if MRUBY
+static R_VAL ruby2d_canvas_ext_draw_polyline(mrb_state* mrb, R_VAL self) {
+  mrb_value config, coords;
+  mrb_get_args(mrb, "oo", &config, &coords);
+#else
+static R_VAL ruby2d_canvas_ext_draw_polyline(R_VAL self, R_VAL config, R_VAL coords) {
+#endif
+  // `config` is an array
+  //       0,        1, 2, 3, 4
+  //    [ thickness, r, g, b, a ]
+  //
+  // `coords` is an array of x, y values
+  //       0,  1,  2,  3, ...
+  //    [ x1, y1, x2, y2, ... ]
+
+  SDL_Renderer *render;
+  r_data_get_struct(self, "@ext_renderer", &renderer_data_type, SDL_Renderer, render);
+
+  long coord_count = RARRAY_LEN(coords);
+  int thickness = NUM2INT(r_ary_entry(config, 0)); 
+  if (thickness == 1) {
+    // use the SDL_Renderer's draw line for single pixel lines
+    SDL_SetRenderDrawColor(render,
+            NUM2DBL(r_ary_entry(config, 1)) * 255, // r
+            NUM2DBL(r_ary_entry(config, 2)) * 255, // g
+            NUM2DBL(r_ary_entry(config, 3)) * 255, // b
+            NUM2DBL(r_ary_entry(config, 4)) * 255  // a
+            );
+    int x1 = NUM2INT(r_ary_entry(coords, 0));
+    int y1 = NUM2INT(r_ary_entry(coords, 1));
+    for (int i = 2; i < coord_count; i+= 2) {
+      int x2 = NUM2INT(r_ary_entry(coords, i));
+      int y2 = NUM2INT(r_ary_entry(coords, i+1));
+      SDL_RenderDrawLine(render, x1, y1, x2, y2);
+      x1 = x2;
+      y1 = y2;
+    }
+  }
+  else if (thickness > 1) {
+    // use a custom handler to convert a thick line into a 
+    // quad and draw using SDL_Renderer's geometry renderer
+
+    SDL_FPoint points[MAX_POLY_POINTS];
+    int num_points = 0;
+
+    points[num_points++] = (SDL_FPoint) { 
+      .x = NUM2INT(r_ary_entry(coords, 0)), 
+      .y = NUM2INT(r_ary_entry(coords, 1))
+    };
+    for (int i = 2; i < coord_count && num_points < MAX_POLY_POINTS; i+= 2) {
+      points[num_points++] = (SDL_FPoint) { 
+        .x = NUM2INT(r_ary_entry(coords, i)), 
+        .y = NUM2INT(r_ary_entry(coords, i+1)) };
+    }
+    R2D_Canvas_DrawThickPolyline(render,
+      points, num_points,
+      thickness,
+      NUM2DBL(r_ary_entry(config, 1)) * 255, // r
+      NUM2DBL(r_ary_entry(config, 2)) * 255, // g
+      NUM2DBL(r_ary_entry(config, 3)) * 255, // b
+      NUM2DBL(r_ary_entry(config, 4)) * 255, // a
+      false // don't skip first/last
+    );
+  }
+
+  return R_NIL;
+}
+
+/*
+ * Ruby2D::Canvas#ext_draw_polygon
+ */
+#if MRUBY
+static R_VAL ruby2d_canvas_ext_draw_polygon(mrb_state* mrb, R_VAL self) {
+  mrb_value config, coords;
+  mrb_get_args(mrb, "oo", &config, &coords);
+#else
+static R_VAL ruby2d_canvas_ext_draw_polygon(R_VAL self, R_VAL config, R_VAL coords) {
+#endif
+  // `config` is an array
+  //       0,        1, 2, 3, 4
+  //    [ thickness, r, g, b, a ]
+  //
+  // `coords` is an array of x, y values
+  //       0,  1,  2,  3, ...
+  //    [ x1, y1, x2, y2, ... ]
+
+  SDL_Renderer *render;
+  r_data_get_struct(self, "@ext_renderer", &renderer_data_type, SDL_Renderer, render);
+
+  long coord_count = RARRAY_LEN(coords);
+  int thickness = NUM2INT(r_ary_entry(config, 0)); 
+  if (thickness == 1) {
+    // use the SDL_Renderer's draw line for single pixel lines
+    SDL_SetRenderDrawColor(render,
+            NUM2DBL(r_ary_entry(config, 1)) * 255, // r
+            NUM2DBL(r_ary_entry(config, 2)) * 255, // g
+            NUM2DBL(r_ary_entry(config, 3)) * 255, // b
+            NUM2DBL(r_ary_entry(config, 4)) * 255  // a
+            );
+    int x1 = NUM2INT(r_ary_entry(coords, 0));
+    int y1 = NUM2INT(r_ary_entry(coords, 1));
+    for (int i = 2; i < coord_count; i+= 2) {
+      int x2 = NUM2INT(r_ary_entry(coords, i));
+      int y2 = NUM2INT(r_ary_entry(coords, i+1));
+      SDL_RenderDrawLine(render, x1, y1, x2, y2);
+      x1 = x2;
+      y1 = y2;
+    }
+    // connect back to first point to close the shape
+    int x2 = NUM2INT(r_ary_entry(coords, 0));
+    int y2 = NUM2INT(r_ary_entry(coords, 1));
+    SDL_RenderDrawLine(render, x1, y1, x2, y2);
+  }
+  else if (thickness > 1) {
+    // use a custom handler to convert a thick line into a 
+    // quad and draw using SDL_Renderer's geometry renderer
+
+    SDL_FPoint points[MAX_POLY_POINTS+3];  // three extra slots to points 0, 1, 2
+    int num_points = 0;
+
+    points[num_points++] = (SDL_FPoint) { 
+      .x = NUM2INT(r_ary_entry(coords, 0)), 
+      .y = NUM2INT(r_ary_entry(coords, 1))
+    };
+    for (int i = 2; i < coord_count && num_points < MAX_POLY_POINTS; i+= 2) {
+      points[num_points++] = (SDL_FPoint) { 
+        .x = NUM2INT(r_ary_entry(coords, i)), 
+        .y = NUM2INT(r_ary_entry(coords, i+1)) };
+    }
+    // repeat first three coordinates at the end
+    points[num_points++] = points[0];
+    points[num_points++] = points[1];
+    points[num_points++] = points[2];
+    // use polyline draw but ask it to skip first and last segments
+    // since we added three more points at the end, these produce the
+    // missing segments with proper joins
+    R2D_Canvas_DrawThickPolyline(render,
+      points, num_points,
+      thickness,
+      NUM2DBL(r_ary_entry(config, 1)) * 255, // r
+      NUM2DBL(r_ary_entry(config, 2)) * 255, // g
+      NUM2DBL(r_ary_entry(config, 3)) * 255, // b
+      NUM2DBL(r_ary_entry(config, 4)) * 255, // a
+      true // skip first/last segments when drawing the polyline
+    );
+  }
+
+  return R_NIL;
+}
+
+/*
+ * Ruby2D::Canvas#ext_fill_polygon
+ */
+#if MRUBY
+static R_VAL ruby2d_canvas_ext_fill_polygon(mrb_state* mrb, R_VAL self) {
+  mrb_value coords, rgbas;
+  mrb_get_args(mrb, "oo", &coords, &rgbas);
+#else
+static R_VAL ruby2d_canvas_ext_fill_polygon(R_VAL self, R_VAL coords, R_VAL rgbas) {
+#endif
+  // `coords` is an array of x, y values
+  //       0,  1,  2,  3, ...
+  //    [ x1, y1, x2, y2, ... ]
+  //
+  // `rgbas` is an array of r, g, b, a values
+  //       0,  1,  2,  3,  4,  5,  6,  7 ...
+  //    [ r1, g1, b1, a1, r2, g2, b2, a2, ... ]
+
+  SDL_Renderer *render;
+  r_data_get_struct(self, "@ext_renderer", &renderer_data_type, SDL_Renderer, render);
+
+  long coord_len = RARRAY_LEN(coords);
+  long rgbas_len = RARRAY_LEN(rgbas);
+
+  if (coord_len >= 6 && rgbas_len > 0) {
+    SDL_FPoint points[MAX_POLY_POINTS];
+    int num_points = 0;
+
+    SDL_Color colors[MAX_POLY_POINTS];
+    int num_colors = 0;
+
+    for (int i = 0; i < coord_len && num_points < MAX_POLY_POINTS; i+= 2) {
+      points[num_points++] = (SDL_FPoint) { 
+        .x = NUM2INT(r_ary_entry(coords, i)), 
+        .y = NUM2INT(r_ary_entry(coords, i+1)) };
+    }
+    for (int i = 0; i < rgbas_len && num_colors < MAX_POLY_POINTS; i+= 4) {
+      colors[num_colors++] = (SDL_Color) { 
+        .r = NUM2DBL(r_ary_entry(rgbas, i)) * 255, // r
+        .g = NUM2DBL(r_ary_entry(rgbas, i+1)) * 255, // g
+        .b = NUM2DBL(r_ary_entry(rgbas, i+2)) * 255, // b
+        .a = NUM2DBL(r_ary_entry(rgbas, i+3)) * 255  // a
+      };
+    }
+
+    R2D_Canvas_FillPolygon(render, points, num_points, colors, num_colors);
+  }
+
+  return R_NIL;
+}
+
+/*
+ * Ruby2D::Canvas#self.ext_fill_ellipse
+ */
+#if MRUBY
+static R_VAL ruby2d_canvas_ext_fill_ellipse(mrb_state* mrb, R_VAL self) {
+  mrb_value a;
+  mrb_get_args(mrb, "o", &a);
+#else
+static R_VAL ruby2d_canvas_ext_fill_ellipse(R_VAL self, R_VAL a) {
+#endif
+  // `a` is the array representing the filled circle
+  //   0  1     2        3        4     5  6  7  8
+  // [ x, y, xradius, yradius, sectors, r, g, b, a ]
+  SDL_Renderer *render;
+  r_data_get_struct(self, "@ext_renderer", &renderer_data_type, SDL_Renderer, render);
+
+  SDL_Vertex verts[3];
+  // center
+  float x, y;
+  verts[0].position = (SDL_FPoint) { 
+    .x = x = NUM2INT(r_ary_entry(a,  0)), 
+    .y = y = NUM2INT(r_ary_entry(a,  1)) 
+  };
+  // dimensions
+  float xradius = NUM2INT(r_ary_entry(a,  2));
+  float yradius = NUM2INT(r_ary_entry(a,  3));
+  float sectors = NUM2INT(r_ary_entry(a,  4));
+  float unit_angle = 2 * M_PI / sectors;
+
+  // colour all vertices
+  verts[1].color = verts[2].color = verts[0].color = (SDL_Color) {
+      .r = NUM2DBL(r_ary_entry(a, 5)) * 255,
+      .g = NUM2DBL(r_ary_entry(a, 6)) * 255,
+      .b = NUM2DBL(r_ary_entry(a, 7)) * 255,
+      .a = NUM2DBL(r_ary_entry(a, 8)) * 255,
+  };
+
+  // point at 0 radians
+  verts[1].position = (SDL_FPoint) { 
+    .x = x + xradius * cosf(0), 
+    .y = y + yradius * sinf(0)
+  };
+  for (float i = 1; i <= sectors; i++) {
+    float angle = i * unit_angle;
+    // re-use from previous calculation
+    verts[2].position = verts[1].position;
+    // calculate new point
+    verts[1].position = (SDL_FPoint) { 
+      .x = x + xradius * cosf(angle), 
+      .y = y + yradius * sinf(angle)
+    };
+    SDL_RenderGeometry(render, NULL, verts, 3, NULL, 0);
+  }
+
+  return R_NIL;
+}
+
+/*
+ * Ruby2D::Canvas#self.ext_draw_ellipse
+ */
+#if MRUBY
+static R_VAL ruby2d_canvas_ext_draw_ellipse(mrb_state* mrb, R_VAL self) {
+  mrb_value a;
+  mrb_get_args(mrb, "o", &a);
+#else
+static R_VAL ruby2d_canvas_ext_draw_ellipse(R_VAL self, R_VAL a) {
+#endif
+  // `a` is the array representing the ellipse to draw
+  //   0  1     2        3        4         5      6  7  8  9
+  // [ x, y, xradius, yradius, sectors, thickness, r, g, b, a ]
+
+  // thickness
+  int thickness = NUM2INT(r_ary_entry(a,  5));
+  if (thickness <= 0) return R_NIL;
+
+  SDL_Renderer *render;
+  r_data_get_struct(self, "@ext_renderer", &renderer_data_type, SDL_Renderer, render);
+
+  // center
+  float x = NUM2INT(r_ary_entry(a,  0));
+  float y = NUM2INT(r_ary_entry(a,  1)) ;
+  // dimensions
+  float xradius = NUM2INT(r_ary_entry(a,  2));
+  float yradius = NUM2INT(r_ary_entry(a,  3));
+  float sectors = NUM2INT(r_ary_entry(a,  4));
+  // colors
+  int clr_r = NUM2DBL(r_ary_entry(a, 6)) * 255;
+  int clr_g = NUM2DBL(r_ary_entry(a, 7)) * 255;
+  int clr_b = NUM2DBL(r_ary_entry(a, 8)) * 255;
+  int clr_a = NUM2DBL(r_ary_entry(a, 9)) * 255;
+  
+  if (thickness > 1) {
+    R2D_Canvas_DrawThickEllipse(render, 
+      x, y, xradius, yradius, sectors, thickness,
+      clr_r, clr_g, clr_b, clr_a);
+  }
+  else {
+    R2D_Canvas_DrawThinEllipse(render, 
+      x, y, xradius, yradius, sectors,
+      clr_r, clr_g, clr_b, clr_a);
+  }
+
+  return R_NIL;
+}
+
+/*
+ * Calculate the cross product of the two lines
+ * connecting the three points clock-wise. A negative value
+ * means the angle "to the right" is > 180. 
+ */
+/* Unused
+static inline int cross_product_corner(x1, y1, x2, y2, x3, y3) {
+  register int vec1_x = x1 - x2;
+  register int vec1_y = y1 - y2;
+  register int vec2_x = x2 - x3;
+  register int vec2_y = y2 - y3;
+
+  return (vec1_x * vec2_y) - (vec1_y * vec2_x);
+}
+*/
+
 /*
  * Ruby2D::Sound#ext_init
  * Initialize sound structure data
@@ -510,7 +1149,22 @@ static R_VAL ruby2d_sound_ext_play(R_VAL self) {
 #endif
   R2D_Sound *snd;
   r_data_get_struct(self, "@data", &sound_data_type, R2D_Sound, snd);
-  R2D_PlaySound(snd);
+  R2D_PlaySound(snd, r_test(r_iv_get(self, "@loop")));
+  return R_NIL;
+}
+
+
+/*
+ * Ruby2D::Sound#ext_stop
+ */
+#if MRUBY
+static R_VAL ruby2d_sound_ext_stop(mrb_state* mrb, R_VAL self) {
+#else
+static R_VAL ruby2d_sound_ext_stop(R_VAL self) {
+#endif
+  R2D_Sound *snd;
+  r_data_get_struct(self, "@data", &sound_data_type, R2D_Sound, snd);
+  R2D_StopSound(snd);
   return R_NIL;
 }
 
@@ -798,6 +1452,30 @@ static void free_surface(SDL_Surface *surface) {
   SDL_FreeSurface(surface);
 }
 
+/*
+ * Free SDL texture structure used within the Ruby 2D `Pixmap` class
+ */
+#if MRUBY
+static void free_sdl_texture(mrb_state *mrb, void *p_) {
+  SDL_Texture *sdl_texure = (SDL_Texture *)p_;
+#else
+static void free_sdl_texture(SDL_Texture *sdl_texure) {
+#endif
+  SDL_DestroyTexture(sdl_texure);
+}
+
+/*
+ * Free renderer structure used within the Ruby 2D `Canvas` class
+ */
+#if MRUBY
+static void free_renderer(mrb_state *mrb, void *p_) {
+  SDL_Renderer *renderer = (SDL_Renderer *)p_;
+#else
+static void free_renderer(SDL_Renderer *renderer) {
+#endif
+  SDL_DestroyRenderer(renderer);
+}
+
 
 /*
  * Free music structure attached to Ruby 2D `Music` class
@@ -1236,11 +1914,11 @@ void Init_ruby2d() {
   // Ruby2D::Circle#self.ext_draw
   r_define_class_method(ruby2d_circle_class, "ext_draw", ruby2d_circle_ext_draw, r_args_req(1));
 
-  // Ruby2D::Image
-  R_CLASS ruby2d_image_class = r_define_class(ruby2d_module, "Image");
+  // Ruby2D::Pixmap
+  R_CLASS ruby2d_pixmap_class = r_define_class(ruby2d_module, "Pixmap");
 
-  // Ruby2D::Image#ext_load_image
-  r_define_class_method(ruby2d_image_class, "ext_load_image", ruby2d_image_ext_load_image, r_args_req(1));
+  // Ruby2D::Pixmap#ext_load_pixmap
+  r_define_method(ruby2d_pixmap_class, "ext_load_pixmap", ruby2d_pixmap_ext_load_pixmap, r_args_req(1));
 
   // Ruby2D::Text
   R_CLASS ruby2d_text_class = r_define_class(ruby2d_module, "Text");
@@ -1257,6 +1935,9 @@ void Init_ruby2d() {
   // Ruby2D::Sound#ext_play
   r_define_method(ruby2d_sound_class, "ext_play", ruby2d_sound_ext_play, r_args_none);
   
+  // Ruby2D::Sound#ext_stop
+  r_define_method(ruby2d_sound_class, "ext_stop", ruby2d_sound_ext_stop, r_args_none);
+
   // Ruby2D::Sound#ext_get_volume
   r_define_method(ruby2d_sound_class, "ext_get_volume", ruby2d_sound_ext_get_volume, r_args_none);
   
@@ -1320,6 +2001,42 @@ void Init_ruby2d() {
   // Ruby2D::Texture#ext_delete
   r_define_method(ruby2d_texture_class, "ext_delete", ruby2d_texture_ext_delete, r_args_req(1));
 
+  // Ruby2D::Canvas
+  R_CLASS ruby2d_canvas_class = r_define_class(ruby2d_module, "Canvas");
+
+  // Ruby2D::Canvas#ext_create
+  r_define_method(ruby2d_canvas_class, "ext_create", ruby2d_canvas_ext_create, r_args_req(1));
+
+  // Ruby2D::Canvas#ext_clear
+  r_define_method(ruby2d_canvas_class, "ext_clear", ruby2d_canvas_ext_clear, r_args_req(1));
+
+  // Ruby2D::Canvas#ext_fill_rectangle
+  r_define_method(ruby2d_canvas_class, "ext_fill_rectangle", ruby2d_canvas_ext_fill_rectangle, r_args_req(1));
+
+  // Ruby2D::Canvas#ext_draw_rectangle
+  r_define_method(ruby2d_canvas_class, "ext_draw_rectangle", ruby2d_canvas_ext_draw_rectangle, r_args_req(1));
+
+  // Ruby2D::Canvas#ext_draw_line
+  r_define_method(ruby2d_canvas_class, "ext_draw_line", ruby2d_canvas_ext_draw_line, r_args_req(1));
+
+  // Ruby2D::Canvas#ext_draw_polyline
+  r_define_method(ruby2d_canvas_class, "ext_draw_polyline", ruby2d_canvas_ext_draw_polyline, r_args_req(2));
+
+  // Ruby2D::Canvas#ext_draw_polygon
+  r_define_method(ruby2d_canvas_class, "ext_draw_polygon", ruby2d_canvas_ext_draw_polygon, r_args_req(2));
+
+  // Ruby2D::Canvas#ext_fill_polygon
+  r_define_method(ruby2d_canvas_class, "ext_fill_polygon", ruby2d_canvas_ext_fill_polygon, r_args_req(2));
+
+  // Ruby2D::Canvas#ext_fill_ellipse
+  r_define_method(ruby2d_canvas_class, "ext_fill_ellipse", ruby2d_canvas_ext_fill_ellipse, r_args_req(1));
+
+  // Ruby2D::Canvas#ext_draw_ellipse
+  r_define_method(ruby2d_canvas_class, "ext_draw_ellipse", ruby2d_canvas_ext_draw_ellipse, r_args_req(1));
+
+  // Ruby2D::Canvas#ext_draw_pixmap
+  r_define_method(ruby2d_canvas_class, "ext_draw_pixmap", ruby2d_canvas_ext_draw_pixmap, r_args_req(6));
+
   // Ruby2D::Window
   R_CLASS ruby2d_window_class = r_define_class(ruby2d_module, "Window");