objc2_scene_kit/generated/
SCNPhysicsBehavior.rs1use core::ffi::*;
4use core::ptr::NonNull;
5use objc2::__framework_prelude::*;
6#[cfg(feature = "objc2-core-foundation")]
7use objc2_core_foundation::*;
8use objc2_foundation::*;
9
10use crate::*;
11
12extern_class!(
13 #[unsafe(super(NSObject))]
17 #[derive(Debug, PartialEq, Eq, Hash)]
18 pub struct SCNPhysicsBehavior;
19);
20
21unsafe impl NSCoding for SCNPhysicsBehavior {}
22
23unsafe impl NSObjectProtocol for SCNPhysicsBehavior {}
24
25unsafe impl NSSecureCoding for SCNPhysicsBehavior {}
26
27impl SCNPhysicsBehavior {
28 extern_methods!();
29}
30
31impl SCNPhysicsBehavior {
33 extern_methods!(
34 #[unsafe(method(init))]
35 #[unsafe(method_family = init)]
36 pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;
37
38 #[unsafe(method(new))]
39 #[unsafe(method_family = new)]
40 pub unsafe fn new() -> Retained<Self>;
41 );
42}
43
44extern_class!(
45 #[unsafe(super(SCNPhysicsBehavior, NSObject))]
49 #[derive(Debug, PartialEq, Eq, Hash)]
50 pub struct SCNPhysicsHingeJoint;
51);
52
53unsafe impl NSCoding for SCNPhysicsHingeJoint {}
54
55unsafe impl NSObjectProtocol for SCNPhysicsHingeJoint {}
56
57unsafe impl NSSecureCoding for SCNPhysicsHingeJoint {}
58
59impl SCNPhysicsHingeJoint {
60 extern_methods!(
61 #[cfg(all(
62 feature = "SCNPhysicsBody",
63 feature = "SceneKitTypes",
64 feature = "objc2-core-foundation"
65 ))]
66 #[unsafe(method(jointWithBodyA:axisA:anchorA:bodyB:axisB:anchorB:))]
67 #[unsafe(method_family = none)]
68 pub unsafe fn jointWithBodyA_axisA_anchorA_bodyB_axisB_anchorB(
69 body_a: &SCNPhysicsBody,
70 axis_a: SCNVector3,
71 anchor_a: SCNVector3,
72 body_b: &SCNPhysicsBody,
73 axis_b: SCNVector3,
74 anchor_b: SCNVector3,
75 ) -> Retained<Self>;
76
77 #[cfg(all(
78 feature = "SCNPhysicsBody",
79 feature = "SceneKitTypes",
80 feature = "objc2-core-foundation"
81 ))]
82 #[unsafe(method(jointWithBody:axis:anchor:))]
83 #[unsafe(method_family = none)]
84 pub unsafe fn jointWithBody_axis_anchor(
85 body: &SCNPhysicsBody,
86 axis: SCNVector3,
87 anchor: SCNVector3,
88 ) -> Retained<Self>;
89
90 #[cfg(feature = "SCNPhysicsBody")]
91 #[unsafe(method(bodyA))]
92 #[unsafe(method_family = none)]
93 pub unsafe fn bodyA(&self) -> Retained<SCNPhysicsBody>;
94
95 #[cfg(all(feature = "SceneKitTypes", feature = "objc2-core-foundation"))]
96 #[unsafe(method(axisA))]
97 #[unsafe(method_family = none)]
98 pub unsafe fn axisA(&self) -> SCNVector3;
99
100 #[cfg(all(feature = "SceneKitTypes", feature = "objc2-core-foundation"))]
101 #[unsafe(method(setAxisA:))]
103 #[unsafe(method_family = none)]
104 pub unsafe fn setAxisA(&self, axis_a: SCNVector3);
105
106 #[cfg(all(feature = "SceneKitTypes", feature = "objc2-core-foundation"))]
107 #[unsafe(method(anchorA))]
108 #[unsafe(method_family = none)]
109 pub unsafe fn anchorA(&self) -> SCNVector3;
110
111 #[cfg(all(feature = "SceneKitTypes", feature = "objc2-core-foundation"))]
112 #[unsafe(method(setAnchorA:))]
114 #[unsafe(method_family = none)]
115 pub unsafe fn setAnchorA(&self, anchor_a: SCNVector3);
116
117 #[cfg(feature = "SCNPhysicsBody")]
118 #[unsafe(method(bodyB))]
119 #[unsafe(method_family = none)]
120 pub unsafe fn bodyB(&self) -> Option<Retained<SCNPhysicsBody>>;
121
122 #[cfg(all(feature = "SceneKitTypes", feature = "objc2-core-foundation"))]
123 #[unsafe(method(axisB))]
124 #[unsafe(method_family = none)]
125 pub unsafe fn axisB(&self) -> SCNVector3;
126
127 #[cfg(all(feature = "SceneKitTypes", feature = "objc2-core-foundation"))]
128 #[unsafe(method(setAxisB:))]
130 #[unsafe(method_family = none)]
131 pub unsafe fn setAxisB(&self, axis_b: SCNVector3);
132
133 #[cfg(all(feature = "SceneKitTypes", feature = "objc2-core-foundation"))]
134 #[unsafe(method(anchorB))]
135 #[unsafe(method_family = none)]
136 pub unsafe fn anchorB(&self) -> SCNVector3;
137
138 #[cfg(all(feature = "SceneKitTypes", feature = "objc2-core-foundation"))]
139 #[unsafe(method(setAnchorB:))]
141 #[unsafe(method_family = none)]
142 pub unsafe fn setAnchorB(&self, anchor_b: SCNVector3);
143 );
144}
145
146impl SCNPhysicsHingeJoint {
148 extern_methods!(
149 #[unsafe(method(init))]
150 #[unsafe(method_family = init)]
151 pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;
152
153 #[unsafe(method(new))]
154 #[unsafe(method_family = new)]
155 pub unsafe fn new() -> Retained<Self>;
156 );
157}
158
159extern_class!(
160 #[unsafe(super(SCNPhysicsBehavior, NSObject))]
164 #[derive(Debug, PartialEq, Eq, Hash)]
165 pub struct SCNPhysicsBallSocketJoint;
166);
167
168unsafe impl NSCoding for SCNPhysicsBallSocketJoint {}
169
170unsafe impl NSObjectProtocol for SCNPhysicsBallSocketJoint {}
171
172unsafe impl NSSecureCoding for SCNPhysicsBallSocketJoint {}
173
174impl SCNPhysicsBallSocketJoint {
175 extern_methods!(
176 #[cfg(all(
177 feature = "SCNPhysicsBody",
178 feature = "SceneKitTypes",
179 feature = "objc2-core-foundation"
180 ))]
181 #[unsafe(method(jointWithBodyA:anchorA:bodyB:anchorB:))]
182 #[unsafe(method_family = none)]
183 pub unsafe fn jointWithBodyA_anchorA_bodyB_anchorB(
184 body_a: &SCNPhysicsBody,
185 anchor_a: SCNVector3,
186 body_b: &SCNPhysicsBody,
187 anchor_b: SCNVector3,
188 ) -> Retained<Self>;
189
190 #[cfg(all(
191 feature = "SCNPhysicsBody",
192 feature = "SceneKitTypes",
193 feature = "objc2-core-foundation"
194 ))]
195 #[unsafe(method(jointWithBody:anchor:))]
196 #[unsafe(method_family = none)]
197 pub unsafe fn jointWithBody_anchor(
198 body: &SCNPhysicsBody,
199 anchor: SCNVector3,
200 ) -> Retained<Self>;
201
202 #[cfg(feature = "SCNPhysicsBody")]
203 #[unsafe(method(bodyA))]
204 #[unsafe(method_family = none)]
205 pub unsafe fn bodyA(&self) -> Retained<SCNPhysicsBody>;
206
207 #[cfg(all(feature = "SceneKitTypes", feature = "objc2-core-foundation"))]
208 #[unsafe(method(anchorA))]
209 #[unsafe(method_family = none)]
210 pub unsafe fn anchorA(&self) -> SCNVector3;
211
212 #[cfg(all(feature = "SceneKitTypes", feature = "objc2-core-foundation"))]
213 #[unsafe(method(setAnchorA:))]
215 #[unsafe(method_family = none)]
216 pub unsafe fn setAnchorA(&self, anchor_a: SCNVector3);
217
218 #[cfg(feature = "SCNPhysicsBody")]
219 #[unsafe(method(bodyB))]
220 #[unsafe(method_family = none)]
221 pub unsafe fn bodyB(&self) -> Option<Retained<SCNPhysicsBody>>;
222
223 #[cfg(all(feature = "SceneKitTypes", feature = "objc2-core-foundation"))]
224 #[unsafe(method(anchorB))]
225 #[unsafe(method_family = none)]
226 pub unsafe fn anchorB(&self) -> SCNVector3;
227
228 #[cfg(all(feature = "SceneKitTypes", feature = "objc2-core-foundation"))]
229 #[unsafe(method(setAnchorB:))]
231 #[unsafe(method_family = none)]
232 pub unsafe fn setAnchorB(&self, anchor_b: SCNVector3);
233 );
234}
235
236impl SCNPhysicsBallSocketJoint {
238 extern_methods!(
239 #[unsafe(method(init))]
240 #[unsafe(method_family = init)]
241 pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;
242
243 #[unsafe(method(new))]
244 #[unsafe(method_family = new)]
245 pub unsafe fn new() -> Retained<Self>;
246 );
247}
248
249extern_class!(
250 #[unsafe(super(SCNPhysicsBehavior, NSObject))]
254 #[derive(Debug, PartialEq, Eq, Hash)]
255 pub struct SCNPhysicsSliderJoint;
256);
257
258unsafe impl NSCoding for SCNPhysicsSliderJoint {}
259
260unsafe impl NSObjectProtocol for SCNPhysicsSliderJoint {}
261
262unsafe impl NSSecureCoding for SCNPhysicsSliderJoint {}
263
264impl SCNPhysicsSliderJoint {
265 extern_methods!(
266 #[cfg(all(
267 feature = "SCNPhysicsBody",
268 feature = "SceneKitTypes",
269 feature = "objc2-core-foundation"
270 ))]
271 #[unsafe(method(jointWithBodyA:axisA:anchorA:bodyB:axisB:anchorB:))]
272 #[unsafe(method_family = none)]
273 pub unsafe fn jointWithBodyA_axisA_anchorA_bodyB_axisB_anchorB(
274 body_a: &SCNPhysicsBody,
275 axis_a: SCNVector3,
276 anchor_a: SCNVector3,
277 body_b: &SCNPhysicsBody,
278 axis_b: SCNVector3,
279 anchor_b: SCNVector3,
280 ) -> Retained<Self>;
281
282 #[cfg(all(
283 feature = "SCNPhysicsBody",
284 feature = "SceneKitTypes",
285 feature = "objc2-core-foundation"
286 ))]
287 #[unsafe(method(jointWithBody:axis:anchor:))]
288 #[unsafe(method_family = none)]
289 pub unsafe fn jointWithBody_axis_anchor(
290 body: &SCNPhysicsBody,
291 axis: SCNVector3,
292 anchor: SCNVector3,
293 ) -> Retained<Self>;
294
295 #[cfg(feature = "SCNPhysicsBody")]
296 #[unsafe(method(bodyA))]
297 #[unsafe(method_family = none)]
298 pub unsafe fn bodyA(&self) -> Retained<SCNPhysicsBody>;
299
300 #[cfg(all(feature = "SceneKitTypes", feature = "objc2-core-foundation"))]
301 #[unsafe(method(axisA))]
302 #[unsafe(method_family = none)]
303 pub unsafe fn axisA(&self) -> SCNVector3;
304
305 #[cfg(all(feature = "SceneKitTypes", feature = "objc2-core-foundation"))]
306 #[unsafe(method(setAxisA:))]
308 #[unsafe(method_family = none)]
309 pub unsafe fn setAxisA(&self, axis_a: SCNVector3);
310
311 #[cfg(all(feature = "SceneKitTypes", feature = "objc2-core-foundation"))]
312 #[unsafe(method(anchorA))]
313 #[unsafe(method_family = none)]
314 pub unsafe fn anchorA(&self) -> SCNVector3;
315
316 #[cfg(all(feature = "SceneKitTypes", feature = "objc2-core-foundation"))]
317 #[unsafe(method(setAnchorA:))]
319 #[unsafe(method_family = none)]
320 pub unsafe fn setAnchorA(&self, anchor_a: SCNVector3);
321
322 #[cfg(feature = "SCNPhysicsBody")]
323 #[unsafe(method(bodyB))]
324 #[unsafe(method_family = none)]
325 pub unsafe fn bodyB(&self) -> Option<Retained<SCNPhysicsBody>>;
326
327 #[cfg(all(feature = "SceneKitTypes", feature = "objc2-core-foundation"))]
328 #[unsafe(method(axisB))]
329 #[unsafe(method_family = none)]
330 pub unsafe fn axisB(&self) -> SCNVector3;
331
332 #[cfg(all(feature = "SceneKitTypes", feature = "objc2-core-foundation"))]
333 #[unsafe(method(setAxisB:))]
335 #[unsafe(method_family = none)]
336 pub unsafe fn setAxisB(&self, axis_b: SCNVector3);
337
338 #[cfg(all(feature = "SceneKitTypes", feature = "objc2-core-foundation"))]
339 #[unsafe(method(anchorB))]
340 #[unsafe(method_family = none)]
341 pub unsafe fn anchorB(&self) -> SCNVector3;
342
343 #[cfg(all(feature = "SceneKitTypes", feature = "objc2-core-foundation"))]
344 #[unsafe(method(setAnchorB:))]
346 #[unsafe(method_family = none)]
347 pub unsafe fn setAnchorB(&self, anchor_b: SCNVector3);
348
349 #[cfg(feature = "objc2-core-foundation")]
350 #[unsafe(method(minimumLinearLimit))]
351 #[unsafe(method_family = none)]
352 pub unsafe fn minimumLinearLimit(&self) -> CGFloat;
353
354 #[cfg(feature = "objc2-core-foundation")]
355 #[unsafe(method(setMinimumLinearLimit:))]
357 #[unsafe(method_family = none)]
358 pub unsafe fn setMinimumLinearLimit(&self, minimum_linear_limit: CGFloat);
359
360 #[cfg(feature = "objc2-core-foundation")]
361 #[unsafe(method(maximumLinearLimit))]
362 #[unsafe(method_family = none)]
363 pub unsafe fn maximumLinearLimit(&self) -> CGFloat;
364
365 #[cfg(feature = "objc2-core-foundation")]
366 #[unsafe(method(setMaximumLinearLimit:))]
368 #[unsafe(method_family = none)]
369 pub unsafe fn setMaximumLinearLimit(&self, maximum_linear_limit: CGFloat);
370
371 #[cfg(feature = "objc2-core-foundation")]
372 #[unsafe(method(minimumAngularLimit))]
373 #[unsafe(method_family = none)]
374 pub unsafe fn minimumAngularLimit(&self) -> CGFloat;
375
376 #[cfg(feature = "objc2-core-foundation")]
377 #[unsafe(method(setMinimumAngularLimit:))]
379 #[unsafe(method_family = none)]
380 pub unsafe fn setMinimumAngularLimit(&self, minimum_angular_limit: CGFloat);
381
382 #[cfg(feature = "objc2-core-foundation")]
383 #[unsafe(method(maximumAngularLimit))]
384 #[unsafe(method_family = none)]
385 pub unsafe fn maximumAngularLimit(&self) -> CGFloat;
386
387 #[cfg(feature = "objc2-core-foundation")]
388 #[unsafe(method(setMaximumAngularLimit:))]
390 #[unsafe(method_family = none)]
391 pub unsafe fn setMaximumAngularLimit(&self, maximum_angular_limit: CGFloat);
392
393 #[cfg(feature = "objc2-core-foundation")]
394 #[unsafe(method(motorTargetLinearVelocity))]
395 #[unsafe(method_family = none)]
396 pub unsafe fn motorTargetLinearVelocity(&self) -> CGFloat;
397
398 #[cfg(feature = "objc2-core-foundation")]
399 #[unsafe(method(setMotorTargetLinearVelocity:))]
401 #[unsafe(method_family = none)]
402 pub unsafe fn setMotorTargetLinearVelocity(&self, motor_target_linear_velocity: CGFloat);
403
404 #[cfg(feature = "objc2-core-foundation")]
405 #[unsafe(method(motorMaximumForce))]
406 #[unsafe(method_family = none)]
407 pub unsafe fn motorMaximumForce(&self) -> CGFloat;
408
409 #[cfg(feature = "objc2-core-foundation")]
410 #[unsafe(method(setMotorMaximumForce:))]
412 #[unsafe(method_family = none)]
413 pub unsafe fn setMotorMaximumForce(&self, motor_maximum_force: CGFloat);
414
415 #[cfg(feature = "objc2-core-foundation")]
416 #[unsafe(method(motorTargetAngularVelocity))]
417 #[unsafe(method_family = none)]
418 pub unsafe fn motorTargetAngularVelocity(&self) -> CGFloat;
419
420 #[cfg(feature = "objc2-core-foundation")]
421 #[unsafe(method(setMotorTargetAngularVelocity:))]
423 #[unsafe(method_family = none)]
424 pub unsafe fn setMotorTargetAngularVelocity(&self, motor_target_angular_velocity: CGFloat);
425
426 #[cfg(feature = "objc2-core-foundation")]
427 #[unsafe(method(motorMaximumTorque))]
428 #[unsafe(method_family = none)]
429 pub unsafe fn motorMaximumTorque(&self) -> CGFloat;
430
431 #[cfg(feature = "objc2-core-foundation")]
432 #[unsafe(method(setMotorMaximumTorque:))]
434 #[unsafe(method_family = none)]
435 pub unsafe fn setMotorMaximumTorque(&self, motor_maximum_torque: CGFloat);
436 );
437}
438
439impl SCNPhysicsSliderJoint {
441 extern_methods!(
442 #[unsafe(method(init))]
443 #[unsafe(method_family = init)]
444 pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;
445
446 #[unsafe(method(new))]
447 #[unsafe(method_family = new)]
448 pub unsafe fn new() -> Retained<Self>;
449 );
450}
451
452extern_class!(
453 #[unsafe(super(SCNPhysicsBehavior, NSObject))]
455 #[derive(Debug, PartialEq, Eq, Hash)]
456 pub struct SCNPhysicsConeTwistJoint;
457);
458
459unsafe impl NSCoding for SCNPhysicsConeTwistJoint {}
460
461unsafe impl NSObjectProtocol for SCNPhysicsConeTwistJoint {}
462
463unsafe impl NSSecureCoding for SCNPhysicsConeTwistJoint {}
464
465impl SCNPhysicsConeTwistJoint {
466 extern_methods!(
467 #[cfg(all(
468 feature = "SCNPhysicsBody",
469 feature = "SceneKitTypes",
470 feature = "objc2-quartz-core"
471 ))]
472 #[cfg(not(target_os = "watchos"))]
473 #[unsafe(method(jointWithBodyA:frameA:bodyB:frameB:))]
474 #[unsafe(method_family = none)]
475 pub unsafe fn jointWithBodyA_frameA_bodyB_frameB(
476 body_a: &SCNPhysicsBody,
477 frame_a: SCNMatrix4,
478 body_b: &SCNPhysicsBody,
479 frame_b: SCNMatrix4,
480 ) -> Retained<Self>;
481
482 #[cfg(all(
483 feature = "SCNPhysicsBody",
484 feature = "SceneKitTypes",
485 feature = "objc2-quartz-core"
486 ))]
487 #[cfg(not(target_os = "watchos"))]
488 #[unsafe(method(jointWithBody:frame:))]
489 #[unsafe(method_family = none)]
490 pub unsafe fn jointWithBody_frame(
491 body: &SCNPhysicsBody,
492 frame: SCNMatrix4,
493 ) -> Retained<Self>;
494
495 #[cfg(feature = "SCNPhysicsBody")]
496 #[unsafe(method(bodyA))]
497 #[unsafe(method_family = none)]
498 pub unsafe fn bodyA(&self) -> Retained<SCNPhysicsBody>;
499
500 #[cfg(all(feature = "SceneKitTypes", feature = "objc2-quartz-core"))]
501 #[cfg(not(target_os = "watchos"))]
502 #[unsafe(method(frameA))]
503 #[unsafe(method_family = none)]
504 pub unsafe fn frameA(&self) -> SCNMatrix4;
505
506 #[cfg(all(feature = "SceneKitTypes", feature = "objc2-quartz-core"))]
507 #[cfg(not(target_os = "watchos"))]
508 #[unsafe(method(setFrameA:))]
510 #[unsafe(method_family = none)]
511 pub unsafe fn setFrameA(&self, frame_a: SCNMatrix4);
512
513 #[cfg(feature = "SCNPhysicsBody")]
514 #[unsafe(method(bodyB))]
515 #[unsafe(method_family = none)]
516 pub unsafe fn bodyB(&self) -> Option<Retained<SCNPhysicsBody>>;
517
518 #[cfg(all(feature = "SceneKitTypes", feature = "objc2-quartz-core"))]
519 #[cfg(not(target_os = "watchos"))]
520 #[unsafe(method(frameB))]
521 #[unsafe(method_family = none)]
522 pub unsafe fn frameB(&self) -> SCNMatrix4;
523
524 #[cfg(all(feature = "SceneKitTypes", feature = "objc2-quartz-core"))]
525 #[cfg(not(target_os = "watchos"))]
526 #[unsafe(method(setFrameB:))]
528 #[unsafe(method_family = none)]
529 pub unsafe fn setFrameB(&self, frame_b: SCNMatrix4);
530
531 #[cfg(feature = "objc2-core-foundation")]
532 #[unsafe(method(maximumAngularLimit1))]
533 #[unsafe(method_family = none)]
534 pub unsafe fn maximumAngularLimit1(&self) -> CGFloat;
535
536 #[cfg(feature = "objc2-core-foundation")]
537 #[unsafe(method(setMaximumAngularLimit1:))]
539 #[unsafe(method_family = none)]
540 pub unsafe fn setMaximumAngularLimit1(&self, maximum_angular_limit1: CGFloat);
541
542 #[cfg(feature = "objc2-core-foundation")]
543 #[unsafe(method(maximumAngularLimit2))]
544 #[unsafe(method_family = none)]
545 pub unsafe fn maximumAngularLimit2(&self) -> CGFloat;
546
547 #[cfg(feature = "objc2-core-foundation")]
548 #[unsafe(method(setMaximumAngularLimit2:))]
550 #[unsafe(method_family = none)]
551 pub unsafe fn setMaximumAngularLimit2(&self, maximum_angular_limit2: CGFloat);
552
553 #[cfg(feature = "objc2-core-foundation")]
554 #[unsafe(method(maximumTwistAngle))]
555 #[unsafe(method_family = none)]
556 pub unsafe fn maximumTwistAngle(&self) -> CGFloat;
557
558 #[cfg(feature = "objc2-core-foundation")]
559 #[unsafe(method(setMaximumTwistAngle:))]
561 #[unsafe(method_family = none)]
562 pub unsafe fn setMaximumTwistAngle(&self, maximum_twist_angle: CGFloat);
563 );
564}
565
566impl SCNPhysicsConeTwistJoint {
568 extern_methods!(
569 #[unsafe(method(init))]
570 #[unsafe(method_family = init)]
571 pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;
572
573 #[unsafe(method(new))]
574 #[unsafe(method_family = new)]
575 pub unsafe fn new() -> Retained<Self>;
576 );
577}
578
579extern_class!(
580 #[unsafe(super(NSObject))]
584 #[derive(Debug, PartialEq, Eq, Hash)]
585 pub struct SCNPhysicsVehicleWheel;
586);
587
588unsafe impl NSCoding for SCNPhysicsVehicleWheel {}
589
590unsafe impl NSCopying for SCNPhysicsVehicleWheel {}
591
592unsafe impl CopyingHelper for SCNPhysicsVehicleWheel {
593 type Result = Self;
594}
595
596unsafe impl NSObjectProtocol for SCNPhysicsVehicleWheel {}
597
598unsafe impl NSSecureCoding for SCNPhysicsVehicleWheel {}
599
600impl SCNPhysicsVehicleWheel {
601 extern_methods!(
602 #[cfg(feature = "SCNNode")]
603 #[unsafe(method(wheelWithNode:))]
604 #[unsafe(method_family = none)]
605 pub unsafe fn wheelWithNode(node: &SCNNode) -> Retained<Self>;
606
607 #[cfg(feature = "SCNNode")]
608 #[unsafe(method(node))]
609 #[unsafe(method_family = none)]
610 pub unsafe fn node(&self) -> Retained<SCNNode>;
611
612 #[cfg(feature = "objc2-core-foundation")]
613 #[unsafe(method(suspensionStiffness))]
614 #[unsafe(method_family = none)]
615 pub unsafe fn suspensionStiffness(&self) -> CGFloat;
616
617 #[cfg(feature = "objc2-core-foundation")]
618 #[unsafe(method(setSuspensionStiffness:))]
620 #[unsafe(method_family = none)]
621 pub unsafe fn setSuspensionStiffness(&self, suspension_stiffness: CGFloat);
622
623 #[cfg(feature = "objc2-core-foundation")]
624 #[unsafe(method(suspensionCompression))]
625 #[unsafe(method_family = none)]
626 pub unsafe fn suspensionCompression(&self) -> CGFloat;
627
628 #[cfg(feature = "objc2-core-foundation")]
629 #[unsafe(method(setSuspensionCompression:))]
631 #[unsafe(method_family = none)]
632 pub unsafe fn setSuspensionCompression(&self, suspension_compression: CGFloat);
633
634 #[cfg(feature = "objc2-core-foundation")]
635 #[unsafe(method(suspensionDamping))]
636 #[unsafe(method_family = none)]
637 pub unsafe fn suspensionDamping(&self) -> CGFloat;
638
639 #[cfg(feature = "objc2-core-foundation")]
640 #[unsafe(method(setSuspensionDamping:))]
642 #[unsafe(method_family = none)]
643 pub unsafe fn setSuspensionDamping(&self, suspension_damping: CGFloat);
644
645 #[cfg(feature = "objc2-core-foundation")]
646 #[unsafe(method(maximumSuspensionTravel))]
647 #[unsafe(method_family = none)]
648 pub unsafe fn maximumSuspensionTravel(&self) -> CGFloat;
649
650 #[cfg(feature = "objc2-core-foundation")]
651 #[unsafe(method(setMaximumSuspensionTravel:))]
653 #[unsafe(method_family = none)]
654 pub unsafe fn setMaximumSuspensionTravel(&self, maximum_suspension_travel: CGFloat);
655
656 #[cfg(feature = "objc2-core-foundation")]
657 #[unsafe(method(frictionSlip))]
658 #[unsafe(method_family = none)]
659 pub unsafe fn frictionSlip(&self) -> CGFloat;
660
661 #[cfg(feature = "objc2-core-foundation")]
662 #[unsafe(method(setFrictionSlip:))]
664 #[unsafe(method_family = none)]
665 pub unsafe fn setFrictionSlip(&self, friction_slip: CGFloat);
666
667 #[cfg(feature = "objc2-core-foundation")]
668 #[unsafe(method(maximumSuspensionForce))]
669 #[unsafe(method_family = none)]
670 pub unsafe fn maximumSuspensionForce(&self) -> CGFloat;
671
672 #[cfg(feature = "objc2-core-foundation")]
673 #[unsafe(method(setMaximumSuspensionForce:))]
675 #[unsafe(method_family = none)]
676 pub unsafe fn setMaximumSuspensionForce(&self, maximum_suspension_force: CGFloat);
677
678 #[cfg(all(feature = "SceneKitTypes", feature = "objc2-core-foundation"))]
679 #[unsafe(method(connectionPosition))]
680 #[unsafe(method_family = none)]
681 pub unsafe fn connectionPosition(&self) -> SCNVector3;
682
683 #[cfg(all(feature = "SceneKitTypes", feature = "objc2-core-foundation"))]
684 #[unsafe(method(setConnectionPosition:))]
686 #[unsafe(method_family = none)]
687 pub unsafe fn setConnectionPosition(&self, connection_position: SCNVector3);
688
689 #[cfg(all(feature = "SceneKitTypes", feature = "objc2-core-foundation"))]
690 #[unsafe(method(steeringAxis))]
691 #[unsafe(method_family = none)]
692 pub unsafe fn steeringAxis(&self) -> SCNVector3;
693
694 #[cfg(all(feature = "SceneKitTypes", feature = "objc2-core-foundation"))]
695 #[unsafe(method(setSteeringAxis:))]
697 #[unsafe(method_family = none)]
698 pub unsafe fn setSteeringAxis(&self, steering_axis: SCNVector3);
699
700 #[cfg(all(feature = "SceneKitTypes", feature = "objc2-core-foundation"))]
701 #[unsafe(method(axle))]
702 #[unsafe(method_family = none)]
703 pub unsafe fn axle(&self) -> SCNVector3;
704
705 #[cfg(all(feature = "SceneKitTypes", feature = "objc2-core-foundation"))]
706 #[unsafe(method(setAxle:))]
708 #[unsafe(method_family = none)]
709 pub unsafe fn setAxle(&self, axle: SCNVector3);
710
711 #[cfg(feature = "objc2-core-foundation")]
712 #[unsafe(method(radius))]
713 #[unsafe(method_family = none)]
714 pub unsafe fn radius(&self) -> CGFloat;
715
716 #[cfg(feature = "objc2-core-foundation")]
717 #[unsafe(method(setRadius:))]
719 #[unsafe(method_family = none)]
720 pub unsafe fn setRadius(&self, radius: CGFloat);
721
722 #[cfg(feature = "objc2-core-foundation")]
723 #[unsafe(method(suspensionRestLength))]
724 #[unsafe(method_family = none)]
725 pub unsafe fn suspensionRestLength(&self) -> CGFloat;
726
727 #[cfg(feature = "objc2-core-foundation")]
728 #[unsafe(method(setSuspensionRestLength:))]
730 #[unsafe(method_family = none)]
731 pub unsafe fn setSuspensionRestLength(&self, suspension_rest_length: CGFloat);
732 );
733}
734
735impl SCNPhysicsVehicleWheel {
737 extern_methods!(
738 #[unsafe(method(init))]
739 #[unsafe(method_family = init)]
740 pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;
741
742 #[unsafe(method(new))]
743 #[unsafe(method_family = new)]
744 pub unsafe fn new() -> Retained<Self>;
745 );
746}
747
748extern_class!(
749 #[unsafe(super(SCNPhysicsBehavior, NSObject))]
753 #[derive(Debug, PartialEq, Eq, Hash)]
754 pub struct SCNPhysicsVehicle;
755);
756
757unsafe impl NSCoding for SCNPhysicsVehicle {}
758
759unsafe impl NSObjectProtocol for SCNPhysicsVehicle {}
760
761unsafe impl NSSecureCoding for SCNPhysicsVehicle {}
762
763impl SCNPhysicsVehicle {
764 extern_methods!(
765 #[cfg(feature = "SCNPhysicsBody")]
766 #[unsafe(method(vehicleWithChassisBody:wheels:))]
767 #[unsafe(method_family = none)]
768 pub unsafe fn vehicleWithChassisBody_wheels(
769 chassis_body: &SCNPhysicsBody,
770 wheels: &NSArray<SCNPhysicsVehicleWheel>,
771 ) -> Retained<Self>;
772
773 #[cfg(feature = "objc2-core-foundation")]
774 #[unsafe(method(speedInKilometersPerHour))]
775 #[unsafe(method_family = none)]
776 pub unsafe fn speedInKilometersPerHour(&self) -> CGFloat;
777
778 #[unsafe(method(wheels))]
779 #[unsafe(method_family = none)]
780 pub unsafe fn wheels(&self) -> Retained<NSArray<SCNPhysicsVehicleWheel>>;
781
782 #[cfg(feature = "SCNPhysicsBody")]
783 #[unsafe(method(chassisBody))]
784 #[unsafe(method_family = none)]
785 pub unsafe fn chassisBody(&self) -> Retained<SCNPhysicsBody>;
786
787 #[cfg(feature = "objc2-core-foundation")]
788 #[unsafe(method(applyEngineForce:forWheelAtIndex:))]
789 #[unsafe(method_family = none)]
790 pub unsafe fn applyEngineForce_forWheelAtIndex(&self, value: CGFloat, index: NSInteger);
791
792 #[cfg(feature = "objc2-core-foundation")]
793 #[unsafe(method(setSteeringAngle:forWheelAtIndex:))]
794 #[unsafe(method_family = none)]
795 pub unsafe fn setSteeringAngle_forWheelAtIndex(&self, value: CGFloat, index: NSInteger);
796
797 #[cfg(feature = "objc2-core-foundation")]
798 #[unsafe(method(applyBrakingForce:forWheelAtIndex:))]
799 #[unsafe(method_family = none)]
800 pub unsafe fn applyBrakingForce_forWheelAtIndex(&self, value: CGFloat, index: NSInteger);
801 );
802}
803
804impl SCNPhysicsVehicle {
806 extern_methods!(
807 #[unsafe(method(init))]
808 #[unsafe(method_family = init)]
809 pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;
810
811 #[unsafe(method(new))]
812 #[unsafe(method_family = new)]
813 pub unsafe fn new() -> Retained<Self>;
814 );
815}