processing 0.5.32 → 0.5.33

data/lib/processing/image.rb

@@ -49,7 +49,7 @@ module Processing
     # @return [nil] nil
     #
     def set(x, y, c)
-      getInternal__.bitmap[x, y] = self.class.fromColor__ c
+      getInternal__.bitmap(true)[x, y] = self.class.fromColor__(c).map {|n| n / 255.0}
       nil
     end
 

data/lib/processing/shape.rb

@@ -152,7 +152,7 @@ module Processing
     end
 
     def fill(*args)
-      @fill = @context.toRaysColor__(*args)
+      @fill = @context.rawColor__(*args)
     end
 
     def setVertex(index, point)
@@ -173,7 +173,7 @@ module Processing
     end
 
     def setFill(*args)
-      color = @context.toRaysColor__(*args)
+      color = @context.rawColor__(*args)
       count = getVertexCount
       if count > 0
         if @colors
@@ -204,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
 
@@ -222,9 +222,17 @@ 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__()

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.43'
-  s.add_runtime_dependency 'rays',      '~> 0.1.48'
-  s.add_runtime_dependency 'reflexion', '~> 0.1.56'
+  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)
@@ -70,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

data/test/p5.rb

@@ -49,7 +49,7 @@ def get_p5rb_html(width, height, draw_src, webgl: false)
   END
 end
 
-def sleep_until (try: 3, timeout: 10, &block)
+def sleep_until(try: 3, timeout: 10, &block)
   now = -> offset = 0 {Time.now.to_f + offset}
   limit = now[timeout]
   until block.call

data/test/test_font.rb

@@ -6,7 +6,7 @@ class TestFont < Test::Unit::TestCase
   P = Processing
 
   def font(*args)
-    P::Font.new(Rays::Font.new *args).tap {|font|
+    P::Font.new(Rays::Font.new(*args)).tap {|font|
       def font.intern()
         getInternal__
       end