Class: RubySketch::Processing::Vector

Inherits:
Object
  • Object
show all
Includes:
Comparable
Defined in:
lib/rubysketch/processing.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]



37
38
39
40
41
42
43
44
45
 
# File 'lib/rubysketch/processing.rb', line 37

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:



279
280
281
282
283
 
# File 'lib/rubysketch/processing.rb', line 279

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



507
508
509
510
511
512
513
514
515
516
 
# File 'lib/rubysketch/processing.rb', line 507

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



463
464
465
 
# File 'lib/rubysketch/processing.rb', line 463

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



404
405
406
 
# File 'lib/rubysketch/processing.rb', line 404

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:



330
331
332
333
334
 
# File 'lib/rubysketch/processing.rb', line 330

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



432
433
434
 
# File 'lib/rubysketch/processing.rb', line 432

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:



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

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



158
159
160
 
# File 'lib/rubysketch/processing.rb', line 158

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



313
314
315
316
317
 
# File 'lib/rubysketch/processing.rb', line 313

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



524
525
526
527
528
 
# File 'lib/rubysketch/processing.rb', line 524

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



536
537
538
539
540
541
542
543
544
545
 
# File 'lib/rubysketch/processing.rb', line 536

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



296
297
298
299
300
 
# File 'lib/rubysketch/processing.rb', line 296

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



254
255
256
 
# File 'lib/rubysketch/processing.rb', line 254

def *(num)
  dup.mult num
end

#+(v) ⇒ Vector

Adds a vector.

Parameters:

  • v (Vector) —

    vector to add

Returns:



234
235
236
 
# File 'lib/rubysketch/processing.rb', line 234

def +(v)
  dup.add v
end

#-(v) ⇒ Vector

Subtracts a vector.

Parameters:

  • v (Vector) —

    vector to subtract

Returns:

  • (Vector) —

    subtracted vector



244
245
246
 
# File 'lib/rubysketch/processing.rb', line 244

def -(v)
  dup.sub v
end

#/(num) ⇒ Vector

Divides a vector by scalar.

Parameters:

  • num (Numeric) —

    number to divide the vector

Returns:



264
265
266
 
# File 'lib/rubysketch/processing.rb', line 264

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:



183
184
185
186
 
# File 'lib/rubysketch/processing.rb', line 183

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



166
167
168
 
# File 'lib/rubysketch/processing.rb', line 166

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



449
450
451
452
453
454
 
# File 'lib/rubysketch/processing.rb', line 449

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



393
394
395
 
# File 'lib/rubysketch/processing.rb', line 393

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

#div(num) ⇒ Vector

Divides a vector by scalar.

Parameters:

  • num (Numeric) —

    number to divide the vector

Returns:



223
224
225
226
 
# File 'lib/rubysketch/processing.rb', line 223

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



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

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



483
484
485
 
# File 'lib/rubysketch/processing.rb', line 483

def heading()
  Math.atan2 y, x
end

#initialize_copy(o) ⇒ Object

Initializer for dup or clone



49
50
51
 
# File 'lib/rubysketch/processing.rb', line 49

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



142
143
144
145
146
147
148
 
# File 'lib/rubysketch/processing.rb', line 142

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:



382
383
384
385
 
# File 'lib/rubysketch/processing.rb', line 382

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

#mag ⇒ Numeric

Returns the length of the vector.

Returns:

  • (Numeric) —

    length



340
341
342
 
# File 'lib/rubysketch/processing.rb', line 340

def mag()
  @point.length
end

#magSq ⇒ Numeric

Returns squared length of the vector.

Returns:

  • (Numeric) —

    squared length



348
349
350
 
# File 'lib/rubysketch/processing.rb', line 348

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



212
213
214
215
 
# File 'lib/rubysketch/processing.rb', line 212

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



372
373
374
 
# File 'lib/rubysketch/processing.rb', line 372

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



473
474
475
476
477
 
# File 'lib/rubysketch/processing.rb', line 473

def rotate(angle)
  angle = @context ? @context.toAngle__(angle) : angle * 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



75
76
77
78
 
# File 'lib/rubysketch/processing.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



362
363
364
 
# File 'lib/rubysketch/processing.rb', line 362

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



201
202
203
204
 
# File 'lib/rubysketch/processing.rb', line 201

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

#x ⇒ Numeric

Gets x value.

Returns:

  • (Numeric) —

    x value of vector



84
85
86
 
# File 'lib/rubysketch/processing.rb', line 84

def x()
  @point.x
end

#x=(x) ⇒ Numeric

Sets x value.

Returns:

  • (Numeric) —

    x value of vector



108
109
110
 
# File 'lib/rubysketch/processing.rb', line 108

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

#y ⇒ Numeric

Gets y value.

Returns:

  • (Numeric) —

    y value of vector



92
93
94
 
# File 'lib/rubysketch/processing.rb', line 92

def y()
  @point.y
end

#y=(y) ⇒ Numeric

Sets y value.

Returns:

  • (Numeric) —

    y value of vector



116
117
118
 
# File 'lib/rubysketch/processing.rb', line 116

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

#z ⇒ Numeric

Gets z value.

Returns:

  • (Numeric) —

    z value of vector



100
101
102
 
# File 'lib/rubysketch/processing.rb', line 100

def z()
  @point.z
end

#z=(z) ⇒ Numeric

Sets z value.

Returns:

  • (Numeric) —

    z value of vector



124
125
126
 
# File 'lib/rubysketch/processing.rb', line 124

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