Class: Jolt::ConstraintCollection

Inherits:
Object
  • Object
show all
Includes:
Enumerable
Defined in:
lib/jolt/constraint_collection.rb

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(system) ⇒ ConstraintCollection

Returns a new instance of ConstraintCollection.



22
23
24
 
# File 'lib/jolt/constraint_collection.rb', line 22

def initialize(system)
  @system = system
end

Class Method Details

.interval(value, name) ⇒ Object 



8
9
10
11
12
13
14
15
16
17
18
19
 
# File 'lib/jolt/constraint_collection.rb', line 8

def interval(value, name)
  values = value.is_a?(Range) ? [value.begin, value.end] : value.to_a
  raise InvalidArgumentError, "#{name} must contain two values" unless values.length == 2

  minimum = Conversions.finite_float(values[0], "#{name} minimum")
  maximum = Conversions.finite_float(values[1], "#{name} maximum")
  raise InvalidArgumentError, "#{name} minimum must not exceed maximum" if minimum > maximum

  [minimum, maximum]
rescue NoMethodError
  raise InvalidArgumentError, "#{name} must be a Range or two-element array"
end

Instance Method Details

#distance(body_a:, body_b:, point_a: nil, point_b: nil, limits: nil) ⇒ Object 



34
35
36
37
38
39
40
41
42
43
 
# File 'lib/jolt/constraint_collection.rb', line 34

def distance(body_a:, body_b:, point_a: nil, point_b: nil, limits: nil)
  validate_body_pair(body_a, body_b)
  point_a ||= body_a.position
  point_b ||= body_b.position
  minimum, maximum = limits ? self.class.interval(limits, "limits") : [-1.0, -1.0]
  create(
    :distance, :JR_Constraint_CreateDistance, body_a, body_b,
    vec(point_a, "point_a"), vec(point_b, "point_b"), minimum, maximum
  )
end

#each(&block) ⇒ Object 



63
64
65
66
67
 
# File 'lib/jolt/constraint_collection.rb', line 63

def each(&block)
  return enum_for(:each) unless block

  @system.__constraints_snapshot.each(&block)
end

#fixed(body_a:, body_b:, anchor: nil) ⇒ Object 



26
27
28
 
# File 'lib/jolt/constraint_collection.rb', line 26

def fixed(body_a:, body_b:, anchor: nil)
  create(:fixed, :JR_Constraint_CreateFixed, body_a, body_b, optional_vec(anchor, "anchor"))
end

#hinge(body_a:, body_b:, anchor:, axis: [0, 1, 0], normal: nil, limits: nil) ⇒ Object 



45
46
47
48
49
50
51
52
53
 
# File 'lib/jolt/constraint_collection.rb', line 45

def hinge(body_a:, body_b:, anchor:, axis: [0, 1, 0], normal: nil, limits: nil)
  axis = unit_vec(axis, "axis")
  normal = normal ? unit_vec(normal, "normal") : perpendicular(axis)
  has_limits, minimum, maximum = optional_interval(limits)
  create(
    :hinge, :JR_Constraint_CreateHinge, body_a, body_b,
    vec(anchor, "anchor"), axis, normal, has_limits, minimum, maximum
  )
end

#point(body_a:, body_b:, anchor:) ⇒ Object 



30
31
32
 
# File 'lib/jolt/constraint_collection.rb', line 30

def point(body_a:, body_b:, anchor:)
  create(:point, :JR_Constraint_CreatePoint, body_a, body_b, vec(anchor, "anchor"))
end

#size ⇒ Object Also known as: length 



69
70
71
 
# File 'lib/jolt/constraint_collection.rb', line 69

def size
  @system.__constraints_snapshot.size
end

#slider(body_a:, body_b:, anchor:, axis:, limits: nil) ⇒ Object 



55
56
57
58
59
60
61
 
# File 'lib/jolt/constraint_collection.rb', line 55

def slider(body_a:, body_b:, anchor:, axis:, limits: nil)
  has_limits, minimum, maximum = optional_interval(limits)
  create(
    :slider, :JR_Constraint_CreateSlider, body_a, body_b,
    vec(anchor, "anchor"), unit_vec(axis, "axis"), has_limits, minimum, maximum
  )
end