forked from NVIDIA-Omniverse/PhysX
-
Notifications
You must be signed in to change notification settings - Fork 9
/
PhysXWasm.idl
executable file
·4449 lines (3984 loc) · 165 KB
/
PhysXWasm.idl
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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
//
// Emscripten / Web IDL Binder compatible .idl file
// Generated by webidl-util from model physx-js-webidl
//
[Prefix="snippetvehicle2::"]
interface BaseVehicle {
boolean initialize();
void destroyState();
void initComponentSequence(boolean addPhysXBeginEndComponents);
void step(float dt, [Const, Ref] PxVehicleSimulationContext context);
[Value] attribute BaseVehicleParams baseParams;
[Value] attribute BaseVehicleState baseState;
[Value] attribute PxVehicleComponentSequence componentSequence;
attribute octet componentSequenceSubstepGroupHandle;
};
[Prefix="snippetvehicle2::"]
interface BaseVehicleParams {
void BaseVehicleParams();
[Value] BaseVehicleParams transformAndScale([Const, Ref] PxVehicleFrame srcFrame, [Const, Ref] PxVehicleFrame trgFrame, [Const, Ref] PxVehicleScale srcScale, [Const, Ref] PxVehicleScale trgScale);
boolean isValid();
[Value] attribute PxVehicleAxleDescription axleDescription;
[Value] attribute PxVehicleFrame frame;
[Value] attribute PxVehicleScale scale;
[Value] attribute PxVehicleSuspensionStateCalculationParams suspensionStateCalculationParams;
[Value] attribute PxVehicleBrakeCommandResponseParams[] brakeResponseParams;
[Value] attribute PxVehicleSteerCommandResponseParams steerResponseParams;
[Value] attribute PxVehicleAckermannParams[] ackermannParams;
[Value] attribute PxVehicleSuspensionParams[] suspensionParams;
[Value] attribute PxVehicleSuspensionComplianceParams[] suspensionComplianceParams;
[Value] attribute PxVehicleSuspensionForceParams[] suspensionForceParams;
[Value] attribute PxVehicleAntiRollForceParams[] antiRollForceParams;
attribute unsigned long nbAntiRollForceParams;
[Value] attribute PxVehicleTireForceParams[] tireForceParams;
[Value] attribute PxVehicleWheelParams[] wheelParams;
[Value] attribute PxVehicleRigidBodyParams rigidBodyParams;
};
[Prefix="snippetvehicle2::"]
interface BaseVehicleState {
void BaseVehicleState();
void setToDefault();
attribute float[] brakeCommandResponseStates;
attribute float[] steerCommandResponseStates;
[Value] attribute PxVehicleWheelActuationState[] actuationStates;
[Value] attribute PxVehicleRoadGeometryState[] roadGeomStates;
[Value] attribute PxVehicleSuspensionState[] suspensionStates;
[Value] attribute PxVehicleSuspensionComplianceState[] suspensionComplianceStates;
[Value] attribute PxVehicleSuspensionForce[] suspensionForces;
[Value] attribute PxVehicleAntiRollTorque antiRollTorque;
[Value] attribute PxVehicleTireGripState[] tireGripStates;
[Value] attribute PxVehicleTireDirectionState[] tireDirectionStates;
[Value] attribute PxVehicleTireSpeedState[] tireSpeedStates;
[Value] attribute PxVehicleTireSlipState[] tireSlipStates;
[Value] attribute PxVehicleTireCamberAngleState[] tireCamberAngleStates;
[Value] attribute PxVehicleTireStickyState[] tireStickyStates;
[Value] attribute PxVehicleTireForce[] tireForces;
[Value] attribute PxVehicleWheelRigidBody1dState[] wheelRigidBody1dStates;
[Value] attribute PxVehicleWheelLocalPose[] wheelLocalPoses;
[Value] attribute PxVehicleRigidBodyState rigidBodyState;
};
[Prefix="physx::PxGjkQueryExt::"]
interface BoxSupport {
void BoxSupport([Const, Ref] PxVec3 halfExtents, optional float margin);
[Value] attribute PxVec3 halfExtents;
attribute float margin;
};
BoxSupport implements Support;
[Prefix="physx::PxGjkQueryExt::"]
interface CapsuleSupport {
void CapsuleSupport(float radius, float halfHeight);
attribute float radius;
attribute float halfHeight;
};
CapsuleSupport implements Support;
[Prefix="physx::PxGjkQueryExt::"]
interface ConvexGeomSupport {
void ConvexGeomSupport();
void ConvexGeomSupport([Const, Ref] PxGeometry geom, optional float margin);
};
ConvexGeomSupport implements Support;
[Prefix="physx::PxGjkQueryExt::"]
interface ConvexMeshSupport {
void ConvexMeshSupport([Const, Ref] PxConvexMesh convexMesh, [Const, Ref] optional PxVec3 scale, [Const, Ref] optional PxQuat scaleRotation, optional float margin);
[Value] attribute PxVec3 scale;
[Value] attribute PxQuat scaleRotation;
attribute float margin;
};
ConvexMeshSupport implements Support;
interface CustomSupport {
float getCustomMargin();
void getCustomSupportLocal([Const, Ref] PxVec3 dir, [Ref] PxVec3 result);
};
CustomSupport implements Support;
[JSImplementation="CustomSupport"]
interface CustomSupportImpl {
void CustomSupportImpl();
float getCustomMargin();
void getCustomSupportLocal([Const, Ref] PxVec3 dir, [Ref] PxVec3 result);
};
[Prefix="snippetvehicle2::"]
interface DirectDriveVehicle {
void DirectDriveVehicle();
boolean initialize([Ref] PxPhysics physics, [Const, Ref] PxCookingParams params, [Ref] PxMaterial defaultMaterial, optional boolean addPhysXBeginEndComponents);
void initComponentSequence(boolean addPhysXBeginEndComponents);
[Value] attribute DirectDrivetrainParams directDriveParams;
[Value] attribute DirectDrivetrainState directDriveState;
[Value] attribute PxVehicleDirectDriveTransmissionCommandState transmissionCommandState;
};
DirectDriveVehicle implements PhysXActorVehicle;
[Prefix="snippetvehicle2::"]
interface DirectDrivetrainParams {
void DirectDrivetrainParams();
[Value] DirectDrivetrainParams transformAndScale([Const, Ref] PxVehicleFrame srcFrame, [Const, Ref] PxVehicleFrame trgFrame, [Const, Ref] PxVehicleScale srcScale, [Const, Ref] PxVehicleScale trgScale);
boolean isValid([Const, Ref] PxVehicleAxleDescription axleDesc);
[Value] attribute PxVehicleDirectDriveThrottleCommandResponseParams directDriveThrottleResponseParams;
};
[Prefix="snippetvehicle2::"]
interface DirectDrivetrainState {
void DirectDrivetrainState();
void setToDefault();
attribute float[] directDriveThrottleResponseStates;
};
[Prefix="snippetvehicle2::"]
interface EngineDriveVehicle {
void EngineDriveVehicle();
boolean initialize([Ref] PxPhysics physics, [Const, Ref] PxCookingParams params, [Ref] PxMaterial defaultMaterial, EngineDriveVehicleEnum differentialType, optional boolean addPhysXBeginEndComponents);
void initComponentSequence(boolean addPhysXBeginEndComponents);
[Value] attribute EngineDrivetrainParams engineDriveParams;
[Value] attribute EngineDrivetrainState engineDriveState;
[Value] attribute PxVehicleEngineDriveTransmissionCommandState transmissionCommandState;
[Value] attribute PxVehicleTankDriveTransmissionCommandState tankDriveTransmissionCommandState;
attribute EngineDriveVehicleEnum differentialType;
};
EngineDriveVehicle implements PhysXActorVehicle;
[Prefix="snippetvehicle2::"]
interface EngineDrivetrainParams {
void EngineDrivetrainParams();
[Value] EngineDrivetrainParams transformAndScale([Const, Ref] PxVehicleFrame srcFrame, [Const, Ref] PxVehicleFrame trgFrame, [Const, Ref] PxVehicleScale srcScale, [Const, Ref] PxVehicleScale trgScale);
boolean isValid([Const, Ref] PxVehicleAxleDescription axleDesc);
[Value] attribute PxVehicleAutoboxParams autoboxParams;
[Value] attribute PxVehicleClutchCommandResponseParams clutchCommandResponseParams;
[Value] attribute PxVehicleEngineParams engineParams;
[Value] attribute PxVehicleGearboxParams gearBoxParams;
[Value] attribute PxVehicleMultiWheelDriveDifferentialParams multiWheelDifferentialParams;
[Value] attribute PxVehicleFourWheelDriveDifferentialParams fourWheelDifferentialParams;
[Value] attribute PxVehicleTankDriveDifferentialParams tankDifferentialParams;
[Value] attribute PxVehicleClutchParams clutchParams;
};
[Prefix="snippetvehicle2::"]
interface EngineDrivetrainState {
void EngineDrivetrainState();
void setToDefault();
[Value] attribute PxVehicleEngineDriveThrottleCommandResponseState throttleCommandResponseState;
[Value] attribute PxVehicleAutoboxState autoboxState;
[Value] attribute PxVehicleClutchCommandResponseState clutchCommandResponseState;
[Value] attribute PxVehicleDifferentialState differentialState;
[Value] attribute PxVehicleWheelConstraintGroupState wheelConstraintGroupState;
[Value] attribute PxVehicleEngineState engineState;
[Value] attribute PxVehicleGearboxState gearboxState;
[Value] attribute PxVehicleClutchSlipState clutchState;
};
interface NativeArrayHelpers {
static octet getU8At([Ref] PxU8ConstPtr base, long index);
static unsigned short getU16At([Ref] PxU16ConstPtr base, long index);
static unsigned long getU32At([Ref] PxU32ConstPtr base, long index);
static float getRealAt([Ref] PxRealPtr base, long index);
static void setU8At(VoidPtr base, long index, octet value);
static void setU16At(VoidPtr base, long index, unsigned short value);
static void setU32At(VoidPtr base, long index, unsigned long value);
static void setRealAt(VoidPtr base, long index, float value);
[Value] static PxU8Ptr voidToU8Ptr(VoidPtr voidPtr);
[Value] static PxU16Ptr voidToU16Ptr(VoidPtr voidPtr);
[Value] static PxU32Ptr voidToU32Ptr(VoidPtr voidPtr);
[Value] static PxI32Ptr voidToI32Ptr(VoidPtr voidPtr);
[Value] static PxRealPtr voidToRealPtr(VoidPtr voidPtr);
static PxActor getActorAt(PxActor base, long index);
static PxBounds3 getBounds3At(PxBounds3 base, long index);
static PxContactPair getContactPairAt(PxContactPair base, long index);
static PxContactPairHeader getContactPairHeaderAt(PxContactPairHeader base, long index);
static PxController getControllerAt(PxController base, long index);
static PxControllerShapeHit getControllerShapeHitAt(PxControllerShapeHit base, long index);
static PxControllersHit getControllersHitAt(PxControllersHit base, long index);
static PxControllerObstacleHit getControllerObstacleHitAt(PxControllerObstacleHit base, long index);
static PxDebugPoint getDebugPointAt(PxDebugPoint base, long index);
static PxDebugLine getDebugLineAt(PxDebugLine base, long index);
static PxDebugTriangle getDebugTriangleAt(PxDebugTriangle base, long index);
static PxObstacle getObstacleAt(PxObstacle base, long index);
static PxShape getShapeAt(PxShape base, long index);
static PxTriggerPair getTriggerPairAt(PxTriggerPair base, long index);
static PxVec3 getVec3At(PxVec3 base, long index);
};
interface PassThroughFilterShader {
unsigned long filterShader(unsigned long attributes0, unsigned long filterData0w0, unsigned long filterData0w1, unsigned long filterData0w2, unsigned long filterData0w3, unsigned long attributes1, unsigned long filterData1w0, unsigned long filterData1w1, unsigned long filterData1w2, unsigned long filterData1w3);
attribute unsigned long outputPairFlags;
};
PassThroughFilterShader implements PxSimulationFilterShader;
[JSImplementation="PassThroughFilterShader"]
interface PassThroughFilterShaderImpl {
void PassThroughFilterShaderImpl();
unsigned long filterShader(unsigned long attributes0, unsigned long filterData0w0, unsigned long filterData0w1, unsigned long filterData0w2, unsigned long filterData0w3, unsigned long attributes1, unsigned long filterData1w0, unsigned long filterData1w1, unsigned long filterData1w2, unsigned long filterData1w3);
};
[Prefix="snippetvehicle2::"]
interface PhysXActorVehicle {
boolean initialize([Ref] PxPhysics physics, [Const, Ref] PxCookingParams params, [Ref] PxMaterial defaultMaterial);
[Value] attribute PhysXIntegrationParams physXParams;
[Value] attribute PhysXIntegrationState physXState;
[Value] attribute PxVehicleCommandState commandState;
};
PhysXActorVehicle implements BaseVehicle;
[Prefix="snippetvehicle2::"]
interface PhysXIntegrationParams {
void PhysXIntegrationParams();
[Value] PhysXIntegrationParams transformAndScale([Const, Ref] PxVehicleFrame srcFrame, [Const, Ref] PxVehicleFrame trgFrame, [Const, Ref] PxVehicleScale srcScale, [Const, Ref] PxVehicleScale trgScale);
boolean isValid([Const, Ref] PxVehicleAxleDescription axleDesc);
void create([Const, Ref] PxVehicleAxleDescription axleDesc, [Const, Ref] PxQueryFilterData roadQueryFilterData, PxQueryFilterCallback roadQueryFilterCallback, PxVehiclePhysXMaterialFriction materialFrictions, unsigned long nbMaterialFrictions, float defaultFriction, [Const, Ref] PxTransform physxActorCMassLocalPose, [Ref] PxGeometry actorGeometry, [Const, Ref] PxTransform physxActorBoxShapeLocalPose, PxVehiclePhysXRoadGeometryQueryTypeEnum roadGeometryQueryType);
[Value] attribute PxVehiclePhysXRoadGeometryQueryParams physxRoadGeometryQueryParams;
[Value] attribute PxVehiclePhysXMaterialFrictionParams[] physxMaterialFrictionParams;
[Value] attribute PxVehiclePhysXSuspensionLimitConstraintParams[] physxSuspensionLimitConstraintParams;
[Value] attribute PxTransform physxActorCMassLocalPose;
attribute PxGeometry physxActorGeometry;
[Value] attribute PxTransform physxActorBoxShapeLocalPose;
[Value] attribute PxTransform[] physxWheelShapeLocalPoses;
[Value] attribute PxShapeFlags physxActorShapeFlags;
[Value] attribute PxFilterData physxActorSimulationFilterData;
[Value] attribute PxFilterData physxActorQueryFilterData;
[Value] attribute PxShapeFlags physxActorWheelShapeFlags;
[Value] attribute PxFilterData physxActorWheelSimulationFilterData;
[Value] attribute PxFilterData physxActorWheelQueryFilterData;
};
[Prefix="snippetvehicle2::"]
interface PhysXIntegrationState {
void PhysXIntegrationState();
void destroyState();
void setToDefault();
void create([Const, Ref] BaseVehicleParams baseParams, [Const, Ref] PhysXIntegrationParams physxParams, [Ref] PxPhysics physics, [Const, Ref] PxCookingParams params, [Ref] PxMaterial defaultMaterial);
[Value] attribute PxVehiclePhysXActor physxActor;
[Value] attribute PxVehiclePhysXSteerState physxSteerState;
[Value] attribute PxVehiclePhysXConstraints physxConstraints;
};
[Prefix="physx::", NoDelete]
interface PxActor {
PxActorTypeEnum getType();
PxScene getScene();
void setName([Const] DOMString name);
[Const] DOMString getName();
[Value] PxBounds3 getWorldBounds(optional float inflation);
void setActorFlag(PxActorFlagEnum flag, boolean value);
void setActorFlags([Ref] PxActorFlags flags);
[Value] PxActorFlags getActorFlags();
void setDominanceGroup(octet dominanceGroup);
octet getDominanceGroup();
void setOwnerClient(octet inClient);
octet getOwnerClient();
attribute VoidPtr userData;
};
PxActor implements PxBase;
[Prefix="physx::"]
interface PxActorFlags {
void PxActorFlags(octet flags);
boolean isSet(PxActorFlagEnum flag);
void raise(PxActorFlagEnum flag);
void clear(PxActorFlagEnum flag);
};
interface PxActorPtr {
};
[Prefix="physx::"]
interface PxActorTypeFlags {
void PxActorTypeFlags(unsigned short flags);
boolean isSet(PxActorTypeFlagEnum flag);
void raise(PxActorTypeFlagEnum flag);
void clear(PxActorTypeFlagEnum flag);
};
[Prefix="physx::", NoDelete]
interface PxAggregate {
boolean addActor([Ref] PxActor actor, [Const] optional PxBVH bvh);
boolean removeActor([Ref] PxActor actor);
boolean addArticulation([Ref] PxArticulationReducedCoordinate articulation);
boolean removeArticulation([Ref] PxArticulationReducedCoordinate articulation);
unsigned long getNbActors();
unsigned long getMaxNbActors();
unsigned long getMaxNbShapes();
PxScene getScene();
boolean getSelfCollision();
};
PxAggregate implements PxBase;
interface PxArray_PxActorPtr {
void PxArray_PxActorPtr();
void PxArray_PxActorPtr(unsigned long size);
PxActor get(unsigned long index);
void set(unsigned long index, [Const, Ref] PxActorPtr value);
PxActorPtr begin();
unsigned long size();
void pushBack(PxActor value);
void clear();
};
interface PxArray_PxContactPairPoint {
void PxArray_PxContactPairPoint();
void PxArray_PxContactPairPoint(unsigned long size);
[Ref] PxContactPairPoint get(unsigned long index);
void set(unsigned long index, [Const, Ref] PxContactPairPoint value);
PxContactPairPoint begin();
unsigned long size();
void pushBack([Ref] PxContactPairPoint value);
void clear();
};
interface PxArray_PxHeightFieldSample {
void PxArray_PxHeightFieldSample();
void PxArray_PxHeightFieldSample(unsigned long size);
[Ref] PxHeightFieldSample get(unsigned long index);
void set(unsigned long index, [Const, Ref] PxHeightFieldSample value);
PxHeightFieldSample begin();
unsigned long size();
void pushBack([Ref] PxHeightFieldSample value);
void clear();
};
interface PxArray_PxMaterialConst {
void PxArray_PxMaterialConst();
void PxArray_PxMaterialConst(unsigned long size);
[Const] PxMaterial get(unsigned long index);
void set(unsigned long index, [Const, Ref] PxMaterialConstPtr value);
PxMaterialConstPtr begin();
unsigned long size();
void pushBack([Const] PxMaterial value);
void clear();
};
interface PxArray_PxRaycastHit {
void PxArray_PxRaycastHit();
void PxArray_PxRaycastHit(unsigned long size);
[Ref] PxRaycastHit get(unsigned long index);
void set(unsigned long index, [Const, Ref] PxRaycastHit value);
PxRaycastHit begin();
unsigned long size();
void pushBack([Ref] PxRaycastHit value);
void clear();
};
interface PxArray_PxReal {
void PxArray_PxReal();
void PxArray_PxReal(unsigned long size);
float get(unsigned long index);
void set(unsigned long index, float value);
VoidPtr begin();
unsigned long size();
void pushBack(float value);
void clear();
};
interface PxArray_PxShapePtr {
void PxArray_PxShapePtr();
void PxArray_PxShapePtr(unsigned long size);
PxShape get(unsigned long index);
void set(unsigned long index, [Const, Ref] PxShapePtr value);
PxShapePtr begin();
unsigned long size();
void pushBack(PxShape value);
void clear();
};
interface PxArray_PxSweepHit {
void PxArray_PxSweepHit();
void PxArray_PxSweepHit(unsigned long size);
[Ref] PxSweepHit get(unsigned long index);
void set(unsigned long index, [Const, Ref] PxSweepHit value);
PxSweepHit begin();
unsigned long size();
void pushBack([Ref] PxSweepHit value);
void clear();
};
interface PxArray_PxU16 {
void PxArray_PxU16();
void PxArray_PxU16(unsigned long size);
unsigned short get(unsigned long index);
void set(unsigned long index, unsigned short value);
VoidPtr begin();
unsigned long size();
void pushBack(unsigned short value);
void clear();
};
interface PxArray_PxU32 {
void PxArray_PxU32();
void PxArray_PxU32(unsigned long size);
unsigned long get(unsigned long index);
void set(unsigned long index, unsigned long value);
VoidPtr begin();
unsigned long size();
void pushBack(unsigned long value);
void clear();
};
interface PxArray_PxU8 {
void PxArray_PxU8();
void PxArray_PxU8(unsigned long size);
octet get(unsigned long index);
void set(unsigned long index, octet value);
VoidPtr begin();
unsigned long size();
void pushBack(octet value);
void clear();
};
interface PxArray_PxVec3 {
void PxArray_PxVec3();
void PxArray_PxVec3(unsigned long size);
[Ref] PxVec3 get(unsigned long index);
void set(unsigned long index, [Const, Ref] PxVec3 value);
PxVec3 begin();
unsigned long size();
void pushBack([Ref] PxVec3 value);
void clear();
};
interface PxArray_PxVec4 {
void PxArray_PxVec4();
void PxArray_PxVec4(unsigned long size);
[Ref] PxVec4 get(unsigned long index);
void set(unsigned long index, [Const, Ref] PxVec4 value);
PxVec4 begin();
unsigned long size();
void pushBack([Ref] PxVec4 value);
void clear();
};
[Prefix="physx::"]
interface PxArticulationAttachment {
void setRestLength(float restLength);
float getRestLength();
void setLimitParameters([Const, Ref] PxArticulationTendonLimit parameters);
[Value] PxArticulationTendonLimit getLimitParameters();
void setRelativeOffset([Const, Ref] PxVec3 offset);
[Value] PxVec3 getRelativeOffset();
void setCoefficient(float coefficient);
float getCoefficient();
PxArticulationLink getLink();
PxArticulationAttachment getParent();
boolean isLeaf();
PxArticulationSpatialTendon getTendon();
void release();
attribute VoidPtr userData;
};
[Prefix="physx::"]
interface PxArticulationCache {
void release();
attribute PxSpatialForce externalForces;
[Value] attribute PxRealPtr denseJacobian;
[Value] attribute PxRealPtr massMatrix;
[Value] attribute PxRealPtr jointVelocity;
[Value] attribute PxRealPtr jointAcceleration;
[Value] attribute PxRealPtr jointPosition;
[Value] attribute PxRealPtr jointForce;
attribute PxSpatialVelocity linkVelocity;
attribute PxSpatialVelocity linkAcceleration;
attribute PxSpatialForce linkIncomingJointForce;
attribute PxArticulationRootLinkData rootLinkData;
[Value] attribute PxRealPtr coefficientMatrix;
[Value] attribute PxRealPtr lambda;
attribute VoidPtr scratchMemory;
attribute VoidPtr scratchAllocator;
attribute unsigned long version;
};
[Prefix="physx::"]
interface PxArticulationCacheFlags {
void PxArticulationCacheFlags(unsigned long flags);
boolean isSet(PxArticulationCacheFlagEnum flag);
void raise(PxArticulationCacheFlagEnum flag);
void clear(PxArticulationCacheFlagEnum flag);
};
[Prefix="physx::"]
interface PxArticulationDrive {
void PxArticulationDrive();
void PxArticulationDrive(float stiffness, float damping, float maxForce, PxArticulationDriveTypeEnum driveType);
attribute float stiffness;
attribute float damping;
attribute float maxForce;
attribute PxArticulationDriveTypeEnum driveType;
};
[Prefix="physx::"]
interface PxArticulationFixedTendon {
PxArticulationTendonJoint createTendonJoint(PxArticulationTendonJoint parent, PxArticulationAxisEnum axis, float coefficient, float recipCoefficient, PxArticulationLink link);
unsigned long getNbTendonJoints();
void setRestLength(float restLength);
float getRestLength();
void setLimitParameters([Const, Ref] PxArticulationTendonLimit parameter);
[Value] PxArticulationTendonLimit getLimitParameters();
};
PxArticulationFixedTendon implements PxArticulationTendon;
[Prefix="physx::"]
interface PxArticulationFlags {
void PxArticulationFlags(octet flags);
boolean isSet(PxArticulationFlagEnum flag);
void raise(PxArticulationFlagEnum flag);
void clear(PxArticulationFlagEnum flag);
};
[Prefix="physx::"]
interface PxArticulationJointReducedCoordinate {
[Ref] PxArticulationLink getParentArticulationLink();
void setParentPose([Const, Ref] PxTransform pose);
[Value] PxTransform getParentPose();
[Ref] PxArticulationLink getChildArticulationLink();
void setChildPose([Const, Ref] PxTransform pose);
[Value] PxTransform getChildPose();
void setJointType(PxArticulationJointTypeEnum jointType);
PxArticulationJointTypeEnum getJointType();
void setMotion(PxArticulationAxisEnum axis, PxArticulationMotionEnum motion);
PxArticulationMotionEnum getMotion(PxArticulationAxisEnum axis);
void setLimitParams(PxArticulationAxisEnum axis, [Const, Ref] PxArticulationLimit limit);
[Value] PxArticulationLimit getLimitParams(PxArticulationAxisEnum axis);
void setDriveParams(PxArticulationAxisEnum axis, [Const, Ref] PxArticulationDrive drive);
void setDriveTarget(PxArticulationAxisEnum axis, float target, optional boolean autowake);
float getDriveTarget(PxArticulationAxisEnum axis);
void setDriveVelocity(PxArticulationAxisEnum axis, float targetVel, optional boolean autowake);
float getDriveVelocity(PxArticulationAxisEnum axis);
void setArmature(PxArticulationAxisEnum axis, float armature);
float getArmature(PxArticulationAxisEnum axis);
void setFrictionCoefficient(float coefficient);
float getFrictionCoefficient();
void setMaxJointVelocity(float maxJointV);
float getMaxJointVelocity();
void setJointPosition(PxArticulationAxisEnum axis, float jointPos);
float getJointPosition(PxArticulationAxisEnum axis);
void setJointVelocity(PxArticulationAxisEnum axis, float jointVel);
float getJointVelocity(PxArticulationAxisEnum axis);
};
PxArticulationJointReducedCoordinate implements PxBase;
[Prefix="physx::"]
interface PxArticulationKinematicFlags {
void PxArticulationKinematicFlags(octet flags);
boolean isSet(PxArticulationKinematicFlagEnum flag);
void raise(PxArticulationKinematicFlagEnum flag);
void clear(PxArticulationKinematicFlagEnum flag);
};
[Prefix="physx::"]
interface PxArticulationLimit {
void PxArticulationLimit();
void PxArticulationLimit(float low, float high);
attribute float low;
attribute float high;
};
[Prefix="physx::", NoDelete]
interface PxArticulationLink {
[Ref] PxArticulationReducedCoordinate getArticulation();
PxArticulationJointReducedCoordinate getInboundJoint();
unsigned long getInboundJointDof();
unsigned long getNbChildren();
unsigned long getLinkIndex();
void setCfmScale(float cfm);
float getCfmScale();
};
PxArticulationLink implements PxRigidBody;
[Prefix="physx::"]
interface PxArticulationReducedCoordinate {
PxScene getScene();
void setSolverIterationCounts(unsigned long minPositionIters, optional unsigned long minVelocityIters);
boolean isSleeping();
void setSleepThreshold(float threshold);
float getSleepThreshold();
void setStabilizationThreshold(float threshold);
float getStabilizationThreshold();
void setWakeCounter(float wakeCounterValue);
float getWakeCounter();
void wakeUp();
void putToSleep();
void setMaxCOMLinearVelocity(float maxLinerVelocity);
float getMaxCOMLinearVelocity();
void setMaxCOMAngularVelocity(float maxAngularVelocity);
float getMaxCOMAngularVelocity();
PxArticulationLink createLink(PxArticulationLink parent, [Const, Ref] PxTransform pose);
unsigned long getNbLinks();
unsigned long getNbShapes();
void setName([Const] DOMString name);
[Const] DOMString getName();
[Value] PxBounds3 getWorldBounds(optional float inflation);
PxAggregate getAggregate();
void setArticulationFlags([Ref] PxArticulationFlags flags);
void setArticulationFlag(PxArticulationFlagEnum flag, boolean value);
[Value] PxArticulationFlags getArticulationFlags();
unsigned long getDofs();
PxArticulationCache createCache();
unsigned long getCacheDataSize();
void zeroCache([Ref] PxArticulationCache cache);
void applyCache([Ref] PxArticulationCache cache, [Ref] PxArticulationCacheFlags flags, optional boolean autowake);
void copyInternalStateToCache([Ref] PxArticulationCache cache, [Const, Ref] PxArticulationCacheFlags flags);
void commonInit();
void computeGeneralizedGravityForce([Ref] PxArticulationCache cache);
void computeCoriolisAndCentrifugalForce([Ref] PxArticulationCache cache);
void computeGeneralizedExternalForce([Ref] PxArticulationCache cache);
void computeJointAcceleration([Ref] PxArticulationCache cache);
void computeJointForce([Ref] PxArticulationCache cache);
void computeCoefficientMatrix([Ref] PxArticulationCache cache);
void computeGeneralizedMassMatrix([Ref] PxArticulationCache cache);
void addLoopJoint(PxConstraint joint);
void removeLoopJoint(PxConstraint joint);
unsigned long getNbLoopJoints();
unsigned long getCoefficientMatrixSize();
void setRootGlobalPose([Const, Ref] PxTransform pose, optional boolean autowake);
[Value] PxTransform getRootGlobalPose();
void setRootLinearVelocity([Const, Ref] PxVec3 linearVelocity, optional boolean autowake);
[Value] PxVec3 getRootLinearVelocity();
void setRootAngularVelocity([Const, Ref] PxVec3 angularVelocity, optional boolean autowake);
[Value] PxVec3 getRootAngularVelocity();
[Value] PxSpatialVelocity getLinkAcceleration(unsigned long linkId);
unsigned long getGpuArticulationIndex();
PxArticulationSpatialTendon createSpatialTendon();
PxArticulationFixedTendon createFixedTendon();
unsigned long getNbSpatialTendons();
unsigned long getNbFixedTendons();
void updateKinematic([Ref] PxArticulationKinematicFlags flags);
};
PxArticulationReducedCoordinate implements PxBase;
[Prefix="physx::"]
interface PxArticulationRootLinkData {
void PxArticulationRootLinkData();
[Value] attribute PxTransform transform;
[Value] attribute PxVec3 worldLinVel;
[Value] attribute PxVec3 worldAngVel;
[Value] attribute PxVec3 worldLinAccel;
[Value] attribute PxVec3 worldAngAccel;
};
[Prefix="physx::"]
interface PxArticulationSpatialTendon {
PxArticulationAttachment createAttachment(PxArticulationAttachment parent, float coefficient, [Const, Ref] PxVec3 relativeOffset, PxArticulationLink link);
unsigned long getNbAttachments();
};
PxArticulationSpatialTendon implements PxArticulationTendon;
[Prefix="physx::"]
interface PxArticulationTendon {
void setStiffness(float stiffness);
float getStiffness();
void setDamping(float damping);
float getDamping();
void setLimitStiffness(float stiffness);
float getLimitStiffness();
void setOffset(float offset, optional boolean autowake);
float getOffset();
PxArticulationReducedCoordinate getArticulation();
};
PxArticulationTendon implements PxBase;
[Prefix="physx::"]
interface PxArticulationTendonJoint {
void setCoefficient(PxArticulationAxisEnum axis, float coefficient, float recipCoefficient);
PxArticulationLink getLink();
PxArticulationTendonJoint getParent();
PxArticulationFixedTendon getTendon();
void release();
attribute VoidPtr userData;
};
[Prefix="physx::"]
interface PxArticulationTendonLimit {
attribute float lowLimit;
attribute float highLimit;
};
[Prefix="physx::", NoDelete]
interface PxBVH {
};
PxBVH implements PxBase;
[Prefix="physx::"]
interface PxBVH33MidphaseDesc {
void setToDefault();
boolean isValid();
attribute float meshSizePerformanceTradeOff;
attribute PxMeshCookingHintEnum meshCookingHint;
};
[Prefix="physx::"]
interface PxBVH34MidphaseDesc {
void setToDefault();
boolean isValid();
attribute unsigned long numPrimsPerLeaf;
};
[Prefix="physx::", NoDelete]
interface PxBase {
void release();
[Const] DOMString getConcreteTypeName();
long getConcreteType();
void setBaseFlag(PxBaseFlagEnum flag, boolean value);
void setBaseFlags([Ref] PxBaseFlags inFlags);
[Value] PxBaseFlags getBaseFlags();
boolean isReleasable();
};
[Prefix="physx::"]
interface PxBaseFlags {
void PxBaseFlags(unsigned short flags);
boolean isSet(PxBaseFlagEnum flag);
void raise(PxBaseFlagEnum flag);
void clear(PxBaseFlagEnum flag);
};
[Prefix="physx::"]
interface PxBaseMaterial {
};
PxBaseMaterial implements PxRefCounted;
[Prefix="physx::"]
interface PxBaseTask {
};
[Prefix="physx::"]
interface PxBoundedData {
void PxBoundedData();
attribute unsigned long count;
};
PxBoundedData implements PxStridedData;
[Prefix="physx::"]
interface PxBounds3 {
void PxBounds3();
void PxBounds3([Const, Ref] PxVec3 minimum, [Const, Ref] PxVec3 maximum);
void setEmpty();
void setMaximal();
void include([Const, Ref] PxVec3 v);
boolean isEmpty();
boolean intersects([Const, Ref] PxBounds3 b);
boolean intersects1D([Const, Ref] PxBounds3 b, unsigned long axis);
boolean contains([Const, Ref] PxVec3 v);
boolean isInside([Const, Ref] PxBounds3 box);
[Value] PxVec3 getCenter();
[Value] PxVec3 getDimensions();
[Value] PxVec3 getExtents();
void scaleSafe(float scale);
void scaleFast(float scale);
void fattenSafe(float distance);
void fattenFast(float distance);
boolean isFinite();
boolean isValid();
[Value] attribute PxVec3 minimum;
[Value] attribute PxVec3 maximum;
};
[Prefix="physx::", NoDelete]
interface PxBoxController {
float getHalfHeight();
float getHalfSideExtent();
float getHalfForwardExtent();
boolean setHalfHeight(float halfHeight);
boolean setHalfSideExtent(float halfSideExtent);
boolean setHalfForwardExtent(float halfForwardExtent);
};
PxBoxController implements PxController;
[Prefix="physx::"]
interface PxBoxControllerDesc {
void PxBoxControllerDesc();
void setToDefault();
attribute float halfHeight;
attribute float halfSideExtent;
attribute float halfForwardExtent;
};
PxBoxControllerDesc implements PxControllerDesc;
[Prefix="physx::"]
interface PxBoxGeometry {
void PxBoxGeometry(float hx, float hy, float hz);
[Value] attribute PxVec3 halfExtents;
};
PxBoxGeometry implements PxGeometry;
[Prefix="physx::"]
interface PxBoxObstacle {
void PxBoxObstacle();
[Value] attribute PxVec3 mHalfExtents;
};
PxBoxObstacle implements PxObstacle;
[Prefix="physx::"]
interface PxBroadPhaseCaps {
void PxBroadPhaseCaps();
attribute unsigned long mMaxNbRegions;
};
[Prefix="physx::"]
interface PxBroadPhaseRegion {
void PxBroadPhaseRegion();
[Value] attribute PxBounds3 mBounds;
attribute VoidPtr mUserData;
};
[Prefix="physx::"]
interface PxBroadPhaseRegionInfo {
void PxBroadPhaseRegionInfo();
[Value] attribute PxBroadPhaseRegion mRegion;
attribute unsigned long mNbStaticObjects;
attribute unsigned long mNbDynamicObjects;
attribute boolean mActive;
attribute boolean mOverlap;
};
[Prefix="physx::", NoDelete]
interface PxCapsuleController {
float getRadius();
boolean setRadius(float radius);
float getHeight();
boolean setHeight(float height);
PxCapsuleClimbingModeEnum getClimbingMode();
boolean setClimbingMode(PxCapsuleClimbingModeEnum mode);
};
PxCapsuleController implements PxController;
[Prefix="physx::"]
interface PxCapsuleControllerDesc {
void PxCapsuleControllerDesc();
void setToDefault();
attribute float radius;
attribute float height;
attribute PxCapsuleClimbingModeEnum climbingMode;
};
PxCapsuleControllerDesc implements PxControllerDesc;
[Prefix="physx::"]
interface PxCapsuleGeometry {
void PxCapsuleGeometry(float radius, float halfHeight);
attribute float radius;
attribute float halfHeight;
};
PxCapsuleGeometry implements PxGeometry;
[Prefix="physx::"]
interface PxCapsuleObstacle {
void PxCapsuleObstacle();
attribute float mHalfHeight;
attribute float mRadius;
};
PxCapsuleObstacle implements PxObstacle;
[Prefix="physx::", NoDelete]
interface PxCollection {
void add([Ref] PxBase obj, optional unsigned long long id);
void remove([Ref] PxBase obj);
boolean contains([Ref] PxBase obj);
void addId([Ref] PxBase obj, unsigned long long id);
void removeId(unsigned long long id);
unsigned long getNbObjects();
[Ref] PxBase getObject(unsigned long index);
PxBase find(unsigned long long id);
unsigned long getNbIds();
unsigned long long getId([Const, Ref] PxBase obj);
void release();
};
[Prefix="physx::"]
interface PxCollectionExt {
static void releaseObjects([Ref] PxCollection collection, optional boolean releaseExclusiveShapes);
static void remove([Ref] PxCollection collection, unsigned short concreteType, optional PxCollection to);
static PxCollection createCollection([Ref] PxScene scene);
};
[Prefix="physx::", NoDelete]
interface PxConstraint {
PxScene getScene();
void setActors(PxRigidActor actor0, PxRigidActor actor1);
void markDirty();
void setFlags([Ref] PxConstraintFlags flags);
[Value] PxConstraintFlags getFlags();
void setFlag(PxConstraintFlagEnum flag, boolean value);
void getForce([Ref] PxVec3 linear, [Ref] PxVec3 angular);
boolean isValid();
void setBreakForce(float linear, float angular);
void setMinResponseThreshold(float threshold);
float getMinResponseThreshold();
};
PxConstraint implements PxBase;
[Prefix="physx::"]
interface PxConstraintConnector {
void prepareData();
void updateOmniPvdProperties();
void onConstraintRelease();
void onComShift(unsigned long actor);
void onOriginShift([Const, Ref] PxVec3 shift);
PxBase getSerializable();
[Value] PxConstraintSolverPrep getPrep();
void getConstantBlock();
void connectToConstraint(PxConstraint constraint);
};
[Prefix="physx::"]
interface PxConstraintFlags {
void PxConstraintFlags(unsigned short flags);
boolean isSet(PxConstraintFlagEnum flag);
void raise(PxConstraintFlagEnum flag);
void clear(PxConstraintFlagEnum flag);
};
[Prefix="physx::"]
interface PxConstraintInfo {
attribute PxConstraint constraint;
attribute VoidPtr externalReference;
attribute unsigned long type;
};
[Prefix="physx::"]
interface PxConstraintSolverPrep {
};
[Prefix="physx::"]
interface PxContactBuffer {
void reset();
boolean contact([Const, Ref] PxVec3 worldPoint, [Const, Ref] PxVec3 worldNormalIn, float separation, optional unsigned long faceIndex1);
boolean contact([Const, Ref] PxContactPoint pt);
[Value] attribute PxContactPoint[] contacts;
attribute unsigned long count;
attribute unsigned long pad;
static readonly attribute unsigned long MAX_CONTACTS;
};
[Prefix="physx::"]
interface PxContactPair {
unsigned long extractContacts(PxContactPairPoint userBuffer, unsigned long bufferSize);
attribute PxShape[] shapes;
attribute octet contactCount;
attribute octet patchCount;
[Value] attribute PxContactPairFlags flags;
[Value] attribute PxPairFlags events;
};
[Prefix="physx::"]
interface PxContactPairFlags {
void PxContactPairFlags(unsigned short flags);
boolean isSet(PxContactPairFlagEnum flag);
void raise(PxContactPairFlagEnum flag);
void clear(PxContactPairFlagEnum flag);
};
[Prefix="physx::"]
interface PxContactPairHeader {
attribute PxActor[] actors;
[Value] attribute PxContactPairHeaderFlags flags;
[Const] attribute PxContactPair pairs;
attribute unsigned long nbPairs;
};
[Prefix="physx::"]
interface PxContactPairHeaderFlags {
void PxContactPairHeaderFlags(unsigned short flags);
boolean isSet(PxContactPairHeaderFlagEnum flag);
void raise(PxContactPairHeaderFlagEnum flag);
void clear(PxContactPairHeaderFlagEnum flag);
};
[Prefix="physx::"]
interface PxContactPairPoint {
[Value] attribute PxVec3 position;
attribute float separation;
[Value] attribute PxVec3 normal;
attribute unsigned long internalFaceIndex0;
[Value] attribute PxVec3 impulse;
attribute unsigned long internalFaceIndex1;
};
[Prefix="physx::"]
interface PxContactPoint {