processing 0.5.31 → 0.5.33

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(true)[x, y] = self.class.fromColor__(c).map {|n| n / 255.0}
       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 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
 
-    def vertex(x, y)
-      raise "vertex() must be called after beginShape()" unless @points
-      @points << x << y
+    # @private
+    def drawingShape__()
+      @curvePoints
+    end
+
+    # @private
+    def drawingContour__()
+      @contourPoints
+    end
+
+    def fill(*args)
+      @fill = @context.rawColor__(*args)
     end
 
     def setVertex(index, point)
@@ -88,6 +172,23 @@ module Processing
       @points.size / 2
     end
 
+    def setFill(*args)
+      color = @context.rawColor__(*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
@@ -103,17 +204,17 @@ module Processing
     end
 
     def translate(x, y, z = 0)
-      matrix__.translate x, y, z
+      matrix__.translate! x, y, z
       nil
     end
 
     def rotate(angle)
-      matrix__.rotate @context.toDegrees__(angle)
+      matrix__.rotate! @context.toDegrees__(angle)
       nil
     end
 
     def scale(x, y, z = 1)
-      matrix__.scale x, y, z
+      matrix__.scale! x, y, z
       nil
     end
 
@@ -121,9 +222,22 @@ module Processing
       @matrix = nil
     end
 
-    def rotateX = nil
-    def rotateY = nil
-    def rotateZ = nil
+    def rotateX(angle)
+      matrix__.rotate! @context.toDegrees__(angle), 1, 0, 0
+    end
+
+    def rotateY(angle)
+      matrix__.rotate! @context.toDegrees__(angle), 0, 1, 0
+    end
+
+    def rotateZ(angle)
+      matrix__.rotate! @context.toDegrees__(angle), 0, 0, 1
+    end
+
+    # @private
+    def clearCache__()
+      @polygon = nil# clear cache
+    end
 
     # @private
     def matrix__()
@@ -133,8 +247,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 +278,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/lib/processing/window.rb

@@ -6,14 +6,6 @@ module Processing
 
     include Xot::Inspectable
 
-    attr_accessor :setup, :update, :draw,
-      :key_down, :key_up,
-      :pointer_down, :pointer_up, :pointer_move,
-      :move, :resize, :motion,
-      :before_draw, :after_draw, :update_window, :update_canvas
-
-    attr_accessor :auto_resize
-
     def initialize(width = 500, height = 500, *args, **kwargs, &block)
       Processing.instance_variable_set :@window, self
 
@@ -26,19 +18,16 @@ module Processing
       @overlay_view = @canvas_view.add Reflex::View.new name: :overlay
 
       super(*args, size: [width, height], **kwargs, &block)
+      self.center = screen.center
     end
 
-    def canvas_image()
-      @canvas.image
-    end
+    attr_accessor :setup, :update, :draw, :move, :resize, :motion,
+      :key_down, :key_up, :pointer_down, :pointer_up, :pointer_move, :wheel,
+      :before_draw, :after_draw, :update_window, :update_canvas
 
-    def canvas_painter()
-      @canvas.painter
-    end
+    attr_accessor :auto_resize
 
-    def window_painter()
-      self.painter
-    end
+    attr_reader :canvas
 
     def event()
       @events.last
@@ -64,7 +53,9 @@ module Processing
     end
 
     def on_change_pixel_density(pixel_density)
-      resize_canvas width, height, window_pixel_density: pixel_density
+      resize_canvas(
+        @canvas.width, @canvas.height,
+        window_pixel_density: pixel_density)
     end
 
     def on_activate(e)
@@ -80,7 +71,7 @@ module Processing
     end
 
     def on_draw(e)
-      window_painter.pixel_density.tap do |pd|
+      painter.pixel_density.tap do |pd|
         prev, @prev_pixel_density = @prev_pixel_density, pd
         on_change_pixel_density pd if prev && pd != prev
       end
@@ -127,28 +118,35 @@ module Processing
       draw_canvas {call_block block, e} if block
     end
 
+    def on_canvas_wheel(e)
+      draw_canvas {call_block @wheel, e} if @wheel
+    end
+
     def on_canvas_resize(e)
       resize_canvas e.width, e.height if @auto_resize
       draw_canvas {call_block @resize, e} if @resize
     end
 
-    def resize_canvas(width, height, pixel_density = nil, window_pixel_density: nil)
-      painting = canvas_painter.painting?
-      canvas_painter.__send__ :end_paint if painting
+    def resize_canvas(
+      width, height,
+      pixel_density       = nil,
+      window_pixel_density: nil,
+      antialiasing:         nil)
+
+      painting = @canvas.painter.painting?
+      @canvas.painter.__send__ :end_paint if painting
 
       @pixel_density = pixel_density if pixel_density
 
       resized =
         begin
-          @canvas.resize width, height, @pixel_density || window_pixel_density
+          pd = @pixel_density || window_pixel_density
+          @canvas.resize width, height, pd, antialiasing
         ensure
-          canvas_painter.__send__ :begin_paint if painting
+          @canvas.painter.__send__ :begin_paint if painting
         end
 
-      if resized
-        @update_canvas.call canvas_image, canvas_painter if @update_canvas
-        size width, height
-      end
+      @update_canvas&.call @canvas.image, @canvas.painter if resized
     end
 
     private
@@ -157,12 +155,12 @@ module Processing
       scrollx, scrolly, zoom = get_scroll_and_zoom
       @canvas_view.scroll_to scrollx, scrolly
       @canvas_view.zoom  = zoom
-      @overlay_view.size = canvas_image.size
+      @overlay_view.size = @canvas.image.size
     end
 
     def get_scroll_and_zoom()
-      ww, wh =              width.to_f,              height.to_f
-      cw, ch = canvas_image.width.to_f, canvas_image.height.to_f
+      ww, wh =               width.to_f,               height.to_f
+      cw, ch = @canvas.image.width.to_f, @canvas.image.height.to_f
       return [0, 0, 1] if ww == 0 || wh == 0 || cw == 0 || ch == 0
 
       wratio, cratio = ww / wh, cw / ch
@@ -184,21 +182,21 @@ module Processing
     end
 
     def begin_draw()
-      canvas_painter.__send__ :begin_paint
+      @canvas.painter.__send__ :begin_paint
       @before_draw&.call
     end
 
     def end_draw()
       @after_draw&.call
-      canvas_painter.__send__ :end_paint
+      @canvas.painter.__send__ :end_paint
     end
 
     def drawing?()
-      canvas_painter.painting?
+      @canvas.painter.painting?
     end
 
     def draw_screen(painter)
-      window_painter.image canvas_image
+      painter.image @canvas.render
     end
 
     def call_block(block, event, *args)
@@ -216,49 +214,84 @@ module Processing
 
   class Window::Canvas
 
-    attr_reader :image, :painter
-
     def initialize(window, width, height)
-      @image   = nil
-      @painter = window.painter
+      @framebuffer = nil
+      @paintable   = nil
+      @painter     = window.painter
+
+      @painter.miter_limit = 10
 
       resize width, height
-      painter.miter_limit = 10
     end
 
-    def resize(width, height, pixel_density = nil)
+    attr_reader :painter
+
+    def resize(width, height, pixel_density = nil, antialiasing = nil)
       return false if width <= 0 || height <= 0
 
+      cs = @framebuffer&.color_space || Rays::RGBA
+      pd = pixel_density || (@framebuffer || @painter).pixel_density
+      aa = antialiasing == nil ? antialiasing? : (antialiasing && pd < 2)
       return false if
-        width         == @image&.width  &&
-        height        == @image&.height &&
-        pixel_density == @painter.pixel_density
+        width  == @framebuffer&.width  &&
+        height == @framebuffer&.height &&
+        pd     == @framebuffer&.pixel_density &&
+        aa     == antialiasing?
 
-      old_image   = @image
-      old_painter = @painter
-      cs          = old_image&.color_space || Rays::RGBA
-      pd          = pixel_density || old_painter.pixel_density
+      old_paintable, old_painter = @paintable, @painter
 
-      @image   = Rays::Image.new width, height, cs, pd
-      @painter = @image.painter
+      @framebuffer = Rays::Image.new width, height, cs, pd
+      @paintable   = aa ? Rays::Image.new(width, height, cs, pd * 2) : @framebuffer
+      @painter     = @paintable.painter
 
-      @painter.paint {image old_image} if old_image
+      @painter.paint {image old_paintable} if old_paintable
       copy_painter old_painter, @painter
 
       GC.start
       return true
     end
 
+    def render()
+      @framebuffer.paint {|p| p.image @paintable} if antialiasing?
+      @framebuffer
+    end
+
+    def image()
+      @paintable
+    end
+
+    def width()
+      @framebuffer.width
+    end
+
+    def height()
+      @framebuffer.height
+    end
+
+    def pixel_density()
+      @framebuffer.pixel_density
+    end
+
+    def antialiasing?()
+      !!@framebuffer && !!@paintable && @framebuffer != @paintable
+    end
+
     private
 
     def copy_painter(from, to)
-      to.fill         = from.fill
-      to.stroke       = from.stroke
-      to.stroke_width = from.stroke_width
-      to.stroke_cap   = from.stroke_cap
-      to.stroke_join  = from.stroke_join
-      to.miter_limit  = from.miter_limit
-      to.font         = from.font
+      to.fill          = from.fill
+      to.stroke        = from.stroke
+      to.stroke_width  = from.stroke_width
+      to.stroke_cap    = from.stroke_cap
+      to.stroke_join   = from.stroke_join
+      to.miter_limit   = from.miter_limit
+      to.clip          = from.clip
+      to.blend_mode    = from.blend_mode
+      to.font          = from.font
+      to.texture       = from.texture
+      to.texcoord_mode = from.texcoord_mode
+      to.texcoord_wrap = from.texcoord_wrap
+      to.shader        = from.shader
     end
 
   end# Window::Canvas
@@ -268,6 +301,7 @@ module Processing
 
     def on_update(e)
       window.on_canvas_update e
+      Thread.pass
     end
 
     def on_draw(e)
@@ -278,6 +312,10 @@ module Processing
       window.on_canvas_pointer e
     end
 
+    def on_wheel(e)
+      window.on_canvas_wheel e
+    end
+
     def on_resize(e)
       window.on_canvas_resize e
     end

data/processing.gemspec

@@ -25,10 +25,10 @@ Gem::Specification.new do |s|
   s.platform              = Gem::Platform::RUBY
   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 'xot',       '~> 0.1.42'
+  s.add_runtime_dependency 'rucy',      '~> 0.1.44'
+  s.add_runtime_dependency 'rays',      '~> 0.1.49'
+  s.add_runtime_dependency 'reflexion', '~> 0.1.57'
 
   s.files            = `git ls-files`.split $/
   s.test_files       = s.files.grep %r{^(test|spec|features)/}

data/test/helper.rb

@@ -34,8 +34,10 @@ def mkdir(dir: nil, filename: nil)
   FileUtils.mkdir_p path unless File.exist? path
 end
 
-def test_label(index = 1)
-  caller_locations[index].then {|loc| "#{loc.label}_#{loc.lineno}"}
+def test_label(frame_offset = 1, suffix: nil)
+  suffix = suffix ? "_#{suffix}" : ''
+  caller_locations[frame_offset]
+    .then {|loc| "#{loc.label}_#{loc.lineno}#{suffix}"}
 end
 
 def temp_path(ext: nil, &block)
@@ -59,7 +61,6 @@ def get_pixels(image)
     .map {image.instance_variable_get _1}
     .compact
     .first
-    .bitmap
     .pixels
 end
 
@@ -71,6 +72,7 @@ end
 
 def test_draw(*sources, width: 1000, height: 1000, pixelDensity: 1, label: nil)
   graphics(width, height, pixelDensity).tap do |g|
+    g.renderMode :p5js
     g.beginDraw {g.instance_eval sources.compact.join("\n")}
     g.save draw_output_path(label, *sources) if label
   end
@@ -107,14 +109,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')