rubysketch 0.3.0 → 0.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6a044fb62451ebcd69c89a5a9cb2781c747d4298142a9e6828f71cdbc63da999
-  data.tar.gz: 6dade74829619df93d947160f930fdc19563cc9042b826ef7b8b4bd6015cfb00
+  metadata.gz: 0df24de4fc3eabd1c7880d51ff34ef8389b44bef43a8159c75e9e6c651953c0d
+  data.tar.gz: cf03a57e9ecbf8a63f0b089c4588c0cd041ef93e2b92c69a580b8aa1f013659e
 SHA512:
-  metadata.gz: 7801ba15e151b5c519047b2145b71e820428b2b9601c9fccaffd1eb6d6b67ff344b6aa7b0cd12c9151d431df01d201c5cc63e3a8ffa92d854b5934a2357fb8ec
-  data.tar.gz: 44f7ad0c273aa88974356dfcc3fbc7d080d8bccb023ab4137db23f2d7b85b0fa2b06b590a97b487f803575d903a87a8747f26ff3e0518b5c76623f26dcafd35d
+  metadata.gz: 953e09a5b8da7f8798186e3f0a4e4b9ca636a5c7a34cdd1eca26da30f09221ac31fe3c5ed9ebc8e498060f84b88de4bb14738ef8054e30544c38ca664522f050
+  data.tar.gz: 4c4ae42689cfda821c84617c2925fc48b6af3ad3672d8dd1c603b999427762b5439cbf7c879a06fdf8830f83632d5e01bd9197d1cf528f6ae948a38728063a2a

data/ChangeLog.md

@@ -1,6 +1,44 @@
 # RubySketch ChangeLog
 
 
+## [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()
+- make all event handler drawable
+- limit font max size to 256
+
+
+## [0.3.0] - 2020-05-21
+
+- add createGraphics()
+
+
 ## [0.2.7] - 2020-04-17
 
 - add strokeCap() and strokeJoin()

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.0
+0.3.5

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
@@ -143,10 +704,36 @@ module RubySketch
     end# TextBounds
 
 
+    # Touch object.
+    #
+    class Touch
+
+      # Horizontal position of touch
+      #
+      attr_reader :x
+
+      # Vertical position of touch
+      #
+      attr_reader :y
+
+      # @private
+      def initialize (x, y)
+        @x, @y = x, y
+      end
+
+      def id ()
+        raise NotImplementedError
+      end
+
+    end# Touch
+
+
     # Drawing context
     #
     module GraphicsContext
 
+      Vector = Processing::Vector
+
       # PI / 2
       #
       HALF_PI    = Math::PI / 2
@@ -187,7 +774,7 @@ module RubySketch
       #
       CORNERS = :CORNERS
 
-      # Mode for rectMode(), ellipseMode() and imageMode().
+      # Mode for rectMode(), ellipseMode(), imageMode() and textAlign().
       #
       CENTER  = :CENTER
 
@@ -195,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
@@ -211,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
@@ -219,6 +824,8 @@ module RubySketch
         @rectMode__    = nil
         @ellipseMode__ = nil
         @imageMode__   = nil
+        @textAlignH__  = nil
+        @textAlignV__  = nil
         @matrixStack__ = []
         @styleStack__  = []
 
@@ -227,6 +834,10 @@ module RubySketch
         rectMode    CORNER
         ellipseMode CENTER
         imageMode   CORNER
+        textAlign   LEFT
+
+        fill 255
+        stroke 0
       end
 
       def beginDraw ()
@@ -264,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
@@ -311,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
@@ -320,7 +932,7 @@ module RubySketch
       end
 
       # @private
-      private def toAngle__ (angle)
+      def toAngle__ (angle)
         angle * @angleScale__
       end
 
@@ -479,26 +1091,49 @@ module RubySketch
       # Sets font.
       #
       # @param name [String]  font name
-      # @param size [Numeric] font size
+      # @param size [Numeric] font size (max 256)
       #
       # @return [Font] current font
       #
       def textFont (name = nil, size = nil)
-        @painter__.font name, size if name || size
+        setFont__ name, size if name || size
         Font.new @painter__.font
       end
 
       # Sets text size.
       #
-      # @param size [Numeric] font size
+      # @param size [Numeric] font size (max 256)
       #
       # @return [nil] nil
       #
       def textSize (size)
-        @painter__.font @painter__.font.name, size
+        setFont__ @painter__.font.name, size
         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
+        @painter__.font name, size
+      end
+
       # Clears screen.
       #
       # @overload background(str)
@@ -728,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
@@ -933,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
 
@@ -952,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 ()
@@ -972,34 +1626,247 @@ module RubySketch
     end# Graphics
 
 
-    module Utility
+    # Processing context
+    #
+    module Context
+
+      include GraphicsContext, Math
+
+      @@context__ = nil
+
+      def self.context__ ()
+        @@context__
+      end
 
       # @private
-      DEG2RAD__ = Math::PI / 180.0
+      def setup__ (window)
+        @@context__ = self
+
+        @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.
+      #
+      def setup (&block)
+        @window__.setup = block
+        nil
+      end
+
+      # Define draw block.
+      #
+      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
-      RAD2DEG__ = 180.0 / Math::PI
+      private def size__ (width, height)
+        raise 'size() must be called on startup or setup block' if @started__
 
-      # Converts degree to radian.
+        @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.
       #
-      # @param degree [Numeric] degree to convert
+      # @return [Integer] total number of frames
       #
-      # @return [Numeric] radian
+      def frameCount ()
+        @frameCount__
+      end
+
+      # Returns number of frames per second.
       #
-      def radians (degree)
-        degree * DEG2RAD__
+      # @return [Float] frames per second
+      #
+      def frameRate ()
+        @window__.event.fps
       end
 
-      # Converts radian to degree.
+      # Returns pixel density
       #
-      # @param radian [Numeric] radian to convert
+      # @return [Numeric] pixel density
       #
-      # @return [Numeric] degree
+      def displayDensity ()
+        @painter__.pixel_density
+      end
+
+      # Returns mouse x position
       #
-      def degrees (radian)
-        radian * RAD2DEG__
+      # @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
@@ -1193,278 +2060,186 @@ 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
-        @mouseX__       =
-        @mouseY__       =
-        @mousePrevX__   =
-        @mousePrevY__   = 0
-        @mousePressed__ = false
-
-        @window__  = window
-        @image__   = @window__.canvas
-        @painter__ = @window__.canvas_painter
-
-        @painter__.miter_limit = 10
-
-        drawFrame = -> event {
-          @image__   = @window__.canvas
-          @painter__ = @window__.canvas_painter
-          begin
-            push
-            @drawBlock__.call event if @drawBlock__
-          ensure
-            pop
-            @frameCount__ += 1
-          end
-        }
-
-        updateMouseState = -> x, y, pressed = nil {
-          @mouseX__       = x
-          @mouseY__       = y
-          @mousePressed__ = pressed if pressed != nil
-        }
-
-        updateMousePrevPos = -> {
-          @mousePrevX__ = @mouseX__
-          @mousePrevY__ = @mouseY__
-        }
-
-        @window__.before_draw = proc {beginDraw}
-        @window__.after_draw  = proc {endDraw}
-
-        @window__.draw = proc do |e|
-          if @loop__ || @redraw__
-            @redraw__ = false
-            drawFrame.call e
-          end
-          updateMousePrevPos.call
-        end
-
-        @window__.pointer_down = proc do |e|
-          updateMouseState.call e.x, e.y, true
-          @mousePressedBlock__.call e if @mousePressedBlock__
-        end
-
-        @window__.pointer_up = proc do |e|
-          updateMouseState.call e.x, e.y, false
-          @mouseReleasedBlock__.call e if @mouseReleasedBlock__
-        end
-
-        @window__.pointer_move = proc do |e|
-          updateMouseState.call e.x, e.y
-          @mouseMovedBlock__.call e if @mouseMovedBlock__
-        end
-
-        @window__.pointer_drag = proc do |e|
-          updateMouseState.call e.x, e.y
-          @mouseDraggedBlock__.call e if @mouseDraggedBlock__
-        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
-
-      # @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 ()
-        @mouseX__
+      # @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 ()
-        @mouseY__
+      # @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 ()
-        @mousePrevX__
+      # @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(high)
+      # @overload random(low, high)
       #
-      def pmouseY ()
-        @mousePrevY__
+      # @param low  [Numeric] lower limit
+      # @param high [Numeric] upper limit
+      #
+      # @return [Float] random number
+      #
+      def random (low = nil, high)
+        rand (low || 0).to_f...high.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