Class: Processing::Vector

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

Overview

Vector class.

See Also:

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]

See Also:



31
32
33
34
35
36
37
38
39
 
# File 'lib/processing/vector.rb', line 31

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:

See Also:



337
338
339
340
341
 
# File 'lib/processing/vector.rb', line 337

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

See Also:



620
621
622
623
624
625
626
627
628
629
 
# File 'lib/processing/vector.rb', line 620

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

See Also:



563
564
565
 
# File 'lib/processing/vector.rb', line 563

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

See Also:



492
493
494
 
# File 'lib/processing/vector.rb', line 492

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:

See Also:



397
398
399
400
401
 
# File 'lib/processing/vector.rb', line 397

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

See Also:



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

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:

See Also:



604
605
606
607
608
 
# File 'lib/processing/vector.rb', line 604

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

See Also:



182
183
184
 
# File 'lib/processing/vector.rb', line 182

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

See Also:



377
378
379
380
381
 
# File 'lib/processing/vector.rb', line 377

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

See Also:



640
641
642
643
644
645
 
# File 'lib/processing/vector.rb', line 640

def self.random2D(target = nil)
  v = self.new(1, 0, 0)
  v.getInternal__.rotate! rand 0.0...360.0
  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

See Also:



656
657
658
659
660
661
662
663
664
665
 
# File 'lib/processing/vector.rb', line 656

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

See Also:



357
358
359
360
361
 
# File 'lib/processing/vector.rb', line 357

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

See Also:



306
307
308
 
# File 'lib/processing/vector.rb', line 306

def *(num)
  dup.mult num
end

#+(v) ⇒ Vector

Adds a vector.

Parameters:

  • v (Vector) —

    vector to add

Returns:

See Also:



280
281
282
 
# File 'lib/processing/vector.rb', line 280

def +(v)
  dup.add v
end

#-(v) ⇒ Vector

Subtracts a vector.

Parameters:

  • v (Vector) —

    vector to subtract

Returns:

  • (Vector) —

    subtracted vector

See Also:



293
294
295
 
# File 'lib/processing/vector.rb', line 293

def -(v)
  dup.sub v
end

#/(num) ⇒ Vector

Divides a vector by scalar.

Parameters:

  • num (Numeric) —

    number to divide the vector

Returns:

See Also:



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

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:

See Also:



217
218
219
220
 
# File 'lib/processing/vector.rb', line 217

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

#array(n = 3) ⇒ Array Also known as: to_a

Returns x, y, z as an array

Parameters:

  • n (Numeric) (defaults to: 3) —

    number of dimensions

Returns:

  • (Array) —

    array of x, y, z

See Also:



195
196
197
 
# File 'lib/processing/vector.rb', line 195

def array(n = 3)
  @point.to_a n
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

See Also:



546
547
548
549
550
551
 
# File 'lib/processing/vector.rb', line 546

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

See Also:



478
479
480
 
# File 'lib/processing/vector.rb', line 478

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

#div(num) ⇒ Vector

Divides a vector by scalar.

Parameters:

  • num (Numeric) —

    number to divide the vector

Returns:

See Also:



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

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

See Also:



512
513
514
 
# File 'lib/processing/vector.rb', line 512

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

See Also:



590
591
592
 
# File 'lib/processing/vector.rb', line 590

def heading()
  Math.atan2 y, x
end

#initialize_copy(o) ⇒ Object

Initializer for dup or clone



43
44
45
 
# File 'lib/processing/vector.rb', line 43

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

#inspect ⇒ String

Returns a string containing a human-readable representation of object.

Returns:

  • (String) —

    inspected text



671
672
673
 
# File 'lib/processing/vector.rb', line 671

def inspect()
  "#<#{self.class.name}: #{x}, #{y}, #{z}>"
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

See Also:



163
164
165
166
167
168
169
 
# File 'lib/processing/vector.rb', line 163

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:

See Also:



464
465
466
467
 
# File 'lib/processing/vector.rb', line 464

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

#mag ⇒ Numeric

Returns the length of the vector.

Returns:

  • (Numeric) —

    length

See Also:



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

def mag()
  @point.length
end

#magSq ⇒ Numeric

Returns squared length of the vector.

Returns:

  • (Numeric) —

    squared length

See Also:



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

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

See Also:



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

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

See Also:



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

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

See Also:



576
577
578
579
580
581
 
# File 'lib/processing/vector.rb', line 576

def rotate(angle)
  deg = @context ?
    @context.toDegrees__(angle) : angle * GraphicsContext::RAD2DEG__
  @point.rotate! deg
  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

See Also:



75
76
77
78
 
# File 'lib/processing/vector.rb', line 75

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

See Also:



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

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

See Also:



238
239
240
241
 
# File 'lib/processing/vector.rb', line 238

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

#x ⇒ Numeric

Gets x value.

Returns:

  • (Numeric) —

    x value of vector

See Also:



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

def x()
  @point.x
end

#x=(x) ⇒ Numeric

Sets x value.

Returns:

  • (Numeric) —

    x value of vector

See Also:



120
121
122
 
# File 'lib/processing/vector.rb', line 120

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

#y ⇒ Numeric

Gets y value.

Returns:

  • (Numeric) —

    y value of vector

See Also:



98
99
100
 
# File 'lib/processing/vector.rb', line 98

def y()
  @point.y
end

#y=(y) ⇒ Numeric

Sets y value.

Returns:

  • (Numeric) —

    y value of vector

See Also:



131
132
133
 
# File 'lib/processing/vector.rb', line 131

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

#z ⇒ Numeric

Gets z value.

Returns:

  • (Numeric) —

    z value of vector

See Also:



109
110
111
 
# File 'lib/processing/vector.rb', line 109

def z()
  @point.z
end

#z=(z) ⇒ Numeric

Sets z value.

Returns:

  • (Numeric) —

    z value of vector

See Also:



142
143
144
 
# File 'lib/processing/vector.rb', line 142

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