processing 0.4.0 → 0.5.0

data/lib/processing/vector.rb

@@ -0,0 +1,559 @@
+module Processing
+
+
+  # Vector class.
+  #
+  class Vector
+
+    include Comparable
+
+    # Initialize vector object.
+    #
+    # @overload new()
+    # @overload new(x)
+    # @overload new(x, y)
+    # @overload new(x, y, z)
+    # @overload new(v)
+    # @overload new(a)
+    #
+    # @param x [Numeric] x of vector
+    # @param y [Numeric] y of vector
+    # @param z [Numeric] z of vector
+    # @param v [Vector]  vector object to copy
+    # @param a [Array]   array like [x, y, z]
+    #
+    def initialize(x = 0, y = 0, z = 0, context: nil)
+      @point = case x
+        when Rays::Point then x.dup
+        when Vector      then x.getInternal__.dup
+        when Array       then Rays::Point.new x[0] || 0, x[1] || 0, x[2] || 0
+        else                  Rays::Point.new x    || 0, y    || 0, z    || 0
+        end
+      @context = context || Context.context__
+    end
+
+    # Initializer for dup or clone
+    #
+    def initialize_copy(o)
+      @point = o.getInternal__.dup
+    end
+
+    # Copy vector object
+    #
+    # @return [Vector] duplicated vector object
+    #
+    alias copy dup
+
+    # Sets x, y and z.
+    #
+    # @overload set(x)
+    # @overload set(x, y)
+    # @overload set(x, y, z)
+    # @overload set(v)
+    # @overload set(a)
+    #
+    # @param x [Numeric] x of vector
+    # @param y [Numeric] y of vector
+    # @param z [Numeric] z of vector
+    # @param v [Vector]  vector object to copy
+    # @param a [Array]   array with x, y, z
+    #
+    # @return [nil] nil
+    #
+    def set(*args)
+      initialize(*args)
+      self
+    end
+
+    # Gets x value.
+    #
+    # @return [Numeric] x value of vector
+    #
+    def x()
+      @point.x
+    end
+
+    # Gets y value.
+    #
+    # @return [Numeric] y value of vector
+    #
+    def y()
+      @point.y
+    end
+
+    # Gets z value.
+    #
+    # @return [Numeric] z value of vector
+    #
+    def z()
+      @point.z
+    end
+
+    # Sets x value.
+    #
+    # @return [Numeric] x value of vector
+    #
+    def x=(x)
+      @point.x = x
+    end
+
+    # Sets y value.
+    #
+    # @return [Numeric] y value of vector
+    #
+    def y=(y)
+      @point.y = y
+    end
+
+    # Sets z value.
+    #
+    # @return [Numeric] z value of vector
+    #
+    def z=(z)
+      @point.z = z
+    end
+
+    # Returns the interpolated vector between 2 vectors.
+    #
+    # @overload lerp(v, amount)
+    # @overload lerp(x, y, amount)
+    # @overload lerp(x, y, z, amount)
+    #
+    # @param v      [Vector]  vector to interpolate
+    # @param x      [Numeric] x of vector to interpolate
+    # @param y      [Numeric] y of vector to interpolate
+    # @param z      [Numeric] z of vector to interpolate
+    # @param amount [Numeric] amount to interpolate
+    #
+    # @return [Vector] interporated vector
+    #
+    def lerp(*args, amount)
+      v      = toVector__(*args)
+      self.x = x + (v.x - x) * amount
+      self.y = y + (v.y - y) * amount
+      self.z = z + (v.z - z) * amount
+      self
+    end
+
+    # Returns the interpolated vector between 2 vectors.
+    #
+    # @param v1     [Vector] vector to interpolate
+    # @param v2     [Vector] vector to interpolate
+    # @param amount [Numeric] amount to interpolate
+    #
+    # @return [Vector] interporated vector
+    #
+    def self.lerp(v1, v2, amount)
+      v1.dup.lerp v2, amount
+    end
+
+    # Returns x, y, z as an array
+    #
+    # @return [Array] array of x, y, z
+    #
+    def array()
+      @point.to_a 3
+    end
+
+    # Adds a vector.
+    #
+    # @overload add(v)
+    # @overload add(x, y)
+    # @overload add(x, y, z)
+    #
+    # @param v [Vector] vector to add
+    # @param x [Vector] x of vector to add
+    # @param y [Vector] y of vector to add
+    # @param z [Vector] z of vector to add
+    #
+    # @return [Vector] added vector
+    #
+    def add(*args)
+      @point += toVector__(*args).getInternal__
+      self
+    end
+
+    # Subtracts a vector.
+    #
+    # @overload sub(v)
+    # @overload sub(x, y)
+    # @overload sub(x, y, z)
+    #
+    # @param v [Vector] vector to subtract
+    # @param x [Vector] x of vector to subtract
+    # @param y [Vector] y of vector to subtract
+    # @param z [Vector] z of vector to subtract
+    #
+    # @return [Vector] subtracted vector
+    #
+    def sub(*args)
+      @point -= toVector__(*args).getInternal__
+      self
+    end
+
+    # Multiplies a vector by scalar.
+    #
+    # @param num [Numeric] number to multiply the vector
+    #
+    # @return [Vector] multiplied vector
+    #
+    def mult(num)
+      @point *= num
+      self
+    end
+
+    # Divides a vector by scalar.
+    #
+    # @param num [Numeric] number to divide the vector
+    #
+    # @return [Vector] divided vector
+    #
+    def div(num)
+      @point /= num
+      self
+    end
+
+    # Adds a vector.
+    #
+    # @param v [Vector] vector to add
+    #
+    # @return [Vector] added vector
+    #
+    def +(v)
+      dup.add v
+    end
+
+    # Subtracts a vector.
+    #
+    # @param v [Vector] vector to subtract
+    #
+    # @return [Vector] subtracted vector
+    #
+    def -(v)
+      dup.sub v
+    end
+
+    # Multiplies a vector by scalar.
+    #
+    # @param num [Numeric] number to multiply the vector
+    #
+    # @return [Vector] multiplied vector
+    #
+    def *(num)
+      dup.mult num
+    end
+
+    # Divides a vector by scalar.
+    #
+    # @param num [Numeric] number to divide the vector
+    #
+    # @return [Vector] divided vector
+    #
+    def /(num)
+      dup.div num
+    end
+
+    # Adds 2 vectors.
+    #
+    # @overload add(v1, v2)
+    # @overload add(v1, v2, target)
+    #
+    # @param v1     [Vector] a vector
+    # @param v2     [Vector] another vector
+    # @param target [Vector] vector to store added vector
+    #
+    # @return [Vector] added vector
+    #
+    def self.add(v1, v2, target = nil)
+      v = v1 + v2
+      target.set v if self === target
+      v
+    end
+
+    # Subtracts 2 vectors.
+    #
+    # @overload sub(v1, v2)
+    # @overload sub(v1, v2, target)
+    #
+    # @param v1     [Vector] a vector
+    # @param v2     [Vector] another vector
+    # @param target [Vector] vector to store subtracted vector
+    #
+    # @return [Vector] subtracted vector
+    #
+    def self.sub(v1, v2, target = nil)
+      v = v1 - v2
+      target.set v if self === target
+      v
+    end
+
+    # Multiplies a vector by scalar.
+    #
+    # @overload mult(v, num)
+    # @overload mult(v, num, target)
+    #
+    # @param v      [Vector]  a vector
+    # @param num    [Numeric] number to multiply the vector
+    # @param target [Vector]  vector to store multiplied vector
+    #
+    # @return [Vector] multiplied vector
+    #
+    def self.mult(v1, num, target = nil)
+      v = v1 * num
+      target.set v if self === target
+      v
+    end
+
+    # Divides a vector by scalar.
+    #
+    # @overload div(v, num)
+    # @overload div(v, num, target)
+    #
+    # @param v      [Vector]  a vector
+    # @param num    [Numeric] number to divide the vector
+    # @param target [Vector]  vector to store divided vector
+    #
+    # @return [Vector] divided vector
+    #
+    def self.div(v1, num, target = nil)
+      v = v1 / num
+      target.set v if self === target
+      v
+    end
+
+    # Returns the length of the vector.
+    #
+    # @return [Numeric] length
+    #
+    def mag()
+      @point.length
+    end
+
+    # Returns squared length of the vector.
+    #
+    # @return [Numeric] squared length
+    #
+    def magSq()
+      Rays::Point::dot(@point, @point)
+    end
+
+    # Changes the length of the vector.
+    #
+    # @overload setMag(len)
+    # @overload setMag(target, len)
+    #
+    # @param len    [Numeric] length of new vector
+    # @param target [Vector]  vector to store new vector
+    #
+    # @return [Vector] vector with new length
+    #
+    def setMag(target = nil, len)
+      (target || self).set @point.normal * len
+    end
+
+    # Changes the length of the vector to 1.0.
+    #
+    # @param target [Vector] vector to store the normalized vector
+    #
+    # @return [Vector] normalized vector
+    #
+    def normalize(target = nil)
+      (target || self).set @point.normal
+    end
+
+    # Changes the length of the vector if it's length is greater than the max value.
+    #
+    # @param max [Numeric] max length
+    #
+    # @return [Vector] new vector
+    #
+    def limit(max)
+      setMag max if magSq > max ** 2
+      self
+    end
+
+    # Returns the distance of 2 vectors.
+    #
+    # @param v [Vector] a vector
+    #
+    # @return [Numeric] the distance
+    #
+    def dist(v)
+      (self - v).mag
+    end
+
+    # Returns the distance of 2 vectors.
+    #
+    # @param v1 [Vector] a vector
+    # @param v2 [Vector] another vector
+    #
+    # @return [Numeric] the distance
+    #
+    def self.dist(v1, v2)
+      v1.dist v2
+    end
+
+    # Calculates the dot product of 2 vectors.
+    #
+    # @overload dot(v)
+    # @overload dot(x, y)
+    # @overload dot(x, y, z)
+    #
+    # @param v [Vector] a vector
+    # @param x [Numeric] x of vector
+    # @param y [Numeric] y of vector
+    # @param z [Numeric] z of vector
+    #
+    # @return [Numeric] result of dot product
+    #
+    def dot(*args)
+      Rays::Point::dot getInternal__, toVector__(*args).getInternal__
+    end
+
+    # Calculates the dot product of 2 vectors.
+    #
+    # @param v1 [Vector] a vector
+    # @param v2 [Vector] another vector
+    #
+    # @return [Numeric] result of dot product
+    #
+    def self.dot(v1, v2)
+      v1.dot v2
+    end
+
+    # Calculates the cross product of 2 vectors.
+    #
+    # @overload cross(v)
+    # @overload cross(x, y)
+    # @overload cross(x, y, z)
+    #
+    # @param v [Vector] a vector
+    # @param x [Numeric] x of vector
+    # @param y [Numeric] y of vector
+    # @param z [Numeric] z of vector
+    #
+    # @return [Numeric] result of cross product
+    #
+    def cross(a, *rest)
+      target = self.class === rest.last ? rest.pop : nil
+      v = self.class.new Rays::Point::cross getInternal__, toVector__(a, *rest).getInternal__
+      target.set v if self.class === target
+      v
+    end
+
+    # Calculates the cross product of 2 vectors.
+    #
+    # @param v1 [Vector] a vector
+    # @param v2 [Vector] another vector
+    #
+    # @return [Numeric] result of cross product
+    #
+    def self.cross(v1, v2, target = nil)
+      v1.cross v2, target
+    end
+
+    # Rotate the vector.
+    #
+    # @param angle [Numeric] the angle of rotation
+    #
+    # @return [Vector] rotated this object
+    #
+    def rotate(angle)
+      angle = @context ?
+        @context.toAngle__(angle) : angle * GraphicsContext::RAD2DEG__
+      @point.rotate! angle
+      self
+    end
+
+    # Returns the angle of rotation for this vector.
+    #
+    # @return [Numeric] the angle in radians
+    #
+    def heading()
+      Math.atan2 y, x
+    end
+
+    # Returns rotated new vector.
+    #
+    # @param angle  [Numeric] the angle of rotation
+    # @param target [Vector]  vector to store new vector
+    #
+    # @return [Vector] rotated vector
+    #
+    def self.fromAngle(angle, target = nil)
+      v = self.new(1, 0, 0).rotate(angle)
+      target.set v if target
+      v
+    end
+
+    # Returns angle between 2 vectors.
+    #
+    # @param v1 [Vector] a vector
+    # @param v2 [Vector] another vector
+    #
+    # @return [Numeric] angle in radians
+    #
+    def self.angleBetween(v1, v2)
+      x1, y1, z1 = v1.array
+      x2, y2, z2 = v2.array
+      return 0 if (x1 == 0 && y1 == 0 && z1 == 0) || (x2 == 0 && y2 == 0 && z2 == 0)
+
+      x = dot(v1, v2) / (v1.mag * v2.mag)
+      return Math::PI if x <= -1
+      return 0        if x >= 1
+      return Math.acos x
+    end
+
+    # Returns a new 2D unit vector with a random direction.
+    #
+    # @param target [Vector] a vector to store the new vector
+    #
+    # @return [Vector] a random vector
+    #
+    def self.random2D(target = nil)
+      v = self.fromAngle rand 0.0...(Math::PI * 2)
+      target.set v if target
+      v
+    end
+
+    # Returns a new 3D unit vector with a random direction.
+    #
+    # @param target [Vector] a vector to store the new vector
+    #
+    # @return [Vector] a random vector
+    #
+    def self.random3D(target = nil)
+      angle = rand 0.0...(Math::PI * 2)
+      z     = rand(-1.0..1.0)
+      z2    = z ** 2
+      x     = Math.sqrt(1.0 - z2) * Math.cos(angle)
+      y     = Math.sqrt(1.0 - z2) * Math.sin(angle)
+      v     = self.new x, y, z
+      target.set v if target
+      v
+    end
+
+    # @private
+    def inspect()
+      "<##{self.class.name} #{x}, #{y}, #{z}>"
+    end
+
+    # @private
+    def <=>(o)
+      @point <=> o.getInternal__
+    end
+
+    # @private
+    def getInternal__()
+      @point
+    end
+
+    # @private
+    private def toVector__(*args)
+      self.class === args.first ? args.first : self.class.new(*args)
+    end
+
+  end# Vector
+
+
+end# Processing

data/lib/processing.rb

@@ -1,11 +1,30 @@
-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'
+require 'processing/all'
+
+
+module Processing
+  WINDOW  = Processing::Window.new {start}
+  CONTEXT = Processing::Context.new WINDOW
+
+  refine Object do
+    (CONTEXT.methods - Object.instance_methods).each do |method|
+      define_method method do |*args, **kwargs, &block|
+        CONTEXT.__send__ method, *args, **kwargs, &block
+      end
+    end
+  end
+end# Processing
+
+
+begin
+  w, c = Processing::WINDOW, Processing::CONTEXT
+
+  c.class.constants.each do |const|
+    self.class.const_set const, c.class.const_get(const)
+  end
+
+  w.__send__ :begin_draw
+  at_exit do
+    w.__send__ :end_draw
+    Processing::App.new {w.show}.start if c.hasDrawBlock__ && !$!
+  end
+end

data/lib/rubysketch-processing.rb

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

data/lib/rubysketch.rb

@@ -1 +1 @@
-require 'processing'
+require 'processing/all'

data/processing.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |s|
 
   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.description = 'Creative Coding Framework has API compatible to Processing or p5.js.'
   s.version     = mod.version
 
   s.authors  = %w[xordog]
@@ -28,7 +28,7 @@ Gem::Specification.new do |s|
   s.platform              = Gem::Platform::RUBY
   s.required_ruby_version = '>= 2.7.0'
 
-  s.add_runtime_dependency 'reflexion', '~> 0.1.29'
+  s.add_runtime_dependency 'reflexion', '~> 0.1.30'
 
   s.add_development_dependency 'yard'
 

data/src/RubyProcessing.mm

@@ -34,7 +34,7 @@ ReflexViewController_show (UIViewController*, ReflexViewController*)
 	+ (void) start: (NSString*) path
 	{
 		[CRuby evaluate:[NSString stringWithFormat:@
-			"raise 'already started' unless require 'processing/include'\n"
+			"raise 'already started' unless require 'processing'\n"
 			"load '%@'\n"
 			"PROCESSING_WINDOW.__send__ :end_draw\n"
 			"PROCESSING_WINDOW.show",

data/test/helper.rb

@@ -2,12 +2,12 @@
 
 
 %w[../xot ../rucy ../rays ../reflex .]
-  .map  {|s| File.expand_path "../../#{s}/lib", __FILE__}
+  .map  {|s| File.expand_path "../#{s}/lib", __dir__}
   .each {|s| $:.unshift s if !$:.include?(s) && File.directory?(s)}
 
 require 'test/unit'
 require 'xot/test'
-require 'processing'
+require 'processing/all'
 
 include Xot::Test
 
@@ -17,3 +17,9 @@ def assert_equal_vector(v1, v2, delta = 0.000001)
   assert_in_delta v1.y, v2.y, delta
   assert_in_delta v1.z, v2.z, delta
 end
+
+def graphics(width = 10, height = 10, &block)
+  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 → test_graphics.rb}

@@ -4,9 +4,9 @@
 require_relative 'helper'
 
 
-class TestProcessingGraphics < Test::Unit::TestCase
+class TestGraphics < Test::Unit::TestCase
 
-  P = Processing::Processing
+  P = Processing
 
   def graphics(w = 10, h = 10)
     P::Graphics.new w, h
@@ -18,4 +18,4 @@ class TestProcessingGraphics < Test::Unit::TestCase
     assert_raise {g.beginDraw}
   end
 
-end# TestProcessingGraphics
+end# TestGraphics

data/test/{processing/test_shader.rb → test_shader.rb}

@@ -4,14 +4,14 @@
 require_relative 'helper'
 
 
-class TestProcessingShader < Test::Unit::TestCase
+class TestShader < Test::Unit::TestCase
 
   def color(*args)
     Rays::Color.new(*args)
   end
 
   def shader(vs = vshader, fs = fshader)
-    Processing::Processing::Shader.new vs, fs
+    Processing::Shader.new vs, fs
   end
 
   def vshader()
@@ -44,4 +44,4 @@ class TestProcessingShader < Test::Unit::TestCase
     end
   end
 
-end# TestProcessingShader
+end# TestShader

data/test/{processing/test_utility.rb → test_utility.rb}

@@ -4,9 +4,9 @@
 require_relative 'helper'
 
 
-class TestProcessingUtility < Test::Unit::TestCase
+class TestUtility < Test::Unit::TestCase
 
-  P = Processing::Processing
+  P = Processing
 
   include P::GraphicsContext
 
@@ -38,4 +38,4 @@ class TestProcessingUtility < Test::Unit::TestCase
     assert_equal P::Shader, createShader(nil, fs).class
   end
 
-end# TestProcessingUtility
+end# TestUtility