Module: Processing::GraphicsContext

Included in:
Context, Graphics
Defined in:
lib/processing/graphics_context.rb

Overview

Drawing context

Constant Summary collapse

PI =

PI

Math::PI
HALF_PI =

PI / 2

PI / 2
QUARTER_PI =

PI / 4

PI / 4
TWO_PI =

PI * 2

PI * 2
TAU =

PI * 2

PI * 2
RGBA =

RGBA format for createImage().

:rgba
RGB =

RGB format for createImage, or RGB mode for colorMode().

:rgb
HSB =

HSB mode for colorMode().

:hsb
RADIANS =

Radian mode for angleMode().

:radians
DEGREES =

Degree mode for angleMode().

:degrees
CORNER =

Mode for rectMode(), ellipseMode() and imageMode().

:corner
CORNERS =

Mode for rectMode(), ellipseMode() and imageMode().

:corners
CENTER =

Mode for rectMode(), ellipseMode(), imageMode() and textAlign().

:center
RADIUS =

Mode for rectMode() and ellipseMode().

:radius
PROJECT =

Mode for strokeCap().

:square
MITER =

Mode for strokeJoin().

:miter
ROUND =

Mode for strokeCap() and strokeJoin().

:round
SQUARE =

Mode for strokeCap() and strokeJoin().

:butt
BLEND =

Mode for blendMode().

:normal
ADD =

Mode for blendMode().

:add
SUBTRACT =

Mode for blendMode().

:subtract
LIGHTEST =

Mode for blendMode().

:lightest
DARKEST =

Mode for blendMode().

:darkest
EXCLUSION =

Mode for blendMode().

:exclusion
MULTIPLY =

Mode for blendMode().

:multiply
SCREEN =

Mode for blendMode().

:screen
REPLACE =

Mode for blendMode().

:replace
LEFT =

Key code or Mode for textAlign().

:left
RIGHT =

Key code or Mode for textAlign().

:right
TOP =

Mode for textAlign().

:top
BOTTOM =

Mode for textAlign().

:bottom
BASELINE =

Mode for textAlign().

:baseline
THRESHOLD =

Filter type for filter()

:threshold
GRAY =

Filter type for filter()

:gray
INVERT =

Filter type for filter()

:invert
BLUR =

Filter type for filter()

:blur
ENTER =

Key codes.

:enter
SPACE = 
:space
TAB = 
:tab
DELETE = 
:delete
BACKSPACE = 
:backspace
ESC = 
:escape
HOME = 
:home
PAGEUP =

END = :end

:pageup
PAGEDOWN = 
:pagedown
CLEAR = 
:clear
SHIFT = 
:shift
CONTROL = 
:control
ALT = 
:alt
WIN = 
:win
COMMAND = 
:command
OPTION = 
:option
FUNCTION = 
:function
CAPSLOCK = 
:capslock
SECTION = 
:section
HELP = 
:help
F1 = 
:f1
F2 = 
:f2
F3 = 
:f3
F4 = 
:f4
F5 = 
:f5
F6 = 
:f6
F7 = 
:f7
F8 = 
:f8
F9 = 
:f9
F10 = 
:f10
F11 = 
:f11
F12 = 
:f12
F13 = 
:f13
F14 = 
:f14
F15 = 
:f15
F16 = 
:f16
F17 = 
:f17
F18 = 
:f18
F19 = 
:f19
F20 = 
:f20
F21 = 
:f21
F22 = 
:f22
F23 = 
:f23
F24 = 
:f24
UP = 
:up
DOWN = 
:down

Instance Method Summary collapse

Instance Method Details

#abs(value) ⇒ Numeric

Returns the absolute number of the value.

Parameters:

  • value (Numeric) —

    number

Returns:

  • (Numeric) —

    absolute number



1273
1274
1275
 
# File 'lib/processing/graphics_context.rb', line 1273

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



1556
1557
1558
 
# File 'lib/processing/graphics_context.rb', line 1556

def acos(value)
  Math.acos value
end

#angleMode(mode = nil) ⇒ RADIANS, DEGREES

Sets angle mode.

Parameters:

Returns:



362
363
364
365
366
367
368
369
370
371
372
373
 
# File 'lib/processing/graphics_context.rb', line 362

def angleMode(mode = nil)
  if mode != nil
    @angleMode__  = mode
    @angleScale__ =
      case mode.downcase.to_sym
      when RADIANS then RAD2DEG__
      when DEGREES then 1.0
      else raise ArgumentError, "invalid angle mode: #{mode}"
      end
  end
  @angleMode__
end

#arc(a, b, c, d, start, stop) ⇒ nil Also known as: drawArc

Draws an arc.

The parameters a, b, c, and d are determined by ellipseMode().

Parameters:

  • a (Numeric) —

    horizontal position of the shape, by default

  • b (Numeric) —

    vertical position of the shape, by default

  • c (Numeric) —

    width of the shape, by default

  • d (Numeric) —

    height of the shape, by default

  • start (Numeric) —

    angle to start the arc

  • stop (Numeric) —

    angle to stop the arc

Returns:

  • (nil) —

    nil



857
858
859
860
861
862
863
864
 
# File 'lib/processing/graphics_context.rb', line 857

def arc(a, b, c, d, start, stop)
  assertDrawing__
  x, y, w, h = toXYWH__ @ellipseMode__, a, b, c, d
  start      = toAngle__(-start)
  stop       = toAngle__(-stop)
  @painter__.ellipse x, y, w, h, from: start, to: stop
  nil
end

#asin(value) ⇒ Numeric

Returns the inverse of sin().

Parameters:

  • value (Numeric) —

    value for calculation

Returns:

  • (Numeric) —

    the arc sine



1546
1547
1548
 
# File 'lib/processing/graphics_context.rb', line 1546

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



1566
1567
1568
 
# File 'lib/processing/graphics_context.rb', line 1566

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



1577
1578
1579
 
# File 'lib/processing/graphics_context.rb', line 1577

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

#background(str) ⇒ nil #background(str, alpha) ⇒ nil #background(gray) ⇒ nil #background(gray, alpha) ⇒ nil #background(r, g, b) ⇒ nil #background(r, g, b, alpha) ⇒ nil

Clears screen.

Parameters:

  • str (String) —

    color code like ‘#00AAFF’

  • gray (Integer) —

    gray value (0..255)

  • r (Integer) —

    red value (0..255)

  • g (Integer) —

    green value (0..255)

  • b (Integer) —

    blue value (0..255)

  • alpha (Integer) —

    alpha value (0..255)

Returns:

  • (nil) —

    nil



731
732
733
734
735
736
737
738
739
740
741
742
 
# File 'lib/processing/graphics_context.rb', line 731

def background(*args)
  assertDrawing__
  rgba = toRGBA__(*args)
  if rgba[3] == 1
    @painter__.background(*rgba)
  else
    @painter__.push fill: rgba, stroke: :none do |_|
      @painter__.rect 0, 0, width, height
    end
  end
  nil
end

#bezier(x1, y1, cx1, cy1, cx2, cy2, x2, y2) ⇒ nil Also known as: drawBezier

Draws a Bezier spline curve.

Parameters:

  • x1 (Numeric) —

    horizontal position of first point

  • y1 (Numeric) —

    vertical position of first point

  • cx1 (Numeric) —

    horizontal position of first control point

  • cy1 (Numeric) —

    vertical position of first control point

  • cx2 (Numeric) —

    horizontal position of second control point

  • cy2 (Numeric) —

    vertical position of second control point

  • x2 (Numeric) —

    horizontal position of second point

  • y2 (Numeric) —

    vertical position of second point

Returns:

  • (nil) —

    nil



956
957
958
959
960
 
# File 'lib/processing/graphics_context.rb', line 956

def bezier(x1, y1, cx1, cy1, cx2, cy2, x2, y2)
  assertDrawing__
  @painter__.bezier x1, y1, cx1, cy1, cx2, cy2, x2, y2
  nil
end

#blend(sx, sy, sw, sh, dx, dy, dw, dh, mode) ⇒ nil #blend(img, sx, sy, sw, sh, dx, dy, dw, dh, mode) ⇒ nil

Blends image.

Parameters:

  • img (Image) (defaults to: nil) —

    image for blend source

  • sx (Numrtic) —

    x position of source region

  • sy (Numrtic) —

    y position of source region

  • sw (Numrtic) —

    width of source region

  • sh (Numrtic) —

    height of source region

  • dx (Numrtic) —

    x position of destination region

  • dy (Numrtic) —

    y position of destination region

  • dw (Numrtic) —

    width of destination region

  • dh (Numrtic) —

    height of destination region

  • mode (BLEND, ADD, SUBTRACT, LIGHTEST, DARKEST, EXCLUSION, MULTIPLY, SCREEN, REPLACE) —

    blend mode

Returns:

  • (nil) —

    nil



1069
1070
1071
1072
1073
1074
1075
1076
 
# File 'lib/processing/graphics_context.rb', line 1069

def blend(img = nil, sx, sy, sw, sh, dx, dy, dw, dh, mode)
  assertDrawing__
  tint  = @tint__ ? toRGBA__(*@tint__) : 1
  img ||= self
  img.drawImage__(
    @painter__, sx, sy, sw, sh, dx, dy, dw, dh,
    fill: tint, stroke: :none, blend_mode: mode)
end

#blendMode(mode = nil) ⇒ nil

Sets blend mode. Default is BLEND.

Parameters:

Returns:

  • (nil) —

    nil



459
460
461
462
463
464
465
 
# File 'lib/processing/graphics_context.rb', line 459

def blendMode(mode = nil)
  if mode != nil
    @blendMode__          = mode
    @painter__.blend_mode = mode
  end
  @blendMode__
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



1283
1284
1285
 
# File 'lib/processing/graphics_context.rb', line 1283

def ceil(value)
  value.ceil
end

#circle(x, y, extent) ⇒ nil Also known as: drawCircle

Draws a circle.

Parameters:

  • x (Numeric) —

    horizontal position of the shape

  • y (Numeric) —

    vertical position of the shape

  • extent (Numeric) —

    width and height of the shape

Returns:

  • (nil) —

    nil



838
839
840
 
# File 'lib/processing/graphics_context.rb', line 838

def circle(x, y, extent)
  ellipse x, y, extent, extent
end

#clip(a, b, c, d) ⇒ nil

Limits the drawable rectangle.

The parameters a, b, c, and d are determined by rectMode().

Parameters:

  • a (Numeric) —

    horizontal position of the drawable area, by default

  • b (Numeric) —

    vertical position of the drawable area, by default

  • c (Numeric) —

    width of the drawable area, by default

  • d (Numeric) —

    height of the drawable area, by default

Returns:

  • (nil) —

    nil



606
607
608
609
610
 
# File 'lib/processing/graphics_context.rb', line 606

def clip(a, b, c, d)
  x, y, w, h = toXYWH__ @imageMode__, a, b, c, d
  @painter__.clip x, y, w, h
  nil
end

#colorMode(mode) ⇒ RGB, HSB #colorMode(mode, max) ⇒ RGB, HSB #colorMode(mode, max1, max2, max3) ⇒ RGB, HSB #colorMode(mode, max1, max2, max3, maxA) ⇒ RGB, HSB

Sets color mode and max color values.

Parameters:

  • mode (RGB, HSB) (defaults to: nil) —

    RGB or HSB

  • max (Numeric) —

    max values for all color values

  • max1 (Numeric) —

    max value for red or hue

  • max2 (Numeric) —

    max value for green or saturation

  • max3 (Numeric) —

    max value for blue or brightness

  • maxA (Numeric) —

    max value for alpha

Returns:



311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
 
# File 'lib/processing/graphics_context.rb', line 311

def colorMode(mode = nil, *maxes)
  if mode != nil
    mode = mode.downcase.to_sym
    raise ArgumentError, "invalid color mode: #{mode}" unless [RGB, HSB].include?(mode)
    raise ArgumentError unless [0, 1, 3, 4].include?(maxes.size)

    @colorMode__ = mode
    @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
    end
  end
  @colorMode__
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



1486
1487
1488
 
# File 'lib/processing/graphics_context.rb', line 1486

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

#copy(sx, sy, sw, sh, dx, dy, dw, dh) ⇒ nil #copy(img, sx, sy, sw, sh, dx, dy, dw, dh) ⇒ nil

Copies image.

Parameters:

  • img (Image) (defaults to: nil) —

    image for copy source

  • sx (Numrtic) —

    x position of source region

  • sy (Numrtic) —

    y position of source region

  • sw (Numrtic) —

    width of source region

  • sh (Numrtic) —

    height of source region

  • dx (Numrtic) —

    x position of destination region

  • dy (Numrtic) —

    y position of destination region

  • dw (Numrtic) —

    width of destination region

  • dh (Numrtic) —

    height of destination region

Returns:

  • (nil) —

    nil



1047
1048
1049
 
# File 'lib/processing/graphics_context.rb', line 1047

def copy(img = nil, sx, sy, sw, sh, dx, dy, dw, dh)
  blend img, sx, sy, sw, sh, dx, dy, dw, dh, BLEND
end

#cos(angle) ⇒ Numeric

Returns the cosine of an angle.

Parameters:

  • angle (Numeric) —

    angle in radians

Returns:

  • (Numeric) —

    the cosine



1526
1527
1528
 
# File 'lib/processing/graphics_context.rb', line 1526

def cos(angle)
  Math.cos angle
end

#createCapture(*args) ⇒ Capture

Creates a camera object as a video input device.

Returns:



1703
1704
1705
 
# File 'lib/processing/graphics_context.rb', line 1703

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

#createGraphics(width, height, pixelDensity = 1) ⇒ Graphics

Creates a new off-screen graphics context object.

Parameters:

  • width (Numeric) —

    width of graphics image

  • height (Numeric) —

    height of graphics image

  • pixelDensity (Numeric) (defaults to: 1) —

    pixel density of graphics image

Returns:



1657
1658
1659
 
# File 'lib/processing/graphics_context.rb', line 1657

def createGraphics(width, height, pixelDensity = 1)
  Graphics.new width, height, pixelDensity
end

#createImage(w, h) ⇒ Image #createImage(w, h, format) ⇒ Image

Creates a new image.

Parameters:

  • w (Numeric) —

    width of new image

  • h (Numeric) —

    height of new image

  • format (RGB, RGBA) (defaults to: RGBA) —

    image format

Returns:

Raises:

  • (ArgumentError) 


1643
1644
1645
1646
1647
 
# File 'lib/processing/graphics_context.rb', line 1643

def createImage(w, h, format = RGBA)
  colorspace = {RGB => Rays::RGB, RGBA => Rays::RGBA}[format]
  raise ArgumentError, "Unknown image format" unless colorspace
  Image.new Rays::Image.new(w, h, colorspace).paint {background 0, 0}
end

#createShader(vertPath, fragPath) ⇒ Shader #createShader(vertSource, fragSource) ⇒ Shader

Creates a shader object.

Passing nil for a vertex shader parameter causes the following default vertex shader to be used. “‘ attribute vec3 position; attribute vec3 texCoord; attribute vec4 color; varying vec4 vertPosition; varying vec4 vertTexCoord; varying vec4 vertColor; uniform mat4 transform; uniform mat4 texMatrix; void main () 

vec4 pos__   = vec4(position, 1.0);
vertPosition = pos__;
vertTexCoord = texMatrix * vec4(texCoord, 1.0);
vertColor    = color;
gl_Position  = transform * pos__;

“‘

Parameters:

  • vertPath (String) —

    vertex shader file path

  • fragPath (String) —

    fragment shader file path

  • vertSource (String) —

    vertex shader source

  • fragSource (String) —

    fragment shader source

Returns:



1693
1694
1695
1696
1697
 
# File 'lib/processing/graphics_context.rb', line 1693

def createShader(vert, frag)
  vert = File.read if vert && File.exist?(vert)
  frag = File.read if frag && File.exist?(frag)
  Shader.new vert, frag
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:



1628
1629
1630
 
# File 'lib/processing/graphics_context.rb', line 1628

def createVector(*args)
  Vector.new(*args, context: self)
end

#curve(cx1, cy1, x1, y1, x2, y2, cx2, cy2) ⇒ nil Also known as: drawCurve

Draws a Catmull-Rom spline curve.

Parameters:

  • cx1 (Numeric) —

    horizontal position of beginning control point

  • cy1 (Numeric) —

    vertical position of beginning control point

  • x1 (Numeric) —

    horizontal position of first point

  • y1 (Numeric) —

    vertical position of first point

  • x2 (Numeric) —

    horizontal position of second point

  • y2 (Numeric) —

    vertical position of second point

  • cx2 (Numeric) —

    horizontal position of ending control point

  • cy2 (Numeric) —

    vertical position of ending control point

Returns:

  • (nil) —

    nil



935
936
937
938
939
 
# File 'lib/processing/graphics_context.rb', line 935

def curve(cx1, cy1, x1, y1, x2, y2, cx2, cy2)
  assertDrawing__
  @painter__.curve cx1, cy1, x1, y1, x2, y2, cx2, cy2
  nil
end

#degrees(radian) ⇒ Numeric

Converts radian to degree.

Parameters:

  • radian (Numeric) —

    radian to convert

Returns:

  • (Numeric) —

    degree



1506
1507
1508
 
# File 'lib/processing/graphics_context.rb', line 1506

def degrees(radian)
  radian * RAD2DEG__
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



1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
 
# File 'lib/processing/graphics_context.rb', line 1392

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

#ellipse(a, b, c, d) ⇒ nil Also known as: drawEllipse

Draws an ellipse.

The parameters a, b, c, and d are determined by ellipseMode().

Parameters:

  • a (Numeric) —

    horizontal position of the shape, by default

  • b (Numeric) —

    vertical position of the shape, by default

  • c (Numeric) —

    width of the shape, by default

  • d (Numeric) —

    height of the shape, by default

Returns:

  • (nil) —

    nil



821
822
823
824
825
826
 
# File 'lib/processing/graphics_context.rb', line 821

def ellipse(a, b, c, d)
  assertDrawing__
  x, y, w, h = toXYWH__ @ellipseMode__, a, b, c, d
  @painter__.ellipse x, y, w, h
  nil
end

#ellipseMode(mode) ⇒ nil

Sets ellipse mode. Default is CENTER.

CORNER -> ellipse(left, top, width, height) CORNERS -> ellipse(left, top, right, bottom) CENTER -> ellipse(center_x, center_y, width, height) RADIUS -> ellipse(center_x, center_y, radius_h, radius_v)

Parameters:

Returns:

  • (nil) —

    nil



424
425
426
 
# File 'lib/processing/graphics_context.rb', line 424

def ellipseMode(mode)
  @ellipseMode__ = mode
end

#exp(n) ⇒ Numeric

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

Parameters:

  • value (Numeric) —

    number

Returns:

  • (Numeric) —

    result number



1323
1324
1325
 
# File 'lib/processing/graphics_context.rb', line 1323

def exp(n)
  Math.exp n
end

#fill(rgb) ⇒ nil #fill(rgb, alpha) ⇒ nil #fill(gray) ⇒ nil #fill(gray, alpha) ⇒ nil #fill(r, g, b) ⇒ nil #fill(r, g, b, alpha) ⇒ nil

Sets fill color.

Parameters:

  • rgb (String) —

    color code like ‘#00AAFF’

  • gray (Integer) —

    gray value (0..255)

  • r (Integer) —

    red value (0..255)

  • g (Integer) —

    green value (0..255)

  • b (Integer) —

    blue value (0..255)

  • alpha (Integer) —

    alpha value (0..255)

Returns:

  • (nil) —

    nil



485
486
487
488
 
# File 'lib/processing/graphics_context.rb', line 485

def fill(*args)
  @painter__.fill(*toRGBA__(*args))
  nil
end

#filter(*args) ⇒ Object

Applies an image filter to screen.

overload filter(shader) overload filter(type) overload filter(type, param)

Parameters:



709
710
711
 
# File 'lib/processing/graphics_context.rb', line 709

def filter(*args)
  @filter__ = Shader.createFilter__(*args)
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



1293
1294
1295
 
# File 'lib/processing/graphics_context.rb', line 1293

def floor(value)
  value.floor
end

#height ⇒ Numeric

Returns the height of the graphics object.

Returns:

  • (Numeric) —

    height



267
268
269
 
# File 'lib/processing/graphics_context.rb', line 267

def height()
  @image__.height
end

#image(img, a, b) ⇒ nil #image(img, a, b, c, d) ⇒ nil Also known as: drawImage

Draws an image.

The parameters a, b, c, and d are determined by imageMode().

Parameters:

  • img (Image) —

    image to draw

  • a (Numeric) —

    horizontal position of the image, by default

  • b (Numeric) —

    vertical position of the image, by default

  • c (Numeric) (defaults to: nil) —

    width of the image, by default

  • d (Numeric) (defaults to: nil) —

    height of the image, by default

Returns:

  • (nil) —

    nil



1020
1021
1022
1023
1024
1025
1026
 
# File 'lib/processing/graphics_context.rb', line 1020

def image(img, a, b, c = nil, d = nil)
  assertDrawing__
  x, y, w, h = toXYWH__ @imageMode__, a, b, c || img.width, d || img.height
  tint       = @tint__ ? toRGBA__(*@tint__) : 1
  img.drawImage__ @painter__, x, y, w, h, fill: tint, stroke: :none
  nil
end

#imageMode(mode) ⇒ nil

Sets image mode. Default is CORNER.

CORNER -> image(img, left, top, width, height) CORNERS -> image(img, left, top, right, bottom) CENTER -> image(img, center_x, center_y, width, height)

Parameters:

Returns:

  • (nil) —

    nil



438
439
440
 
# File 'lib/processing/graphics_context.rb', line 438

def imageMode(mode)
  @imageMode__ = mode
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



1426
1427
1428
 
# File 'lib/processing/graphics_context.rb', line 1426

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

#line(x1, y1, x2, y2) ⇒ nil Also known as: drawLine

Draws a line.

Parameters:

  • x1 (Numeric) —

    horizontal position of first point

  • y1 (Numeric) —

    vertical position of first point

  • x2 (Numeric) —

    horizontal position of second point

  • y2 (Numeric) —

    vertical position of second point

Returns:

  • (nil) —

    nil



768
769
770
771
772
 
# File 'lib/processing/graphics_context.rb', line 768

def line(x1, y1, x2, y2)
  assertDrawing__
  @painter__.line x1, y1, x2, y2
  nil
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



1714
1715
1716
1717
 
# File 'lib/processing/graphics_context.rb', line 1714

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

#loadShader(fragPath) ⇒ Shader #loadShader(fragPath, vertPath) ⇒ Shader

Loads shader file.

Parameters:

  • fragPath (String) —

    fragment shader file path

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

    vertex shader file path

Returns:

  • (Shader) —

    loaded shader object



1729
1730
1731
 
# File 'lib/processing/graphics_context.rb', line 1729

def loadShader(fragPath, vertPath = nil)
  createShader vertPath, fragPath
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



1313
1314
1315
 
# File 'lib/processing/graphics_context.rb', line 1313

def log(n)
  Math.log n
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



1369
1370
1371
1372
1373
1374
1375
1376
 
# File 'lib/processing/graphics_context.rb', line 1369

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



1440
1441
1442
 
# File 'lib/processing/graphics_context.rb', line 1440

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



1474
1475
1476
 
# File 'lib/processing/graphics_context.rb', line 1474

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



1457
1458
1459
 
# File 'lib/processing/graphics_context.rb', line 1457

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

#noClip ⇒ nil

Disables clipping.

Returns:

  • (nil) —

    nil



616
617
618
619
 
# File 'lib/processing/graphics_context.rb', line 616

def noClip()
  @painter__.no_clip
  nil
end

#noFill ⇒ nil

Disables filling.

Returns:

  • (nil) —

    nil



494
495
496
497
 
# File 'lib/processing/graphics_context.rb', line 494

def noFill()
  @painter__.fill nil
  nil
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)



1593
1594
1595
 
# File 'lib/processing/graphics_context.rb', line 1593

def noise(x, y = 0, z = 0)
  Rays.perlin(x, y, z) / 2.0 + 0.5
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



1414
1415
1416
 
# File 'lib/processing/graphics_context.rb', line 1414

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

#noStroke ⇒ nil

Disables drawing stroke.

Returns:

  • (nil) —

    nil



526
527
528
529
 
# File 'lib/processing/graphics_context.rb', line 526

def noStroke()
  @painter__.stroke nil
  nil
end

#noTint ⇒ nil

Resets tint color.

Returns:

  • (nil) —

    nil



591
592
593
 
# File 'lib/processing/graphics_context.rb', line 591

def noTint()
  @tint__ = nil
end

#pixelDensity ⇒ Numeric

Returns the pixel density of the graphics object.

Returns:

  • (Numeric) —

    pixel density



291
292
293
 
# File 'lib/processing/graphics_context.rb', line 291

def pixelDensity()
  @painter__.pixel_density
end

#pixelHeight ⇒ Numeric

Returns the height of the graphics object in pixels.

Returns:

  • (Numeric) —

    height



283
284
285
 
# File 'lib/processing/graphics_context.rb', line 283

def pixelHeight()
  height * pixelDensity
end

#pixelWidth ⇒ Numeric

Returns the width of the graphics object in pixels.

Returns:

  • (Numeric) —

    width



275
276
277
 
# File 'lib/processing/graphics_context.rb', line 275

def pixelWidth()
  width * pixelDensity
end

#point(x, y) ⇒ nil Also known as: drawPoint

Draws a point.

Parameters:

  • x (Numeric) —

    horizontal position

  • y (Numeric) —

    vertical position

Returns:

  • (nil) —

    nil



751
752
753
754
755
 
# File 'lib/processing/graphics_context.rb', line 751

def point(x, y)
  assertDrawing__
  @painter__.line x, y, x, y
  nil
end

#pop ⇒ nil

Restore styles and transformations from stack.

Returns:

  • (nil) —

    nil



1240
1241
1242
1243
 
# File 'lib/processing/graphics_context.rb', line 1240

def pop()
  popMatrix
  popStyle
end

#popMatrix ⇒ nil

Pops the current transformation matrix from stack.

Returns:

  • (nil) —

    nil



1148
1149
1150
1151
1152
1153
 
# File 'lib/processing/graphics_context.rb', line 1148

def popMatrix()
  assertDrawing__
  raise "matrix stack underflow" if @matrixStack__.empty?
  @painter__.matrix = @matrixStack__.pop
  nil
end

#popStyle ⇒ nil

Restore style values from the style stack.

Returns:

  • (nil) —

    nil



1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
 
# File 'lib/processing/graphics_context.rb', line 1200

def popStyle()
  assertDrawing__
  raise "style stack underflow" if @styleStack__.empty?
  @painter__.fill,
  @painter__.stroke,
  @painter__.stroke_width,
  @painter__.stroke_cap,
  @painter__.stroke_join,
  @painter__.clip,
  @painter__.blend_mode,
  @painter__.font,
  @painter__.shader,
  @hsbColor__,
  @colorMaxes__,
  @angleScale__,
  @rectMode__,
  @ellipseMode__,
  @imageMode__,
  @textAlignH__,
  @textAlignV__,
  @tint__ = @styleStack__.pop
  nil
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



1334
1335
1336
 
# File 'lib/processing/graphics_context.rb', line 1334

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

#push(&block) ⇒ Object

Save current styles and transformations to stack.

Returns:

  • (Object) —

    result of the expression at the end of the block



1228
1229
1230
1231
1232
1233
1234
 
# File 'lib/processing/graphics_context.rb', line 1228

def push(&block)
  pushMatrix
  pushStyle
  block.call if block
ensure
  pop if block
end

#pushMatrix(&block) ⇒ Object

Pushes the current transformation matrix to stack.

Returns:

  • (Object) —

    result of the expression at the end of the block



1136
1137
1138
1139
1140
1141
1142
 
# File 'lib/processing/graphics_context.rb', line 1136

def pushMatrix(&block)
  assertDrawing__
  @matrixStack__.push @painter__.matrix
  block.call if block
ensure
  popMatrix if block
end

#pushStyle(&block) ⇒ Object

Save current style values to the style stack.

Returns:

  • (Object) —

    result of the expression at the end of the block



1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
 
# File 'lib/processing/graphics_context.rb', line 1169

def pushStyle(&block)
  assertDrawing__
  @styleStack__.push [
    @painter__.fill,
    @painter__.stroke,
    @painter__.stroke_width,
    @painter__.stroke_cap,
    @painter__.stroke_join,
    @painter__.clip,
    @painter__.blend_mode,
    @painter__.font,
    @painter__.shader,
    @hsbColor__,
    @colorMaxes__,
    @angleScale__,
    @rectMode__,
    @ellipseMode__,
    @imageMode__,
    @textAlignH__,
    @textAlignV__,
    @tint__,
  ]
  block.call if block
ensure
  popStyle if block
end

#quad(x1, y1, x2, y2, x3, y3, x4, y4) ⇒ nil Also known as: drawQuad

Draws a quad.

Parameters:

  • x1 (Numeric) —

    horizontal position of first point

  • y1 (Numeric) —

    vertical position of first point

  • x2 (Numeric) —

    horizontal position of second point

  • y2 (Numeric) —

    vertical position of second point

  • x3 (Numeric) —

    horizontal position of third point

  • y3 (Numeric) —

    vertical position of third point

  • x4 (Numeric) —

    horizontal position of fourth point

  • y4 (Numeric) —

    vertical position of fourth point

Returns:

  • (nil) —

    nil



914
915
916
917
918
 
# File 'lib/processing/graphics_context.rb', line 914

def quad(x1, y1, x2, y2, x3, y3, x4, y4)
  assertDrawing__
  @painter__.line x1, y1, x2, y2, x3, y3, x4, y4, loop: true
  nil
end

#radians(degree) ⇒ Numeric

Converts degree to radian.

Parameters:

  • degree (Numeric) —

    degree to convert

Returns:

  • (Numeric) —

    radian



1496
1497
1498
 
# File 'lib/processing/graphics_context.rb', line 1496

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



1610
1611
1612
1613
1614
 
# File 'lib/processing/graphics_context.rb', line 1610

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

#rect(a, b, c, d) ⇒ nil #rect(a, b, c, d, r) ⇒ nil #rect(a, b, c, d, tl, tr, br, bl) ⇒ nil Also known as: drawRect

Draws a rectangle.

The parameters a, b, c, and d are determined by rectMode().

Parameters:

  • a (Numeric) —

    horizontal position of the shape, by default

  • b (Numeric) —

    vertical position of the shape, by default

  • c (Numeric) —

    width of the shape, by default

  • d (Numeric) —

    height of the shape, by default

  • r (Numeric) —

    radius for all corners

  • tl (Numeric) —

    radius for top-left corner

  • tr (Numeric) —

    radius for top-right corner

  • br (Numeric) —

    radius for bottom-right corner

  • bl (Numeric) —

    radius for bottom-left corner

Returns:

  • (nil) —

    nil



796
797
798
799
800
801
802
803
804
805
806
 
# File 'lib/processing/graphics_context.rb', line 796

def rect(a, b, c, d, *args)
  assertDrawing__
  x, y, w, h = toXYWH__ @rectMode__, a, b, c, d
  case args.size
  when 0 then @painter__.rect x, y, w, h
  when 1 then @painter__.rect x, y, w, h, round: args[0]
  when 4 then @painter__.rect x, y, w, h, lt: args[0], rt: args[1], rb: args[2], lb: args[3]
  else raise ArgumentError # ToDo: refine error message
  end
  nil
end

#rectMode(mode) ⇒ nil

Sets rect mode. Default is CORNER.

CORNER -> rect(left, top, width, height) CORNERS -> rect(left, top, right, bottom) CENTER -> rect(center_x, center_y, width, height) RADIUS -> rect(center_x, center_y, radius_h, radius_v)

Parameters:

Returns:

  • (nil) —

    nil



409
410
411
 
# File 'lib/processing/graphics_context.rb', line 409

def rectMode(mode)
  @rectMode__ = mode
end

#resetMatrix ⇒ nil

Reset current transformation matrix with identity matrix.

Returns:

  • (nil) —

    nil



1159
1160
1161
1162
1163
 
# File 'lib/processing/graphics_context.rb', line 1159

def resetMatrix()
  assertDrawing__
  @painter__.matrix = 1
  nil
end

#resetShader ⇒ nil

Resets shader.

Returns:

  • (nil) —

    nil



694
695
696
697
 
# File 'lib/processing/graphics_context.rb', line 694

def resetShader()
  @painter__.no_shader
  nil
end

#rotate(angle) ⇒ nil

Applies rotation matrix to current transformation matrix.

Parameters:

  • angle (Numeric) —

    angle for rotation

Returns:

  • (nil) —

    nil



1126
1127
1128
1129
1130
 
# File 'lib/processing/graphics_context.rb', line 1126

def rotate(angle)
  assertDrawing__
  @painter__.rotate toAngle__ angle
  nil
end

#round(value) ⇒ Numeric

Returns the closest integer number.

Parameters:

  • value (Numeric) —

    number

Returns:

  • (Numeric) —

    rounded number



1303
1304
1305
 
# File 'lib/processing/graphics_context.rb', line 1303

def round(value)
  value.round
end

#save(filename) ⇒ Object

Saves screen image to file.

Parameters:

  • filename (String) —

    file name to save image



1082
1083
1084
 
# File 'lib/processing/graphics_context.rb', line 1082

def save(filename)
  @window__.canvas_image.save filename
end

#scale(s) ⇒ nil #scale(x, y) ⇒ nil

Applies scale matrix to current transformation matrix.

Parameters:

  • s (Numeric) —

    horizontal and vertical scale

  • x (Numeric) —

    horizontal scale

  • y (Numeric) —

    vertical scale

Returns:

  • (nil) —

    nil



1114
1115
1116
1117
1118
 
# File 'lib/processing/graphics_context.rb', line 1114

def scale(x, y)
  assertDrawing__
  @painter__.scale x, y
  nil
end

#shader(shader) ⇒ nil

Sets shader.

Parameters:

  • shader (Shader) —

    a shader to apply

Returns:

  • (nil) —

    nil



685
686
687
688
 
# File 'lib/processing/graphics_context.rb', line 685

def shader(shader)
  @painter__.shader shader&.getInternal__
  nil
end

#sin(angle) ⇒ Numeric

Returns the sine of an angle.

Parameters:

  • angle (Numeric) —

    angle in radians

Returns:

  • (Numeric) —

    the sine



1516
1517
1518
 
# File 'lib/processing/graphics_context.rb', line 1516

def sin(angle)
  Math.sin angle
end

#sq(value) ⇒ Numeric

Returns squared value.

Parameters:

  • value (Numeric) —

    number

Returns:

  • (Numeric) —

    squared value



1344
1345
1346
 
# File 'lib/processing/graphics_context.rb', line 1344

def sq(value)
  value * value
end

#sqrt(value) ⇒ Numeric

Returns squared value.

Parameters:

  • value (Numeric) —

    number

Returns:

  • (Numeric) —

    squared value



1354
1355
1356
 
# File 'lib/processing/graphics_context.rb', line 1354

def sqrt(value)
  Math.sqrt value
end

#square(x, y, extent) ⇒ nil Also known as: drawSquare

Draws a square.

Parameters:

  • x (Numeric) —

    horizontal position of the shape

  • y (Numeric) —

    vertical position of the shape

  • extent (Numeric) —

    width and height of the shape

Returns:

  • (nil) —

    nil



876
877
878
 
# File 'lib/processing/graphics_context.rb', line 876

def square(x, y, extent)
  rect x, y, extent, extent
end

#stroke(rgb) ⇒ nil #stroke(rgb, alpha) ⇒ nil #stroke(gray) ⇒ nil #stroke(gray, alpha) ⇒ nil #stroke(r, g, b) ⇒ nil #stroke(r, g, b, alpha) ⇒ nil

Sets stroke color.

Parameters:

  • rgb (String) —

    color code like ‘#00AAFF’

  • gray (Integer) —

    gray value (0..255)

  • r (Integer) —

    red value (0..255)

  • g (Integer) —

    green value (0..255)

  • b (Integer) —

    blue value (0..255)

  • alpha (Integer) —

    alpha value (0..255)

Returns:

  • (nil) —

    nil



517
518
519
520
 
# File 'lib/processing/graphics_context.rb', line 517

def stroke(*args)
  @painter__.stroke(*toRGBA__(*args))
  nil
end

#strokeCap(cap) ⇒ nil

Sets stroke cap mode.

Parameters:

Returns:

  • (nil) —

    nil



548
549
550
551
 
# File 'lib/processing/graphics_context.rb', line 548

def strokeCap(cap)
  @painter__.stroke_cap cap
  nil
end

#strokeJoin(join) ⇒ nil

Sets stroke join mode.

Parameters:

Returns:

  • (nil) —

    nil



559
560
561
562
 
# File 'lib/processing/graphics_context.rb', line 559

def strokeJoin(join)
  @painter__.stroke_join join
  nil
end

#strokeWeight(weight) ⇒ nil

Sets stroke weight.

Parameters:

  • weight (Numeric) —

    width of stroke

Returns:

  • (nil) —

    nil



537
538
539
540
 
# File 'lib/processing/graphics_context.rb', line 537

def strokeWeight(weight)
  @painter__.stroke_width weight
  nil
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



1536
1537
1538
 
# File 'lib/processing/graphics_context.rb', line 1536

def tan(angle)
  Math.tan angle
end

#text(str) ⇒ nil #text(str, x, y) ⇒ nil #text(str, a, b, c, d) ⇒ nil Also known as: drawText

Draws a text.

The parameters a, b, c, and d are determined by rectMode().

Parameters:

  • str (String) —

    text to draw

  • x (Numeric) —

    horizontal position of the text

  • y (Numeric) —

    vertical position of the text

  • a (Numeric) —

    horizontal position of the text, by default

  • b (Numeric) —

    vertical position of the text, by default

  • c (Numeric) —

    width of the text, by default

  • d (Numeric) —

    height of the text, by default

Returns:

  • (nil) —

    nil



982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
 
# File 'lib/processing/graphics_context.rb', line 982

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

#textAlign(horizontal, vertical = BASELINE) ⇒ Object 



662
663
664
665
 
# File 'lib/processing/graphics_context.rb', line 662

def textAlign(horizontal, vertical = BASELINE)
  @textAlignH__ = horizontal
  @textAlignV__ = vertical
end

#textAscent ⇒ Object 



654
655
656
 
# File 'lib/processing/graphics_context.rb', line 654

def textAscent()
  @painter__.font.ascent
end

#textDescent ⇒ Object 



658
659
660
 
# File 'lib/processing/graphics_context.rb', line 658

def textDescent()
  @painter__.font.descent
end

#textFont(font) ⇒ Font #textFont(name) ⇒ Font #textFont(font, size) ⇒ Font #textFont(name, size) ⇒ Font

Sets font.

Parameters:

  • font (Font) (defaults to: nil) —

    font

  • name (String) —

    font name

  • size (Numeric) (defaults to: nil) —

    font size (max 256)

Returns:

  • (Font) —

    current font



634
635
636
637
 
# File 'lib/processing/graphics_context.rb', line 634

def textFont(font = nil, size = nil)
  setFont__ font, size if font || size
  Font.new @painter__.font
end

#textSize(size) ⇒ nil

Sets text size.

Parameters:

  • size (Numeric) —

    font size (max 256)

Returns:

  • (nil) —

    nil



645
646
647
648
 
# File 'lib/processing/graphics_context.rb', line 645

def textSize(size)
  setFont__ nil, size
  nil
end

#textWidth(str) ⇒ Object 



650
651
652
 
# File 'lib/processing/graphics_context.rb', line 650

def textWidth(str)
  @painter__.font.width str
end

#tint(rgb) ⇒ nil #tint(rgb, alpha) ⇒ nil #tint(gray) ⇒ nil #tint(gray, alpha) ⇒ nil #tint(r, g, b) ⇒ nil #tint(r, g, b, alpha) ⇒ nil

Sets fill color for drawing images.

Parameters:

  • rgb (String) —

    color code like ‘#00AAFF’

  • gray (Integer) —

    gray value (0..255)

  • r (Integer) —

    red value (0..255)

  • g (Integer) —

    green value (0..255)

  • b (Integer) —

    blue value (0..255)

  • alpha (Integer) —

    alpha value (0..255)

Returns:

  • (nil) —

    nil



582
583
584
585
 
# File 'lib/processing/graphics_context.rb', line 582

def tint(*args)
  @tint__ = args
  nil
end

#translate(x, y) ⇒ nil #translate(x, y, z) ⇒ nil

Applies translation matrix to current transformation matrix.

Parameters:

  • x (Numeric) —

    left/right translation

  • y (Numeric) —

    up/down translation

  • y (Numeric) —

    forward/backward translation

Returns:

  • (nil) —

    nil



1097
1098
1099
1100
1101
 
# File 'lib/processing/graphics_context.rb', line 1097

def translate(x, y, z = 0)
  assertDrawing__
  @painter__.translate x, y, z
  nil
end

#triangle(x1, y1, x2, y2, x3, y3) ⇒ nil Also known as: drawTriangle

Draws a triangle.

Parameters:

  • x1 (Numeric) —

    horizontal position of first point

  • y1 (Numeric) —

    vertical position of first point

  • x2 (Numeric) —

    horizontal position of second point

  • y2 (Numeric) —

    vertical position of second point

  • x3 (Numeric) —

    horizontal position of third point

  • y3 (Numeric) —

    vertical position of third point

Returns:

  • (nil) —

    nil



893
894
895
896
897
 
# File 'lib/processing/graphics_context.rb', line 893

def triangle(x1, y1, x2, y2, x3, y3)
  assertDrawing__
  @painter__.line x1, y1, x2, y2, x3, y3, loop: true
  nil
end

#width ⇒ Numeric

Returns the width of the graphics object.

Returns:

  • (Numeric) —

    width



259
260
261
 
# File 'lib/processing/graphics_context.rb', line 259

def width()
  @image__.width
end