ruby2d 0.11.3 → 0.12.0

data/ext/ruby2d/ruby2d.h

@@ -129,7 +129,7 @@ extern "C" {
   #define GL_GLEXT_PROTOTYPES 1
   #if WINDOWS
     #define GLEW_STATIC
-    #include <glew.h>
+    #include <GL/glew.h>
   #endif
   #include <SDL2/SDL_opengl.h>
 #endif
@@ -321,6 +321,7 @@ typedef struct {
 typedef struct {
   const char *path;
   Mix_Chunk *data;
+  int channel;
 } R2D_Sound;
 
 // R2D_Music
@@ -471,7 +472,12 @@ R2D_Sound *R2D_CreateSound(const char *path);
 /*
  * Play the sound
  */
-void R2D_PlaySound(R2D_Sound *snd);
+void R2D_PlaySound(R2D_Sound *snd, bool loop);
+
+/*
+ * Stop the sound
+ */
+void R2D_StopSound(R2D_Sound *snd);
 
 /*
  * Get the sound's length
@@ -503,6 +509,63 @@ void R2D_SetSoundMixVolume(int volume);
  */
 void R2D_FreeSound(R2D_Sound *snd);
 
+// Canvas //////////////////////////////////////////////////////////////////////
+
+/*
+ * Draw a thick rectangle on a canvas using a pre-converted RGBA colour value.
+ * @param [int] thickness must be > 1, else does nothing
+ */
+void R2D_Canvas_DrawThickRect(SDL_Renderer *render, int x, int y, int width,
+                              int height, int thickness, int r, int g, int b,
+                              int a);
+
+/*
+ * Draw a thick line on a canvas using a pre-converted RGBA colour value.
+ * @param [int] thickness must be > 1, else does nothing
+ */
+void R2D_Canvas_DrawThickLine(SDL_Renderer *render, 
+                       int x1, int y1, int x2, int y2, int thickness, 
+                       int r, int g, int b, int a);
+
+/*
+ * Draw a thin (single pixel) ellipse on a canvas using a pre-converted RGBA
+ * colour value.
+ */
+void R2D_Canvas_DrawThinEllipse(SDL_Renderer *render, int x, int y,
+                                float xradius, float yradius, float sectors,
+                                int r, int g, int b, int a);
+
+/*
+ * Draw a thick ellipse on a canvas using a pre-converted RGBA colour value.
+ * @param [int] thickness must be > 1, else does nothing
+ */
+void R2D_Canvas_DrawThickEllipse(SDL_Renderer *render, int x, int y,
+                                 float xradius, float yradius, float sectors,
+                                 int thickness, int r, int g, int b, int a);
+
+/*
+ * Draw a thick N-point polyline, with a mitre join where two
+ * segments are joined.
+ * @param [int] thickness must be > 1, else does nothing
+ * @param [bool] skip_first_last use false for polyline, true for polygon when specifying first, second points again at the end
+ */
+void R2D_Canvas_DrawThickPolyline(SDL_Renderer *render, SDL_FPoint *points,
+                                  int num_points, int thickness, int r, int g,
+                                  int b, int a, bool skip_first_last);
+
+/*
+ * Fill a polygon with a single colour.
+ * @param points Array of points
+ * @param num_points Number of points
+ * @param colors Array of colours
+ * @param num_colors Number of colors, must be at least 1, and may be less than
+ *                      +num_points+ in which case the colours will be repeated
+ *                      via modulo.
+ * @note Currently supports only: convex polygons or simple polygons with one concave corner. For now.
+ */
+void R2D_Canvas_FillPolygon(SDL_Renderer *render, SDL_FPoint *points,
+                            int num_points, SDL_Color *colors, int num_colors);
+
 // Music ///////////////////////////////////////////////////////////////////////
 
 /*
@@ -639,7 +702,7 @@ int R2D_GL_CheckLinked(GLuint program, const char *name);
 void R2D_GL_GetViewportScale(R2D_Window *window, int *w, int *h, double *scale);
 void R2D_GL_SetViewport(R2D_Window *window);
 void R2D_GL_CreateTexture(
-  GLuint *id, GLint format,
+  GLuint *id, GLint internalFormat, GLint format, GLenum type,
   int w, int h,
   const GLvoid *data, GLint filter);
 void R2D_GL_DrawTriangle(

data/ext/ruby2d/sound.c

@@ -40,9 +40,23 @@ R2D_Sound *R2D_CreateSound(const char *path) {
 /*
  * Play the sound
  */
-void R2D_PlaySound(R2D_Sound *snd) {
+void R2D_PlaySound(R2D_Sound *snd, bool loop) {
   if (!snd) return;
-  Mix_PlayChannel(-1, snd->data, 0);
+
+  // If looping, set to -1 times; else 0
+  int times = loop ? -1 : 0;
+
+  // times: 0 == once, -1 == forever
+  snd->channel = Mix_PlayChannel(-1, snd->data, times);
+}
+
+/*
+ * Stop the sound
+ */
+void R2D_StopSound(R2D_Sound *snd) {
+  if (!snd) return;
+
+  Mix_HaltChannel(snd->channel);
 }
 
 

data/lib/ruby2d/canvas.rb

@@ -0,0 +1,315 @@
+# frozen_string_literal: true
+
+# Ruby2D::Canvas
+
+module Ruby2D
+  #
+  # Canvas provides a surface into which you can draw using primitives and render the contents
+  # as if it were an image/texture.
+  #
+  # @example A basic Canvas positioned at (0, 0)
+  #   Canvas.new width: 320, height: 240
+  # @example A Canvas that doesn't update texture on every draw method
+  #   Canvas.new width: 320, height: 240, update: false
+  #
+  class Canvas
+    include Renderable
+
+    # Create a Canvas.
+    #
+    # @param [Numeric] width The +width+ of the canvas in pixels
+    # @param [Numeric] height The +height+ of the canvas in pixels
+    # @param [Numeric] x
+    # @param [Numeric] y
+    # @param [Numeric] z
+    # @param [Numeric] rotate Angle, default is 0
+    # @param [String] fill Colour to clear the canvas, respects transparency
+    # @param [String] color or +colour+ Tint the texture when rendering
+    # @param [Numeric] opacity Opacity of the texture when rendering
+    # @param [true, false] update If +true+ updates the texture for every draw/fill call
+    # @param [true, false] show If +true+ the canvas is added to +Window+ automatically.
+    def initialize(width:, height:, x: 0, y: 0, z: 0, rotate: 0,
+                   fill: [0, 0, 0, 0], color: nil, colour: nil, opacity: nil,
+                   update: true, show: true)
+      @x = x
+      @y = y
+      @z = z
+      @width = width
+      @height = height
+      @rotate = rotate
+      @fill = Color.new(fill)
+      self.color = color || colour || 'white'
+      color.opacity = opacity if opacity
+      @update = update
+
+      ext_create([@width, @height, @fill.r, @fill.g, @fill.b, @fill.a]) # sets @ext_pixel_data
+      @texture = Texture.new(@ext_pixel_data, @width, @height)
+      add if show
+    end
+
+    # Clear the entire canvas, replacing every pixel with fill colour without blending.
+    # @param [Color] fill_color
+    def clear(fill_color = @fill)
+      color = fill_color || @fill
+      ext_clear([color.r, color.g, color.b, color.a])
+      update_texture if @update
+    end
+
+    # Draw a filled triangle with a single colour or per-vertex colour blending.
+    # @param [Numeric] x1
+    # @param [Numeric] y1
+    # @param [Numeric] x2
+    # @param [Numeric] y2
+    # @param [Numeric] x3
+    # @param [Numeric] y3
+    # @param [Color, Color::Set] color (or +colour+) Set one or per-vertex colour
+    def fill_triangle(x1:, y1:, x2:, y2:, x3:, y3:, color: nil, colour: nil)
+      fill_polygon coordinates: [x1, y1, x2, y2, x3, y3], color: color || colour
+    end
+
+    # Draw a filled quad(rilateral) with a single colour or per-vertex colour blending.
+    # @param [Numeric] x1
+    # @param [Numeric] y1
+    # @param [Numeric] x2
+    # @param [Numeric] y2
+    # @param [Numeric] x3
+    # @param [Numeric] y3
+    # @param [Numeric] x4
+    # @param [Numeric] y4
+    # @param [Color, Color::Set] color (or +colour+) Set one or per-vertex colour
+    def fill_quad(x1:, y1:, x2:, y2:, x3:, y3:, x4:, y4:, color: nil, colour: nil)
+      fill_polygon coordinates: [x1, y1, x2, y2, x3, y3, x4, y4], color: color || colour
+    end
+
+    # Draw a circle.
+    # @param [Numeric] x Centre
+    # @param [Numeric] y Centre
+    # @param [Numeric] radius
+    # @param [Numeric] sectors The number of segments to subdivide the circumference.
+    # @param [Numeric] stroke_width The thickness of the circle in pixels
+    # @param [Color] color (or +colour+) The fill colour
+    def draw_circle(x:, y:, radius:, sectors: 30, stroke_width: 1, color: nil, colour: nil)
+      clr = color || colour
+      clr = Color.new(clr) unless clr.is_a? Color
+      ext_draw_ellipse([
+                         x, y, radius, radius, sectors, stroke_width,
+                         clr.r, clr.g, clr.b, clr.a
+                       ])
+      update_texture if @update
+    end
+
+    # Draw an ellipse
+    # @param [Numeric] x Centre
+    # @param [Numeric] y Centre
+    # @param [Numeric] xradius
+    # @param [Numeric] yradius
+    # @param [Numeric] sectors The number of segments to subdivide the circumference.
+    # @param [Numeric] stroke_width The thickness of the circle in pixels
+    # @param [Color] color (or +colour+) The fill colour
+    def draw_ellipse(x:, y:, xradius:, yradius:, sectors: 30, stroke_width: 1, color: nil, colour: nil)
+      clr = color || colour
+      clr = Color.new(clr) unless clr.is_a? Color
+      ext_draw_ellipse([
+                         x, y, xradius, yradius, sectors, stroke_width,
+                         clr.r, clr.g, clr.b, clr.a
+                       ])
+      update_texture if @update
+    end
+
+    # Draw a filled circle.
+    # @param [Numeric] x Centre
+    # @param [Numeric] y Centre
+    # @param [Numeric] radius
+    # @param [Numeric] sectors The number of segments to subdivide the circumference.
+    # @param [Color] color (or +colour+) The fill colour
+    def fill_circle(x:, y:, radius:, sectors: 30, color: nil, colour: nil)
+      clr = color || colour
+      clr = Color.new(clr) unless clr.is_a? Color
+      ext_fill_ellipse([
+                         x, y, radius, radius, sectors,
+                         clr.r, clr.g, clr.b, clr.a
+                       ])
+      update_texture if @update
+    end
+
+    # Draw a filled ellipse.
+    # @param [Numeric] x Centre
+    # @param [Numeric] y Centre
+    # @param [Numeric] xradius
+    # @param [Numeric] yradius
+    # @param [Numeric] sectors The number of segments to subdivide the circumference.
+    # @param [Color] color (or +colour+) The fill colour
+    def fill_ellipse(x:, y:, xradius:, yradius:, sectors: 30, color: nil, colour: nil)
+      clr = color || colour
+      clr = Color.new(clr) unless clr.is_a? Color
+      ext_fill_ellipse([
+                         x, y, xradius, yradius, sectors,
+                         clr.r, clr.g, clr.b, clr.a
+                       ])
+      update_texture if @update
+    end
+
+    # Draw a filled rectangle.
+    # @param [Numeric] x
+    # @param [Numeric] y
+    # @param [Numeric] width
+    # @param [Numeric] height
+    # @param [Color] color (or +colour+) The fill colour
+    def fill_rectangle(x:, y:, width:, height:, color: nil, colour: nil)
+      clr = color || colour
+      clr = Color.new(clr) unless clr.is_a? Color
+      ext_fill_rectangle([
+                           x, y, width, height,
+                           clr.r, clr.g, clr.b, clr.a
+                         ])
+      update_texture if @update
+    end
+
+    # Draw an outline of a triangle.
+    # @param [Numeric] x1
+    # @param [Numeric] y1
+    # @param [Numeric] x2
+    # @param [Numeric] y2
+    # @param [Numeric] x3
+    # @param [Numeric] y3
+    # @param [Numeric] stroke_width The thickness of the rectangle in pixels
+    # @param [Color] color (or +colour+) The line colour
+    def draw_triangle(x1:, y1:, x2:, y2:, x3:, y3:, stroke_width: 1, color: nil, colour: nil)
+      draw_polyline closed: true,
+                    coordinates: [x1, y1, x2, y2, x3, y3],
+                    color: color, colour: colour, stroke_width: stroke_width
+    end
+
+    # Draw an outline of a quad.
+    # @param [Numeric] x1
+    # @param [Numeric] y1
+    # @param [Numeric] x2
+    # @param [Numeric] y2
+    # @param [Numeric] x3
+    # @param [Numeric] y3
+    # @param [Numeric] x4
+    # @param [Numeric] y4
+    # @param [Numeric] stroke_width The thickness of the rectangle in pixels
+    # @param [Color] color (or +colour+) The line colour
+    def draw_quad(x1:, y1:, x2:, y2:, x3:, y3:, x4:, y4:, stroke_width: 1, color: nil, colour: nil)
+      draw_polyline closed: true,
+                    coordinates: [x1, y1, x2, y2, x3, y3, x4, y4],
+                    color: color, colour: colour, stroke_width: stroke_width
+    end
+
+    # Draw an outline of a rectangle
+    # @param [Numeric] x
+    # @param [Numeric] y
+    # @param [Numeric] width
+    # @param [Numeric] height
+    # @param [Numeric] stroke_width The thickness of the rectangle in pixels
+    # @param [Color] color (or +colour+) The line colour
+    def draw_rectangle(x:, y:, width:, height:, stroke_width: 1, color: nil, colour: nil)
+      clr = color || colour
+      clr = Color.new(clr) unless clr.is_a? Color
+      ext_draw_rectangle([
+                           x, y, width, height, stroke_width,
+                           clr.r, clr.g, clr.b, clr.a
+                         ])
+      update_texture if @update
+    end
+
+    # Draw a straight line between two points
+    # @param [Numeric] x1
+    # @param [Numeric] y1
+    # @param [Numeric] x2
+    # @param [Numeric] y2
+    # @param [Numeric] stroke_width The line's thickness in pixels; defaults to 1.
+    # @param [Color] color (or +colour+) The line colour
+    def draw_line(x1:, y1:, x2:, y2:, stroke_width: 1, color: nil, colour: nil)
+      clr = color || colour
+      clr = Color.new(clr) unless clr.is_a? Color
+      ext_draw_line([
+                      x1, y1, x2, y2, stroke_width,
+                      clr.r, clr.g, clr.b, clr.a
+                    ])
+      update_texture if @update
+    end
+
+    # Draw a poly-line between N points.
+    # @param [Array] coordinates An array of numbers x1, y1, x2, y2 ... with at least three coordinates (6 values)
+    # @param [Numeric] stroke_width The line's thickness in pixels; defaults to 1.
+    # @param [Color] color (or +colour+) The line colour
+    # @param [Boolean] closed Use +true+ to draw this as a closed shape
+    def draw_polyline(coordinates:, stroke_width: 1, color: nil, colour: nil, closed: false)
+      return if coordinates.nil? || coordinates.count < 6
+
+      clr = color || colour
+      clr = Color.new(clr) unless clr.is_a? Color
+      config = [stroke_width, clr.r, clr.g, clr.b, clr.a]
+      if closed
+        ext_draw_polygon(config, coordinates)
+      else
+        ext_draw_polyline(config, coordinates)
+      end
+      update_texture if @update
+    end
+
+    # Fill a polygon made up of N points.
+    # @note Currently only supports convex polygons or simple polygons with one concave corner.
+    # @note Supports per-vertex coloring, but the triangulation may change and affect the coloring.
+    # @param [Array] coordinates An array of numbers x1, y1, x2, y2 ... with at least three coordinates (6 values)
+    # @param [Color, Color::Set] color (or +colour+) Set one or per-vertex colour; at least one colour must be specified.
+    def fill_polygon(coordinates:, color: nil, colour: nil)
+      return if coordinates.nil? || coordinates.count < 6 || (color.nil? && colour.nil?)
+
+      colors = colors_to_a(color || colour)
+      ext_fill_polygon(coordinates, colors)
+      update_texture if @update
+    end
+
+    # Draw the pixmap at the specified location and size
+    #
+    # @note This API will evolve to be able to draw a portion of the pixmap; coming soon.
+    # @param [Pixmap] pixmap
+    # @param [Numeric] x
+    # @param [Numeric] y
+    # @param [Numeric] width Optional, specify to scale the size
+    # @param [Numeric] height  Optional, specify to scale the size
+    # @param [Hash] crop Optional, specify a hash with `x:, y:, width:, height:` to crop from within the pixmap to draw.
+    def draw_pixmap(pixmap, x:, y:, width: nil, height: nil, crop: nil)
+      src_rect = crop ? [crop[:x], crop[:y], crop[:width], crop[:height]] : nil
+      ext_draw_pixmap pixmap, src_rect, x, y, width, height
+    end
+
+    def update
+      update_texture
+    end
+
+    private
+
+    # Converts +color_or_set+ as a sequence of colour components; e.g. +[ r1, g1, b1, a1, ...]+
+    # @param [Color, Color::Set] color_or_set
+    # @return an array of r, g, b, a values
+    def colors_to_a(color_or_set)
+      if color_or_set.is_a? Color::Set
+        color_a = []
+        color_or_set.each do |clr|
+          color_a << clr.r << clr.g << clr.b << clr.a
+        end
+        return color_a
+      end
+
+      color_or_set = Color.new(color_or_set) unless color_or_set.is_a? Color
+      color_or_set.to_a
+    end
+
+    def update_texture
+      @texture.delete
+      @texture = Texture.new(@ext_pixel_data, @width, @height)
+    end
+
+    def render(x: @x, y: @y, width: @width, height: @height, color: @color, rotate: @rotate)
+      vertices = Vertices.new(x, y, width, height, rotate)
+
+      @texture.draw(
+        vertices.coordinates, vertices.texture_coordinates, color
+      )
+    end
+  end
+end

data/lib/ruby2d/circle.rb

@@ -1,22 +1,38 @@
+# frozen_string_literal: true
+
 # Ruby2D::Circle
 
 module Ruby2D
+  #
+  # Create a circle using +Circle.new+
+  #
   class Circle
     include Renderable
 
     attr_accessor :x, :y, :radius, :sectors
 
-    def initialize(opts = {})
-      @x = opts[:x] || 25
-      @y = opts[:y] || 25
-      @z = opts[:z] || 0
-      @radius = opts[:radius] || 50
-      @sectors = opts[:sectors] || 30
-      self.color = opts[:color] || 'white'
-      self.color.opacity = opts[:opacity] if opts[:opacity]
+    # Create a circle
+    #
+    # @param [Numeric] x
+    # @param [Numeric] y
+    # @param [Numeric] z
+    # @param [Numeric] radius
+    # @param [Numeric] sectors Smoothness of the circle is better when more +sectors+ are used.
+    # @param [String | Color] color Or +colour+
+    # @param [Float] opacity
+    def initialize(x: 25, y: 25, z: 0, radius: 50, sectors: 30,
+                   color: nil, colour: nil, opacity: nil)
+      @x = x
+      @y = y
+      @z = z
+      @radius = radius
+      @sectors = sectors
+      self.color = color || colour || 'white'
+      self.color.opacity = opacity unless opacity.nil?
       add
     end
 
+    # Check if the circle contains the point at +(x, y)+
     def contains?(x, y)
       Math.sqrt((x - @x)**2 + (y - @y)**2) <= @radius
     end
@@ -25,19 +41,18 @@ module Ruby2D
       Window.render_ready_check
 
       ext_draw([
-        opts[:x], opts[:y], opts[:radius], opts[:sectors],
-        opts[:color][0], opts[:color][1], opts[:color][2], opts[:color][3]
-      ])
+                 opts[:x], opts[:y], opts[:radius], opts[:sectors],
+                 opts[:color][0], opts[:color][1], opts[:color][2], opts[:color][3]
+               ])
     end
 
     private
 
     def render
       self.class.ext_draw([
-        @x, @y, @radius, @sectors,
-        @color.r, @color.g, @color.b, @color.a
-      ])
+                            @x, @y, @radius, @sectors,
+                            @color.r, @color.g, @color.b, @color.a
+                          ])
     end
-
   end
 end

data/lib/ruby2d/cli/build.rb

@@ -14,7 +14,6 @@ require 'ruby2d/cli/platform'
   'color',
   'window',
   'dsl',
-  'entity',
   'quad',
   'line',
   'circle',
@@ -22,11 +21,14 @@ require 'ruby2d/cli/platform'
   'square',
   'triangle',
   'pixel',
+  'pixmap',
+  'pixmap_atlas',
   'image',
   'sprite',
   'tileset',
   'font',
   'text',
+  'canvas',
   'sound',
   'music',
   'texture',
@@ -161,7 +163,7 @@ def compile_native
 
     ld_flags = ''
     ['mruby', 'SDL2', 'SDL2_image', 'SDL2_mixer', 'SDL2_ttf',
-     'jpeg', 'png16', 'tiff', 'webp',
+     'jpeg', 'jxl', 'avif', 'png', 'tiff', 'webp',
      'mpg123', 'ogg', 'FLAC', 'vorbis', 'vorbisfile', 'modplug',
      'freetype', 'harfbuzz', 'graphite2'].each do |name|
       add_ld_flags(ld_flags, name, :archive, ld_dir)
@@ -188,7 +190,7 @@ def compile_native
     ld_flags = '-static -Wl,--start-group '
     ['mruby',
      'SDL2',
-     'SDL2_image', 'jpeg', 'png16', 'tiff', 'webp', 'jbig', 'deflate', 'lzma', 'zstd', 'Lerc',
+     'SDL2_image', 'jpeg', 'png', 'tiff', 'webp', 'jxl', 'hwy', 'jbig', 'deflate', 'lzma', 'zstd', 'Lerc',
      'SDL2_mixer', 'mpg123', 'FLAC', 'vorbis', 'vorbisfile', 'ogg', 'modplug', 'opus', 'opusfile', 'sndfile',
      'SDL2_ttf', 'freetype', 'harfbuzz', 'graphite2', 'bz2', 'brotlicommon', 'brotlidec',
      'glew32', 'stdc++', 'z', 'ssp'

data/lib/ruby2d/cli/enable_console.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 # Enable the interactive console
 
 require 'io/wait'
 
-$ruby2d_console_mode = true
+ENV['RUBY2D_ENABLE_CONSOLE'] = 'true'