rubysketch 0.3.1 → 0.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1f63f771b469d060307fa88a2992cc373c2439cec8facf531984533303f0a023
-  data.tar.gz: 5787db4cf63408b746fb538a6a612c2b90f440e08c1ded38b382b69200d372c9
+  metadata.gz: 1a40d65c055cc2baacd0a7489ec511a0db37b8e534f58fc02d5c095f78ecca66
+  data.tar.gz: 9c8634c610e0df8201655809b82bc8e7dbc2adab8cad405e2033ecc321c09137
 SHA512:
-  metadata.gz: 1bcb9bfe5d0f1732c7e44a509d8c5e83b5b84f28bb988fe3e4d9083cb342b6fc4cb44df48c0f176a18599cfd334583e808db41dadb377ac5c78436ed55533c29
-  data.tar.gz: ac78631d29b3843a32f376b7330011477523e33f40b1adb5d40dc1a66335bc294fdf91720146194b016497e4444b9531dbdc9529723c936c939c518df343c671
+  metadata.gz: 04d5e9096e7cef9ea5d6c16e3397d5965bc8da07f699fc3b241e91ad982c755fe7b4faf4296b6ce74612da690cc7d7cfd507612387f43276b0e2ab0d05566ddf
+  data.tar.gz: 224f32277392e5b84c84b6ef13a437813859f960e47dce696f97dd547273d0d86a3e62685a171a7055981989fd99679e60b843e12b839bc2b501c4e9fbb7e622

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,38 @@
 # RubySketch ChangeLog
 
 
+## [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
+- add textWidth(), textAscent(), textDescent() and textAlign()
+- change initial color for fill() and stroke()
+- change initial background color to grayscale 0.8
+
+
 ## [0.3.1] - 2020-07-17
 
 - add touchStarted(), touchEnded(), touchMoved() and touches()

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.1
+0.3.6

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 = Context.lerp x, v.x, amount
+        self.y = Context.lerp y, v.y, amount
+        self.z = Context.lerp z, v.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
@@ -171,6 +732,8 @@ module RubySketch
     #
     module GraphicsContext
 
+      Vector = Processing::Vector
+
       # PI / 2
       #
       HALF_PI    = Math::PI / 2
@@ -211,7 +774,7 @@ module RubySketch
       #
       CORNERS = :CORNERS
 
-      # Mode for rectMode(), ellipseMode() and imageMode().
+      # Mode for rectMode(), ellipseMode(), imageMode() and textAlign().
       #
       CENTER  = :CENTER
 
@@ -219,6 +782,21 @@ module RubySketch
       #
       RADIUS  = :RADIUS
 
+      # Mode for textAlign().
+      LEFT     = :LEFT
+
+      # Mode for textAlign().
+      RIGHT    = :RIGHT
+
+      # Mode for textAlign().
+      TOP      = :TOP
+
+      # Mode for textAlign().
+      BOTTOM   = :BOTTOM
+
+      # Mode for textAlign().
+      BASELINE = :BASELINE
+
       # Mode for strokeCap().
       #
       BUTT   = :butt
@@ -235,7 +813,10 @@ module RubySketch
       #
       SQUARE = :square
 
-      def setup__ ()
+      def setup__ (painter)
+        @painter__             = painter
+        @painter__.miter_limit = 10
+
         @drawing       = false
         @hsbColor__    = false
         @colorMaxes__  = [1.0] * 4
@@ -243,6 +824,8 @@ module RubySketch
         @rectMode__    = nil
         @ellipseMode__ = nil
         @imageMode__   = nil
+        @textAlignH__  = nil
+        @textAlignV__  = nil
         @matrixStack__ = []
         @styleStack__  = []
 
@@ -251,6 +834,10 @@ module RubySketch
         rectMode    CORNER
         ellipseMode CENTER
         imageMode   CORNER
+        textAlign   LEFT
+
+        fill 255
+        stroke 0
       end
 
       def beginDraw ()
@@ -288,10 +875,11 @@ module RubySketch
       # @return [nil] nil
       #
       def colorMode (mode, *maxes)
+        mode = mode.upcase.to_sym
         raise ArgumentError, "invalid color mode: #{mode}" unless [RGB, HSB].include?(mode)
         raise ArgumentError unless [0, 1, 3, 4].include?(maxes.size)
 
-        @hsbColor__ = mode.upcase == HSB
+        @hsbColor__ = mode == HSB
         case maxes.size
         when 1    then @colorMaxes__                 = [maxes.first.to_f] * 4
         when 3, 4 then @colorMaxes__[0...maxes.size] = maxes.map &:to_f
@@ -335,8 +923,8 @@ module RubySketch
       # @return [nil] nil
       #
       def angleMode (mode)
-        @angleScale__ = case mode
-          when RADIANS then Utility::RAD2DEG__
+        @angleScale__ = case mode.upcase.to_sym
+          when RADIANS then RAD2DEG__
           when DEGREES then 1.0
           else raise ArgumentError, "invalid angle mode: #{mode}"
           end
@@ -344,7 +932,7 @@ module RubySketch
       end
 
       # @private
-      private def toAngle__ (angle)
+      def toAngle__ (angle)
         angle * @angleScale__
       end
 
@@ -523,6 +1111,23 @@ module RubySketch
         nil
       end
 
+      def textWidth (str)
+        @painter__.font.width str
+      end
+
+      def textAscent ()
+        @painter__.font.ascent
+      end
+
+      def textDescent ()
+        @painter__.font.descent
+      end
+
+      def textAlign (horizontal, vertical = BASELINE)
+        @textAlignH__ = horizontal
+        @textAlignV__ = vertical
+      end
+
       # @private
       def setFont__ (name, size)
         size = 256 if size && size > 256
@@ -758,15 +1363,35 @@ module RubySketch
       #
       # @overload text(str)
       # @overload text(str, x, y)
+      # @overload text(str, a, b, c, d)
       #
       # @param str [String]  text to draw
       # @param x   [Numeric] horizontal position of the text
       # @param y   [Numeric] vertical position of the text
+      # @param a   [Numeric] equivalent to parameters of the rect(), see rectMode()
+      # @param b   [Numeric] equivalent to parameters of the rect(), see rectMode()
+      # @param c   [Numeric] equivalent to parameters of the rect(), see rectMode()
+      # @param d   [Numeric] equivalent to parameters of the rect(), see rectMode()
       #
       # @return [nil] nil
       #
-      def text (str, x, y)
+      def text (str, x, y, x2 = nil, y2 = nil)
         assertDrawing__
+        if x2
+          raise ArgumentError, "missing y2 parameter" unless y2
+          x, y, w, h = toXYWH__ @rectMode__, x, y, x2, y2
+          case @textAlignH__
+          when RIGHT  then x +=  w - @painter__.font.width(str)
+          when CENTER then x += (w - @painter__.font.width(str)) / 2
+          end
+          case @textAlignV__
+          when BOTTOM then y +=  h - @painter__.font.height
+          when CENTER then y += (h - @painter__.font.height) / 2
+          else
+          end
+        else
+          y -= @painter__.font.ascent
+        end
         @painter__.text str, x, y
         nil
       end
@@ -963,12 +1588,12 @@ module RubySketch
       end
 
       # @private
-      def getInternal__ ()
+      private def getInternal__ ()
         @image__
       end
 
       # @private
-      def assertDrawing__ ()
+      private def assertDrawing__ ()
         raise "call beginDraw() before drawing" unless @drawing
       end
 
@@ -982,9 +1607,8 @@ module RubySketch
       include GraphicsContext
 
       def initialize (width, height)
-        setup__
-        @image__   = Rays::Image.new width, height
-        @painter__ = @image__.painter
+        @image__ = Rays::Image.new width, height
+        setup__ @image__.painter
       end
 
       def beginDraw ()
@@ -1002,34 +1626,247 @@ module RubySketch
     end# Graphics
 
 
-    module Utility
-
-      # @private
-      DEG2RAD__ = Math::PI / 180.0
+    # Processing context
+    #
+    module Context
+
+      include GraphicsContext, Math
+
+      @@context__ = nil
+
+      def self.context__ ()
+        @@context__
+      end
 
       # @private
-      RAD2DEG__ = 180.0 / Math::PI
+      def setup__ (window)
+        @@context__ = self
 
-      # Converts degree to radian.
+        @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
+      end
+
+      # Define setup block.
       #
-      # @param degree [Numeric] degree to convert
+      def setup (&block)
+        @window__.setup = block
+        nil
+      end
+
+      # Define draw block.
       #
-      # @return [Numeric] radian
+      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.
       #
-      def radians (degree)
-        degree * DEG2RAD__
+      # @return [Integer] total number of frames
+      #
+      def frameCount ()
+        @frameCount__
       end
 
-      # Converts radian to degree.
+      # Returns number of frames per second.
       #
-      # @param radian [Numeric] radian to convert
+      # @return [Float] frames per second
       #
-      # @return [Numeric] degree
+      def frameRate ()
+        @window__.event.fps
+      end
+
+      # Returns pixel density
       #
-      def degrees (radian)
-        radian * RAD2DEG__
+      # @return [Numeric] pixel density
+      #
+      def displayDensity ()
+        @painter__.pixel_density
+      end
+
+      # Returns mouse x position
+      #
+      # @return [Numeric] horizontal position of mouse
+      #
+      def mouseX ()
+        @mousePos__.x
+      end
+
+      # Returns mouse y position
+      #
+      # @return [Numeric] vertical position of mouse
+      #
+      def mouseY ()
+        @mousePos__.y
+      end
+
+      # 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
 
+      module_function
+
       # Returns the absolute number of the value.
       #
       # @param value [Numeric] number
@@ -1223,295 +2060,191 @@ 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)
-        super()
-        @loop__         = true
-        @redraw__       = false
-        @frameCount__   = 0
-        @mousePos__     =
-        @mousePrevPos__ = Rays::Point.new 0
-        @mousePressed__ = false
-        @touches__      = []
-
-        @window__  = window
-        @image__   = @window__.canvas
-        @painter__ = @window__.canvas_painter
-
-        @painter__.miter_limit = 10
-
-        @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
-      end
-
-      def windowHeight ()
-        @window__.height
+      # @return [Numeric] the sine
+      #
+      def sin (angle)
+        Math.sin angle
       end
 
-      # Returns number of frames since program started.
+      # Returns the cosine of an angle.
       #
-      # @return [Integer] total number of frames
+      # @param angle [Numeric] angle in radians
       #
-      def frameCount ()
-        @frameCount__
+      # @return [Numeric] the cosine
+      #
+      def cos (angle)
+        Math.cos angle
       end
 
-      # Returns number of frames per second.
+      # Returns the ratio of the sine and cosine of an angle.
       #
-      # @return [Float] frames per second
+      # @param angle [Numeric] angle in radians
       #
-      def frameRate ()
-        @window__.event.fps
+      # @return [Numeric] the tangent
+      #
+      def tan (angle)
+        Math.tan angle
       end
 
-      # Returns pixel density
+      # Returns the inverse of sin().
       #
-      # @return [Numeric] pixel density
+      # @param value [Numeric] value for calculation
       #
-      def displayDensity ()
-        @painter__.pixel_density
+      # @return [Numeric] the arc sine
+      #
+      def asin (value)
+        Math.asin value
       end
 
-      # Returns mouse x position
+      # Returns the inverse of cos().
       #
-      # @return [Numeric] horizontal position of mouse
+      # @param value [Numeric] value for calculation
       #
-      def mouseX ()
-        @mousePos__.x
+      # @return [Numeric] the arc cosine
+      #
+      def acos (value)
+        Math.acos value
       end
 
-      # Returns mouse y position
+      # Returns the inverse of tan().
       #
-      # @return [Numeric] vertical position of mouse
+      # @param value [Numeric] value for valculation
       #
-      def mouseY ()
-        @mousePos__.y
+      # @return [Numeric] the arc tangent
+      #
+      def atan (value)
+        Math.atan value
       end
 
-      # Returns mouse x position in previous frame
+      # Returns the angle from a specified point.
       #
-      # @return [Numeric] horizontal position of mouse
+      # @param y [Numeric] y of the point
+      # @param x [Numeric] x of the point
       #
-      def pmouseX ()
-        @mousePrevPos__.x
+      # @return [Numeric] the angle in radians
+      #
+      def atan2 (y, x)
+        Math.atan2 y, x
       end
 
-      # Returns mouse y position in previous frame
+      # Returns the perlin noise value.
       #
-      # @return [Numeric] vertical position of mouse
+      # @overload noise(x)
+      # @overload noise(x, y)
+      # @overload noise(x, y, z)
       #
-      def pmouseY ()
-        @mousePrevPos__.y
+      # @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 array of touches
+      # Returns a random number in range low...high
       #
-      # @return [Array] Touch objects
+      # @overload random()
+      # @overload random(high)
+      # @overload random(low, high)
+      # @overload random(choices)
       #
-      def touches ()
-        @touches__
+      # @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
 
-      # Enables calling draw block on every frame.
+      # Creates a new vector.
       #
-      # @return [nil] nil
+      # @overload createVector()
+      # @overload createVector(x, y)
+      # @overload createVector(x, y, z)
       #
-      def loop ()
-        @loop__ = true
+      # @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
 
-      # 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