processing 0.5.14 → 0.5.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 311dd968164719386205299dcfeaf129213ab0837975e995f09568fb9180e0e3
-  data.tar.gz: 0b566cc36e09ba7e87624144ad5293f699f3662f1b114d24fd5738ed137a079b
+  metadata.gz: d69cca41be46b8a061bcafc55fd36cf71d50616b5b5697ab558dfac1c9c2449c
+  data.tar.gz: 4b3869b1fb410a2da488c03dd58e95fa1f0c42521888869bd70c0c18904831dc
 SHA512:
-  metadata.gz: c4c627e0c5f44104b12dcb83b0e08257d416115797923af02ee156d8c6c72f309bc55fe19cce5db73de41582546550e31e42d0e543bd9a368107cfb7a3870ec4
-  data.tar.gz: 7c452bb4ad0144326991dddfd12f4e2ff60b5db8095b649630d27a9620b2070eb1b3a63424f03b13d26c45bc2c9a346670b3bd814604fce8f10d67a5612a9e54
+  metadata.gz: 0db54f243695541c85db93d6f28bf3bc42dc76d68e40e3d63cc4e3524110f33372987be661a9fe1e58698d7c3eae40c32b6a76f7660102efbd952591f041db33
+  data.tar.gz: e0719f14ed2fddc28d2dc908339fb633a3dcf645f20a98a52a333541078154aab4c5bcdb1dd36032b1dabbed8f229915ee8b36549085a785446b6aae38e6debc

data/ChangeLog.md

@@ -1,6 +1,28 @@
 # processing ChangeLog
 
 
+## [v0.5.17] - 2023-06-07
+
+- Add Image#set() and Image#get()
+- Add color(), red(), green(), blue(), and alpha()
+- Add lerpColor()
+- Add focused()
+
+
+## [v0.5.16] - 2023-06-02
+
+- Fix failed tests and add tests
+
+
+## [v0.5.15] - 2023-06-02
+
+- Set initial canvas size to same as the window size
+- Use WIDTH and HEIGHT env vars for initial canvas size
+- Shader class can take shadertoy frament shader source
+- createGraphics() can take pixelDensity parameter
+- Pass self to the block call of beginDraw(), and ensure endDraw
+
+
 ## [v0.5.14] - 2023-05-29
 
 - Add windowMove() and windowResize()

data/VERSION

@@ -1 +1 @@
-0.5.14
+0.5.17

data/lib/processing/context.rb

@@ -468,6 +468,14 @@ module Processing
       @window__.height
     end
 
+    # Returns weather the window is active or not.
+    #
+    # @return [Boolean] active or not
+    #
+    def focused()
+      @window__.active?
+    end
+
     # Returns the number of frames since the program started.
     #
     # @return [Integer] total number of frames

data/lib/processing/graphics.rb

@@ -10,8 +10,8 @@ module Processing
 
     # Initialize graphics object.
     #
-    def initialize(width, height)
-      image = Rays::Image.new width, height
+    def initialize(width, height, pixelDensity = 1)
+      image = Rays::Image.new width, height, Rays::RGBA, pixelDensity
       init__ image, image.painter
     end
 
@@ -22,8 +22,11 @@ module Processing
       @painter__.__send__ :begin_paint
       push
       if block
-        block.call
-        endDraw
+        begin
+          block.call self
+        ensure
+          endDraw
+        end
       end
     end
 

data/lib/processing/graphics_context.rb

@@ -324,6 +324,59 @@ module Processing
       @colorMode__
     end
 
+    # Creates color value.
+    #
+    # @overload color(gray)
+    # @overload color(gray, alpha)
+    # @overload color(v1, v2, v3)
+    # @overload color(v1, v2, v3, alpha)
+    #
+    # @param gray  [Numeric] the value for gray
+    # @param alpha [Numeric] the value for alpha
+    # @param v1    [Numeric] the value for red or hue
+    # @param v2    [Numeric] the value for green or saturation
+    # @param v3    [Numeric] the value for blue or brightness
+    #
+    # @return [Integer] the rgba color value
+    #
+    def color(*args)
+      toRGBA__(*args)
+        .map {|n| (n * 255).to_i.clamp 0, 255}
+        .then {|r, g, b, a| Image.toColor__ r, g, b, a}
+    end
+
+    # Returns the red value of the color.
+    #
+    # @return [Numeric] the red value
+    #
+    def red(color)
+      ((color >> 16) & 0xff) / 255.0 * @colorMaxes__[0]
+    end
+
+    # Returns the green value of the color.
+    #
+    # @return [Numeric] the green value
+    #
+    def green(color)
+      ((color >> 8) & 0xff) / 255.0 * @colorMaxes__[1]
+    end
+
+    # Returns the blue value of the color.
+    #
+    # @return [Numeric] the blue value
+    #
+    def blue(color)
+      (color & 0xff) / 255.0 * @colorMaxes__[2]
+    end
+
+    # Returns the red value of the color.
+    #
+    # @return [Numeric] the red value
+    #
+    def alpha(color)
+      ((color >> 24) & 0xff) / 255.0 * @colorMaxes__[3]
+    end
+
     # @private
     private def toRGBA__(*args)
       a, b, c, d = args
@@ -1427,6 +1480,22 @@ module Processing
       start + (stop - start) * amount
     end
 
+    # Returns the interpolated color between color1 and color2.
+    #
+    # @param color1 [Integer] the 1st color for interpolation
+    # @param color2 [Integer] the 2nd color for interpolation
+    # @param amount [Numeric] amount to interpolate
+    #
+    # @return [Integer] interporated color
+    #
+    def lerpColor(color1, color2, amount)
+      color(
+        lerp(red(  color1), red(  color2), amount),
+        lerp(green(color1), green(color2), amount),
+        lerp(blue( color1), blue( color2), amount),
+        lerp(alpha(color1), alpha(color2), amount))
+    end
+
     # Maps a number from range start1..stop1 to range start2..stop2.
     #
     # @param value  [Numeric] number to be mapped
@@ -1648,13 +1717,14 @@ module Processing
 
     # Creates a new off-screen graphics context object.
     #
-    # @param width  [Numeric] width of graphics image
-    # @param height [Numeric] height of graphics image
+    # @param width        [Numeric] width of graphics image
+    # @param height       [Numeric] height of graphics image
+    # @param pixelDensity [Numeric] pixel density of graphics image
     #
     # @return [Graphics] graphics object
     #
-    def createGraphics(width, height)
-      Graphics.new width, height
+    def createGraphics(width, height, pixelDensity = 1)
+      Graphics.new width, height, pixelDensity
     end
 
     # Creates a shader object.

data/lib/processing/image.rb

@@ -39,6 +39,30 @@ module Processing
       @image.size
     end
 
+    # Sets the color of the pixel.
+    #
+    # @param x [Integer] x position of the pixel
+    # @param y [Integer] y position of the pixel
+    # @param c [Integer] color value
+    #
+    # @return [nil] nil
+    #
+    def set(x, y, c)
+      @image.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]
+        .map {|n| (n * 255).to_i.clamp 0, 255}
+        .then {|r, g, b, a| self.class.toColor__ r, g, b, a}
+    end
+
     # Applies an image filter.
     #
     # overload filter(shader)
@@ -135,6 +159,24 @@ module Processing
       end
     end
 
+    # @private
+    def self.fromColor__(color)
+      [
+        color >> 16 & 0xff,
+        color >> 8  & 0xff,
+        color       & 0xff,
+        color >> 24 & 0xff
+      ]
+    end
+
+    # @private
+    def self.toColor__(r, g, b, a)
+      (r & 0xff) << 16 |
+      (g & 0xff) << 8  |
+      (b & 0xff)       |
+      (a & 0xff) << 24
+    end
+
   end# Image
 
 

data/lib/processing/shader.rb

@@ -13,7 +13,7 @@ module Processing
     # @param fragSrc [String] fragment shader source
     #
     def initialize(vertSrc, fragSrc)
-      @shader = Rays::Shader.new fragSrc, vertSrc, ENV__
+      @shader = Rays::Shader.new modifyFragSource(fragSrc), vertSrc, ENV__
     end
 
     # Sets uniform variables.
@@ -83,74 +83,117 @@ module Processing
       when Shader
         arg
       when :threshold
-        self.new(nil, <<~END).tap {|sh| sh.set :threshold, (args.shift || 0.5)}
-          uniform float threshold;
-          uniform sampler2D texMap;
-          varying vec4 vertTexCoord;
-          varying vec4 vertColor;
-          void main() {
-            vec4 col     = texture2D(texMap, vertTexCoord.xy) * vertColor;
-            float gray   = col.r * 0.3 + col.g * 0.59 + col.b * 0.11;
-            gl_FragColor = vec4(vec3(gray > threshold ? 1.0 : 0.0), 1.0);
-          }
-        END
+        self.new(nil, THRESHOLD_SOURCE).tap {|sh| sh.set :threshold, (args.shift || 0.5)}
       when :gray
-        self.new nil, <<~END
-          uniform sampler2D texMap;
-          varying vec4 vertTexCoord;
-          varying vec4 vertColor;
-          void main() {
-            vec4 col     = texture2D(texMap, vertTexCoord.xy);
-            float gray   = col.r * 0.3 + col.g * 0.59 + col.b * 0.11;
-            gl_FragColor = vec4(vec3(gray), 1.0) * vertColor;
-          }
-        END
+        self.new nil, GRAY_SOURCE
       when :invert
-        self.new nil, <<~END
-          uniform sampler2D texMap;
-          varying vec4 vertTexCoord;
-          varying vec4 vertColor;
-          void main() {
-            vec4 col     = texture2D(texMap, vertTexCoord.xy);
-            gl_FragColor = vec4(vec3(1.0 - col.rgb), 1.0) * vertColor;
-          }
-        END
+        self.new nil, INVERT_SOURCE
       when :blur
-        self.new(nil, <<~END).tap {|sh| sh.set :radius, (args.shift || 1).to_f}
-          #define PI 3.1415926538
-          uniform float radius;
-          uniform sampler2D texMap;
-          uniform vec3 texMin;
-          uniform vec3 texMax;
-          uniform vec3 texOffset;
+        self.new(nil, BLUR_SOURCE).tap {|sh| sh.set :radius, (args.shift || 1).to_f}
+      else
+        nil
+      end
+    end
+
+    private
+
+    THRESHOLD_SOURCE = <<~END
+      uniform float threshold;
+      uniform sampler2D texMap;
+      varying vec4 vertTexCoord;
+      varying vec4 vertColor;
+      void main() {
+        vec4 col     = texture2D(texMap, vertTexCoord.xy) * vertColor;
+        float gray   = col.r * 0.3 + col.g * 0.59 + col.b * 0.11;
+        gl_FragColor = vec4(vec3(gray > threshold ? 1.0 : 0.0), 1.0);
+      }
+    END
+
+    GRAY_SOURCE = <<~END
+      uniform sampler2D texMap;
+      varying vec4 vertTexCoord;
+      varying vec4 vertColor;
+      void main() {
+        vec4 col     = texture2D(texMap, vertTexCoord.xy);
+        float gray   = col.r * 0.3 + col.g * 0.59 + col.b * 0.11;
+        gl_FragColor = vec4(vec3(gray), 1.0) * vertColor;
+      }
+    END
+
+    INVERT_SOURCE = <<~END
+      uniform sampler2D texMap;
+      varying vec4 vertTexCoord;
+      varying vec4 vertColor;
+      void main() {
+        vec4 col     = texture2D(texMap, vertTexCoord.xy);
+        gl_FragColor = vec4(vec3(1.0 - col.rgb), 1.0) * vertColor;
+      }
+    END
+
+    BLUR_SOURCE = <<~END
+      #define PI 3.1415926538
+      uniform float radius;
+      uniform sampler2D texMap;
+      uniform vec3 texMin;
+      uniform vec3 texMax;
+      uniform vec3 texOffset;
+      varying vec4 vertTexCoord;
+      varying vec4 vertColor;
+      float gaussian(vec2 pos, float sigma) {
+        float s2 = sigma * sigma;
+        return 1.0 / (2.0 * PI * s2) * exp(-(dot(pos, pos) / (2.0 * s2)));
+      }
+      void main() {
+        float sigma        = radius * 0.5;
+        vec3 color         = vec3(0.0);
+        float total_weight = 0.0;
+        for (float y = -radius; y < radius; y += 1.0)
+        for (float x = -radius; x < radius; x += 1.0) {
+          vec2 offset   = vec2(x, y);
+          float weight  = gaussian(offset, sigma);
+          vec2 texcoord = vertTexCoord.xy + offset * texOffset.xy;
+          if (
+            texcoord.x < texMin.x || texMax.x < texcoord.x ||
+            texcoord.y < texMin.y || texMax.y < texcoord.y
+          ) continue;
+          color += texture2D(texMap, texcoord).rgb * weight;
+          total_weight += weight;
+        }
+        gl_FragColor = vec4(color / total_weight, 1.0) * vertColor;
+      }
+    END
+
+    def modifyFragSource(source)
+      return nil unless source
+      if hasShadertoyMainImage?(source) && source !~ /void\s+main\s*\(/
+        source += <<~END
           varying vec4 vertTexCoord;
-          varying vec4 vertColor;
-          float gaussian(vec2 pos, float sigma) {
-            float s2 = sigma * sigma;
-            return 1.0 / (2.0 * PI * s2) * exp(-(dot(pos, pos) / (2.0 * s2)));
-          }
           void main() {
-            float sigma        = radius * 0.5;
-            vec3 color         = vec3(0.0);
-            float total_weight = 0.0;
-            for (float y = -radius; y < radius; y += 1.0)
-            for (float x = -radius; x < radius; x += 1.0) {
-              vec2 offset   = vec2(x, y);
-              float weight  = gaussian(offset, sigma);
-              vec2 texcoord = vertTexCoord.xy + offset * texOffset.xy;
-              if (
-                texcoord.x < texMin.x || texMax.x < texcoord.x ||
-                texcoord.y < texMin.y || texMax.y < texcoord.y
-              ) continue;
-              color += texture2D(texMap, texcoord).rgb * weight;
-              total_weight += weight;
-            }
-            gl_FragColor = vec4(color / total_weight, 1.0) * vertColor;
+            mainImage(gl_FragColor, vertTexCoord.xy);
           }
         END
-      else
-        nil
       end
+      {
+        iTime:       :float,
+        iResolution: :vec2,
+        iMouse:      :vec2
+      }.each do |uniformName, type|
+        if needsUniformDeclaration type, uniformName, source
+          source = <<~END + source
+            uniform #{type} #{uniformName};
+          END
+        end
+      end
+      source
+    end
+
+    def hasShadertoyMainImage?(source)
+      source =~ /void\s+mainImage\s*\(\s*out\s+vec4\s+\w+\s*,\s*in\s+vec2\s+\w+\s*\)/
+    end
+
+    def needsUniformDeclaration(type, uniformName, source)
+      source.include?(uniformName.to_s) &&
+        source !~ /uniform\s+#{type}\s+#{uniformName}/
     end
 
   end# Shader

data/lib/processing/window.rb

@@ -6,7 +6,7 @@ module Processing
 
     include Xot::Inspectable
 
-    attr_accessor :setup, :update, :draw, :resize,
+    attr_accessor :setup, :update, :draw,
       :key_down, :key_up,
       :pointer_down, :pointer_up, :pointer_move, :pointer_drag,
       :move, :resize, :motion,
@@ -18,9 +18,10 @@ module Processing
       Processing.instance_variable_set :@window, self
 
       @events       = []
+      @active       = false
       @error        = nil
       @auto_resize  = true
-      @canvas       = Canvas.new self
+      @canvas       = Canvas.new self, width, height
       @canvas_view  =              add   CanvasView.new name: :canvas
       @overlay_view = @canvas_view.add Reflex::View.new name: :overlay
 
@@ -43,6 +44,10 @@ module Processing
       @events.last
     end
 
+    def active?()
+      @active
+    end
+
     def add_overlay(view)
       @overlay_view.add view
     end
@@ -58,14 +63,18 @@ module Processing
       call_block @setup, nil
     end
 
-    def on_resize(e)
-      on_canvas_resize e
-    end
-
     def on_change_pixel_density(pixel_density)
       resize_canvas width, height, window_pixel_density: pixel_density
     end
 
+    def on_activate(e)
+      @active = true
+    end
+
+    def on_deactivate(e)
+      @active = false
+    end
+
     def on_draw(e)
       window_painter.pixel_density.tap do |pd|
         prev, @prev_pixel_density = @prev_pixel_density, pd
@@ -204,11 +213,11 @@ module Processing
 
     attr_reader :image, :painter
 
-    def initialize(window)
+    def initialize(window, width, height)
       @image   = nil
       @painter = window.painter
 
-      resize 1, 1
+      resize width, height
       painter.miter_limit = 10
     end
 

data/lib/processing.rb

@@ -2,7 +2,9 @@ require 'processing/all'
 
 
 module Processing
-  WINDOW  = Processing::Window.new {start}
+  w = (ENV['WIDTH']  || 500).to_i
+  h = (ENV['HEIGHT'] || 500).to_i
+  WINDOW  = Processing::Window.new(w, h) {start}
   CONTEXT = Processing::Context.new WINDOW
 
   refine Object do

data/processing.gemspec

@@ -27,8 +27,8 @@ Gem::Specification.new do |s|
 
   s.add_runtime_dependency 'xot',       '~> 0.1.38'
   s.add_runtime_dependency 'rucy',      '~> 0.1.38'
-  s.add_runtime_dependency 'rays',      '~> 0.1.39'
-  s.add_runtime_dependency 'reflexion', '~> 0.1.41'
+  s.add_runtime_dependency 'rays',      '~> 0.1.40'
+  s.add_runtime_dependency 'reflexion', '~> 0.1.43'
 
   s.add_development_dependency 'rake'
   s.add_development_dependency 'test-unit'

data/test/test_graphics_context.rb

@@ -40,4 +40,44 @@ class TestGraphicsContext < Test::Unit::TestCase
     assert_raise {g.blendMode LEFT}
   end
 
+  def test_color()
+    g = graphics
+
+    g.colorMode G::RGB, 255
+    c = g.color 10, 20, 30, 40
+    assert_equal 0x280a141e, c
+    assert_equal [10, 20, 30, 40], [g.red(c), g.green(c), g.blue(c), g.alpha(c)]
+
+    g.colorMode G::RGB, 1.0
+    c = g.color 0.1, 0.2, 0.3, 0.4
+    assert_equal 0x6619334c, 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_lerp()
+    g = graphics
+
+    assert_equal 1.0, g.lerp(1.0, 2.0, 0.0)
+    assert_equal 1.5, g.lerp(1.0, 2.0, 0.5)
+    assert_equal 2.0, g.lerp(1.0, 2.0, 1.0)
+
+    assert_equal 0.9, g.lerp(1.0, 2.0, -0.1)
+    assert_equal 2.1, g.lerp(1.0, 2.0,  1.1)
+  end
+
+  def test_lerpColor()
+    g = graphics
+    c = -> red, green, blue {g.color red, green, blue}
+
+    assert_equal c[10, 20, 30], g.lerpColor(c[10, 20, 30], c[50, 60, 70], 0.0)
+    assert_equal c[30, 40, 50], g.lerpColor(c[10, 20, 30], c[50, 60, 70], 0.5)
+    assert_equal c[50, 60, 70], g.lerpColor(c[10, 20, 30], c[50, 60, 70], 1.0)
+
+    assert_equal c[-10, 0,  10], g.lerpColor(c[10, 20, 30], c[50, 60, 70], -0.5)
+    assert_equal c[ 70, 80, 90], g.lerpColor(c[10, 20, 30], c[50, 60, 70],  1.5)
+  end
+
 end# TestGraphics

data/test/test_image.rb

@@ -5,8 +5,36 @@ class TestImage < Test::Unit::TestCase
 
   P = Processing
 
-  def image(w = 10, h = 10)
-    P::Image.new(Rays::Image.new w, h)
+  def image(w = 10, h = 10, &block)
+    img = Rays::Image.new w, h
+    img.paint &block if block
+    P::Image.new img
+  end
+
+  def test_set_color()
+    g = graphics
+    i = image(2, 2) {fill 0; rect 0, 0, 1, 1}
+
+    assert_equal g.color(0, 0, 0),   i.get(0, 0)
+
+    i.set 0, 0,  g.color(0, 255, 0)
+    assert_equal g.color(0, 255, 0), i.get(0, 0)
+
+    i.set 0, 0,  g.color(0, 0, 255)
+    assert_equal g.color(0, 0, 255), i.get(0, 0)
+  end
+
+  def test_get_color()
+    g = graphics
+    i = image 2, 2 do
+      fill 1, 0, 0; rect 0, 0, 1, 1
+      fill 0, 1, 0; rect 1, 0, 1, 1
+      fill 0, 0, 1; rect 0, 1, 1, 1
+    end
+
+    assert_equal g.color(255, 0, 0), i.get(0, 0)
+    assert_equal g.color(0, 255, 0), i.get(1, 0)
+    assert_equal g.color(0, 0, 255), i.get(0, 1)
   end
 
   def test_inspect()

data/test/test_shader.rb

@@ -41,6 +41,20 @@ class TestShader < Test::Unit::TestCase
     end
   end
 
+  def test_shadertoy_shader()
+    assert_equal <<~EXPECTED, shader(nil, <<~ACTUAL).instance_variable_get(:@shader).fragment_shader_source
+      void mainImage(out vec4 fragColor, in vec2 fragCoord) {
+      }
+      varying vec4 vertTexCoord;
+      void main() {
+        mainImage(gl_FragColor, vertTexCoord.xy);
+      }
+    EXPECTED
+      void mainImage(out vec4 fragColor, in vec2 fragCoord) {
+      }
+    ACTUAL
+  end
+
   def test_inspect()
     assert_match %r|#<Processing::Shader:0x\w{16}>|, shader.inspect
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: processing
 version: !ruby/object:Gem::Version
-  version: 0.5.14
+  version: 0.5.17
 platform: ruby
 authors:
 - xordog
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-05-29 00:00:00.000000000 Z
+date: 2023-06-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: xot
@@ -44,28 +44,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.39
+        version: 0.1.40
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.39
+        version: 0.1.40
 - !ruby/object:Gem::Dependency
   name: reflexion
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.41
+        version: 0.1.43
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.41
+        version: 0.1.43
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement