pub fn make_square(half_width: f32) -> PolygonExpand description
Make a square polygon, bypassing the need for a convex hull. (b2MakeSquare)
Examples found in repository?
examples/benchmark/utils.rs (line 96)
84pub fn random_polygon(extent: f32) -> Polygon {
85 let count = 3 + random_int() % 6;
86 let mut points = Vec::with_capacity(count as usize);
87 for _ in 0..count {
88 points.push(random_vec2(-extent, extent));
89 }
90
91 let hull = compute_hull(&points);
92 if hull.count > 0 {
93 return make_polygon(&hull, 0.0);
94 }
95
96 make_square(extent)
97}More examples
examples/benchmark/scenes/pyramids.rs (line 104)
82pub fn create_large_pyramid(world: &mut World) {
83 world_enable_sleeping(world, false);
84
85 let base_count: i32 = if BENCHMARK_DEBUG { 20 } else { 100 };
86
87 {
88 let mut body_def = default_body_def();
89 body_def.position = to_pos(Vec2 { x: 0.0, y: -1.0 });
90 let ground_id = create_body(world, &body_def);
91
92 let box_shape = make_box(100.0, 1.0);
93 let shape_def = default_shape_def();
94 create_polygon_shape(world, ground_id, &shape_def, &box_shape);
95 }
96
97 let mut body_def = default_body_def();
98 body_def.type_ = BodyType::Dynamic;
99
100 let mut shape_def = default_shape_def();
101 shape_def.density = 1.0;
102
103 let a = 0.5;
104 let box_shape = make_square(a);
105
106 let shift = 1.0 * a;
107
108 for i in 0..base_count {
109 let y = (2.0 * i as f32 + 1.0) * shift;
110
111 for j in i..base_count {
112 let x = (i as f32 + 1.0) * shift + 2.0 * (j - i) as f32 * shift - a * base_count as f32;
113
114 body_def.position = to_pos(Vec2 { x, y });
115
116 let body_id = create_body(world, &body_def);
117 create_polygon_shape(world, body_id, &shape_def, &box_shape);
118 }
119 }
120}
121
122// (static CreateSmallPyramid)
123fn create_small_pyramid(
124 world: &mut World,
125 base_count: i32,
126 extent: f32,
127 center_x: f32,
128 base_y: f32,
129) {
130 let mut body_def = default_body_def();
131 body_def.type_ = BodyType::Dynamic;
132
133 let shape_def = default_shape_def();
134
135 let box_shape = make_square(extent);
136
137 for i in 0..base_count {
138 let y = (2.0 * i as f32 + 1.0) * extent + base_y;
139
140 for j in i..base_count {
141 let x = (i as f32 + 1.0) * extent + 2.0 * (j - i) as f32 * extent + center_x - 0.5;
142 body_def.position = to_pos(Vec2 { x, y });
143
144 let body_id = create_body(world, &body_def);
145 create_polygon_shape(world, body_id, &shape_def, &box_shape);
146 }
147 }
148}examples/benchmark/scenes/machines.rs (line 110)
39pub fn create_spinner(world: &mut World) {
40 let ground_id;
41 {
42 let body_def = default_body_def();
43 ground_id = create_body(world, &body_def);
44
45 let q = make_rot(-2.0 * PI / SPINNER_POINT_COUNT as f32);
46 let mut p = Vec2 { x: 40.0, y: 0.0 };
47 let mut points: Vec<Vec2> = Vec::with_capacity(SPINNER_POINT_COUNT);
48 for _ in 0..SPINNER_POINT_COUNT {
49 points.push(Vec2 {
50 x: p.x,
51 y: p.y + 32.0,
52 });
53 p = rotate_vector(q, p);
54 }
55
56 // C: b2SurfaceMaterial material = { 0 }; material.friction = 0.1f;
57 let material = SurfaceMaterial {
58 friction: 0.1,
59 restitution: 0.0,
60 rolling_resistance: 0.0,
61 tangent_speed: 0.0,
62 user_material_id: 0,
63 custom_color: 0,
64 };
65
66 let mut chain_def = default_chain_def();
67 chain_def.points = points;
68 chain_def.is_loop = true;
69 chain_def.materials = vec![material];
70
71 create_chain(world, ground_id, &chain_def);
72 }
73
74 {
75 let mut body_def = default_body_def();
76 body_def.type_ = BodyType::Dynamic;
77 body_def.position = to_pos(Vec2 { x: 0.0, y: 12.0 });
78 body_def.enable_sleep = false;
79
80 let spinner_id = create_body(world, &body_def);
81
82 let box_shape = make_rounded_box(0.4, 20.0, 0.2);
83 let mut shape_def = default_shape_def();
84 shape_def.material.friction = 0.0;
85 create_polygon_shape(world, spinner_id, &shape_def, &box_shape);
86
87 let motor_speed = 5.0;
88 let max_motor_torque = f32::MAX;
89 let mut joint_def = default_revolute_joint_def();
90 joint_def.base.body_id_a = ground_id;
91 joint_def.base.body_id_b = spinner_id;
92 joint_def.base.local_frame_a.p = body_get_local_point(world, ground_id, body_def.position);
93 joint_def.enable_motor = true;
94 joint_def.motor_speed = motor_speed;
95 joint_def.max_motor_torque = max_motor_torque;
96
97 let joint_id = create_revolute_joint(world, &joint_def);
98 SPINNER_ID.with(|id| id.set(joint_id));
99 }
100
101 let capsule = Capsule {
102 center1: Vec2 { x: -0.25, y: 0.0 },
103 center2: Vec2 { x: 0.25, y: 0.0 },
104 radius: 0.25,
105 };
106 let circle = Circle {
107 center: Vec2 { x: 0.0, y: 0.0 },
108 radius: 0.35,
109 };
110 let square = make_square(0.35);
111
112 let mut body_def = default_body_def();
113 body_def.type_ = BodyType::Dynamic;
114 let mut shape_def = default_shape_def();
115 shape_def.material.friction = 0.1;
116 shape_def.material.restitution = 0.1;
117 shape_def.density = 0.25;
118
119 let body_count: i32 = if BENCHMARK_DEBUG { 499 } else { 2 * 3038 };
120
121 let mut x = -23.0;
122 let mut y = 2.0;
123 for i in 0..body_count {
124 body_def.position = to_pos(Vec2 { x, y });
125 let body_id = create_body(world, &body_def);
126
127 let remainder = i % 3;
128 if remainder == 0 {
129 create_capsule_shape(world, body_id, &shape_def, &capsule);
130 } else if remainder == 1 {
131 create_circle_shape(world, body_id, &shape_def, &circle);
132 } else if remainder == 2 {
133 create_polygon_shape(world, body_id, &shape_def, &square);
134 }
135
136 x += 0.5;
137
138 if x >= 23.0 {
139 x = -23.0;
140 y += 0.5;
141 }
142 }
143}
144
145// (StepSpinner)
146pub fn step_spinner(world: &mut World, _step_count: i32) -> f32 {
147 let joint_id = SPINNER_ID.with(|id| id.get());
148 revolute_joint_get_angle(world, joint_id)
149}
150
151// (CreateSmash)
152pub fn create_smash(world: &mut World) {
153 world_set_gravity(world, VEC2_ZERO);
154
155 {
156 let box_shape = make_box(4.0, 4.0);
157
158 let mut body_def = default_body_def();
159 body_def.type_ = BodyType::Dynamic;
160 body_def.position = to_pos(Vec2 { x: -20.0, y: 0.0 });
161 body_def.linear_velocity = Vec2 { x: 40.0, y: 0.0 };
162 let body_id = create_body(world, &body_def);
163
164 let mut shape_def = default_shape_def();
165 shape_def.density = 8.0;
166 create_polygon_shape(world, body_id, &shape_def, &box_shape);
167 }
168
169 let d = 0.4;
170 let box_shape = make_square(0.5 * d);
171
172 let mut body_def = default_body_def();
173 body_def.type_ = BodyType::Dynamic;
174 body_def.is_awake = false;
175
176 let shape_def = default_shape_def();
177
178 let columns: i32 = if BENCHMARK_DEBUG { 20 } else { 120 };
179 let rows: i32 = if BENCHMARK_DEBUG { 10 } else { 80 };
180
181 for i in 0..columns {
182 for j in 0..rows {
183 body_def.position = to_pos(Vec2 {
184 x: i as f32 * d + 30.0,
185 y: (j as f32 - rows as f32 / 2.0) * d,
186 });
187 let body_id = create_body(world, &body_def);
188 create_polygon_shape(world, body_id, &shape_def, &box_shape);
189 }
190 }
191}
192
193// (CreateTumbler)
194pub fn create_tumbler(world: &mut World) {
195 let ground_id;
196 {
197 let body_def = default_body_def();
198 ground_id = create_body(world, &body_def);
199 }
200
201 {
202 let mut body_def = default_body_def();
203 body_def.type_ = BodyType::Dynamic;
204 body_def.position = to_pos(Vec2 { x: 0.0, y: 10.0 });
205 let body_id = create_body(world, &body_def);
206
207 let mut shape_def = default_shape_def();
208 shape_def.density = 50.0;
209
210 let polygon = make_offset_box(0.5, 10.0, Vec2 { x: 10.0, y: 0.0 }, ROT_IDENTITY);
211 create_polygon_shape(world, body_id, &shape_def, &polygon);
212 let polygon = make_offset_box(0.5, 10.0, Vec2 { x: -10.0, y: 0.0 }, ROT_IDENTITY);
213 create_polygon_shape(world, body_id, &shape_def, &polygon);
214 let polygon = make_offset_box(10.0, 0.5, Vec2 { x: 0.0, y: 10.0 }, ROT_IDENTITY);
215 create_polygon_shape(world, body_id, &shape_def, &polygon);
216 let polygon = make_offset_box(10.0, 0.5, Vec2 { x: 0.0, y: -10.0 }, ROT_IDENTITY);
217 create_polygon_shape(world, body_id, &shape_def, &polygon);
218
219 let motor_speed = 25.0;
220
221 let mut joint_def = default_revolute_joint_def();
222 joint_def.base.body_id_a = ground_id;
223 joint_def.base.body_id_b = body_id;
224 joint_def.base.local_frame_a.p = Vec2 { x: 0.0, y: 10.0 };
225 joint_def.base.local_frame_b.p = Vec2 { x: 0.0, y: 0.0 };
226 joint_def.motor_speed = (PI / 180.0) * motor_speed;
227 joint_def.max_motor_torque = 1e8;
228 joint_def.enable_motor = true;
229
230 create_revolute_joint(world, &joint_def);
231 }
232
233 let grid_count: i32 = if BENCHMARK_DEBUG { 20 } else { 45 };
234
235 let polygon = make_box(0.125, 0.125);
236 let mut body_def = default_body_def();
237 body_def.type_ = BodyType::Dynamic;
238 let shape_def = default_shape_def();
239
240 let mut y = -0.2 * grid_count as f32 + 10.0;
241 for _ in 0..grid_count {
242 let mut x = -0.2 * grid_count as f32;
243
244 for _ in 0..grid_count {
245 body_def.position = to_pos(Vec2 { x, y });
246 let body_id = create_body(world, &body_def);
247
248 create_polygon_shape(world, body_id, &shape_def, &polygon);
249
250 x += 0.4;
251 }
252
253 y += 0.4;
254 }
255}
256
257// (CreateWasher)
258pub fn create_washer(world: &mut World) {
259 let kinematic = true;
260
261 {
262 let body_def = default_body_def();
263 // groundId is only used to anchor the (disabled) revolute joint branch.
264 let _ground_id = create_body(world, &body_def);
265 }
266
267 {
268 let motor_speed = 25.0;
269
270 let mut body_def = default_body_def();
271 body_def.position = to_pos(Vec2 { x: 0.0, y: 10.0 });
272
273 if kinematic {
274 body_def.type_ = BodyType::Kinematic;
275 body_def.angular_velocity = (PI / 180.0) * motor_speed;
276 body_def.linear_velocity = Vec2 {
277 x: 0.001,
278 y: -0.002,
279 };
280 } else {
281 body_def.type_ = BodyType::Dynamic;
282 }
283
284 let body_id = create_body(world, &body_def);
285
286 let shape_def = default_shape_def();
287
288 let r0 = 14.0;
289 let r1 = 16.0;
290 let r2 = 18.0;
291
292 let angle = PI / 18.0;
293 let q = Rot {
294 c: angle.cos(),
295 s: angle.sin(),
296 };
297 let qo = Rot {
298 c: (0.1 * angle).cos(),
299 s: (0.1 * angle).sin(),
300 };
301 let mut u1 = Vec2 { x: 1.0, y: 0.0 };
302 for i in 0..36 {
303 let u2 = if i == 35 {
304 Vec2 { x: 1.0, y: 0.0 }
305 } else {
306 rotate_vector(q, u1)
307 };
308
309 {
310 let a1 = inv_rotate_vector(qo, u1);
311 let a2 = rotate_vector(qo, u2);
312
313 let p1 = mul_sv(r1, a1);
314 let p2 = mul_sv(r2, a1);
315 let p3 = mul_sv(r1, a2);
316 let p4 = mul_sv(r2, a2);
317
318 let points = [p1, p2, p3, p4];
319 let hull = compute_hull(&points);
320
321 let polygon = make_polygon(&hull, 0.0);
322 create_polygon_shape(world, body_id, &shape_def, &polygon);
323 }
324
325 if i % 9 == 0 {
326 let p1 = mul_sv(r0, u1);
327 let p2 = mul_sv(r1, u1);
328 let p3 = mul_sv(r0, u2);
329 let p4 = mul_sv(r1, u2);
330
331 let points = [p1, p2, p3, p4];
332 let hull = compute_hull(&points);
333
334 let polygon = make_polygon(&hull, 0.0);
335 create_polygon_shape(world, body_id, &shape_def, &polygon);
336 }
337
338 u1 = u2;
339 }
340 }
341
342 let grid_count: i32 = if BENCHMARK_DEBUG { 20 } else { 90 };
343 let a = 0.1;
344
345 let polygon = make_square(a);
346 let mut body_def = default_body_def();
347 body_def.type_ = BodyType::Dynamic;
348 let mut shape_def = default_shape_def();
349 shape_def.enable_hit_events = true;
350
351 let mut y = -1.1 * a * grid_count as f32 + 10.0;
352 for _ in 0..grid_count {
353 let mut x = -1.1 * a * grid_count as f32;
354
355 for _ in 0..grid_count {
356 body_def.position = to_pos(Vec2 { x, y });
357 let body_id = create_body(world, &body_def);
358
359 create_polygon_shape(world, body_id, &shape_def, &polygon);
360
361 x += 2.1 * a;
362 }
363
364 y += 2.1 * a;
365 }
366}