processing 0.5.31 → 0.5.32

data/lib/processing/image.rb

@@ -10,6 +10,7 @@ module Processing
     # @private
     def initialize(image)
       @image = image
+      @pixels, @error = nil, false
     end
 
     # Gets width of image.
@@ -17,7 +18,7 @@ module Processing
     # @return [Numeric] width of image
     #
     def width()
-      @image.width
+      @image&.width || (@error ? -1 : 0)
     end
 
     # Gets height of image.
@@ -25,7 +26,7 @@ module Processing
     # @return [Numeric] height of image
     #
     def height()
-      @image.height
+      @image&.height || (@error ? -1 : 0)
     end
 
     alias w width
@@ -36,7 +37,7 @@ module Processing
     # @return [Array<Numeric>] [width, height]
     #
     def size()
-      @image.size
+      [width, height]
     end
 
     # Sets the color of the pixel.
@@ -48,21 +49,43 @@ module Processing
     # @return [nil] nil
     #
     def set(x, y, c)
-      @image.bitmap[x, y] = self.class.fromColor__ c
+      getInternal__.bitmap[x, y] = self.class.fromColor__ c
       nil
     end
 
-
     # Returns the color of the pixel.
     #
     # @return [Integer] color value (0xAARRGGBB)
     #
     def get(x, y)
-      @image.bitmap[x, y]
+      getInternal__.bitmap[x, y]
         .map {|n| (n * 255).to_i.clamp 0, 255}
         .then {|r, g, b, a| self.class.toColor__ r, g, b, a}
     end
 
+    # Loads all pixels to the 'pixels' array.
+    #
+    # @return [nil] nil
+    #
+    def loadPixels()
+      @pixels = getInternal__.pixels
+    end
+
+    # Update the image pixels with the 'pixels' array.
+    #
+    # @return [nil] nil
+    #
+    def updatePixels()
+      return unless @pixels
+      getInternal__.pixels = @pixels
+      @pixels = nil
+    end
+
+    # An array of all pixels.
+    # Call loadPixels() before accessing the array.
+    #
+    attr_reader :pixels
+
     # Applies an image filter.
     #
     # overload filter(shader)
@@ -86,7 +109,7 @@ module Processing
     #
     def resize(width, height)
       @image = Rays::Image.new(width, height).paint do |painter|
-        painter.image @image, 0, 0, width, height
+        painter.image getInternal__, 0, 0, width, height
       end
       nil
     end
@@ -132,7 +155,7 @@ module Processing
     #
     def blend(img = nil, sx, sy, sw, sh, dx, dy, dw, dh, mode)
       img ||= self
-      @image.paint do |painter|
+      getInternal__.paint do |painter|
         img.drawImage__ painter, sx, sy, sw, sh, dx, dy, dw, dh, blend_mode: mode
       end
       nil
@@ -145,13 +168,18 @@ module Processing
     # @return [nil] nil
     #
     def save(filename)
-      @image.save filename
+      getInternal__.save filename
       nil
     end
 
     # @private
     def getInternal__()
-      @image
+      @image or raise 'Invalid image object'
+    end
+
+    # @private
+    def setInternal__(image, error = false)
+      @image, @error = image, error
     end
 
     # @private

data/lib/processing/shape.rb

@@ -7,10 +7,11 @@ module Processing
 
     # @private
     def initialize(polygon = nil, children = nil, context: nil)
-      @polygon, @children = polygon, children
-      @context            = context || Context.context__
-      @visible, @matrix   = true, nil
-      @mode = @points = @closed = nil
+      @polygon, @children      = polygon, children
+      @context                 = context || Context.context__
+      @visible, @fill, @matrix = true, nil, nil
+      @type = @points = @curvePoints = @colors = @texcoords = @close = nil
+      @contours = @contourPoints = @contourColors = @contourTexCoords = nil
     end
 
     # Gets width of shape.
@@ -53,22 +54,105 @@ module Processing
       nil
     end
 
-    def beginShape(mode = nil)
-      @mode     = mode
-      @points ||= []
-      @polygon  = nil# clear cache
+    def beginShape(type = nil)
+      raise "beginShape() cannot be called twice" if drawingShape__
+      @type        = type
+      @points    ||= []
+      @curvePoints = []
+      @colors    ||= []
+      @texcoords ||= []
+      @close       = nil
+      @contours  ||= []
+      clearCache__
       nil
     end
 
     def endShape(close = nil)
-      raise "endShape() must be called after beginShape()" unless @points
-      @closed = close == GraphicsContext::CLOSE
+      raise "endShape() must be called after beginShape()" unless drawingShape__
+      @close = close == GraphicsContext::CLOSE || @contours.size > 0
+      if @close && @curvePoints.size >= 8
+        x, y = @curvePoints[0, 2]
+        2.times {curveVertex x, y}
+      end
+      @curvePoints = nil
+      nil
+    end
+
+    def beginContour()
+      raise "beginContour() must be called after beginShape()" unless drawingShape__
+      @contourPoints, @contourColors, @contourTexCoords = [], [], []
+      nil
+    end
+
+    def endContour()
+      raise "endContour() must be called after beginContour()" unless drawingContour__
+      @contours << Rays::Polyline.new(
+        *@contourPoints, colors: @contourColors, texcoords: @contourTexCoords,
+        loop: true, hole: true)
+      @contoursPoints = @contoursColors = @contoursTexCoords = nil
+      nil
+    end
+
+    def vertex(x, y, u = nil, v = nil)
+      raise "vertex() must be called after beginShape()" unless drawingShape__
+      raise "Either 'u' or 'v' is missing" if (u == nil) != (v == nil)
+      u   ||= x
+      v   ||= y
+      color = @fill || @context.getFill__
+      if drawingContour__
+        @contourPoints    << x << y
+        @contourColors    << color
+        @contourTexCoords << u << v
+      else
+        @points    << x << y
+        @colors    << color
+        @texcoords << u << v
+      end
+    end
+
+    def curveVertex(x, y)
+      raise "curveVertex() must be called after beginShape()" unless drawingShape__
+      @curvePoints << x << y
+      if @curvePoints.size >= 8
+        Rays::Polygon.curve(*@curvePoints[-8, 8])
+          .first.to_a.tap {|a| a.shift if @curvePoints.size > 8}
+          .each {|p| vertex p.x, p.y}
+      end
       nil
     end
 
-    def vertex(x, y)
-      raise "vertex() must be called after beginShape()" unless @points
-      @points << x << y
+    def bezierVertex(x2, y2, x3, y3, x4, y4)
+      raise "bezierVertex() must be called after beginShape()" unless drawingShape__
+      x1, y1 = @points[-2, 2]
+      raise "vertex() is required before calling bezierVertex()" unless x1 && y1
+      Rays::Polygon.bezier(x1, y1, x2, y2, x3, y3, x4, y4)
+        .first.to_a.tap {|a| a.shift}
+        .each {|p| vertex p.x, p.y}
+      nil
+    end
+
+    def quadraticVertex(cx, cy, x3, y3)
+      x1, y1 = @points[-2, 2]
+      raise "vertex() is required before calling quadraticVertex()" unless x1 && y1
+      bezierVertex(
+        x1 + (cx - x1) * 2.0 / 3.0, y1 + (cy - y1) * 2.0 / 3.0,
+        x3 + (cx - x3) * 2.0 / 3.0, y3 + (cy - y3) * 2.0 / 3.0,
+        x3,                         y3)
+      nil
+    end
+
+    # @private
+    def drawingShape__()
+      @curvePoints
+    end
+
+    # @private
+    def drawingContour__()
+      @contourPoints
+    end
+
+    def fill(*args)
+      @fill = @context.toRaysColor__(*args)
     end
 
     def setVertex(index, point)
@@ -88,6 +172,23 @@ module Processing
       @points.size / 2
     end
 
+    def setFill(*args)
+      color = @context.toRaysColor__(*args)
+      count = getVertexCount
+      if count > 0
+        if @colors
+          @colors.fill color
+        else
+          @colors = [color] * count
+        end
+        clearCache__
+      elsif @polygon
+        @polygon = @polygon.transform do |polylines|
+          polylines.map {|pl| pl.with colors: pl.points.map {color}}
+        end
+      end
+    end
+
     def addChild(child)
       return unless @children
       @children.push child
@@ -125,6 +226,11 @@ module Processing
     def rotateY = nil
     def rotateZ = nil
 
+    # @private
+    def clearCache__()
+      @polygon = nil# clear cache
+    end
+
     # @private
     def matrix__()
       @matrix ||= Rays::Matrix.new
@@ -133,8 +239,10 @@ module Processing
     # @private
     def getInternal__()
       unless @polygon
-        return nil unless @points && @closed != nil
-        @polygon = self.class.createPolygon__ @mode, @points, @closed
+        return nil unless @points && @close != nil
+        @polygon = self.class.createPolygon__(
+          @type, @points, @close, @colors, @texcoords)
+        @polygon += @contours if @polygon
       end
       @polygon
     end
@@ -162,18 +270,21 @@ module Processing
     end
 
     # @private
-    def self.createPolygon__(mode, points, close = false)
-      g = GraphicsContext
-      case mode
-      when g::POINTS         then Rays::Polygon.points(        *points)
-      when g::LINES          then Rays::Polygon.lines(         *points)
-      when g::TRIANGLES      then Rays::Polygon.triangles(     *points)
-      when g::TRIANGLE_FAN   then Rays::Polygon.triangle_fan(  *points)
-      when g::TRIANGLE_STRIP then Rays::Polygon.triangle_strip(*points)
-      when g::QUADS          then Rays::Polygon.quads(         *points)
-      when g::QUAD_STRIP     then Rays::Polygon.quad_strip(    *points)
-      when g::TESS, nil      then Rays::Polygon.new(*points, loop: close)
-      else raise ArgumentError, "invalid polygon mode '#{mode}'"
+    def self.createPolygon__(
+      type, points, close = false, colors = nil, texcoords = nil)
+
+      kwargs = {colors: colors, texcoords: texcoords}
+      g, p   = GraphicsContext, Rays::Polygon
+      case type
+      when g::POINTS         then p.points(        *points)
+      when g::LINES          then p.lines(         *points)
+      when g::TRIANGLES      then p.triangles(     *points, **kwargs)
+      when g::TRIANGLE_FAN   then p.triangle_fan(  *points, **kwargs)
+      when g::TRIANGLE_STRIP then p.triangle_strip(*points, **kwargs)
+      when g::QUADS          then p.quads(         *points, **kwargs)
+      when g::QUAD_STRIP     then p.quad_strip(    *points, **kwargs)
+      when g::TESS, nil      then p.new(           *points, **kwargs, loop: close)
+      else raise ArgumentError, "invalid polygon type '#{type}'"
       end
     end
 

data/processing.gemspec

@@ -26,9 +26,9 @@ Gem::Specification.new do |s|
   s.required_ruby_version = '>= 3.0.0'
 
   s.add_runtime_dependency 'xot',       '~> 0.1.41'
-  s.add_runtime_dependency 'rucy',      '~> 0.1.42'
-  s.add_runtime_dependency 'rays',      '~> 0.1.47'
-  s.add_runtime_dependency 'reflexion', '~> 0.1.55'
+  s.add_runtime_dependency 'rucy',      '~> 0.1.43'
+  s.add_runtime_dependency 'rays',      '~> 0.1.48'
+  s.add_runtime_dependency 'reflexion', '~> 0.1.56'
 
   s.files            = `git ls-files`.split $/
   s.test_files       = s.files.grep %r{^(test|spec|features)/}

data/test/helper.rb

@@ -59,7 +59,6 @@ def get_pixels(image)
     .map {image.instance_variable_get _1}
     .compact
     .first
-    .bitmap
     .pixels
 end
 
@@ -107,14 +106,14 @@ end
 
 def assert_p5_draw(
   *sources, default_header: DEFAULT_DRAW_HEADER,
-  width: 1000, height: 1000, threshold: 0.99, label: test_label)
+  width: 1000, height: 1000, threshold: 0.99, label: test_label, **kwargs)
 
   return unless test_with_p5?
 
   source = [default_header, *sources].compact.join("\n")
   path   = draw_output_path "#{label}_expected", source
 
-  pd     = draw_p5rb width, height, source, path, headless: true
+  pd     = draw_p5rb width, height, source, path, **kwargs
   actual = test_draw source, width: width, height: height, pixelDensity: pd
   actual.save path.sub('_expected', '_actual')
 

data/test/p5.rb

@@ -13,7 +13,7 @@ def browser(width, height, headless: true)
   hash[key] ||= Ferrum::Browser.new headless: headless, window_size: [width, height]
 end
 
-def get_p5rb_html(width, height, draw_src)
+def get_p5rb_html(width, height, draw_src, webgl: false)
   <<~END
     <html>
       <head>
@@ -34,9 +34,10 @@ def get_p5rb_html(width, height, draw_src)
         </script>
         <script type="text/ruby">
           def setup()
-            createCanvas #{width}, #{height}
+            createCanvas #{width}, #{height}#{webgl ? ', WEBGL' : ''}
           end
           def draw()
+            #{webgl ? 'translate -width / 2, -height / 2' : ''}
             #{draw_src}
             JS.global.completed
           end
@@ -62,11 +63,11 @@ def sleep_until (try: 3, timeout: 10, &block)
   end
 end
 
-def draw_p5rb(width, height, draw_src, path, headless: true)
+def draw_p5rb(width, height, draw_src, path, headless: true, webgl: false)
   b = browser width, height, headless: headless
   unless File.exist? path
     b.reset
-    b.main_frame.content = get_p5rb_html width, height, draw_src
+    b.main_frame.content = get_p5rb_html width, height, draw_src, webgl: webgl
     sleep_until do
       b.evaluate 'document.querySelector("#completed") != null'
     end

data/test/test_font.rb

@@ -5,12 +5,43 @@ class TestFont < Test::Unit::TestCase
 
   P = Processing
 
-  def font()
-    P::Font.new Rays::Font.new(nil, 10)
+  def font(*args)
+    P::Font.new(Rays::Font.new *args).tap {|font|
+      def font.intern()
+        getInternal__
+      end
+    }
+  end
+
+  def test_initialize()
+    assert_not_nil        font(nil)    .intern.name
+    assert_equal 'Arial', font('Arial').intern.name
+
+    assert_equal 12, font         .intern.size
+    assert_equal 10, font(nil, 10).intern.size
+  end
+
+  def test_size()
+    f  = font nil, 10
+    id = f.intern.object_id
+
+    assert_equal 10, f.intern.size
+
+    f.setSize__ 11
+    assert_equal 11, f.intern.size
+    assert_not_equal id, f.intern.object_id
+
+    f.setSize__ 10
+    assert_equal 10, f.intern.size
+    assert_equal id, f.intern.object_id
   end
 
   def test_inspect()
     assert_match %r|#<Processing::Font: name:'[\w\s]+' size:[\d\.]+>|, font.inspect
   end
 
+  def test_list()
+    assert_not P::Font.list.empty?
+  end
+
 end# TestFont

data/test/test_graphics_context.rb

@@ -76,6 +76,67 @@ class TestGraphicsContext < Test::Unit::TestCase
     END
   end
 
+  def test_textFont()
+    graphics do |g|
+      arial10     = g.createFont 'Arial',     10
+      helvetica11 = g.createFont 'Helvetica', 11
+
+      font        = -> {g.instance_variable_get(:@textFont__).getInternal__}
+      painterFont = -> {g.instance_variable_get(:@painter__).font}
+
+      assert_not_nil            font[]       .name
+      assert_not_equal 'Arial', font[]       .name
+      assert_equal     12,      font[]       .size
+      assert_equal     12,      painterFont[].size
+
+      g.textFont arial10
+      assert_equal 'Arial', font[]       .name
+      assert_equal 10,      font[]       .size
+      assert_equal 10,      painterFont[].size
+
+      g.push do
+        g.textFont helvetica11
+        assert_equal 'Helvetica', font[]       .name
+        assert_equal 11,          font[]       .size
+        assert_equal 11,          painterFont[].size
+      end
+
+      assert_equal 'Arial', font[]       .name
+      assert_equal 10,      font[]       .size
+      assert_equal 10,      painterFont[].size
+
+      g.push do
+        g.textFont arial10, 13
+        assert_equal 'Arial', font[]       .name
+        assert_equal 13,      font[]       .size
+        assert_equal 13,      painterFont[].size
+      end
+
+      assert_equal 'Arial', font[]       .name
+      assert_equal 10,      font[]       .size
+      assert_equal 10,      painterFont[].size
+    end
+  end
+
+  def test_textSize()
+    graphics do |g|
+      font        = -> {g.instance_variable_get(:@textFont__).getInternal__}
+      painterFont = -> {g.instance_variable_get(:@painter__).font}
+
+      assert_equal 12, font[]       .size
+      assert_equal 12, painterFont[].size
+
+      g.push do
+        g.textSize 10
+        assert_equal 10, font[]       .size
+        assert_equal 10, painterFont[].size
+      end
+
+      assert_equal 12, font[]       .size
+      assert_equal 12, painterFont[].size
+    end
+  end
+
   def test_clear()
     colors = -> g {get_pixels(g).uniq}
 
@@ -468,6 +529,155 @@ class TestGraphicsContext < Test::Unit::TestCase
     assert_p5_fill_stroke src, 'endShape CLOSE'
   end
 
+  def test_beginShape_with_fill()
+    assert_equal_draw <<~HEADER, <<~EXPECTED, <<~ACTUAL
+      noStroke
+    HEADER
+      fill 0, 255, 0
+      rect 100, 100, 500, 400
+    EXPECTED
+      beginShape
+      fill 0, 255, 0
+      vertex 100, 100
+      vertex 600, 100
+      vertex 600, 500
+      vertex 100, 500
+      endShape
+    ACTUAL
+  end
+
+  def test_curveVertex()
+    src = <<~END
+      beginShape
+      curveVertex 100, 100
+      curveVertex 800, 100
+      curveVertex 800, 800
+      curveVertex 100, 800
+    END
+    assert_p5_fill        src, 'endShape'
+    assert_p5_stroke      src, 'endShape'
+    assert_p5_fill_stroke src, 'endShape'
+    assert_p5_fill        src, 'endShape CLOSE'
+    assert_p5_stroke      src, 'endShape CLOSE'
+    assert_p5_fill_stroke src, 'endShape CLOSE'
+
+    src = <<~END
+      beginShape
+      curveVertex 200, 200
+      curveVertex 200, 200
+      curveVertex 800, 200
+      curveVertex 800, 400
+      curveVertex 200, 400
+      curveVertex 200, 800
+      curveVertex 800, 800
+      curveVertex 800, 700
+      curveVertex 800, 700
+    END
+    assert_p5_fill        src, 'endShape',       threshold: THRESHOLD_TO_BE_FIXED
+    assert_p5_stroke      src, 'endShape'
+    assert_p5_fill_stroke src, 'endShape',       threshold: THRESHOLD_TO_BE_FIXED
+    assert_p5_fill        src, 'endShape CLOSE', threshold: THRESHOLD_TO_BE_FIXED
+    assert_p5_stroke      src, 'endShape CLOSE'
+    assert_p5_fill_stroke src, 'endShape CLOSE', threshold: THRESHOLD_TO_BE_FIXED
+  end
+
+  def test_bezierVertex()
+    src = <<~END
+      beginShape
+      vertex 100, 100
+      bezierVertex 900, 100, 900, 900, 200, 500
+    END
+    assert_p5_fill        src, 'endShape'
+    assert_p5_stroke      src, 'endShape'
+    assert_p5_fill_stroke src, 'endShape'
+    assert_p5_fill        src, 'endShape CLOSE'
+    assert_p5_stroke      src, 'endShape CLOSE'
+    assert_p5_fill_stroke src, 'endShape CLOSE'
+
+    src = <<~END
+      beginShape
+      vertex 100, 100
+      bezierVertex 900, 100, 900, 500, 300, 500
+      bezierVertex 100, 900, 900, 900, 900, 600
+    END
+    assert_p5_fill        src, 'endShape',       threshold: THRESHOLD_TO_BE_FIXED
+    assert_p5_stroke      src, 'endShape'
+    assert_p5_fill_stroke src, 'endShape',       threshold: THRESHOLD_TO_BE_FIXED
+    assert_p5_fill        src, 'endShape CLOSE', threshold: THRESHOLD_TO_BE_FIXED
+    assert_p5_stroke      src, 'endShape CLOSE'
+    assert_p5_fill_stroke src, 'endShape CLOSE', threshold: THRESHOLD_TO_BE_FIXED
+  end
+
+  def test_quadraticVertex()
+    src = <<~END
+      beginShape
+      vertex 100, 100
+      quadraticVertex 800, 500, 200, 800
+    END
+    assert_p5_fill        src, 'endShape'
+    assert_p5_stroke      src, 'endShape'
+    assert_p5_fill_stroke src, 'endShape'
+    assert_p5_fill        src, 'endShape CLOSE'
+    assert_p5_stroke      src, 'endShape CLOSE'
+    assert_p5_fill_stroke src, 'endShape CLOSE'
+
+    src = <<~END
+      beginShape
+      vertex 100, 100
+      quadraticVertex 800, 100, 500, 500
+      quadraticVertex 100, 800, 800, 800
+    END
+    assert_p5_fill        src, 'endShape',       threshold: THRESHOLD_TO_BE_FIXED
+    assert_p5_stroke      src, 'endShape'
+    assert_p5_fill_stroke src, 'endShape',       threshold: THRESHOLD_TO_BE_FIXED
+    assert_p5_fill        src, 'endShape CLOSE', threshold: THRESHOLD_TO_BE_FIXED
+    assert_p5_stroke      src, 'endShape CLOSE'
+    assert_p5_fill_stroke src, 'endShape CLOSE', threshold: THRESHOLD_TO_BE_FIXED
+  end
+
+  def test_contour()
+    src = <<~END
+      beginShape
+      vertex 100, 100
+      vertex 100, 900
+      vertex 900, 900
+      vertex 900, 100
+      beginContour
+      vertex 200, 200
+      vertex 800, 200
+      vertex 700, 700
+      vertex 200, 800
+      endContour
+    END
+    assert_p5_fill        src, 'endShape'
+    assert_p5_stroke      src, 'endShape'
+    assert_p5_fill_stroke src, 'endShape'
+    assert_p5_fill        src, 'endShape CLOSE'
+    assert_p5_stroke      src, 'endShape CLOSE'
+    assert_p5_fill_stroke src, 'endShape CLOSE'
+  end
+
+  def test_pixels()
+    g = graphics 2, 2
+
+    g.loadPixels
+    assert_equal [0] * 4, g.pixels
+    assert_equal [0] * 4, g.getInternal__.pixels
+
+    g.pixels.replace [0xffff0000, 0xff00ff00, 0xff0000ff, 0xff000000]
+    assert_equal [0xffff0000, 0xff00ff00, 0xff0000ff, 0xff000000], g.pixels
+    assert_equal [0] * 4,                                          g.getInternal__.pixels
+
+    g.updatePixels
+    assert_nil                                                     g.pixels
+    assert_equal [0xffff0000, 0xff00ff00, 0xff0000ff, 0xff000000], g.getInternal__.pixels
+    assert_nothing_raised {g.updatePixels}
+
+    g.loadPixels
+    g.pixels.replace [0xff000000]
+    assert_raise(ArgumentError) {g.updatePixels}
+  end
+
   def test_lerp()
     g = graphics
 
@@ -491,6 +701,16 @@ class TestGraphicsContext < Test::Unit::TestCase
     assert_equal c[ 70, 80, 90], g.lerpColor(c[10, 20, 30], c[50, 60, 70],  1.5)
   end
 
+  def test_createFont()
+    g = graphics
+
+    assert_not_nil        g.createFont(nil,     nil).getInternal__.name
+    assert_equal 'Arial', g.createFont('Arial', nil).getInternal__.name
+
+    assert_equal 12, g.createFont(nil, nil).getInternal__.size
+    assert_equal 10, g.createFont(nil, 10) .getInternal__.size
+  end
+
   def test_createShape_line()
     assert_equal_draw <<~EXPECTED, <<~ACTUAL
       line 100, 200, 800, 900