Class: Processing::Vector

Inherits:
Object
  • Object
show all
Includes:
Comparable
Defined in:
lib/processing/vector.rb

Overview

Vector class.

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#new ⇒ Vector #new(x) ⇒ Vector #new(x, y) ⇒ Vector #new(x, y, z) ⇒ Vector #new(v) ⇒ Vector #new(a) ⇒ Vector

Initialize vector object.

Parameters:

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

    x of vector

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

    y of vector

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

    z of vector

  • v (Vector) —

    vector object to copy

  • a (Array) —

    array like [x, y, z]



25
26
27
28
29
30
31
32
33
 
# File 'lib/processing/vector.rb', line 25

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

Class Method Details

.add(v1, v2) ⇒ Vector .add(v1, v2, target) ⇒ Vector

Adds 2 vectors.

Parameters:

  • v1 (Vector) —

    a vector

  • v2 (Vector) —

    another vector

  • target (Vector) (defaults to: nil) —

    vector to store added vector

Returns:



267
268
269
270
271
 
# File 'lib/processing/vector.rb', line 267

def self.add(v1, v2, target = nil)
  v = v1 + v2
  target.set v if self === target
  v
end

.angleBetween(v1, v2) ⇒ Numeric

Returns angle between 2 vectors.

Parameters:

Returns:

  • (Numeric) —

    angle in radians



496
497
498
499
500
501
502
503
504
505
 
# File 'lib/processing/vector.rb', line 496

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

.cross(v1, v2, target = nil) ⇒ Numeric

Calculates the cross product of 2 vectors.

Parameters:

Returns:

  • (Numeric) —

    result of cross product



451
452
453
 
# File 'lib/processing/vector.rb', line 451

def self.cross(v1, v2, target = nil)
  v1.cross v2, target
end

.dist(v1, v2) ⇒ Numeric

Returns the distance of 2 vectors.

Parameters:

Returns:

  • (Numeric) —

    the distance



392
393
394
 
# File 'lib/processing/vector.rb', line 392

def self.dist(v1, v2)
  v1.dist v2
end

.div(v, num) ⇒ Vector .div(v, num, target) ⇒ Vector

Divides a vector by scalar.

Parameters:

  • v (Vector) —

    a vector

  • num (Numeric) —

    number to divide the vector

  • target (Vector) (defaults to: nil) —

    vector to store divided vector

Returns:



318
319
320
321
322
 
# File 'lib/processing/vector.rb', line 318

def self.div(v1, num, target = nil)
  v = v1 / num
  target.set v if self === target
  v
end

.dot(v1, v2) ⇒ Numeric

Calculates the dot product of 2 vectors.

Parameters:

Returns:

  • (Numeric) —

    result of dot product



420
421
422
 
# File 'lib/processing/vector.rb', line 420

def self.dot(v1, v2)
  v1.dot v2
end

.fromAngle(angle, target = nil) ⇒ Vector

Returns rotated new vector.

Parameters:

  • angle (Numeric) —

    the angle of rotation

  • target (Vector) (defaults to: nil) —

    vector to store new vector

Returns:



483
484
485
486
487
 
# File 'lib/processing/vector.rb', line 483

def self.fromAngle(angle, target = nil)
  v = self.new(1, 0, 0).rotate(angle)
  target.set v if target
  v
end

.lerp(v1, v2, amount) ⇒ Vector

Returns the interpolated vector between 2 vectors.

Parameters:

  • v1 (Vector) —

    vector to interpolate

  • v2 (Vector) —

    vector to interpolate

  • amount (Numeric) —

    amount to interpolate

Returns:

  • (Vector) —

    interporated vector



146
147
148
 
# File 'lib/processing/vector.rb', line 146

def self.lerp(v1, v2, amount)
  v1.dup.lerp v2, amount
end

.mult(v, num) ⇒ Vector .mult(v, num, target) ⇒ Vector

Multiplies a vector by scalar.

Parameters:

  • v (Vector) —

    a vector

  • num (Numeric) —

    number to multiply the vector

  • target (Vector) (defaults to: nil) —

    vector to store multiplied vector

Returns:

  • (Vector) —

    multiplied vector



301
302
303
304
305
 
# File 'lib/processing/vector.rb', line 301

def self.mult(v1, num, target = nil)
  v = v1 * num
  target.set v if self === target
  v
end

.random2D(target = nil) ⇒ Vector

Returns a new 2D unit vector with a random direction.

Parameters:

  • target (Vector) (defaults to: nil) —

    a vector to store the new vector

Returns:

  • (Vector) —

    a random vector



513
514
515
516
517
 
# File 'lib/processing/vector.rb', line 513

def self.random2D(target = nil)
  v = self.fromAngle rand 0.0...(Math::PI * 2)
  target.set v if target
  v
end

.random3D(target = nil) ⇒ Vector

Returns a new 3D unit vector with a random direction.

Parameters:

  • target (Vector) (defaults to: nil) —

    a vector to store the new vector

Returns:

  • (Vector) —

    a random vector



525
526
527
528
529
530
531
532
533
534
 
# File 'lib/processing/vector.rb', line 525

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

.sub(v1, v2) ⇒ Vector .sub(v1, v2, target) ⇒ Vector

Subtracts 2 vectors.

Parameters:

  • v1 (Vector) —

    a vector

  • v2 (Vector) —

    another vector

  • target (Vector) (defaults to: nil) —

    vector to store subtracted vector

Returns:

  • (Vector) —

    subtracted vector



284
285
286
287
288
 
# File 'lib/processing/vector.rb', line 284

def self.sub(v1, v2, target = nil)
  v = v1 - v2
  target.set v if self === target
  v
end

Instance Method Details

#*(num) ⇒ Vector

Multiplies a vector by scalar.

Parameters:

  • num (Numeric) —

    number to multiply the vector

Returns:

  • (Vector) —

    multiplied vector



242
243
244
 
# File 'lib/processing/vector.rb', line 242

def *(num)
  dup.mult num
end

#+(v) ⇒ Vector

Adds a vector.

Parameters:

  • v (Vector) —

    vector to add

Returns:



222
223
224
 
# File 'lib/processing/vector.rb', line 222

def +(v)
  dup.add v
end

#-(v) ⇒ Vector

Subtracts a vector.

Parameters:

  • v (Vector) —

    vector to subtract

Returns:

  • (Vector) —

    subtracted vector



232
233
234
 
# File 'lib/processing/vector.rb', line 232

def -(v)
  dup.sub v
end

#/(num) ⇒ Vector

Divides a vector by scalar.

Parameters:

  • num (Numeric) —

    number to divide the vector

Returns:



252
253
254
 
# File 'lib/processing/vector.rb', line 252

def /(num)
  dup.div num
end

#add(v) ⇒ Vector #add(x, y) ⇒ Vector #add(x, y, z) ⇒ Vector

Adds a vector.

Parameters:

  • v (Vector) —

    vector to add

  • x (Vector) —

    x of vector to add

  • y (Vector) —

    y of vector to add

  • z (Vector) —

    z of vector to add

Returns:



171
172
173
174
 
# File 'lib/processing/vector.rb', line 171

def add(*args)
  @point += toVector__(*args).getInternal__
  self
end

#array ⇒ Array

Returns x, y, z as an array

Returns:

  • (Array) —

    array of x, y, z



154
155
156
 
# File 'lib/processing/vector.rb', line 154

def array()
  @point.to_a 3
end

#cross(v) ⇒ Numeric #cross(x, y) ⇒ Numeric #cross(x, y, z) ⇒ Numeric

Calculates the cross product of 2 vectors.

Parameters:

  • v (Vector) —

    a vector

  • x (Numeric) —

    x of vector

  • y (Numeric) —

    y of vector

  • z (Numeric) —

    z of vector

Returns:

  • (Numeric) —

    result of cross product



437
438
439
440
441
442
 
# File 'lib/processing/vector.rb', line 437

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

#dist(v) ⇒ Numeric

Returns the distance of 2 vectors.

Parameters:

Returns:

  • (Numeric) —

    the distance



381
382
383
 
# File 'lib/processing/vector.rb', line 381

def dist(v)
  (self - v).mag
end

#div(num) ⇒ Vector

Divides a vector by scalar.

Parameters:

  • num (Numeric) —

    number to divide the vector

Returns:



211
212
213
214
 
# File 'lib/processing/vector.rb', line 211

def div(num)
  @point /= num
  self
end

#dot(v) ⇒ Numeric #dot(x, y) ⇒ Numeric #dot(x, y, z) ⇒ Numeric

Calculates the dot product of 2 vectors.

Parameters:

  • v (Vector) —

    a vector

  • x (Numeric) —

    x of vector

  • y (Numeric) —

    y of vector

  • z (Numeric) —

    z of vector

Returns:

  • (Numeric) —

    result of dot product



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

def dot(*args)
  Rays::Point::dot getInternal__, toVector__(*args).getInternal__
end

#heading ⇒ Numeric

Returns the angle of rotation for this vector.

Returns:

  • (Numeric) —

    the angle in radians



472
473
474
 
# File 'lib/processing/vector.rb', line 472

def heading()
  Math.atan2 y, x
end

#initialize_copy(o) ⇒ Object

Initializer for dup or clone



37
38
39
 
# File 'lib/processing/vector.rb', line 37

def initialize_copy(o)
  @point = o.getInternal__.dup
end

#lerp(v, amount) ⇒ Vector #lerp(x, y, amount) ⇒ Vector #lerp(x, y, z, amount) ⇒ Vector

Returns the interpolated vector between 2 vectors.

Parameters:

  • v (Vector) —

    vector to interpolate

  • x (Numeric) —

    x of vector to interpolate

  • y (Numeric) —

    y of vector to interpolate

  • z (Numeric) —

    z of vector to interpolate

  • amount (Numeric) —

    amount to interpolate

Returns:

  • (Vector) —

    interporated vector



130
131
132
133
134
135
136
 
# File 'lib/processing/vector.rb', line 130

def lerp(*args, amount)
  v      = toVector__(*args)
  self.x = x + (v.x - x) * amount
  self.y = y + (v.y - y) * amount
  self.z = z + (v.z - z) * amount
  self
end

#limit(max) ⇒ Vector

Changes the length of the vector if it’s length is greater than the max value.

Parameters:

  • max (Numeric) —

    max length

Returns:



370
371
372
373
 
# File 'lib/processing/vector.rb', line 370

def limit(max)
  setMag max if magSq > max ** 2
  self
end

#mag ⇒ Numeric

Returns the length of the vector.

Returns:

  • (Numeric) —

    length



328
329
330
 
# File 'lib/processing/vector.rb', line 328

def mag()
  @point.length
end

#magSq ⇒ Numeric

Returns squared length of the vector.

Returns:

  • (Numeric) —

    squared length



336
337
338
 
# File 'lib/processing/vector.rb', line 336

def magSq()
  Rays::Point::dot(@point, @point)
end

#mult(num) ⇒ Vector

Multiplies a vector by scalar.

Parameters:

  • num (Numeric) —

    number to multiply the vector

Returns:

  • (Vector) —

    multiplied vector



200
201
202
203
 
# File 'lib/processing/vector.rb', line 200

def mult(num)
  @point *= num
  self
end

#normalize(target = nil) ⇒ Vector

Changes the length of the vector to 1.0.

Parameters:

  • target (Vector) (defaults to: nil) —

    vector to store the normalized vector

Returns:

  • (Vector) —

    normalized vector



360
361
362
 
# File 'lib/processing/vector.rb', line 360

def normalize(target = nil)
  (target || self).set @point.normal
end

#rotate(angle) ⇒ Vector

Rotate the vector.

Parameters:

  • angle (Numeric) —

    the angle of rotation

Returns:

  • (Vector) —

    rotated this object



461
462
463
464
465
466
 
# File 'lib/processing/vector.rb', line 461

def rotate(angle)
  angle = @context ?
    @context.toAngle__(angle) : angle * GraphicsContext::RAD2DEG__
  @point.rotate! angle
  self
end

#set(x) ⇒ nil #set(x, y) ⇒ nil #set(x, y, z) ⇒ nil #set(v) ⇒ nil #set(a) ⇒ nil

Sets x, y and z.

Parameters:

  • x (Numeric) —

    x of vector

  • y (Numeric) —

    y of vector

  • z (Numeric) —

    z of vector

  • v (Vector) —

    vector object to copy

  • a (Array) —

    array with x, y, z

Returns:

  • (nil) —

    nil



63
64
65
66
 
# File 'lib/processing/vector.rb', line 63

def set(*args)
  initialize(*args)
  self
end

#setMag(len) ⇒ Vector #setMag(target, len) ⇒ Vector

Changes the length of the vector.

Parameters:

  • len (Numeric) —

    length of new vector

  • target (Vector) (defaults to: nil) —

    vector to store new vector

Returns:

  • (Vector) —

    vector with new length



350
351
352
 
# File 'lib/processing/vector.rb', line 350

def setMag(target = nil, len)
  (target || self).set @point.normal * len
end

#sub(v) ⇒ Vector #sub(x, y) ⇒ Vector #sub(x, y, z) ⇒ Vector

Subtracts a vector.

Parameters:

  • v (Vector) —

    vector to subtract

  • x (Vector) —

    x of vector to subtract

  • y (Vector) —

    y of vector to subtract

  • z (Vector) —

    z of vector to subtract

Returns:

  • (Vector) —

    subtracted vector



189
190
191
192
 
# File 'lib/processing/vector.rb', line 189

def sub(*args)
  @point -= toVector__(*args).getInternal__
  self
end

#x ⇒ Numeric

Gets x value.

Returns:

  • (Numeric) —

    x value of vector



72
73
74
 
# File 'lib/processing/vector.rb', line 72

def x()
  @point.x
end

#x=(x) ⇒ Numeric

Sets x value.

Returns:

  • (Numeric) —

    x value of vector



96
97
98
 
# File 'lib/processing/vector.rb', line 96

def x=(x)
  @point.x = x
end

#y ⇒ Numeric

Gets y value.

Returns:

  • (Numeric) —

    y value of vector



80
81
82
 
# File 'lib/processing/vector.rb', line 80

def y()
  @point.y
end

#y=(y) ⇒ Numeric

Sets y value.

Returns:

  • (Numeric) —

    y value of vector



104
105
106
 
# File 'lib/processing/vector.rb', line 104

def y=(y)
  @point.y = y
end

#z ⇒ Numeric

Gets z value.

Returns:

  • (Numeric) —

    z value of vector



88
89
90
 
# File 'lib/processing/vector.rb', line 88

def z()
  @point.z
end

#z=(z) ⇒ Numeric

Sets z value.

Returns:

  • (Numeric) —

    z value of vector



112
113
114
 
# File 'lib/processing/vector.rb', line 112

def z=(z)
  @point.z = z
end