processing 0.4.0

data/lib/processing/window.rb

@@ -0,0 +1,238 @@
+module Processing
+
+
+  class Window < Reflex::Window
+
+    class CanvasView < Reflex::View
+      def on_update(e)
+        window.on_canvas_update e
+      end
+
+      def on_draw(e)
+        window.on_canvas_draw e
+      end
+
+      def on_pointer(e)
+        window.on_canvas_pointer e
+      end
+
+      def on_resize(e)
+        window.on_canvas_resize e
+      end
+    end
+
+    attr_accessor :setup, :update, :draw, :resize,
+      :key_down, :key_up,
+      :pointer_down, :pointer_up, :pointer_move, :pointer_drag,
+      :motion,
+      :before_draw, :after_draw, :update_canvas
+
+    attr_accessor :auto_resize
+
+    def initialize(width = 500, height = 500, *args, **kwargs, &block)
+      Processing.instance_variable_set :@window, self
+
+      @events      = []
+      @error       = nil
+      @auto_resize = true
+      @canvas      = Canvas.new self
+      @canvas_view = add CanvasView.new name: :canvas
+
+      super(*args, size: [width, height], **kwargs, &block)
+    end
+
+    def canvas_image()
+      @canvas.image
+    end
+
+    def canvas_painter()
+      @canvas.painter
+    end
+
+    def window_painter()
+      self.painter
+    end
+
+    def event()
+      @events.last
+    end
+
+    def start(&block)
+      draw_canvas do
+        block.call if block
+        on_setup
+      end
+    end
+
+    def resize_canvas(width, height, pixel_density = nil, window_pixel_density: nil)
+      @pixel_density = pixel_density if pixel_density
+      if @canvas.resize width, height, pixel_density || @pixel_density || window_pixel_density
+        @update_canvas.call canvas_image, canvas_painter if @update_canvas
+        size width, height
+      end
+    end
+
+    def on_setup()
+      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_draw(e)
+      window_painter.pixel_density.tap do |pd|
+        prev, @prev_pixel_density = @prev_pixel_density, pd
+        on_change_pixel_density pd if prev && pd != prev
+      end
+      update_canvas_view
+    end
+
+    def on_key(e)
+      block = case e.action
+        when :down then @key_down
+        when :up   then @key_up
+      end
+      draw_canvas {call_block block, e} if block
+    end
+
+    def on_motion(e)
+      draw_canvas {call_block @motion, e} if @motion
+    end
+
+    def on_canvas_update(e)
+      call_block @update, e
+      @canvas_view.redraw
+    end
+
+    def on_canvas_draw(e)
+      draw_canvas {call_block @draw, e} if @draw
+      draw_screen e.painter
+    end
+
+    def on_canvas_pointer(e)
+      block = case e.action
+        when :down        then @pointer_down
+        when :up, :cancel then @pointer_up
+        when :move        then e.drag? ? @pointer_drag : @pointer_move
+      end
+      draw_canvas {call_block block, e} if block
+    end
+
+    def on_canvas_resize(e)
+      resize_canvas e.width, e.height if @auto_resize
+      draw_canvas {call_block @resize, e} if @resize
+    end
+
+    private
+
+    def update_canvas_view()
+      scrollx, scrolly, zoom = get_scroll_and_zoom
+      @canvas_view.scroll_to scrollx, scrolly
+      @canvas_view.zoom zoom
+    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
+      return [0, 0, 1] if ww == 0 || wh == 0 || cw == 0 || ch == 0
+
+      wratio, cratio = ww / wh, cw / ch
+      if wratio >= cratio
+        scaled_w = wh * cratio
+        return (ww - scaled_w) / 2, 0, scaled_w / cw
+      else
+        scaled_h = ww / cratio
+        return 0, (wh - scaled_h) / 2, ww / cw
+      end
+    end
+
+    def draw_canvas(&block)
+      begin_draw
+      block.call
+    ensure
+      end_draw
+    end
+
+    def begin_draw()
+      canvas_painter.__send__ :begin_paint
+      @before_draw&.call
+    end
+
+    def end_draw()
+      @after_draw&.call
+      canvas_painter.__send__ :end_paint
+    end
+
+    def draw_screen(painter)
+      window_painter.image canvas_image
+    end
+
+    def call_block(block, event, *args)
+      @events.push event
+      block.call event, *args if block && !@error
+    rescue Exception => e
+      @error = e
+      $stderr.puts e.full_message
+    ensure
+      @events.pop
+    end
+
+  end# Window
+
+
+  class Window::Canvas
+
+    attr_reader :image, :painter
+
+    def initialize(window)
+      @image   = nil
+      @painter = window.painter
+
+      resize 1, 1
+      painter.miter_limit = 10
+    end
+
+    def resize(width, height, pixel_density = nil)
+      return false if width <= 0 || height <= 0
+
+      return false if
+        width         == @image&.width  &&
+        height        == @image&.height &&
+        pixel_density == @painter.pixel_density
+
+      old_image   = @image
+      old_painter = @painter
+      cs          = old_image&.color_space || Rays::RGBA
+      pd          = pixel_density || old_painter.pixel_density
+
+      @image   = Rays::Image.new width, height, cs, pd
+      @painter = @image.painter
+
+      @painter.paint {image old_image} if old_image
+      copy_painter old_painter, @painter
+
+      GC.start
+      return true
+    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
+    end
+
+  end# Window::Canvas
+
+
+end# Processing

data/lib/processing.rb

@@ -0,0 +1,11 @@
+require 'set'
+require 'digest/sha1'
+require 'pathname'
+require 'tmpdir'
+require 'open-uri'
+
+require 'reflex'
+require 'processing/module'
+require 'processing/app'
+require 'processing/window'
+require 'processing/processing'

data/lib/rubysketch-processing.rb

@@ -0,0 +1 @@
+require 'processing/include'

data/lib/rubysketch.rb

@@ -0,0 +1 @@
+require 'processing'

data/processing.gemspec

@@ -0,0 +1,38 @@
+# -*- mode: ruby -*-
+
+
+File.expand_path('lib', __dir__)
+  .tap {|s| $:.unshift s if !$:.include?(s) && File.directory?(s)}
+
+require 'processing/module'
+
+
+Gem::Specification.new do |s|
+  glob = -> *patterns do
+    patterns.map {|pat| Dir.glob(pat).to_a}.flatten
+  end
+
+  mod   = Processing::Module
+  name  = mod.name.downcase
+  rdocs = glob.call *%w[README]
+
+  s.name        = name
+  s.summary     = 'Processing compatible Creative Coding Framework.'
+  s.description = 'Creative Coding Framework has API compatible to Processing API or p5.js.'
+  s.version     = mod.version
+
+  s.authors  = %w[xordog]
+  s.email    = 'xordog@gmail.com'
+  s.homepage = "https://github.com/xord/processing"
+
+  s.platform              = Gem::Platform::RUBY
+  s.required_ruby_version = '>= 2.7.0'
+
+  s.add_runtime_dependency 'reflexion', '~> 0.1.29'
+
+  s.add_development_dependency 'yard'
+
+  s.files            = `git ls-files`.split $/
+  s.test_files       = s.files.grep %r{^(test|spec|features)/}
+  s.extra_rdoc_files = rdocs.to_a
+end

data/src/RubyProcessing.h

@@ -0,0 +1,15 @@
+// -*- mode: objc -*-
+#import <Foundation/Foundation.h>
+
+
+@interface RubyProcessing : NSObject
+
+	+ (void) setup;
+
+	+ (void) start: (NSString*) path;
+
+	+ (void) setActiveReflexViewController: (id) reflexViewController;
+
+	+ (void) resetActiveReflexViewController;
+
+@end

data/src/RubyProcessing.mm

@@ -0,0 +1,55 @@
+#import <CRuby.h>
+#import "RubyProcessing.h"
+#include "../src/ios/view_controller.h"
+
+
+static ReflexViewController* active_reflex_view_controller = nil;
+
+static ReflexViewController*
+ReflexViewController_create()
+{
+	return active_reflex_view_controller;
+}
+
+static void
+ReflexViewController_show (UIViewController*, ReflexViewController*)
+{
+}
+
+
+@implementation RubyProcessing
+
+	+ (void) setup
+	{
+		static BOOL done = NO;
+		if (done) return;
+		done = YES;
+
+		[CRuby addLibrary:@"RubyProcessing" bundle:[NSBundle bundleForClass:RubyProcessing.class]];
+
+		ReflexViewController_set_create_fun(ReflexViewController_create);
+		ReflexViewController_set_show_fun(ReflexViewController_show);
+	}
+
+	+ (void) start: (NSString*) path
+	{
+		[CRuby evaluate:[NSString stringWithFormat:@
+			"raise 'already started' unless require 'processing/include'\n"
+			"load '%@'\n"
+			"PROCESSING_WINDOW.__send__ :end_draw\n"
+			"PROCESSING_WINDOW.show",
+			path
+		]];
+	}
+
+	+ (void) setActiveReflexViewController: (id) reflexViewController
+	{
+		active_reflex_view_controller = reflexViewController;
+	}
+
+	+ (void) resetActiveReflexViewController
+	{
+		active_reflex_view_controller = nil;
+	}
+
+@end

data/test/helper.rb

@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+
+
+%w[../xot ../rucy ../rays ../reflex .]
+  .map  {|s| File.expand_path "../../#{s}/lib", __FILE__}
+  .each {|s| $:.unshift s if !$:.include?(s) && File.directory?(s)}
+
+require 'test/unit'
+require 'xot/test'
+require 'processing'
+
+include Xot::Test
+
+
+def assert_equal_vector(v1, v2, delta = 0.000001)
+  assert_in_delta v1.x, v2.x, delta
+  assert_in_delta v1.y, v2.y, delta
+  assert_in_delta v1.z, v2.z, delta
+end

data/test/processing/helper.rb

@@ -0,0 +1,11 @@
+# -*- coding: utf-8 -*-
+
+
+require_relative '../helper'
+
+
+def graphics(width = 10, height = 10, &block)
+  Processing::Processing::Graphics.new(width, height).tap do |g|
+    g.beginDraw {block.call g, g.getInternal__} if block
+  end
+end

data/test/processing/test_graphics.rb

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+
+
+require_relative 'helper'
+
+
+class TestProcessingGraphics < Test::Unit::TestCase
+
+  P = Processing::Processing
+
+  def graphics(w = 10, h = 10)
+    P::Graphics.new w, h
+  end
+
+  def test_beginDraw()
+    g = graphics
+    g.beginDraw
+    assert_raise {g.beginDraw}
+  end
+
+end# TestProcessingGraphics

data/test/processing/test_shader.rb

@@ -0,0 +1,47 @@
+# -*- coding: utf-8 -*-
+
+
+require_relative 'helper'
+
+
+class TestProcessingShader < Test::Unit::TestCase
+
+  def color(*args)
+    Rays::Color.new(*args)
+  end
+
+  def shader(vs = vshader, fs = fshader)
+    Processing::Processing::Shader.new vs, fs
+  end
+
+  def vshader()
+    "void main() {gl_Position = vec4(0.0, 0.0, 0.0, 1.0);}"
+  end
+
+  def fshader()
+    "void main() {gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);}"
+  end
+
+  def test_initialize()
+    assert shader vshader, fshader
+    assert shader nil,     fshader
+
+    assert_raise(ArgumentError) {shader "", fshader}
+    assert_raise(ArgumentError) {shader vshader, ""}
+    assert_raise(ArgumentError) {shader vshader, nil}
+  end
+
+  def test_uniform()
+    sh = shader(nil, <<~END).tap {|s| s.set :val, 1.0}
+      uniform float val;
+      void main() {gl_FragColor = vec4(val, 0.0, 0.0, 1.0);}
+    END
+
+    graphics do |g, image|
+      g.shader sh
+      g.rect 0, 0, 10, 10
+      assert_equal color(1, 0, 0, 1), image[0, 0]
+    end
+  end
+
+end# TestProcessingShader

data/test/processing/test_utility.rb

@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+
+
+require_relative 'helper'
+
+
+class TestProcessingUtility < Test::Unit::TestCase
+
+  P = Processing::Processing
+
+  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
+
+  def test_createShader()
+    fs = "void main() {gl_FragColor = vec4(1.0);}"
+    assert_equal P::Shader, createShader(nil, fs).class
+  end
+
+end# TestProcessingUtility