box2d-rs 0.0.4

Port of Box2d to Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

use crate::b2_collision::*;
use crate::b2_math::*;
use crate::b2_time_step::*;
use crate::b2_common::*;
use crate::b2rs_common::UserDataType;
use crate::b2_contact::*;

use super::b2_contact_solver_private as private;

#[derive(Default,Copy, Clone)]
pub(crate) struct B2velocityConstraintPoint
{
	pub(crate)  r_a: B2vec2,
	 pub(crate)  r_b: B2vec2,
	 pub(crate)  normal_impulse: f32,
	 pub(crate) tangent_impulse: f32,
	pub(crate) normal_mass: f32,
	pub(crate) tangent_mass: f32,
	pub(crate) velocity_bias: f32,
}

#[derive(Default,Copy, Clone)]
pub(crate) struct B2contactVelocityConstraint
{
	pub(crate) points: [B2velocityConstraintPoint;B2_MAX_MANIFOLD_POINTS],
	pub(crate) normal: B2vec2,
	pub(crate) normal_mass: B2Mat22,
	pub(crate) k: B2Mat22,
	pub(crate) index_a: i32,
	pub(crate) index_b: i32,
	pub(crate) inv_mass_a: f32,
	pub(crate) inv_mass_b: f32,
	pub(crate) inv_ia: f32,
	pub(crate) inv_ib: f32,
	pub(crate) friction: f32,
	pub(crate) restitution: f32,
	pub(crate) threshold: f32,
	pub(crate) tangent_speed: f32,
	pub(crate) point_count: i32,
	pub(crate) contact_index: i32,
}


pub(crate) struct B2contactSolverDef
{
	pub(crate) step: B2timeStep,
	//box2d-rs: not using struct because of borrowing and mutability
	//pub(crate) contacts: &'a mut  Vec<ContactPtr<D>>,
	//pub(crate) positions: &'a mut  Vec<B2position>,
	//pub(crate) velocities: &'a mut  Vec<B2velocity>,
	//b2StackAllocator* allocator;
}

impl B2contactSolver
{
	pub fn new<D: UserDataType>(def: &B2contactSolverDef, 
		contacts: &Vec<ContactPtr<D>>)->Self{
		return private::new(def, contacts);
	}

	pub fn  initialize_velocity_constraints<D: UserDataType>(&mut self,
		m_positions: &[B2position], m_velocities: &[B2velocity], m_contacts: &[ContactPtr<D>]){
		private::initialize_velocity_constraints(self, m_positions, m_velocities, m_contacts);
	}

	pub fn  warm_start(&mut self, m_velocities: &mut [B2velocity]){
		private::warm_start(self, m_velocities);
	}
	pub fn  solve_velocity_constraints(&mut self, m_velocities: &mut [B2velocity]){
		private::solve_velocity_constraints(self, m_velocities);
	}
	pub fn  store_impulses<D: UserDataType>(&mut self, m_contacts: &[ContactPtr<D>]){
		private::store_impulses(self, m_contacts);
	}

	pub fn  solve_position_constraints(&mut self, m_positions: &mut [B2position]) -> bool
	{
		return private::solve_position_constraints(self, m_positions);
	}
	pub fn  solve_toiposition_constraints(&mut self, toi_index_a: i32, toi_index_b: i32, 
		m_positions: &mut [B2position]) -> bool
	{
		return private::solve_toiposition_constraints(self, toi_index_a, toi_index_b, m_positions);
	}

}

#[derive(Default,Clone)]
pub(crate) struct B2contactSolver
{
	pub(crate) m_step: B2timeStep,
	//m_positions: Vec<B2position>,
	//m_velocities: Vec<B2velocity>,
	//m_contacts: Vec<ContactPtr<D>>,
	//m_count: i32,
	//b2StackAllocator* m_allocator;
	pub(crate) m_position_constraints: Vec<B2contactPositionConstraint>,
	pub(crate) m_velocity_constraints: Vec<B2contactVelocityConstraint>,
}

#[derive(Default, Copy, Clone)]
pub(crate) struct B2contactPositionConstraint
{
	pub(crate) local_points: [B2vec2; B2_MAX_MANIFOLD_POINTS],
	pub(crate) local_normal: B2vec2,
	pub(crate) local_point: B2vec2,
	pub(crate) index_a: i32,
	pub(crate) index_b: i32,
	pub(crate) inv_mass_a: f32, 
	pub(crate) inv_mass_b: f32,
	pub(crate) local_center_a: B2vec2, 
	pub(crate) local_center_b: B2vec2,
	pub(crate) inv_ia: f32, 
	pub(crate) inv_ib: f32,
	pub(crate) mtype: B2manifoldType,
	pub(crate) radius_a: f32,
	pub(crate) radius_b: f32,
	pub(crate)  point_count: i32,
}