processing 0.5.32 → 0.5.33

data/test/test_graphics_context.rb

@@ -8,7 +8,7 @@ class TestGraphicsContext < Test::Unit::TestCase
 
   THRESHOLD_TO_BE_FIXED = 0.0
 
-  def test_color()
+  def test_rgb_color()
     g = graphics
 
     g.colorMode G::RGB, 255
@@ -23,6 +23,32 @@ class TestGraphicsContext < Test::Unit::TestCase
     assert_in_delta 0.2, g.green(c), 1 / 256.0
     assert_in_delta 0.3, g.blue(c),  1 / 256.0
     assert_in_delta 0.4, g.alpha(c), 1 / 256.0
+
+    g.colorMode G::RGB, 0.5
+    c = g.color 0.1, 0.2, 0.3, 0.4
+    assert_equal 0xcc336699, c
+    assert_in_delta 0.1, g.red(c),   1 / 256.0
+    assert_in_delta 0.2, g.green(c), 1 / 256.0
+    assert_in_delta 0.3, g.blue(c),  1 / 256.0
+    assert_in_delta 0.4, g.alpha(c), 1 / 256.0
+  end
+
+  def test_hsb_color()
+    g = graphics
+
+    g.colorMode G::HSB, 1.0
+    c = g.color 0.1, 0.2, 0.3, 0.4
+    assert_in_delta 0.1, g.hue(c),        1 / 256.0
+    assert_in_delta 0.2, g.saturation(c), 1 / 256.0
+    assert_in_delta 0.3, g.brightness(c), 1 / 256.0
+    assert_in_delta 0.4, g.alpha(c),      1 / 256.0
+
+    g.colorMode G::HSB, 0.5
+    c = g.color 0.1, 0.2, 0.3, 0.4
+    assert_in_delta 0.1, g.hue(c),        1 / 256.0
+    assert_in_delta 0.2, g.saturation(c), 1 / 256.0
+    assert_in_delta 0.3, g.brightness(c), 1 / 256.0
+    assert_in_delta 0.4, g.alpha(c),      1 / 256.0
   end
 
   def test_colorMode()
@@ -137,6 +163,24 @@ class TestGraphicsContext < Test::Unit::TestCase
     end
   end
 
+  def test_textLeading()
+    assert_p5_draw <<~END, threshold: 0.97
+      noStroke
+      textSize 200
+      push
+      text "X\nX", 100, 200
+      textLeading 300
+      text "X\nX", 250, 200
+      textLeading 400
+      text "X\nX", 400, 200
+      textLeading 100
+      text "X\nX", 550, 200
+      textLeading 0
+      text "X\nX", 700, 200
+      pop
+    END
+  end
+
   def test_clear()
     colors = -> g {get_pixels(g).uniq}
 
@@ -247,16 +291,42 @@ class TestGraphicsContext < Test::Unit::TestCase
 
   def test_curve()
     src = 'curve 100,100, 100,500, 500,500, 600,100'
-    assert_p5_fill        src, threshold: 0
-    assert_p5_stroke      src, threshold: 0
-    assert_p5_fill_stroke src, threshold: 0
+    assert_p5_fill        src, threshold: THRESHOLD_TO_BE_FIXED
+    assert_p5_stroke      src
+    assert_p5_fill_stroke src
   end
 
   def test_bezier()
-    src = 'curve 100,100, 100,500, 500,500, 600,100'
-    assert_p5_fill        src, threshold: 0
-    assert_p5_stroke      src, threshold: 0
-    assert_p5_fill_stroke src, threshold: 0
+    src = 'bezier 100,100, 100,500, 500,500, 600,100'
+    assert_p5_fill        src
+    assert_p5_stroke      src
+    assert_p5_fill_stroke src
+  end
+
+  def test_curveDetail()
+    opts = {
+      webgl: true,
+      # tests in headless mode will time out...
+      headless: false,
+      # Something is wrong with the behavior of `p5.js + WEBGL + curve()`
+      threshold: THRESHOLD_TO_BE_FIXED
+    }
+    [1, 2, 3, 5, 10, 100].each do |detail|
+      assert_p5_stroke <<~END, label: test_label(2, suffix: detail), **opts
+        curveDetail #{detail}
+        curve 100,100, 100,500, 500,500, 600,100
+       END
+    end
+  end
+
+  def test_bezierDetail()
+    opts = {webgl: true, headless: false} # tests in headless mode will time out...
+    [1, 2, 3, 5, 10, 100].each do |detail|
+      assert_p5_stroke <<~END, label: test_label(2, suffix: detail), **opts
+        bezierDetail #{detail}
+        bezier 100,100, 100,500, 500,500, 600,100
+      END
+    end
   end
 
   def test_shape_with_shapeMode_corner()
@@ -678,6 +748,181 @@ class TestGraphicsContext < Test::Unit::TestCase
     assert_raise(ArgumentError) {g.updatePixels}
   end
 
+  def test_pixels_and_modified_flags()
+    drawRect     = -> g, x, *rgb do
+      g.beginDraw do
+        g.fill(*rgb)
+        g.rect x, 0, 2, 2
+      end
+    end
+    updatePixels = -> g, i, *rgb do
+      g.loadPixels
+      g.pixels[i] = g.color(*rgb)
+      g.updatePixels
+    end
+    getPixels    = -> g do
+      g.getInternal__.pixels
+        .select.with_index {|_, i| i.even?}
+        .map {|n| n.to_s 16}
+    end
+
+    g = graphics 6, 1
+    drawRect    .call g, 0, 255,0,0
+    assert_equal %w[ffff0000 0        0],        getPixels.call(g)
+
+    g = graphics 6, 1
+    drawRect    .call g, 0, 255,0,0
+    updatePixels.call g, 2, 0,255,0
+    assert_equal %w[ffff0000 ff00ff00 0],        getPixels.call(g)
+
+    g = graphics 6, 1
+    drawRect    .call g, 0, 255,0,0
+    updatePixels.call g, 2, 0,255,0
+    drawRect    .call g, 4, 0,0,255
+    assert_equal %w[ffff0000 ff00ff00 ff0000ff], getPixels.call(g)
+  end
+
+  def test_rotateX()
+    assert_p5_draw <<~END, webgl: true, headless: false
+      noStroke
+      translate 100, 100
+      rotateX PI * 0.1
+      rect 0, 0, 500, 500
+    END
+  end
+
+  def test_rotateY()
+    assert_p5_draw <<~END, webgl: true, headless: false
+      noStroke
+      translate 100, 100
+      rotateY PI * 0.1
+      rect 0, 0, 500, 500
+    END
+  end
+
+  def test_rotateZ()
+    assert_p5_draw <<~END, webgl: true, headless: false
+      noStroke
+      translate 100, 100
+      rotateZ PI * 0.1
+      rect 0, 0, 500, 500
+    END
+  end
+
+  def test_shearX()
+    assert_p5_draw <<~END
+      translate 100, 100
+      shearX PI * 0.2
+      rect 0, 0, 500, 500
+    END
+  end
+
+  def test_shearY()
+    assert_p5_draw <<~END
+      translate 100, 100
+      shearY PI * 0.2
+      rect 0, 0, 500, 500
+    END
+  end
+
+  def test_applyMatrix()
+    g = graphics
+
+    painterMatrix = -> {g.instance_variable_get(:@painter__).matrix.to_a}
+
+    g.beginDraw do
+      g.resetMatrix
+      g.applyMatrix  1,2,     3,4,              5,6
+      assert_equal  [1,2,0,0, 3,4,0,0, 0,0,1,0, 5,6,0,1], painterMatrix.call
+
+      g.resetMatrix
+      g.applyMatrix [1,2,     3,4,              5,6]
+      assert_equal  [1,2,0,0, 3,4,0,0, 0,0,1,0, 5,6,0,1], painterMatrix.call
+
+      g.resetMatrix
+      g.applyMatrix  1,2,3,4, 5,6,7,8, 9,10,11,12, 13,14,15,16
+      assert_equal  [1,2,3,4, 5,6,7,8, 9,10,11,12, 13,14,15,16], painterMatrix.call
+
+      g.resetMatrix
+      g.applyMatrix [1,2,3,4, 5,6,7,8, 9,10,11,12, 13,14,15,16]
+      assert_equal  [1,2,3,4, 5,6,7,8, 9,10,11,12, 13,14,15,16], painterMatrix.call
+
+      ((0..17).to_a - [6, 16]).each do |n|
+        assert_raise(ArgumentError) {g.applyMatrix   [0] * n}
+        assert_raise(ArgumentError) {g.applyMatrix(*([0] * n))}
+      end
+    end
+  end
+
+  def test_applyMatrix_translate()
+    assert_p5_draw <<~END
+      applyMatrix  1, 0, 0, 1, 100, 200
+      rect 100, 100, 500, 600
+    END
+    assert_p5_draw <<~END
+      applyMatrix [1, 0, 0, 1, 100, 200]
+      rect 100, 100, 500, 600
+    END
+    assert_p5_draw <<~END, webgl: true, headless: false
+      applyMatrix  1,0,0,0, 0,1,0,0, 0,0,1,0, 100,200,0,1
+      rect 100, 100, 500, 600
+    END
+    assert_p5_draw <<~END, webgl: true, headless: false
+      applyMatrix [1,0,0,0, 0,1,0,0, 0,0,1,0, 100,200,0,1]
+      rect 100, 100, 500, 600
+    END
+  end
+
+  def test_applyMatrix_scale()
+    assert_p5_draw <<~END
+      applyMatrix  2, 0, 0, 3, 0, 0
+      rect 100, 100, 200, 200
+    END
+    assert_p5_draw <<~END
+      applyMatrix [2, 0, 0, 3, 0, 0]
+      rect 100, 100, 200, 200
+    END
+    assert_p5_draw <<~END, webgl: true, headless: false, threshold: THRESHOLD_TO_BE_FIXED
+      applyMatrix  2,0,0,0, 0,3,0,0, 0,0,1,0, 0,0,0,1
+      rect 100, 100, 200, 200
+    END
+    assert_p5_draw <<~END, webgl: true, headless: false, threshold: THRESHOLD_TO_BE_FIXED
+      applyMatrix [2,0,0,0, 0,3,0,0, 0,0,1,0, 0,0,0,1]
+      rect 100, 100, 200, 200
+    END
+  end
+
+  def test_applyMatrix_rotate()
+    header = 's, c = Math.sin(Math::PI / 10), Math.cos(Math::PI / 10)'
+    assert_p5_draw header, <<~END
+      applyMatrix  c, s, -s, c, 0, 0
+      rect 100, 100, 500, 600
+    END
+    assert_p5_draw header, <<~END
+      applyMatrix [c, s, -s, c, 0, 0]
+      rect 100, 100, 500, 600
+    END
+    assert_p5_draw header, <<~END, webgl: true, headless: false
+      applyMatrix  c,s,0,0, -s,c,0,0, 0,0,1,0, 0,0,0,1
+      rect 100, 100, 500, 600
+    END
+    assert_p5_draw header, <<~END, webgl: true, headless: false
+      applyMatrix [c,s,0,0, -s,c,0,0, 0,0,1,0, 0,0,0,1]
+      rect 100, 100, 500, 600
+    END
+  end
+
+  def test_applyMatrix_multiple_times()
+    assert_p5_draw <<~END
+      applyMatrix 1, 0, 0, 1, 100, 200
+      s = Math.sin(Math::PI / 10)
+      c = Math.cos(Math::PI / 10)
+      applyMatrix c, s, -s, c, 0, 0
+      applyMatrix 2, 0, 0, 3, 0, 0
+      rect 100, 100, 100, 100
+    END
+  end
+
   def test_lerp()
     g = graphics
 
@@ -759,4 +1004,193 @@ class TestGraphicsContext < Test::Unit::TestCase
     ACTUAL
   end
 
+  def test_curvePoint()
+    assert_p5_draw <<~END
+      steps = 8
+      (0..steps).each do |i|
+        t = i.to_f / steps.to_f;
+        x = curvePoint(*[20,  20,  292, 292].map {|n| n * 3}, t)
+        y = curvePoint(*[104, 104, 96,  244].map {|n| n * 3}, t)
+        point x, y
+        x = curvePoint(*[20,  292, 292, 60] .map {|n| n * 3}, t)
+        y = curvePoint(*[104, 96,  244, 260].map {|n| n * 3}, t)
+        point x, y
+      end
+    END
+  end
+
+  def test_bezierPoint()
+    assert_p5_draw <<~END
+      steps = 10
+      (0..steps).each do |i|
+        t = i.to_f / steps.to_f
+        x = bezierPoint(*[85, 10, 90, 15].map {|n| n * 10}, t)
+        y = bezierPoint(*[20, 10, 90, 80].map {|n| n * 10}, t)
+        point x, y
+      end
+    END
+  end
+
+  def test_curveTangent()
+    assert_p5_draw <<~END
+      drawTangent = -> x, y, tx, ty do
+        tv = createVector tx, ty
+        tv.normalize
+        tv.rotate radians(-90)
+        point x, y
+        push
+        stroke 0, 0, 255
+        strokeWeight 20
+        line x, y, x + tv.x * 100, y + tv.y * 100
+        pop
+      end
+      steps = 8
+      (0..steps).each do |i|
+        t = i.to_f / steps.to_f;
+
+        xx = [20,  20,  292, 292].map {|n| n * 2}
+        yy = [104, 104, 96,  244].map {|n| n * 3}
+        x  = curvePoint(  *xx, t)
+        y  = curvePoint(  *yy, t)
+        tx = curveTangent(*xx, t)
+        ty = curveTangent(*yy, t)
+        drawTangent.call x, y, tx, ty
+
+        xx = [20,  292, 292, 60] .map {|n| n * 2}
+        yy = [104, 96,  244, 260].map {|n| n * 3}
+        x  = curvePoint(  *xx, t)
+        y  = curvePoint(  *yy, t)
+        tx = curveTangent(*xx, t)
+        ty = curveTangent(*yy, t)
+        drawTangent.call x, y, tx, ty
+      end
+    END
+  end
+
+  def test_bezierTangent()
+    assert_p5_draw <<~END
+      drawTangent = -> x, y, tx, ty do
+        tv = createVector tx, ty
+        tv.normalize
+        tv.rotate radians(-90)
+        point x, y
+        push
+        stroke 0, 0, 255
+        strokeWeight 20
+        line x, y, x + tv.x * 100, y + tv.y * 100
+        pop
+      end
+      steps = 10
+      (0..steps).each do |i|
+        t = i.to_f / steps.to_f
+
+        xx = *[85, 10, 90, 15].map {|n| n * 10}
+        yy = *[20, 10, 90, 80].map {|n| n * 10}
+        x  = bezierPoint(  *xx, t)
+        y  = bezierPoint(  *yy, t)
+        tx = bezierTangent(*xx, t)
+        ty = bezierTangent(*yy, t)
+        drawTangent.call x, y, tx, ty
+      end
+    END
+  end
+
+  def test_random()
+    g = graphics
+
+    assert_equal Float, g.random()        .class
+    assert_equal Float, g.random(1)       .class
+    assert_equal Float, g.random(1.0)     .class
+    assert_equal Float, g.random(1,   2)  .class
+    assert_equal Float, g.random(1.0, 2.0).class
+
+    assert_not_equal g.random(1.0), g.random(1.0)
+
+    assert_raise(ArgumentError) {g.random 0}
+    assert_raise(ArgumentError) {g.random 1, 1}
+
+    array = 10000.times.map {g.random 1, 2}
+    assert array.all? {|n| (1.0...2.0).include? n}
+    assert_in_delta 1.5, array.sum.to_f / array.size, 0.01
+  end
+
+  def test_random_choice()
+    g = graphics
+
+    assert_equal :a,  g.random([:a])
+    assert_equal :a,  g.random([:a, :a])
+    assert_equal nil, g.random([])
+    assert_equal nil, g.random([nil])
+
+    array = 10000.times.map {g.random([1, 2])}
+    assert array.all? {|n| (1..10).include? n}
+    assert_in_delta 1.5, array.sum.to_f / array.size, 0.02
+  end
+
+  def test_randomSeed()
+    g = graphics
+                    r0 = g.random 1
+    g.randomSeed 1; r1 = g.random 1
+    g.randomSeed 2; r2 = g.random 1
+
+    assert_equal 3, [r0, r1, r2].uniq.size
+
+    g.randomSeed 1
+    assert_equal r1, g.random(1)
+  end
+
+  def test_randomSeed_choice()
+    g = graphics
+                    r0 = g.random((0...10000).to_a)
+    g.randomSeed 1; r1 = g.random((0...10000).to_a)
+    g.randomSeed 2; r2 = g.random((0...10000).to_a)
+
+    assert_equal 3, [r0, r1, r2].uniq.size
+
+    g.randomSeed 1
+    assert_equal r1, g.random((0...10000).to_a)
+  end
+
+  def test_randomGaussian()
+    g = graphics
+
+    assert_equal Float, g.randomGaussian.class
+
+    array = 10000.times.map {g.randomGaussian}
+    assert array.select {|n| (0...3).include? n.abs}.size > 9800
+    assert_in_delta 0, array.sum.to_f / array.size, 0.05
+  end
+
+  def test_noise()
+    g = graphics
+    assert_equal     g.noise(0.1, 0.2, 0.3), g.noise(0.1, 0.2, 0.3)
+    assert_not_equal g.noise(0.1, 0.2, 0.3), g.noise(0.2, 0.2, 0.3)
+    assert_not_equal g.noise(0.1, 0.2, 0.3), g.noise(0.1, 0.3, 0.3)
+    assert_not_equal g.noise(0.1, 0.2, 0.3), g.noise(0.1, 0.2, 0.4)
+  end
+
+  def test_noiseSeed()
+    g = graphics
+                   n0 = g.noise 0.1, 0.2, 0.3
+    g.noiseSeed 1; n1 = g.noise 0.1, 0.2, 0.3
+    g.noiseSeed 2; n2 = g.noise 0.1, 0.2, 0.3
+
+    assert_equal 3, [n0, n1, n2].uniq.size
+
+    g.noiseSeed 1
+    assert_equal n1, g.noise(0.1, 0.2, 0.3)
+  end
+
+  def test_noiseDetail()
+    g = graphics
+                     n0 = g.noise 0.1, 0.2, 0.3
+    g.noiseDetail 1; n1 = g.noise 0.1, 0.2, 0.3
+    g.noiseDetail 2; n2 = g.noise 0.1, 0.2, 0.3
+    g.noiseDetail 3; n3 = g.noise 0.1, 0.2, 0.3
+    g.noiseDetail 4; n4 = g.noise 0.1, 0.2, 0.3
+
+    assert_equal 4,  [n1, n2, n3, n4].uniq.size
+    assert_equal n4, n0
+  end
+
 end# TestGraphicsContext

data/test/test_utility.rb

@@ -7,25 +7,6 @@ class TestUtility < Test::Unit::TestCase
 
   include P::GraphicsContext
 
-  def test_random()
-    assert_equal Float,  random(1).class
-    assert_equal Float,  random(1.0).class
-    assert_equal Symbol, random((:a..:z).to_a).class
-
-    assert_not_equal random, random
-
-    10000.times do
-      n = random
-      assert 0 <= n && n < 1
-
-      n = random 1
-      assert 0 <= n && n < 1
-
-      n = random 1, 2
-      assert 1.0 <= n && n < 2.0
-    end
-  end
-
   def test_createVector()
     assert_equal P::Vector, createVector(1, 2).class
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: processing
 version: !ruby/object:Gem::Version
-  version: 0.5.32
+  version: 0.5.33
 platform: ruby
 authors:
 - xordog
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-01-07 00:00:00.000000000 Z
+date: 2024-02-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: xot
@@ -16,56 +16,56 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.41
+        version: 0.1.42
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.41
+        version: 0.1.42
 - !ruby/object:Gem::Dependency
   name: rucy
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.43
+        version: 0.1.44
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.43
+        version: 0.1.44
 - !ruby/object:Gem::Dependency
   name: rays
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.48
+        version: 0.1.49
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.48
+        version: 0.1.49
 - !ruby/object:Gem::Dependency
   name: reflexion
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.56
+        version: 0.1.57
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.56
+        version: 0.1.57
 description: Creative Coding Framework has API compatible to Processing or p5.js.
 email: xordog@gmail.com
 executables: []
@@ -100,6 +100,7 @@ files:
 - lib/processing/app.rb
 - lib/processing/capture.rb
 - lib/processing/context.rb
+- lib/processing/events.rb
 - lib/processing/extension.rb
 - lib/processing/font.rb
 - lib/processing/graphics.rb
@@ -143,7 +144,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.4.19
 signing_key:
 specification_version: 4
 summary: Processing compatible Creative Coding Framework.