Class: RubySketch::Processing::Context

Inherits:
Object
  • Object
show all
Includes:
GraphicsContext
Defined in:
lib/rubysketch/processing.rb

Overview

Processing context

Constant Summary collapse

Vector = 
Processing::Vector
Capture = 
Processing::Capture
Graphics = 
Processing::Graphics

Constants included from GraphicsContext

GraphicsContext::BASELINE, GraphicsContext::BOTTOM, GraphicsContext::BUTT, GraphicsContext::CENTER, GraphicsContext::CORNER, GraphicsContext::CORNERS, GraphicsContext::DEGREES, GraphicsContext::HALF_PI, GraphicsContext::HSB, GraphicsContext::LEFT, GraphicsContext::MITER, GraphicsContext::PI, GraphicsContext::QUARTER_PI, GraphicsContext::RADIANS, GraphicsContext::RADIUS, GraphicsContext::RGB, GraphicsContext::RIGHT, GraphicsContext::ROUND, GraphicsContext::SQUARE, GraphicsContext::TAU, GraphicsContext::TOP, GraphicsContext::TWO_PI

Instance Method Summary collapse

Methods included from GraphicsContext

#angleMode, #arc, #background, #bezier, #circle, #colorMode, #copy, #curve, #ellipse, #ellipseMode, #fill, #height, #image, #imageMode, #line, #noFill, #noStroke, #point, #pop, #popMatrix, #popStyle, #push, #pushMatrix, #pushStyle, #quad, #rect, #rectMode, #resetMatrix, #rotate, #scale, #setup__, #square, #stroke, #strokeCap, #strokeJoin, #strokeWeight, #text, #textAlign, #textAscent, #textDescent, #textFont, #textSize, #textWidth, #translate, #triangle, #width

Instance Method Details

#abs(value) ⇒ Numeric

Returns the absolute number of the value.

Parameters:

  • value (Numeric) —

    number

Returns:

  • (Numeric) —

    absolute number



1997
1998
1999
 
# File 'lib/rubysketch/processing.rb', line 1997

def abs (value)
  value.abs
end

#acos(value) ⇒ Numeric

Returns the inverse of cos().

Parameters:

  • value (Numeric) —

    value for calculation

Returns:

  • (Numeric) —

    the arc cosine



2280
2281
2282
 
# File 'lib/rubysketch/processing.rb', line 2280

def acos (value)
  Math.acos value
end

#asin(value) ⇒ Numeric

Returns the inverse of sin().

Parameters:

  • value (Numeric) —

    value for calculation

Returns:

  • (Numeric) —

    the arc sine



2270
2271
2272
 
# File 'lib/rubysketch/processing.rb', line 2270

def asin (value)
  Math.asin value
end

#atan(value) ⇒ Numeric

Returns the inverse of tan().

Parameters:

  • value (Numeric) —

    value for valculation

Returns:

  • (Numeric) —

    the arc tangent



2290
2291
2292
 
# File 'lib/rubysketch/processing.rb', line 2290

def atan (value)
  Math.atan value
end

#atan2(y, x) ⇒ Numeric

Returns the angle from a specified point.

Parameters:

  • y (Numeric) —

    y of the point

  • x (Numeric) —

    x of the point

Returns:

  • (Numeric) —

    the angle in radians



2301
2302
2303
 
# File 'lib/rubysketch/processing.rb', line 2301

def atan2 (y, x)
  Math.atan2 y, x
end

#ceil(value) ⇒ Numeric

Returns the closest integer number greater than or equal to the value.

Parameters:

  • value (Numeric) —

    number

Returns:

  • (Numeric) —

    rounded up number



2007
2008
2009
 
# File 'lib/rubysketch/processing.rb', line 2007

def ceil (value)
  value.ceil
end

#constrain(value, min, max) ⇒ Numeric

Constrains the number between min..max.

Parameters:

  • value (Numeric) —

    number to be constrained

  • min (Numeric) —

    lower bound of the range

  • max (Numeric) —

    upper bound of the range

Returns:

  • (Numeric) —

    constrained number



2210
2211
2212
 
# File 'lib/rubysketch/processing.rb', line 2210

def constrain (value, min, max)
  value < min ? min : (value > max ? max : value)
end

#cos(angle) ⇒ Numeric

Returns the cosine of an angle.

Parameters:

  • angle (Numeric) —

    angle in radians

Returns:

  • (Numeric) —

    the cosine



2250
2251
2252
 
# File 'lib/rubysketch/processing.rb', line 2250

def cos (angle)
  Math.cos angle
end

#createCapture(*args) ⇒ Capture

Creates a camera object as a video input device.

Returns:



2360
2361
2362
 
# File 'lib/rubysketch/processing.rb', line 2360

def createCapture (*args)
  Capture.new *args
end

#createGraphics(width, height) ⇒ Graphics

Creates a new off-screen graphics context object.

Parameters:

  • width (Numeric) —

    width of graphics image

  • height (Numeric) —

    height of graphics image

Returns:



2371
2372
2373
 
# File 'lib/rubysketch/processing.rb', line 2371

def createGraphics (width, height)
  Graphics.new width, height
end

#createVector ⇒ Vector #createVector(x, y) ⇒ Vector #createVector(x, y, z) ⇒ Vector

Creates a new vector.

Parameters:

  • x (Numeric) —

    x of new vector

  • y (Numeric) —

    y of new vector

  • z (Numeric) —

    z of new vector

Returns:



2352
2353
2354
 
# File 'lib/rubysketch/processing.rb', line 2352

def createVector (*args)
  Vector.new *args
end

#degrees(radian) ⇒ Numeric

Converts radian to degree.

Parameters:

  • radian (Numeric) —

    radian to convert

Returns:

  • (Numeric) —

    degree



2230
2231
2232
 
# File 'lib/rubysketch/processing.rb', line 2230

def degrees (radian)
  radian * RAD2DEG__
end

#displayDensity ⇒ Numeric

Returns pixel density

Returns:

  • (Numeric) —

    pixel density



1919
1920
1921
 
# File 'lib/rubysketch/processing.rb', line 1919

def displayDensity ()
  @painter__.pixel_density
end

#dist(x1, y1, x2, y2) ⇒ Numeric #dist(x1, y1, z1, x2, y2, z2) ⇒ Numeric

Returns distance between 2 points.

Parameters:

  • x1 (Numeric) —

    x of first point

  • y1 (Numeric) —

    y of first point

  • z1 (Numeric) —

    z of first point

  • x2 (Numeric) —

    x of second point

  • y2 (Numeric) —

    y of second point

  • z2 (Numeric) —

    z of second point

Returns:

  • (Numeric) —

    distance between 2 points



2116
2117
2118
2119
2120
2121
2122
2123
2124
2125
2126
2127
2128
 
# File 'lib/rubysketch/processing.rb', line 2116

def dist (*args)
  case args.size
  when 4
    x1, y1, x2, y2 = *args
    xx, yy = x2 - x1, y2 - y1
    Math.sqrt xx * xx + yy * yy
  when 3
    x1, y1, z1, x2, y2, z2 = *args
    xx, yy, zz = x2 - x1, y2 - y1, z2 - z1
    Math.sqrt xx * xx + yy * yy + zz * zz
  else raise ArgumentError
  end
end

#draw(&block) ⇒ Object

Define draw block.



1835
1836
1837
1838
 
# File 'lib/rubysketch/processing.rb', line 1835

def draw (&block)
  @drawBlock__ = block if block
  nil
end

#exp(n) ⇒ Numeric

Returns Euler's number e raised to the power of value.

Parameters:

  • value (Numeric) —

    number

Returns:

  • (Numeric) —

    result number



2047
2048
2049
 
# File 'lib/rubysketch/processing.rb', line 2047

def exp (n)
  Math.exp n
end

#floor(value) ⇒ Numeric

Returns the closest integer number less than or equal to the value.

Parameters:

  • value (Numeric) —

    number

Returns:

  • (Numeric) —

    rounded down number



2017
2018
2019
 
# File 'lib/rubysketch/processing.rb', line 2017

def floor (value)
  value.floor
end

#frameCount ⇒ Integer

Returns number of frames since program started.

Returns:

  • (Integer) —

    total number of frames



1903
1904
1905
 
# File 'lib/rubysketch/processing.rb', line 1903

def frameCount ()
  @frameCount__
end

#frameRate ⇒ Float

Returns number of frames per second.

Returns:

  • (Float) —

    frames per second



1911
1912
1913
 
# File 'lib/rubysketch/processing.rb', line 1911

def frameRate ()
  @window__.event.fps
end

#key(&block) ⇒ Object 



1840
1841
1842
1843
 
# File 'lib/rubysketch/processing.rb', line 1840

def key (&block)
  @window__.key = block
  nil
end

#lerp(start, stop, amount) ⇒ Numeric

Returns the interpolated number between range start..stop.

Parameters:

  • start (Numeric) —

    lower bound of the range

  • stop (Numeric) —

    upper bound of the range

  • amount (Numeric) —

    amount to interpolate

Returns:

  • (Numeric) —

    interporated number



2150
2151
2152
 
# File 'lib/rubysketch/processing.rb', line 2150

def lerp (start, stop, amount)
  start + (stop - start) * amount
end

#loadImage(filename, extension = nil) ⇒ Image

Loads image.

Parameters:

  • filename (String) —

    file name to load image

  • extension (String) (defaults to: nil) —

    type of image to load (ex. 'png')

Returns:

  • (Image) —

    loaded image object



2382
2383
2384
2385
 
# File 'lib/rubysketch/processing.rb', line 2382

def loadImage (filename, extension = nil)
  filename = getImage__ filename, extension if filename =~ %r|^https?://|
  Image.new Rays::Image.load filename
end

#log(n) ⇒ Numeric

Returns the natural logarithm (the base-e logarithm) of a number.

Parameters:

  • value (Numeric) —

    number (> 0.0)

Returns:

  • (Numeric) —

    result number



2037
2038
2039
 
# File 'lib/rubysketch/processing.rb', line 2037

def log (n)
  Math.log n
end

#loop ⇒ nil

Enables calling draw block on every frame.

Returns:

  • (nil) —

    nil



1967
1968
1969
 
# File 'lib/rubysketch/processing.rb', line 1967

def loop ()
  @loop__ = true
end

#mag(x, y) ⇒ Numeric #mag(x, y, z) ⇒ Numeric

Returns the magnitude (or length) of a vector.

Parameters:

  • x (Numeric) —

    x of point

  • y (Numeric) —

    y of point

  • z (Numeric) —

    z of point

Returns:

  • (Numeric) —

    magnitude



2093
2094
2095
2096
2097
2098
2099
2100
 
# File 'lib/rubysketch/processing.rb', line 2093

def mag (*args)
  x, y, z = *args
  case args.size
  when 2 then Math.sqrt x * x + y * y
  when 3 then Math.sqrt x * x + y * y + z * z
  else raise ArgumentError
  end
end

#map(value, start1, stop1, start2, stop2) ⇒ Numeric

Maps a number from range start1..stop1 to range start2..stop2.

Parameters:

  • value (Numeric) —

    number to be mapped

  • start1 (Numeric) —

    lower bound of the range1

  • stop1 (Numeric) —

    upper bound of the range1

  • start2 (Numeric) —

    lower bound of the range2

  • stop2 (Numeric) —

    upper bound of the range2

Returns:

  • (Numeric) —

    mapped number



2164
2165
2166
 
# File 'lib/rubysketch/processing.rb', line 2164

def map (value, start1, stop1, start2, stop2)
  lerp start2, stop2, norm(value, start1, stop1)
end

#max(a, b) ⇒ Numeric #max(a, b, c) ⇒ Numeric #max(array) ⇒ Numeric

Returns maximum value.

Parameters:

  • a (Numeric) —

    value to compare

  • b (Numeric) —

    value to compare

  • c (Numeric) —

    value to compare

  • array (Numeric) —

    values to compare

Returns:

  • (Numeric) —

    maximum value



2198
2199
2200
 
# File 'lib/rubysketch/processing.rb', line 2198

def max (*args)
  args.flatten.max
end

#min(a, b) ⇒ Numeric #min(a, b, c) ⇒ Numeric #min(array) ⇒ Numeric

Returns minimum value.

Parameters:

  • a (Numeric) —

    value to compare

  • b (Numeric) —

    value to compare

  • c (Numeric) —

    value to compare

  • array (Numeric) —

    values to compare

Returns:

  • (Numeric) —

    minimum value



2181
2182
2183
 
# File 'lib/rubysketch/processing.rb', line 2181

def min (*args)
  args.flatten.min
end

#mouseDragged(&block) ⇒ Object 



1860
1861
1862
1863
 
# File 'lib/rubysketch/processing.rb', line 1860

def mouseDragged (&block)
  @mouseDraggedBlock__ = block if block
  nil
end

#mouseMoved(&block) ⇒ Object 



1855
1856
1857
1858
 
# File 'lib/rubysketch/processing.rb', line 1855

def mouseMoved (&block)
  @mouseMovedBlock__ = block if block
  nil
end

#mousePressed(&block) ⇒ Object 



1845
1846
1847
1848
 
# File 'lib/rubysketch/processing.rb', line 1845

def mousePressed (&block)
  @mousePressedBlock__ = block if block
  @mousePressed__
end

#mouseReleased(&block) ⇒ Object 



1850
1851
1852
1853
 
# File 'lib/rubysketch/processing.rb', line 1850

def mouseReleased (&block)
  @mouseReleasedBlock__ = block if block
  nil
end

#mouseX ⇒ Numeric

Returns mouse x position

Returns:

  • (Numeric) —

    horizontal position of mouse



1927
1928
1929
 
# File 'lib/rubysketch/processing.rb', line 1927

def mouseX ()
  @mousePos__.x
end

#mouseY ⇒ Numeric

Returns mouse y position

Returns:

  • (Numeric) —

    vertical position of mouse



1935
1936
1937
 
# File 'lib/rubysketch/processing.rb', line 1935

def mouseY ()
  @mousePos__.y
end

#noise(x) ⇒ Numeric #noise(x, y) ⇒ Numeric #noise(x, y, z) ⇒ Numeric

Returns the perlin noise value.

Parameters:

  • x (Numeric) —

    horizontal point in noise space

  • y (Numeric) (defaults to: 0) —

    vertical point in noise space

  • z (Numeric) (defaults to: 0) —

    depth point in noise space

Returns:

  • (Numeric) —

    noise value (0.0..1.0)



2317
2318
2319
 
# File 'lib/rubysketch/processing.rb', line 2317

def noise (x, y = 0, z = 0)
  Rays.perlin(x, y, z) / 2.0 + 0.5
end

#noLoop ⇒ nil

Disables calling draw block on every frame.

Returns:

  • (nil) —

    nil



1975
1976
1977
 
# File 'lib/rubysketch/processing.rb', line 1975

def noLoop ()
  @loop__ = false
end

#norm(value, start, stop) ⇒ Numeric

Normalize the value from range start..stop into 0..1.

Parameters:

  • value (Numeric) —

    number to be normalized

  • start (Numeric) —

    lower bound of the range

  • stop (Numeric) —

    upper bound of the range

Returns:

  • (Numeric) —

    normalized value between 0..1



2138
2139
2140
 
# File 'lib/rubysketch/processing.rb', line 2138

def norm (value, start, stop)
  (value.to_f - start.to_f) / (stop.to_f - start.to_f)
end

#pmouseX ⇒ Numeric

Returns mouse x position in previous frame

Returns:

  • (Numeric) —

    horizontal position of mouse



1943
1944
1945
 
# File 'lib/rubysketch/processing.rb', line 1943

def pmouseX ()
  @mousePrevPos__.x
end

#pmouseY ⇒ Numeric

Returns mouse y position in previous frame

Returns:

  • (Numeric) —

    vertical position of mouse



1951
1952
1953
 
# File 'lib/rubysketch/processing.rb', line 1951

def pmouseY ()
  @mousePrevPos__.y
end

#pow(value, exponent) ⇒ Numeric

Returns value raised to the power of exponent.

Parameters:

  • value (Numeric) —

    base number

  • exponent (Numeric) —

    exponent number

Returns:

  • (Numeric) —

    value ** exponent



2058
2059
2060
 
# File 'lib/rubysketch/processing.rb', line 2058

def pow (value, exponent)
  value ** exponent
end

#radians(degree) ⇒ Numeric

Converts degree to radian.

Parameters:

  • degree (Numeric) —

    degree to convert

Returns:

  • (Numeric) —

    radian



2220
2221
2222
 
# File 'lib/rubysketch/processing.rb', line 2220

def radians (degree)
  degree * DEG2RAD__
end

#random ⇒ Float #random(high) ⇒ Float #random(low, high) ⇒ Float #random(choices) ⇒ Float

Returns a random number in range low…high

Parameters:

  • low (Numeric) —

    lower limit

  • high (Numeric) —

    upper limit

  • choices (Array) —

    array to choose from

Returns:

  • (Float) —

    random number



2334
2335
2336
2337
2338
 
# File 'lib/rubysketch/processing.rb', line 2334

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

#redraw ⇒ nil

Calls draw block to redraw frame.

Returns:

  • (nil) —

    nil



1983
1984
1985
 
# File 'lib/rubysketch/processing.rb', line 1983

def redraw ()
  @redraw__ = true
end

#round(value) ⇒ Numeric

Returns the closest integer number.

Parameters:

  • value (Numeric) —

    number

Returns:

  • (Numeric) —

    rounded number



2027
2028
2029
 
# File 'lib/rubysketch/processing.rb', line 2027

def round (value)
  value.round
end

#setup(&block) ⇒ Object

Define setup block.



1828
1829
1830
1831
 
# File 'lib/rubysketch/processing.rb', line 1828

def setup (&block)
  @window__.setup = block
  nil
end

#sin(angle) ⇒ Numeric

Returns the sine of an angle.

Parameters:

  • angle (Numeric) —

    angle in radians

Returns:

  • (Numeric) —

    the sine



2240
2241
2242
 
# File 'lib/rubysketch/processing.rb', line 2240

def sin (angle)
  Math.sin angle
end

#sq(value) ⇒ Numeric

Returns squared value.

Parameters:

  • value (Numeric) —

    number

Returns:

  • (Numeric) —

    squared value



2068
2069
2070
 
# File 'lib/rubysketch/processing.rb', line 2068

def sq (value)
  value * value
end

#sqrt(value) ⇒ Numeric

Returns squared value.

Parameters:

  • value (Numeric) —

    number

Returns:

  • (Numeric) —

    squared value



2078
2079
2080
 
# File 'lib/rubysketch/processing.rb', line 2078

def sqrt (value)
  Math.sqrt value
end

#tan(angle) ⇒ Numeric

Returns the ratio of the sine and cosine of an angle.

Parameters:

  • angle (Numeric) —

    angle in radians

Returns:

  • (Numeric) —

    the tangent



2260
2261
2262
 
# File 'lib/rubysketch/processing.rb', line 2260

def tan (angle)
  Math.tan angle
end

#touchEnded(&block) ⇒ Object 



1870
1871
1872
1873
 
# File 'lib/rubysketch/processing.rb', line 1870

def touchEnded (&block)
  @touchEndedBlock__ = block if block
  nil
end

#touches ⇒ Array

Returns array of touches

Returns:

  • (Array) —

    Touch objects



1959
1960
1961
 
# File 'lib/rubysketch/processing.rb', line 1959

def touches ()
  @touches__
end

#touchMoved(&block) ⇒ Object 



1875
1876
1877
1878
 
# File 'lib/rubysketch/processing.rb', line 1875

def touchMoved (&block)
  @touchMovedBlock__ = block if block
  nil
end

#touchStarted(&block) ⇒ Object 



1865
1866
1867
1868
 
# File 'lib/rubysketch/processing.rb', line 1865

def touchStarted (&block)
  @touchStartedBlock__ = block if block
  nil
end

#windowHeight ⇒ Object 



1895
1896
1897
 
# File 'lib/rubysketch/processing.rb', line 1895

def windowHeight ()
  @window__.height
end

#windowWidth ⇒ Object 



1891
1892
1893
 
# File 'lib/rubysketch/processing.rb', line 1891

def windowWidth ()
  @window__.width
end