rubysketch 0.3.2 → 0.3.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 83aecf951db1320693714768446ccc95aa0a87f23012e02fff31b032c88be3c6
-  data.tar.gz: 6d1f67cbe65c15468cb606666acceacf19f56bf8c83dd1abae2a1b21d7daf94b
+  metadata.gz: 41b3a75aeb6c8bdc443d2d87e44c60361a527e4d6b8b3918e8b1eaa2503f92e4
+  data.tar.gz: 7f373d0f3fdb31d38bb76d8e8ed88ce2f3cedca0c696d8a5f571ded1e78fb15d
 SHA512:
-  metadata.gz: 9946ba3029ce56a90042daa9be9e6c2f74f5d7ef7d318b5263b10c03ca35c26f5f7e67c61e6f78bd90f4224c267f732dcb937d86030adbe2b0ac51350a225f6e
-  data.tar.gz: 627eb17aa1e83da474f9ab9457b449b278ecf95d84956f98b82d3185c6bc87fa9b5788ad65c1144f80364171b14a4f7322d86a42066925ccbca8f2e19ff46cc3
+  metadata.gz: ffcba1a2e5ae98525c4c1512230d249995071e6be9183918b6f62ed5293d9ac8f530d38aa5f544d2d4fc431ca17f38c7746955df313e9609e0ee528551045a51
+  data.tar.gz: cb49daa453cdf6dd9027a59c508363a63fed2e210b0acbcfa311e66334b107a88471e5b8b59dac7f77b5aa04423aaa2d0cd2b2fa0c4b1221b76997a93ce89e79

data/.github/workflows/release.yml

@@ -0,0 +1,62 @@
+name: Release
+
+on:
+  push:
+    tags: ['v[0-9]*']
+
+jobs:
+  release:
+    runs-on: macos-latest
+
+    steps:
+      - name: checkout
+        uses: actions/checkout@v2
+
+      - name: ruby 2.6
+        uses: actions/setup-ruby@v1
+        with:
+          ruby-version: 2.6.x
+
+      - name: install gems
+        run: |
+          gem install bundler
+          bundle install --jobs 4 --retry 3
+
+      - name: version
+        id: version
+        run: |
+          echo ::set-output name=value::$(ruby -e 'print "${{ github.ref }}"[/\/v([\w\.\-]+)/, 1]')
+
+      - name: create gem
+        run: rake clean gem
+
+      - name: create release
+        id: create_release
+        uses: actions/create-release@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          tag_name: ${{ github.ref }}
+          release_name: ${{ github.ref }}
+          draft: false
+          prerelease: false
+
+      - name: upload to releases
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: ./rubysketch-${{ steps.version.outputs.value }}.gem
+          asset_name:   rubysketch-${{ steps.version.outputs.value }}.gem
+          asset_content_type: application/zip
+
+      - name: upload to rubygems
+        env:
+          GEM_HOST_API_KEY: ${{ secrets.RUBYGEMS_AUTH_TOKEN }}
+        run: |
+          mkdir -p $HOME/.gem
+          touch $HOME/.gem/credentials
+          chmod 0600 $HOME/.gem/credentials
+          printf -- "---\n:rubygems_api_key: ${GEM_HOST_API_KEY}\n" > $HOME/.gem/credentials
+          rake upload

data/.github/workflows/test.yml

@@ -0,0 +1,27 @@
+name: Test
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    branches: [master]
+
+jobs:
+  test:
+    runs-on: macos-latest
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: ruby 2.6
+        uses: actions/setup-ruby@v1
+        with:
+          ruby-version: 2.6.x
+
+      - name: install gems
+        run: |
+          gem install bundler
+          bundle install --jobs 4 --retry 3
+
+      - name: test
+        run: rake test

data/ChangeLog.md

@@ -1,6 +1,39 @@
 # RubySketch ChangeLog
 
 
+## [0.3.7] - 2020-11-18
+
+- add Capture class
+- add log(), exp(), sqrt() and PI
+- add examples/camera.rb
+- add examples/breakout.rb
+- fix error on calling image()
+
+
+## [0.3.6] - 2020-08-02
+
+- random() can take array or nothing
+- use github actions to release gem package
+
+
+## [0.3.5] - 2020-08-02
+
+- add random()
+- add sin(), cos(), tan(), asin(), acos(), atan() and atan2()
+- make Vector class accessible from user script context
+- fix error on calling rotate()
+
+
+## [0.3.4] - 2020-08-02
+
+- delete Utility module
+
+
+## [0.3.3] - 2020-08-01
+
+- add Vector class
+
+
 ## [0.3.2] - 2020-07-22
 
 - text() draws to the baseline by default

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+gem 'yard'
+gem 'reflexion'

data/Rakefile

@@ -18,6 +18,7 @@ MODULES = [Xot, Rucy, Rays, Reflex, RubySketch]
 
 ENV['RDOC'] = 'yardoc --no-private'
 
+test_ruby_extension
 generate_documents
 build_ruby_gem
 

data/VERSION

@@ -1 +1 @@
-0.3.2
+0.3.7

data/examples/breakout.rb

@@ -0,0 +1,212 @@
+%w[xot rays reflex rubysketch]
+  .map  {|s| File.expand_path "../../#{s}/lib", __dir__}
+  .each {|s| $:.unshift s if !$:.include?(s) && File.directory?(s)}
+
+require 'rubysketch-processing'
+
+
+PADDING = 50
+BRICK_COUNT = 10
+
+$objs = []
+$bar = nil
+$gameover = false
+
+setup do
+  addWalls
+  addBricks
+
+  colorMode HSB, 360, 100, 100
+  ellipseMode CORNER
+  background 0
+  noStroke
+  fill 0, 0, 100
+end
+
+draw do
+  background 0
+  $objs.each do |o|
+    o.update
+    o.draw
+  end
+  drawTexts
+end
+
+mousePressed do
+  start unless started?
+end
+
+mouseDragged do
+  $bar.pos.x = mouseX - $bar.w / 2 if $bar
+end
+
+def start()
+  $bar = Bar.new
+  $objs += [$bar, Ball.new($bar)]
+end
+
+def started?()
+  $bar
+end
+
+def gameover?()
+  started? &&
+    $objs.count {|o| o.kind_of? Ball} == 0
+end
+
+def cleared?()
+  started? && !gameover? &&
+    $objs.count {|o| o.kind_of? Brick} == 0
+end
+
+def addWalls()
+  left = Obj.new 0, 0, 10, height
+  top = Obj.new 0, 0, width, 10
+  right = Obj.new width - 10, 0, 10, height
+  bottom = Bottom.new 0, height - 10, width, 10
+  $objs += [top, bottom, left, right]
+end
+
+def addBricks()
+  brickW = (width - PADDING * 2) / BRICK_COUNT
+  5.times do |y|
+    BRICK_COUNT.times do |x|
+      xx = PADDING + brickW * x
+      yy = PADDING + 30 * y
+      $objs.push Brick.new(xx, yy, brickW - 5, 20, y * 60)
+    end
+  end
+end
+
+def drawTexts()
+  push do
+    textAlign CENTER, CENTER
+
+    if !started?
+      fill 50, 100, 100
+      textSize 50
+      text "BREAKOUT", 0, 0, width, height
+      textSize 20
+      translate 0, 100
+      text "Tap to start!", 0, 0, width, height
+    elsif cleared?
+      fill 100, 80, 100
+      textSize 50
+      text "CLEAR!", 0, 0, width, height
+    elsif gameover?
+      fill 0, 20, 100
+      textSize 50
+      text "GAMEOVER", 0, 0, width, height
+    end
+  end
+end
+
+class Obj
+  attr_reader :pos, :w, :h, :vel
+
+  def initialize(x, y, w, h, vx = 0, vy = 0)
+    @pos = createVector x, y
+    @w, @h = w, h
+    @vel = createVector vx, vy
+  end
+
+  def update()
+    @pos.add @vel
+  end
+
+  def draw()
+    rect @pos.x, @pos.y, @w, @h
+  end
+
+  def bounds()
+    x, y = @pos.x, @pos.y
+    return x, y, x + @w, y + @h
+  end
+
+  def center()
+    createVector @pos.x + @w / 2, @pos.y + @h / 2
+  end
+end
+
+class Ball < Obj
+  def initialize(bar)
+    super bar.pos.x, bar.pos.y - bar.h, 20, 20
+    self.vel = createVector random(-1, 1), -1
+  end
+
+  def vel=(v)
+    @vel = v.dup.normalize.mult 8
+  end
+
+  def update()
+    b = bounds.dup
+    super
+    checkHit b
+  end
+
+  def checkHit(prevBounds)
+    x1, y1, x2, y2 = prevBounds
+    hitH = hitV = false
+    hits = []
+    $objs.each do |o|
+      next if o == self
+      next unless intersect? o
+      hits.push o
+      ox1, oy1, ox2, oy2 = o.bounds
+      hitH ||= !overlap?(x1, x2, ox1, ox2)
+      hitV ||= !overlap?(y1, y2, oy1, oy2)
+    end
+    vel.x *= -1 if hitH
+    vel.y *= -1 if hitV
+
+    hits.each {|o| hit o}
+  end
+
+  def intersect?(o)
+    x1, y1, x2, y2 = bounds
+    ox1, oy1, ox2, oy2 = o.bounds
+    overlap?(x1, x2, ox1, ox2) && overlap?(y1, y2, oy1, oy2)
+  end
+
+  def overlap?(a1, a2, b1, b2)
+    a1 <= b2 && b1 <= a2
+  end
+
+  def hit(o)
+    case o
+    when Bar then self.vel = center.sub o.center
+    when Brick then $objs.delete o
+    when Bottom then $objs.delete self unless cleared?
+    end
+  end
+end
+
+class Bar < Obj
+  def initialize()
+    w = 100
+    super (width - w) / 2, height - 50, w, 20
+  end
+end
+
+class Brick < Obj
+  def initialize(x, y, w, h, hue)
+    super x, y, w, h
+    @hue = hue
+  end
+
+  def draw()
+    push do
+      fill @hue, 50, 100
+      super
+    end
+  end
+end
+
+class Bottom < Obj
+  def draw()
+    push do
+      fill 0, 0, 50
+      super
+    end
+  end
+end

data/examples/camera.rb

@@ -0,0 +1,14 @@
+%w[xot rays reflex rubysketch]
+  .map  {|s| File.expand_path "../../#{s}/lib", __dir__}
+  .each {|s| $:.unshift s if !$:.include?(s) && File.directory?(s)}
+
+require 'rubysketch-processing'
+
+
+cam = Capture.new
+cam.start
+
+draw do
+  background 0
+  image cam, 0, 0
+end

data/lib/rubysketch-processing.rb

@@ -2,10 +2,18 @@ require 'rubysketch'
 
 
 begin
-  include RubySketch::Processing::Context
+  window  = RubySketch::Window.new {start}
+  context = RubySketch::Processing::Context.new window
 
-  window = RubySketch::Window.new {start}
-  setup__ window
+  (context.methods - Object.instance_methods).each do |method|
+    define_method method do |*args, &block|
+      context.__send__ method, *args, &block
+    end
+  end
+
+  context.class.constants.each do |const|
+    self.class.const_set const, context.class.const_get(const)
+  end
 
   window.__send__ :begin_draw
   at_exit do

data/lib/rubysketch/processing.rb

@@ -6,13 +6,574 @@ module RubySketch
   module Processing
 
 
+    # @private
+    DEG2RAD__ = Math::PI / 180.0
+
+    # @private
+    RAD2DEG__ = 180.0 / Math::PI
+
+
+    # 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 * 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
+      protected def getInternal__ ()
+        @point
+      end
+
+      # @private
+      private def toVector__ (*args)
+        self.class === args.first ? args.first : self.class.new(*args)
+      end
+
+    end# Vector
+
+
     # Image object.
     #
     class Image
 
       # @private
       def initialize (image)
-        @image__ = image
+        @image = image
       end
 
       # Gets width of image.
@@ -20,7 +581,7 @@ module RubySketch
       # @return [Numeric] width of image
       #
       def width ()
-        @image__.width
+        @image.width
       end
 
       # Gets height of image.
@@ -28,7 +589,7 @@ module RubySketch
       # @return [Numeric] height of image
       #
       def height ()
-        @image__.height
+        @image.height
       end
 
       # Resizes image.
@@ -39,8 +600,8 @@ module RubySketch
       # @return [nil] nil
       #
       def resize (width, height)
-        @image__ = Rays::Image.new(width, height).paint do |painter|
-          painter.image @image__, 0, 0, width, height
+        @image = Rays::Image.new(width, height).paint do |painter|
+          painter.image @image, 0, 0, width, height
         end
         nil
       end
@@ -64,7 +625,7 @@ module RubySketch
       #
       def copy (img = nil, sx, sy, sw, sh, dx, dy, dw, dh)
         img ||= self
-        @image__.paint do |painter|
+        @image.paint do |painter|
           painter.image img.getInternal__, sx, sy, sw, sh, dx, dy, dw, dh
         end
       end
@@ -74,12 +635,12 @@ module RubySketch
       # @param filename [String] file name to save image
       #
       def save (filename)
-        @image__.save filename
+        @image.save filename
       end
 
       # @private
       def getInternal__ ()
-        @image__
+        @image
       end
 
     end# Image
@@ -167,43 +728,110 @@ module RubySketch
     end# Touch
 
 
-    # Drawing context
+    # Camera object.
     #
-    module GraphicsContext
+    class Capture
 
-      # PI / 2
+      # Returns a list of available camera device names
       #
-      HALF_PI    = Math::PI / 2
-
-      # PI / 4
+      # @return [Array] device name list
       #
-      QUARTER_PI = Math::PI / 4
+      def self.list ()
+        ['default']
+      end
 
-      # PI * 2
+      # Initialize camera object.
       #
-      TWO_PI     = Math::PI * 2
+      def initialize ()
+        @camera = Rays::Camera.new
+      end
 
-      # PI * 2
+      # Start capturing.
       #
-      TAU        = Math::PI * 2
-
-      # RGB mode for colorMode().
+      # @return [Capture] self
       #
-      RGB = :RGB
+      def start ()
+        raise "Failed to start capture" unless @camera.start
+        self
+      end
 
-      # HSB mode for colorMode().
+      # Stop capturing.
       #
-      HSB = :HSB
-
-      # Radian mode for angleMode().
+      # @return [nil] nil
       #
-      RADIANS = :RADIANS
+      def stop ()
+        @camera.stop
+        nil
+      end
 
-      # Degree mode for angleMode().
+      # Returns is the next captured image available?
       #
-      DEGREES = :DEGREES
-
-      # Mode for rectMode(), ellipseMode() and imageMode().
+      # @return [Boolean] true means object has next frame
+      #
+      def available ()
+        @camera.active?
+      end
+
+      # Reads next frame image
+      #
+      def read ()
+        @camera.image
+      end
+
+      # @private
+      def getInternal__ ()
+        @camera.image || dummyImage__
+      end
+
+      # @private
+      private def dummyImage__ ()
+        @dummy ||= Rays::Image.new 1, 1
+      end
+
+    end# Capture
+
+
+    # Drawing context
+    #
+    module GraphicsContext
+
+      # PI
+      #
+      PI         = Math::PI
+
+      # PI / 2
+      #
+      HALF_PI    = PI / 2
+
+      # PI / 4
+      #
+      QUARTER_PI = PI / 4
+
+      # PI * 2
+      #
+      TWO_PI     = PI * 2
+
+      # PI * 2
+      #
+      TAU        = PI * 2
+
+      # RGB mode for colorMode().
+      #
+      RGB = :RGB
+
+      # HSB mode for colorMode().
+      #
+      HSB = :HSB
+
+      # Radian mode for angleMode().
+      #
+      RADIANS = :RADIANS
+
+      # Degree mode for angleMode().
+      #
+      DEGREES = :DEGREES
+
+      # Mode for rectMode(), ellipseMode() and imageMode().
       #
       CORNER  = :CORNER
 
@@ -254,7 +882,7 @@ module RubySketch
         @painter__             = painter
         @painter__.miter_limit = 10
 
-        @drawing       = false
+        @drawing__     = false
         @hsbColor__    = false
         @colorMaxes__  = [1.0] * 4
         @angleScale__  = 1.0
@@ -280,11 +908,11 @@ module RubySketch
       def beginDraw ()
         @matrixStack__.clear
         @styleStack__.clear
-        @drawing = true
+        @drawing__ = true
       end
 
       def endDraw ()
-        @drawing = false
+        @drawing__ = false
       end
 
       def width ()
@@ -361,7 +989,7 @@ module RubySketch
       #
       def angleMode (mode)
         @angleScale__ = case mode.upcase.to_sym
-          when RADIANS then Utility::RAD2DEG__
+          when RADIANS then RAD2DEG__
           when DEGREES then 1.0
           else raise ArgumentError, "invalid angle mode: #{mode}"
           end
@@ -369,7 +997,7 @@ module RubySketch
       end
 
       # @private
-      private def toAngle__ (angle)
+      def toAngle__ (angle)
         angle * @angleScale__
       end
 
@@ -848,8 +1476,9 @@ module RubySketch
       #
       def image (img, a, b, c = nil, d = nil)
         assertDrawing__
-        x, y, w, h = toXYWH__ @imageMode__, a, b, c || img.width, d || img.height
-        @painter__.image img.getInternal__, x, y, w, h
+        i = img.getInternal__
+        x, y, w, h = toXYWH__ @imageMode__, a, b, c || i.width, d || i.height
+        @painter__.image i, x, y, w, h
         nil
       end
 
@@ -1030,8 +1659,8 @@ module RubySketch
       end
 
       # @private
-      def assertDrawing__ ()
-        raise "call beginDraw() before drawing" unless @drawing
+      private def assertDrawing__ ()
+        raise "call beginDraw() before drawing" unless @drawing__
       end
 
     end# GraphicsContext
@@ -1043,17 +1672,23 @@ module RubySketch
 
       include GraphicsContext
 
+      # Initialize graphics object.
+      #
       def initialize (width, height)
         @image__ = Rays::Image.new width, height
         setup__ @image__.painter
       end
 
+      # Start drawing.
+      #
       def beginDraw ()
         @painter__.__send__ :begin_paint
         super
         push
       end
 
+      # End drawing.
+      #
       def endDraw ()
         pop
         super
@@ -1063,86 +1698,325 @@ module RubySketch
     end# Graphics
 
 
-    module Utility
+    # Processing context
+    #
+    class Context
 
-      # @private
-      DEG2RAD__ = Math::PI / 180.0
+      include GraphicsContext
+
+      Vector   = Processing::Vector
+      Capture  = Processing::Capture
+      Graphics = Processing::Graphics
+
+      @@context__ = nil
+
+      def self.context__ ()
+        @@context__
+      end
 
       # @private
-      RAD2DEG__ = 180.0 / Math::PI
+      def initialize (window)
+        @@context__ = self
 
-      # Converts degree to radian.
-      #
-      # @param degree [Numeric] degree to convert
-      #
-      # @return [Numeric] radian
-      #
-      def radians (degree)
-        degree * DEG2RAD__
+        @window__ = window
+        @image__  = @window__.canvas
+        setup__ @window__.canvas_painter.paint {background 0.8}
+
+        @loop__         = true
+        @redraw__       = false
+        @frameCount__   = 0
+        @mousePos__     =
+        @mousePrevPos__ = Rays::Point.new 0
+        @mousePressed__ = false
+        @touches__      = []
+
+        @window__.before_draw = proc {beginDraw}
+        @window__.after_draw  = proc {endDraw}
+
+        drawFrame = -> {
+          @image__   = @window__.canvas
+          @painter__ = @window__.canvas_painter
+          begin
+            push
+            @drawBlock__.call if @drawBlock__
+          ensure
+            pop
+            @frameCount__ += 1
+          end
+        }
+
+        @window__.draw = proc do |e|
+          if @loop__ || @redraw__
+            @redraw__ = false
+            drawFrame.call
+          end
+          @mousePrevPos__ = @mousePos__
+        end
+
+        updatePointerStates = -> event, pressed = nil {
+          @mousePos__     = event.pos
+          @mousePressed__ = pressed if pressed != nil
+          @touches__      = event.positions.map {|pos| Touch.new pos.x, pos.y}
+        }
+
+        @window__.pointer_down = proc do |e|
+          updatePointerStates.call e, true
+          (@touchStartedBlock__ || @mousePressedBlock__)&.call
+        end
+
+        @window__.pointer_up = proc do |e|
+          updatePointerStates.call e, false
+          (@touchEndedBlock__ || @mouseReleasedBlock__)&.call
+        end
+
+        @window__.pointer_move = proc do |e|
+          updatePointerStates.call e
+          (@touchMovedBlock__ || @mouseMovedBlock__)&.call
+        end
+
+        @window__.pointer_drag = proc do |e|
+          updatePointerStates.call e
+          (@touchMovedBlock__ || @mouseDraggedBlock__)&.call
+        end
       end
 
-      # Converts radian to degree.
-      #
-      # @param radian [Numeric] radian to convert
-      #
-      # @return [Numeric] degree
+      # Define setup block.
       #
-      def degrees (radian)
-        radian * RAD2DEG__
+      def setup (&block)
+        @window__.setup = block
+        nil
       end
 
-      # Returns the absolute number of the value.
+      # Define draw block.
       #
-      # @param value [Numeric] number
+      def draw (&block)
+        @drawBlock__ = block if block
+        nil
+      end
+
+      def key (&block)
+        @window__.key = block
+        nil
+      end
+
+      def mousePressed (&block)
+        @mousePressedBlock__ = block if block
+        @mousePressed__
+      end
+
+      def mouseReleased (&block)
+        @mouseReleasedBlock__ = block if block
+        nil
+      end
+
+      def mouseMoved (&block)
+        @mouseMovedBlock__ = block if block
+        nil
+      end
+
+      def mouseDragged (&block)
+        @mouseDraggedBlock__ = block if block
+        nil
+      end
+
+      def touchStarted (&block)
+        @touchStartedBlock__ = block if block
+        nil
+      end
+
+      def touchEnded (&block)
+        @touchEndedBlock__ = block if block
+        nil
+      end
+
+      def touchMoved (&block)
+        @touchMovedBlock__ = block if block
+        nil
+      end
+
+      # @private
+      private def size__ (width, height)
+        raise 'size() must be called on startup or setup block' if @started__
+
+        @painter__.__send__ :end_paint
+        @window__.__send__ :reset_canvas, width, height
+        @painter__.__send__ :begin_paint
+
+        @auto_resize__ = false
+      end
+
+      def windowWidth ()
+        @window__.width
+      end
+
+      def windowHeight ()
+        @window__.height
+      end
+
+      # Returns number of frames since program started.
       #
-      # @return [Numeric] absolute number
+      # @return [Integer] total number of frames
       #
-      def abs (value)
-        value.abs
+      def frameCount ()
+        @frameCount__
       end
 
-      # Returns the closest integer number greater than or equal to the value.
-      #
-      # @param value [Numeric] number
+      # Returns number of frames per second.
       #
-      # @return [Numeric] rounded up number
+      # @return [Float] frames per second
       #
-      def ceil (value)
-        value.ceil
+      def frameRate ()
+        @window__.event.fps
       end
 
-      # Returns the closest integer number less than or equal to the value.
-      #
-      # @param value [Numeric] number
+      # Returns pixel density
       #
-      # @return [Numeric] rounded down number
+      # @return [Numeric] pixel density
       #
-      def floor (value)
-        value.floor
+      def displayDensity ()
+        @painter__.pixel_density
       end
 
-      # Returns the closest integer number.
-      #
-      # @param value [Numeric] number
+      # Returns mouse x position
       #
-      # @return [Numeric] rounded number
+      # @return [Numeric] horizontal position of mouse
       #
-      def round (value)
-        value.round
+      def mouseX ()
+        @mousePos__.x
       end
 
-      # Returns value raised to the power of exponent.
-      #
-      # @param value    [Numeric] base number
-      # @param exponent [Numeric] exponent number
+      # Returns mouse y position
       #
-      # @return [Numeric] value ** exponent
+      # @return [Numeric] vertical position of mouse
       #
-      def pow (value, exponent)
-        value ** exponent
+      def mouseY ()
+        @mousePos__.y
       end
 
-      # Returns squared value.
+      # Returns mouse x position in previous frame
+      #
+      # @return [Numeric] horizontal position of mouse
+      #
+      def pmouseX ()
+        @mousePrevPos__.x
+      end
+
+      # Returns mouse y position in previous frame
+      #
+      # @return [Numeric] vertical position of mouse
+      #
+      def pmouseY ()
+        @mousePrevPos__.y
+      end
+
+      # Returns array of touches
+      #
+      # @return [Array] Touch objects
+      #
+      def touches ()
+        @touches__
+      end
+
+      # Enables calling draw block on every frame.
+      #
+      # @return [nil] nil
+      #
+      def loop ()
+        @loop__ = true
+      end
+
+      # Disables calling draw block on every frame.
+      #
+      # @return [nil] nil
+      #
+      def noLoop ()
+        @loop__ = false
+      end
+
+      # Calls draw block to redraw frame.
+      #
+      # @return [nil] nil
+      #
+      def redraw ()
+        @redraw__ = true
+      end
+
+      #
+      # Utilities
+      #
+
+      # Returns the absolute number of the value.
+      #
+      # @param value [Numeric] number
+      #
+      # @return [Numeric] absolute number
+      #
+      def abs (value)
+        value.abs
+      end
+
+      # Returns the closest integer number greater than or equal to the value.
+      #
+      # @param value [Numeric] number
+      #
+      # @return [Numeric] rounded up number
+      #
+      def ceil (value)
+        value.ceil
+      end
+
+      # Returns the closest integer number less than or equal to the value.
+      #
+      # @param value [Numeric] number
+      #
+      # @return [Numeric] rounded down number
+      #
+      def floor (value)
+        value.floor
+      end
+
+      # Returns the closest integer number.
+      #
+      # @param value [Numeric] number
+      #
+      # @return [Numeric] rounded number
+      #
+      def round (value)
+        value.round
+      end
+
+      # Returns the natural logarithm (the base-e logarithm) of a number.
+      #
+      # @param value [Numeric] number (> 0.0)
+      #
+      # @return [Numeric] result number
+      #
+      def log (n)
+        Math.log n
+      end
+
+      # Returns Euler's number e raised to the power of value.
+      #
+      # @param value [Numeric] number
+      #
+      # @return [Numeric] result number
+      #
+      def exp (n)
+        Math.exp n
+      end
+
+      # Returns value raised to the power of exponent.
+      #
+      # @param value    [Numeric] base number
+      # @param exponent [Numeric] exponent number
+      #
+      # @return [Numeric] value ** exponent
+      #
+      def pow (value, exponent)
+        value ** exponent
+      end
+
+      # Returns squared value.
       #
       # @param value [Numeric] number
       #
@@ -1152,6 +2026,16 @@ module RubySketch
         value * value
       end
 
+      # Returns squared value.
+      #
+      # @param value [Numeric] number
+      #
+      # @return [Numeric] squared value
+      #
+      def sqrt (value)
+        Math.sqrt value
+      end
+
       # Returns the magnitude (or length) of a vector.
       #
       # @overload mag(x, y)
@@ -1284,292 +2168,199 @@ module RubySketch
         value < min ? min : (value > max ? max : value)
       end
 
-      # Returns the perlin noise value.
-      #
-      # @overload noise(x)
-      # @overload noise(x, y)
-      # @overload noise(x, y, z)
+      # Converts degree to radian.
       #
-      # @param x [Numeric] horizontal point in noise space
-      # @param y [Numeric] vertical point in noise space
-      # @param z [Numeric] depth point in noise space
+      # @param degree [Numeric] degree to convert
       #
-      # @return [Numeric] noise value (0.0..1.0)
+      # @return [Numeric] radian
       #
-      def noise (x, y = 0, z = 0)
-        Rays.perlin(x, y, z) / 2.0 + 0.5
+      def radians (degree)
+        degree * DEG2RAD__
       end
 
-      # Loads image.
+      # Converts radian to degree.
       #
-      # @param filename  [String] file name to load image
-      # @param extension [String] type of image to load (ex. 'png')
+      # @param radian [Numeric] radian to convert
       #
-      # @return [Image] loaded image object
+      # @return [Numeric] degree
       #
-      def loadImage (filename, extension = nil)
-        filename = getImage__ filename, extension if filename =~ %r|^https?://|
-        Image.new Rays::Image.load filename
-      end
-
-      # @private
-      private def getImage__ (uri, ext)
-        ext ||= File.extname uri
-        raise "unsupported image type -- #{ext}" unless ext =~ /^\.?(png)$/i
-
-        tmpdir = Pathname(Dir.tmpdir) + Digest::SHA1.hexdigest(self.class.name)
-        path   = tmpdir + Digest::SHA1.hexdigest(uri)
-        path   = path.sub_ext ext
-
-        unless path.file?
-          URI.open uri do |input|
-            tmpdir.mkdir unless tmpdir.directory?
-            path.open('w') do |output|
-              while buf = input.read(2 ** 16)
-                output.write buf
-              end
-            end
-          end
-        end
-        path.to_s
-      end
-
-      def createGraphics (width, height)
-        Graphics.new width, height
-      end
-
-    end# Utility
-
-
-    # Processing context
-    #
-    module Context
-
-      include GraphicsContext, Utility, Math
-
-      # @private
-      def setup__ (window)
-        @window__ = window
-        @image__  = @window__.canvas
-        super @window__.canvas_painter.paint {background 0.8}
-
-        @loop__         = true
-        @redraw__       = false
-        @frameCount__   = 0
-        @mousePos__     =
-        @mousePrevPos__ = Rays::Point.new 0
-        @mousePressed__ = false
-        @touches__      = []
-
-        @window__.before_draw = proc {beginDraw}
-        @window__.after_draw  = proc {endDraw}
-
-        drawFrame = -> {
-          @image__   = @window__.canvas
-          @painter__ = @window__.canvas_painter
-          begin
-            push
-            @drawBlock__.call if @drawBlock__
-          ensure
-            pop
-            @frameCount__ += 1
-          end
-        }
-
-        @window__.draw = proc do |e|
-          if @loop__ || @redraw__
-            @redraw__ = false
-            drawFrame.call
-          end
-          @mousePrevPos__ = @mousePos__
-        end
-
-        updatePointerStates = -> event, pressed = nil {
-          @mousePos__     = event.pos
-          @mousePressed__ = pressed if pressed != nil
-          @touches__      = event.positions.map {|pos| Touch.new pos.x, pos.y}
-        }
-
-        @window__.pointer_down = proc do |e|
-          updatePointerStates.call e, true
-          (@touchStartedBlock__ || @mousePressedBlock__)&.call
-        end
-
-        @window__.pointer_up = proc do |e|
-          updatePointerStates.call e, false
-          (@touchEndedBlock__ || @mouseReleasedBlock__)&.call
-        end
-
-        @window__.pointer_move = proc do |e|
-          updatePointerStates.call e
-          (@touchMovedBlock__ || @mouseMovedBlock__)&.call
-        end
-
-        @window__.pointer_drag = proc do |e|
-          updatePointerStates.call e
-          (@touchMovedBlock__ || @mouseDraggedBlock__)&.call
-        end
+      def degrees (radian)
+        radian * RAD2DEG__
       end
 
-      # Define setup block.
+      # Returns the sine of an angle.
       #
-      def setup (&block)
-        @window__.setup = block
-        nil
-      end
-
-      # Define draw block.
+      # @param angle [Numeric] angle in radians
       #
-      def draw (&block)
-        @drawBlock__ = block if block
-        nil
-      end
-
-      def key (&block)
-        @window__.key = block
-        nil
-      end
-
-      def mousePressed (&block)
-        @mousePressedBlock__ = block if block
-        @mousePressed__
-      end
-
-      def mouseReleased (&block)
-        @mouseReleasedBlock__ = block if block
-        nil
-      end
-
-      def mouseMoved (&block)
-        @mouseMovedBlock__ = block if block
-        nil
-      end
-
-      def mouseDragged (&block)
-        @mouseDraggedBlock__ = block if block
-        nil
-      end
-
-      def touchStarted (&block)
-        @touchStartedBlock__ = block if block
-        nil
-      end
-
-      def touchEnded (&block)
-        @touchEndedBlock__ = block if block
-        nil
-      end
-
-      def touchMoved (&block)
-        @touchMovedBlock__ = block if block
-        nil
-      end
-
-      # @private
-      private def size__ (width, height)
-        raise 'size() must be called on startup or setup block' if @started__
-
-        @painter__.__send__ :end_paint
-        @window__.__send__ :reset_canvas, width, height
-        @painter__.__send__ :begin_paint
-
-        @auto_resize__ = false
-      end
-
-      def windowWidth ()
-        @window__.width
+      # @return [Numeric] the sine
+      #
+      def sin (angle)
+        Math.sin angle
       end
 
-      def windowHeight ()
-        @window__.height
+      # Returns the cosine of an angle.
+      #
+      # @param angle [Numeric] angle in radians
+      #
+      # @return [Numeric] the cosine
+      #
+      def cos (angle)
+        Math.cos angle
       end
 
-      # Returns number of frames since program started.
+      # Returns the ratio of the sine and cosine of an angle.
       #
-      # @return [Integer] total number of frames
+      # @param angle [Numeric] angle in radians
       #
-      def frameCount ()
-        @frameCount__
+      # @return [Numeric] the tangent
+      #
+      def tan (angle)
+        Math.tan angle
       end
 
-      # Returns number of frames per second.
+      # Returns the inverse of sin().
       #
-      # @return [Float] frames per second
+      # @param value [Numeric] value for calculation
       #
-      def frameRate ()
-        @window__.event.fps
+      # @return [Numeric] the arc sine
+      #
+      def asin (value)
+        Math.asin value
       end
 
-      # Returns pixel density
+      # Returns the inverse of cos().
       #
-      # @return [Numeric] pixel density
+      # @param value [Numeric] value for calculation
       #
-      def displayDensity ()
-        @painter__.pixel_density
+      # @return [Numeric] the arc cosine
+      #
+      def acos (value)
+        Math.acos value
       end
 
-      # Returns mouse x position
+      # Returns the inverse of tan().
       #
-      # @return [Numeric] horizontal position of mouse
+      # @param value [Numeric] value for valculation
       #
-      def mouseX ()
-        @mousePos__.x
+      # @return [Numeric] the arc tangent
+      #
+      def atan (value)
+        Math.atan value
       end
 
-      # Returns mouse y position
+      # Returns the angle from a specified point.
       #
-      # @return [Numeric] vertical position of mouse
+      # @param y [Numeric] y of the point
+      # @param x [Numeric] x of the point
       #
-      def mouseY ()
-        @mousePos__.y
+      # @return [Numeric] the angle in radians
+      #
+      def atan2 (y, x)
+        Math.atan2 y, x
       end
 
-      # Returns mouse x position in previous frame
+      # Returns the perlin noise value.
       #
-      # @return [Numeric] horizontal position of mouse
+      # @overload noise(x)
+      # @overload noise(x, y)
+      # @overload noise(x, y, z)
       #
-      def pmouseX ()
-        @mousePrevPos__.x
+      # @param x [Numeric] horizontal point in noise space
+      # @param y [Numeric] vertical point in noise space
+      # @param z [Numeric] depth point in noise space
+      #
+      # @return [Numeric] noise value (0.0..1.0)
+      #
+      def noise (x, y = 0, z = 0)
+        Rays.perlin(x, y, z) / 2.0 + 0.5
       end
 
-      # Returns mouse y position in previous frame
+      # Returns a random number in range low...high
       #
-      # @return [Numeric] vertical position of mouse
+      # @overload random()
+      # @overload random(high)
+      # @overload random(low, high)
+      # @overload random(choices)
       #
-      def pmouseY ()
-        @mousePrevPos__.y
+      # @param low     [Numeric] lower limit
+      # @param high    [Numeric] upper limit
+      # @param choices [Array]   array to choose from
+      #
+      # @return [Float] random number
+      #
+      def random (*args)
+        return args.first.sample if args.first.kind_of? Array
+        high, low = args.reverse
+        rand (low || 0).to_f...(high || 1).to_f
       end
 
-      # Returns array of touches
+      # Creates a new vector.
       #
-      # @return [Array] Touch objects
+      # @overload createVector()
+      # @overload createVector(x, y)
+      # @overload createVector(x, y, z)
       #
-      def touches ()
-        @touches__
+      # @param x [Numeric] x of new vector
+      # @param y [Numeric] y of new vector
+      # @param z [Numeric] z of new vector
+      #
+      # @return [Vector] new vector
+      #
+      def createVector (*args)
+        Vector.new *args
       end
 
-      # Enables calling draw block on every frame.
+      # Creates a camera object as a video input device.
       #
-      # @return [nil] nil
+      # @return [Capture] camera object
       #
-      def loop ()
-        @loop__ = true
+      def createCapture (*args)
+        Capture.new *args
       end
 
-      # Disables calling draw block on every frame.
+      # Creates a new off-screen graphics context object.
       #
-      # @return [nil] nil
+      # @param width  [Numeric] width of graphics image
+      # @param height [Numeric] height of graphics image
       #
-      def noLoop ()
-        @loop__ = false
+      # @return [Graphics] graphics object
+      #
+      def createGraphics (width, height)
+        Graphics.new width, height
       end
 
-      # Calls draw block to redraw frame.
+      # Loads image.
       #
-      # @return [nil] nil
+      # @param filename  [String] file name to load image
+      # @param extension [String] type of image to load (ex. 'png')
       #
-      def redraw ()
-        @redraw__ = true
+      # @return [Image] loaded image object
+      #
+      def loadImage (filename, extension = nil)
+        filename = getImage__ filename, extension if filename =~ %r|^https?://|
+        Image.new Rays::Image.load filename
+      end
+
+      # @private
+      private def getImage__ (uri, ext)
+        ext ||= File.extname uri
+        raise "unsupported image type -- #{ext}" unless ext =~ /^\.?(png)$/i
+
+        tmpdir = Pathname(Dir.tmpdir) + Digest::SHA1.hexdigest(self.class.name)
+        path   = tmpdir + Digest::SHA1.hexdigest(uri)
+        path   = path.sub_ext ext
+
+        unless path.file?
+          URI.open uri do |input|
+            tmpdir.mkdir unless tmpdir.directory?
+            path.open('w') do |output|
+              while buf = input.read(2 ** 16)
+                output.write buf
+              end
+            end
+          end
+        end
+        path.to_s
       end
 
     end# Context