Heretek-AI/GDevelop
1
0
Fork 0
mirror of https://github.com/Heretek-AI/GDevelop.git synced 2026-08-25 12:23:58 -04:00
Code Issues 2 Packages Projects Releases 2 Wiki Activity
Files
URL-CreateNewProject
GDevelop/Extensions/Physics3DBehavior/jolt-physics.d.ts
T
D8H 7289030b38 Add support for a custom shape ("Mesh") for static objects having the 3D physics behavior (#8080) 
- This allows your characters and other dynamic objects to collide exactly with the shape of a platform, background or any **static** 3D object. 
- By default, the model of the 3D model itself is used. You can choose to use another model if needed (useful in case of a very complex 3D model: you can make the collision happen on a simplified version).
- Also ugrade to [Jolt-Physics.js
0.39.0](https://github.com/jrouwe/JoltPhysics.js/releases).
2026-01-08 10:47:43 +01:00

5333 lines
188 KiB
TypeScript
Raw Permalink Blame History

declare namespace Jolt {
function destroy(obj: any): void;
function _malloc(size: number): number;
function _free(ptr: number): void;
function wrapPointer<C extends new (...args: any) => any>(
ptr: number,
Class: C
): InstanceType<C>;
function getPointer(obj: unknown): number;
function castObject<C extends new (...args: any) => any>(
object: unknown,
Class: C
): InstanceType<C>;
function compare(object1: unknown, object2: unknown): boolean;
const HEAP8: Int8Array;
const HEAP16: Int16Array;
const HEAP32: Int32Array;
const HEAPU8: Uint8Array;
const HEAPU16: Uint16Array;
const HEAPU32: Uint32Array;
const HEAPF32: Float32Array;
const HEAPF64: Float64Array;
class JPHString {
constructor(str: string, length: number);
c_str(): string;
size(): number;
}
class ArrayVec3 {
constructor();
empty(): boolean;
size(): number;
at(inIndex: number): Vec3;
push_back(inValue: Vec3): void;
reserve(inSize: number): void;
resize(inSize: number): void;
clear(): void;
data(): Vec3MemRef;
}
class ArrayQuat {
constructor();
empty(): boolean;
size(): number;
at(inIndex: number): Quat;
push_back(inValue: Quat): void;
reserve(inSize: number): void;
resize(inSize: number): void;
clear(): void;
data(): QuatMemRef;
}
class ArrayMat44 {
constructor();
empty(): boolean;
size(): number;
at(inIndex: number): Mat44;
push_back(inValue: Mat44): void;
reserve(inSize: number): void;
resize(inSize: number): void;
clear(): void;
data(): Mat44MemRef;
}
class ArrayBodyID {
constructor();
empty(): boolean;
size(): number;
at(inIndex: number): BodyID;
push_back(inValue: BodyID): void;
reserve(inSize: number): void;
resize(inSize: number): void;
clear(): void;
data(): BodyIDMemRef;
}
class ArrayBodyPtr {
constructor();
empty(): boolean;
size(): number;
at(inIndex: number): Body;
push_back(inValue: Body): void;
reserve(inSize: number): void;
resize(inSize: number): void;
clear(): void;
data(): BodyPtrMemRef;
}
const EBodyType_RigidBody: number;
const EBodyType_SoftBody: number;
type EBodyType = typeof EBodyType_RigidBody | typeof EBodyType_SoftBody;
function _emscripten_enum_EBodyType_EBodyType_RigidBody(): EBodyType;
function _emscripten_enum_EBodyType_EBodyType_SoftBody(): EBodyType;
const EMotionType_Static: number;
const EMotionType_Kinematic: number;
const EMotionType_Dynamic: number;
type EMotionType =
| typeof EMotionType_Static
| typeof EMotionType_Kinematic
| typeof EMotionType_Dynamic;
function _emscripten_enum_EMotionType_EMotionType_Static(): EMotionType;
function _emscripten_enum_EMotionType_EMotionType_Kinematic(): EMotionType;
function _emscripten_enum_EMotionType_EMotionType_Dynamic(): EMotionType;
const EMotionQuality_Discrete: number;
const EMotionQuality_LinearCast: number;
type EMotionQuality =
| typeof EMotionQuality_Discrete
| typeof EMotionQuality_LinearCast;
function _emscripten_enum_EMotionQuality_EMotionQuality_Discrete(): EMotionQuality;
function _emscripten_enum_EMotionQuality_EMotionQuality_LinearCast(): EMotionQuality;
const EActivation_Activate: number;
const EActivation_DontActivate: number;
type EActivation =
| typeof EActivation_Activate
| typeof EActivation_DontActivate;
function _emscripten_enum_EActivation_EActivation_Activate(): EActivation;
function _emscripten_enum_EActivation_EActivation_DontActivate(): EActivation;
const EShapeType_Convex: number;
const EShapeType_Compound: number;
const EShapeType_Decorated: number;
const EShapeType_Mesh: number;
const EShapeType_HeightField: number;
const EShapeType_Plane: number;
const EShapeType_Empty: number;
type EShapeType =
| typeof EShapeType_Convex
| typeof EShapeType_Compound
| typeof EShapeType_Decorated
| typeof EShapeType_Mesh
| typeof EShapeType_HeightField
| typeof EShapeType_Plane
| typeof EShapeType_Empty;
function _emscripten_enum_EShapeType_EShapeType_Convex(): EShapeType;
function _emscripten_enum_EShapeType_EShapeType_Compound(): EShapeType;
function _emscripten_enum_EShapeType_EShapeType_Decorated(): EShapeType;
function _emscripten_enum_EShapeType_EShapeType_Mesh(): EShapeType;
function _emscripten_enum_EShapeType_EShapeType_HeightField(): EShapeType;
function _emscripten_enum_EShapeType_EShapeType_Plane(): EShapeType;
function _emscripten_enum_EShapeType_EShapeType_Empty(): EShapeType;
const EShapeSubType_Sphere: number;
const EShapeSubType_Box: number;
const EShapeSubType_Capsule: number;
const EShapeSubType_TaperedCapsule: number;
const EShapeSubType_Cylinder: number;
const EShapeSubType_TaperedCylinder: number;
const EShapeSubType_ConvexHull: number;
const EShapeSubType_StaticCompound: number;
const EShapeSubType_MutableCompound: number;
const EShapeSubType_RotatedTranslated: number;
const EShapeSubType_Scaled: number;
const EShapeSubType_OffsetCenterOfMass: number;
const EShapeSubType_Mesh: number;
const EShapeSubType_HeightField: number;
const EShapeSubType_Plane: number;
const EShapeSubType_Empty: number;
type EShapeSubType =
| typeof EShapeSubType_Sphere
| typeof EShapeSubType_Box
| typeof EShapeSubType_Capsule
| typeof EShapeSubType_TaperedCapsule
| typeof EShapeSubType_Cylinder
| typeof EShapeSubType_TaperedCylinder
| typeof EShapeSubType_ConvexHull
| typeof EShapeSubType_StaticCompound
| typeof EShapeSubType_MutableCompound
| typeof EShapeSubType_RotatedTranslated
| typeof EShapeSubType_Scaled
| typeof EShapeSubType_OffsetCenterOfMass
| typeof EShapeSubType_Mesh
| typeof EShapeSubType_HeightField
| typeof EShapeSubType_Plane
| typeof EShapeSubType_Empty;
function _emscripten_enum_EShapeSubType_EShapeSubType_Sphere(): EShapeSubType;
function _emscripten_enum_EShapeSubType_EShapeSubType_Box(): EShapeSubType;
function _emscripten_enum_EShapeSubType_EShapeSubType_Capsule(): EShapeSubType;
function _emscripten_enum_EShapeSubType_EShapeSubType_TaperedCapsule(): EShapeSubType;
function _emscripten_enum_EShapeSubType_EShapeSubType_Cylinder(): EShapeSubType;
function _emscripten_enum_EShapeSubType_EShapeSubType_TaperedCylinder(): EShapeSubType;
function _emscripten_enum_EShapeSubType_EShapeSubType_ConvexHull(): EShapeSubType;
function _emscripten_enum_EShapeSubType_EShapeSubType_StaticCompound(): EShapeSubType;
function _emscripten_enum_EShapeSubType_EShapeSubType_MutableCompound(): EShapeSubType;
function _emscripten_enum_EShapeSubType_EShapeSubType_RotatedTranslated(): EShapeSubType;
function _emscripten_enum_EShapeSubType_EShapeSubType_Scaled(): EShapeSubType;
function _emscripten_enum_EShapeSubType_EShapeSubType_OffsetCenterOfMass(): EShapeSubType;
function _emscripten_enum_EShapeSubType_EShapeSubType_Mesh(): EShapeSubType;
function _emscripten_enum_EShapeSubType_EShapeSubType_HeightField(): EShapeSubType;
function _emscripten_enum_EShapeSubType_EShapeSubType_Plane(): EShapeSubType;
function _emscripten_enum_EShapeSubType_EShapeSubType_Empty(): EShapeSubType;
const EConstraintSpace_LocalToBodyCOM: number;
const EConstraintSpace_WorldSpace: number;
type EConstraintSpace =
| typeof EConstraintSpace_LocalToBodyCOM
| typeof EConstraintSpace_WorldSpace;
function _emscripten_enum_EConstraintSpace_EConstraintSpace_LocalToBodyCOM(): EConstraintSpace;
function _emscripten_enum_EConstraintSpace_EConstraintSpace_WorldSpace(): EConstraintSpace;
const ESpringMode_FrequencyAndDamping: number;
const ESpringMode_StiffnessAndDamping: number;
type ESpringMode =
| typeof ESpringMode_FrequencyAndDamping
| typeof ESpringMode_StiffnessAndDamping;
function _emscripten_enum_ESpringMode_ESpringMode_FrequencyAndDamping(): ESpringMode;
function _emscripten_enum_ESpringMode_ESpringMode_StiffnessAndDamping(): ESpringMode;
const EOverrideMassProperties_CalculateMassAndInertia: number;
const EOverrideMassProperties_CalculateInertia: number;
const EOverrideMassProperties_MassAndInertiaProvided: number;
type EOverrideMassProperties =
| typeof EOverrideMassProperties_CalculateMassAndInertia
| typeof EOverrideMassProperties_CalculateInertia
| typeof EOverrideMassProperties_MassAndInertiaProvided;
function _emscripten_enum_EOverrideMassProperties_EOverrideMassProperties_CalculateMassAndInertia(): EOverrideMassProperties;
function _emscripten_enum_EOverrideMassProperties_EOverrideMassProperties_CalculateInertia(): EOverrideMassProperties;
function _emscripten_enum_EOverrideMassProperties_EOverrideMassProperties_MassAndInertiaProvided(): EOverrideMassProperties;
const EAllowedDOFs_TranslationX: number;
const EAllowedDOFs_TranslationY: number;
const EAllowedDOFs_TranslationZ: number;
const EAllowedDOFs_RotationX: number;
const EAllowedDOFs_RotationY: number;
const EAllowedDOFs_RotationZ: number;
const EAllowedDOFs_Plane2D: number;
const EAllowedDOFs_All: number;
type EAllowedDOFs =
| typeof EAllowedDOFs_TranslationX
| typeof EAllowedDOFs_TranslationY
| typeof EAllowedDOFs_TranslationZ
| typeof EAllowedDOFs_RotationX
| typeof EAllowedDOFs_RotationY
| typeof EAllowedDOFs_RotationZ
| typeof EAllowedDOFs_Plane2D
| typeof EAllowedDOFs_All;
function _emscripten_enum_EAllowedDOFs_EAllowedDOFs_TranslationX(): EAllowedDOFs;
function _emscripten_enum_EAllowedDOFs_EAllowedDOFs_TranslationY(): EAllowedDOFs;
function _emscripten_enum_EAllowedDOFs_EAllowedDOFs_TranslationZ(): EAllowedDOFs;
function _emscripten_enum_EAllowedDOFs_EAllowedDOFs_RotationX(): EAllowedDOFs;
function _emscripten_enum_EAllowedDOFs_EAllowedDOFs_RotationY(): EAllowedDOFs;
function _emscripten_enum_EAllowedDOFs_EAllowedDOFs_RotationZ(): EAllowedDOFs;
function _emscripten_enum_EAllowedDOFs_EAllowedDOFs_Plane2D(): EAllowedDOFs;
function _emscripten_enum_EAllowedDOFs_EAllowedDOFs_All(): EAllowedDOFs;
const EStateRecorderState_None: number;
const EStateRecorderState_Global: number;
const EStateRecorderState_Bodies: number;
const EStateRecorderState_Contacts: number;
const EStateRecorderState_Constraints: number;
const EStateRecorderState_All: number;
type EStateRecorderState =
| typeof EStateRecorderState_None
| typeof EStateRecorderState_Global
| typeof EStateRecorderState_Bodies
| typeof EStateRecorderState_Contacts
| typeof EStateRecorderState_Constraints
| typeof EStateRecorderState_All;
function _emscripten_enum_EStateRecorderState_EStateRecorderState_None(): EStateRecorderState;
function _emscripten_enum_EStateRecorderState_EStateRecorderState_Global(): EStateRecorderState;
function _emscripten_enum_EStateRecorderState_EStateRecorderState_Bodies(): EStateRecorderState;
function _emscripten_enum_EStateRecorderState_EStateRecorderState_Contacts(): EStateRecorderState;
function _emscripten_enum_EStateRecorderState_EStateRecorderState_Constraints(): EStateRecorderState;
function _emscripten_enum_EStateRecorderState_EStateRecorderState_All(): EStateRecorderState;
const EBackFaceMode_IgnoreBackFaces: number;
const EBackFaceMode_CollideWithBackFaces: number;
type EBackFaceMode =
| typeof EBackFaceMode_IgnoreBackFaces
| typeof EBackFaceMode_CollideWithBackFaces;
function _emscripten_enum_EBackFaceMode_EBackFaceMode_IgnoreBackFaces(): EBackFaceMode;
function _emscripten_enum_EBackFaceMode_EBackFaceMode_CollideWithBackFaces(): EBackFaceMode;
const EGroundState_OnGround: number;
const EGroundState_OnSteepGround: number;
const EGroundState_NotSupported: number;
const EGroundState_InAir: number;
type EGroundState =
| typeof EGroundState_OnGround
| typeof EGroundState_OnSteepGround
| typeof EGroundState_NotSupported
| typeof EGroundState_InAir;
function _emscripten_enum_EGroundState_EGroundState_OnGround(): EGroundState;
function _emscripten_enum_EGroundState_EGroundState_OnSteepGround(): EGroundState;
function _emscripten_enum_EGroundState_EGroundState_NotSupported(): EGroundState;
function _emscripten_enum_EGroundState_EGroundState_InAir(): EGroundState;
const ValidateResult_AcceptAllContactsForThisBodyPair: number;
const ValidateResult_AcceptContact: number;
const ValidateResult_RejectContact: number;
const ValidateResult_RejectAllContactsForThisBodyPair: number;
type ValidateResult =
| typeof ValidateResult_AcceptAllContactsForThisBodyPair
| typeof ValidateResult_AcceptContact
| typeof ValidateResult_RejectContact
| typeof ValidateResult_RejectAllContactsForThisBodyPair;
function _emscripten_enum_ValidateResult_ValidateResult_AcceptAllContactsForThisBodyPair(): ValidateResult;
function _emscripten_enum_ValidateResult_ValidateResult_AcceptContact(): ValidateResult;
function _emscripten_enum_ValidateResult_ValidateResult_RejectContact(): ValidateResult;
function _emscripten_enum_ValidateResult_ValidateResult_RejectAllContactsForThisBodyPair(): ValidateResult;
const SoftBodyValidateResult_AcceptContact: number;
const SoftBodyValidateResult_RejectContact: number;
type SoftBodyValidateResult =
| typeof SoftBodyValidateResult_AcceptContact
| typeof SoftBodyValidateResult_RejectContact;
function _emscripten_enum_SoftBodyValidateResult_SoftBodyValidateResult_AcceptContact(): SoftBodyValidateResult;
function _emscripten_enum_SoftBodyValidateResult_SoftBodyValidateResult_RejectContact(): SoftBodyValidateResult;
const EActiveEdgeMode_CollideOnlyWithActive: number;
const EActiveEdgeMode_CollideWithAll: number;
type EActiveEdgeMode =
| typeof EActiveEdgeMode_CollideOnlyWithActive
| typeof EActiveEdgeMode_CollideWithAll;
function _emscripten_enum_EActiveEdgeMode_EActiveEdgeMode_CollideOnlyWithActive(): EActiveEdgeMode;
function _emscripten_enum_EActiveEdgeMode_EActiveEdgeMode_CollideWithAll(): EActiveEdgeMode;
const ECollectFacesMode_CollectFaces: number;
const ECollectFacesMode_NoFaces: number;
type ECollectFacesMode =
| typeof ECollectFacesMode_CollectFaces
| typeof ECollectFacesMode_NoFaces;
function _emscripten_enum_ECollectFacesMode_ECollectFacesMode_CollectFaces(): ECollectFacesMode;
function _emscripten_enum_ECollectFacesMode_ECollectFacesMode_NoFaces(): ECollectFacesMode;
const SixDOFConstraintSettings_EAxis_TranslationX: number;
const SixDOFConstraintSettings_EAxis_TranslationY: number;
const SixDOFConstraintSettings_EAxis_TranslationZ: number;
const SixDOFConstraintSettings_EAxis_RotationX: number;
const SixDOFConstraintSettings_EAxis_RotationY: number;
const SixDOFConstraintSettings_EAxis_RotationZ: number;
type SixDOFConstraintSettings_EAxis =
| typeof SixDOFConstraintSettings_EAxis_TranslationX
| typeof SixDOFConstraintSettings_EAxis_TranslationY
| typeof SixDOFConstraintSettings_EAxis_TranslationZ
| typeof SixDOFConstraintSettings_EAxis_RotationX
| typeof SixDOFConstraintSettings_EAxis_RotationY
| typeof SixDOFConstraintSettings_EAxis_RotationZ;
function _emscripten_enum_SixDOFConstraintSettings_EAxis_SixDOFConstraintSettings_EAxis_TranslationX(): SixDOFConstraintSettings_EAxis;
function _emscripten_enum_SixDOFConstraintSettings_EAxis_SixDOFConstraintSettings_EAxis_TranslationY(): SixDOFConstraintSettings_EAxis;
function _emscripten_enum_SixDOFConstraintSettings_EAxis_SixDOFConstraintSettings_EAxis_TranslationZ(): SixDOFConstraintSettings_EAxis;
function _emscripten_enum_SixDOFConstraintSettings_EAxis_SixDOFConstraintSettings_EAxis_RotationX(): SixDOFConstraintSettings_EAxis;
function _emscripten_enum_SixDOFConstraintSettings_EAxis_SixDOFConstraintSettings_EAxis_RotationY(): SixDOFConstraintSettings_EAxis;
function _emscripten_enum_SixDOFConstraintSettings_EAxis_SixDOFConstraintSettings_EAxis_RotationZ(): SixDOFConstraintSettings_EAxis;
const EConstraintType_Constraint: number;
const EConstraintType_TwoBodyConstraint: number;
type EConstraintType =
| typeof EConstraintType_Constraint
| typeof EConstraintType_TwoBodyConstraint;
function _emscripten_enum_EConstraintType_EConstraintType_Constraint(): EConstraintType;
function _emscripten_enum_EConstraintType_EConstraintType_TwoBodyConstraint(): EConstraintType;
const EConstraintSubType_Fixed: number;
const EConstraintSubType_Point: number;
const EConstraintSubType_Hinge: number;
const EConstraintSubType_Slider: number;
const EConstraintSubType_Distance: number;
const EConstraintSubType_Cone: number;
const EConstraintSubType_SwingTwist: number;
const EConstraintSubType_SixDOF: number;
const EConstraintSubType_Path: number;
const EConstraintSubType_Vehicle: number;
const EConstraintSubType_RackAndPinion: number;
const EConstraintSubType_Gear: number;
const EConstraintSubType_Pulley: number;
type EConstraintSubType =
| typeof EConstraintSubType_Fixed
| typeof EConstraintSubType_Point
| typeof EConstraintSubType_Hinge
| typeof EConstraintSubType_Slider
| typeof EConstraintSubType_Distance
| typeof EConstraintSubType_Cone
| typeof EConstraintSubType_SwingTwist
| typeof EConstraintSubType_SixDOF
| typeof EConstraintSubType_Path
| typeof EConstraintSubType_Vehicle
| typeof EConstraintSubType_RackAndPinion
| typeof EConstraintSubType_Gear
| typeof EConstraintSubType_Pulley;
function _emscripten_enum_EConstraintSubType_EConstraintSubType_Fixed(): EConstraintSubType;
function _emscripten_enum_EConstraintSubType_EConstraintSubType_Point(): EConstraintSubType;
function _emscripten_enum_EConstraintSubType_EConstraintSubType_Hinge(): EConstraintSubType;
function _emscripten_enum_EConstraintSubType_EConstraintSubType_Slider(): EConstraintSubType;
function _emscripten_enum_EConstraintSubType_EConstraintSubType_Distance(): EConstraintSubType;
function _emscripten_enum_EConstraintSubType_EConstraintSubType_Cone(): EConstraintSubType;
function _emscripten_enum_EConstraintSubType_EConstraintSubType_SwingTwist(): EConstraintSubType;
function _emscripten_enum_EConstraintSubType_EConstraintSubType_SixDOF(): EConstraintSubType;
function _emscripten_enum_EConstraintSubType_EConstraintSubType_Path(): EConstraintSubType;
function _emscripten_enum_EConstraintSubType_EConstraintSubType_Vehicle(): EConstraintSubType;
function _emscripten_enum_EConstraintSubType_EConstraintSubType_RackAndPinion(): EConstraintSubType;
function _emscripten_enum_EConstraintSubType_EConstraintSubType_Gear(): EConstraintSubType;
function _emscripten_enum_EConstraintSubType_EConstraintSubType_Pulley(): EConstraintSubType;
const EMotorState_Off: number;
const EMotorState_Velocity: number;
const EMotorState_Position: number;
type EMotorState =
| typeof EMotorState_Off
| typeof EMotorState_Velocity
| typeof EMotorState_Position;
function _emscripten_enum_EMotorState_EMotorState_Off(): EMotorState;
function _emscripten_enum_EMotorState_EMotorState_Velocity(): EMotorState;
function _emscripten_enum_EMotorState_EMotorState_Position(): EMotorState;
const ETransmissionMode_Auto: number;
const ETransmissionMode_Manual: number;
type ETransmissionMode =
| typeof ETransmissionMode_Auto
| typeof ETransmissionMode_Manual;
function _emscripten_enum_ETransmissionMode_ETransmissionMode_Auto(): ETransmissionMode;
function _emscripten_enum_ETransmissionMode_ETransmissionMode_Manual(): ETransmissionMode;
const ETireFrictionDirection_Longitudinal: number;
const ETireFrictionDirection_Lateral: number;
type ETireFrictionDirection =
| typeof ETireFrictionDirection_Longitudinal
| typeof ETireFrictionDirection_Lateral;
function _emscripten_enum_ETireFrictionDirection_ETireFrictionDirection_Longitudinal(): ETireFrictionDirection;
function _emscripten_enum_ETireFrictionDirection_ETireFrictionDirection_Lateral(): ETireFrictionDirection;
const ESwingType_Cone: number;
const ESwingType_Pyramid: number;
type ESwingType = typeof ESwingType_Cone | typeof ESwingType_Pyramid;
function _emscripten_enum_ESwingType_ESwingType_Cone(): ESwingType;
function _emscripten_enum_ESwingType_ESwingType_Pyramid(): ESwingType;
const EPathRotationConstraintType_Free: number;
const EPathRotationConstraintType_ConstrainAroundTangent: number;
const EPathRotationConstraintType_ConstrainAroundNormal: number;
const EPathRotationConstraintType_ConstrainAroundBinormal: number;
const EPathRotationConstraintType_ConstrainToPath: number;
const EPathRotationConstraintType_FullyConstrained: number;
type EPathRotationConstraintType =
| typeof EPathRotationConstraintType_Free
| typeof EPathRotationConstraintType_ConstrainAroundTangent
| typeof EPathRotationConstraintType_ConstrainAroundNormal
| typeof EPathRotationConstraintType_ConstrainAroundBinormal
| typeof EPathRotationConstraintType_ConstrainToPath
| typeof EPathRotationConstraintType_FullyConstrained;
function _emscripten_enum_EPathRotationConstraintType_EPathRotationConstraintType_Free(): EPathRotationConstraintType;
function _emscripten_enum_EPathRotationConstraintType_EPathRotationConstraintType_ConstrainAroundTangent(): EPathRotationConstraintType;
function _emscripten_enum_EPathRotationConstraintType_EPathRotationConstraintType_ConstrainAroundNormal(): EPathRotationConstraintType;
function _emscripten_enum_EPathRotationConstraintType_EPathRotationConstraintType_ConstrainAroundBinormal(): EPathRotationConstraintType;
function _emscripten_enum_EPathRotationConstraintType_EPathRotationConstraintType_ConstrainToPath(): EPathRotationConstraintType;
function _emscripten_enum_EPathRotationConstraintType_EPathRotationConstraintType_FullyConstrained(): EPathRotationConstraintType;
const SoftBodySharedSettings_EBendType_None: number;
const SoftBodySharedSettings_EBendType_Distance: number;
const SoftBodySharedSettings_EBendType_Dihedral: number;
type SoftBodySharedSettings_EBendType =
| typeof SoftBodySharedSettings_EBendType_None
| typeof SoftBodySharedSettings_EBendType_Distance
| typeof SoftBodySharedSettings_EBendType_Dihedral;
function _emscripten_enum_SoftBodySharedSettings_EBendType_SoftBodySharedSettings_EBendType_None(): SoftBodySharedSettings_EBendType;
function _emscripten_enum_SoftBodySharedSettings_EBendType_SoftBodySharedSettings_EBendType_Distance(): SoftBodySharedSettings_EBendType;
function _emscripten_enum_SoftBodySharedSettings_EBendType_SoftBodySharedSettings_EBendType_Dihedral(): SoftBodySharedSettings_EBendType;
const SoftBodySharedSettings_ELRAType_None: number;
const SoftBodySharedSettings_ELRAType_EuclideanDistance: number;
const SoftBodySharedSettings_ELRAType_GeodesicDistance: number;
type SoftBodySharedSettings_ELRAType =
| typeof SoftBodySharedSettings_ELRAType_None
| typeof SoftBodySharedSettings_ELRAType_EuclideanDistance
| typeof SoftBodySharedSettings_ELRAType_GeodesicDistance;
function _emscripten_enum_SoftBodySharedSettings_ELRAType_SoftBodySharedSettings_ELRAType_None(): SoftBodySharedSettings_ELRAType;
function _emscripten_enum_SoftBodySharedSettings_ELRAType_SoftBodySharedSettings_ELRAType_EuclideanDistance(): SoftBodySharedSettings_ELRAType;
function _emscripten_enum_SoftBodySharedSettings_ELRAType_SoftBodySharedSettings_ELRAType_GeodesicDistance(): SoftBodySharedSettings_ELRAType;
const MeshShapeSettings_EBuildQuality_FavorRuntimePerformance: number;
const MeshShapeSettings_EBuildQuality_FavorBuildSpeed: number;
type MeshShapeSettings_EBuildQuality =
| typeof MeshShapeSettings_EBuildQuality_FavorRuntimePerformance
| typeof MeshShapeSettings_EBuildQuality_FavorBuildSpeed;
function _emscripten_enum_MeshShapeSettings_EBuildQuality_MeshShapeSettings_EBuildQuality_FavorRuntimePerformance(): MeshShapeSettings_EBuildQuality;
function _emscripten_enum_MeshShapeSettings_EBuildQuality_MeshShapeSettings_EBuildQuality_FavorBuildSpeed(): MeshShapeSettings_EBuildQuality;
class Vec3MemRef {}
class QuatMemRef {}
class Mat44MemRef {}
class BodyIDMemRef {}
class BodyPtrMemRef {}
class FloatMemRef {}
class Uint8MemRef {}
class UintMemRef {}
class Vec3 {
constructor();
constructor(inV: Float3);
constructor(inX: number, inY: number, inZ: number);
sZero(): Vec3;
sOne(): Vec3;
sAxisX(): Vec3;
sAxisY(): Vec3;
sAxisZ(): Vec3;
sReplicate(inValue: number): Vec3;
sMin(inLHS: Vec3, inRHS: Vec3): Vec3;
sMax(inLHS: Vec3, inRHS: Vec3): Vec3;
sClamp(inValue: Vec3, inMin: Vec3, inMax: Vec3): Vec3;
sFusedMultiplyAdd(inMul1: Vec3, inMul2: Vec3, inAdd: Vec3): Vec3;
sOr(inV1: Vec3, inV2: Vec3): Vec3;
sXor(inV1: Vec3, inV2: Vec3): Vec3;
sAnd(inV1: Vec3, inV2: Vec3): Vec3;
sUnitSpherical(inTheta: number, inPhi: number): Vec3;
GetComponent(inCoordinate: number): number;
Equals(inV: Vec3): boolean;
NotEquals(inV: Vec3): boolean;
LengthSq(): number;
Length(): number;
Normalized(): Vec3;
NormalizedOr(inZeroValue: Vec3): Vec3;
GetNormalizedPerpendicular(): Vec3;
GetX(): number;
GetY(): number;
GetZ(): number;
SetX(inX: number): void;
SetY(inY: number): void;
SetZ(inZ: number): void;
Set(inX: number, inY: number, inZ: number): void;
SetComponent(inCoordinate: number, inValue: number): void;
IsNearZero(inMaxDistSq?: number): boolean;
IsClose(inV: Vec3, inMaxDistSq?: number): boolean;
IsNormalized(inTolerance?: number): boolean;
GetLowestComponentIndex(): number;
GetHighestComponentIndex(): number;
Abs(): Vec3;
Reciprocal(): Vec3;
Cross(inRHS: Vec3): Vec3;
Dot(inRHS: Vec3): number;
DotV(inRHS: Vec3): Vec3;
DotV4(inRHS: Vec3): Vec4;
Add(inV: Vec3): Vec3;
Sub(inV: Vec3): Vec3;
Mul(inV: number): Vec3;
Div(inV: number): Vec3;
MulVec3(inV: Vec3): Vec3;
MulFloat(inV: number): Vec3;
DivVec3(inV: Vec3): Vec3;
DivFloat(inV: number): Vec3;
AddVec3(inV: Vec3): Vec3;
SubVec3(inV: Vec3): Vec3;
SplatX(): Vec4;
SplatY(): Vec4;
SplatZ(): Vec4;
ReduceMin(): number;
ReduceMax(): number;
Sqrt(): Vec3;
GetSign(): Vec3;
}
class RVec3 {
constructor();
constructor(inX: number, inY: number, inZ: number);
sZero(): RVec3;
sOne(): RVec3;
sAxisX(): RVec3;
sAxisY(): RVec3;
sAxisZ(): RVec3;
sReplicate(inValue: number): RVec3;
sMin(inLHS: RVec3, inRHS: RVec3): RVec3;
sMax(inLHS: RVec3, inRHS: RVec3): RVec3;
sClamp(inValue: RVec3, inMin: RVec3, inMax: RVec3): RVec3;
GetComponent(inCoordinate: number): number;
Equals(inV: RVec3): boolean;
NotEquals(inV: RVec3): boolean;
LengthSq(): number;
Length(): number;
Normalized(): RVec3;
GetX(): number;
GetY(): number;
GetZ(): number;
SetX(inX: number): void;
SetY(inY: number): void;
SetZ(inZ: number): void;
Set(inX: number, inY: number, inZ: number): void;
SetComponent(inCoordinate: number, inValue: number): void;
IsNearZero(inMaxDistSq?: number): boolean;
IsClose(inV: RVec3, inMaxDistSq?: number): boolean;
IsNormalized(inTolerance?: number): boolean;
Abs(): RVec3;
Reciprocal(): RVec3;
Cross(inRHS: RVec3): RVec3;
Dot(inRHS: RVec3): number;
Add(inV: Vec3): RVec3;
Sub(inV: Vec3): RVec3;
Mul(inV: number): RVec3;
Div(inV: number): RVec3;
MulRVec3(inV: RVec3): RVec3;
MulFloat(inV: number): RVec3;
DivRVec3(inV: RVec3): RVec3;
DivFloat(inV: number): RVec3;
AddRVec3(inV: RVec3): RVec3;
SubRVec3(inV: RVec3): RVec3;
Sqrt(): RVec3;
GetSign(): RVec3;
}
class Vec4 {
constructor();
constructor(inV: Vec4);
constructor(inV: Vec3, inW: number);
constructor(inX: number, inY: number, inZ: number, inW: number);
sZero(): Vec4;
sOne(): Vec4;
sReplicate(inV: number): Vec4;
sMin(inLHS: Vec4, inRHS: Vec4): Vec4;
sMax(inLHS: Vec4, inRHS: Vec4): Vec4;
sClamp(inValue: Vec4, inMin: Vec4, inMax: Vec4): Vec4;
sFusedMultiplyAdd(inMul1: Vec4, inMul2: Vec4, inAdd: Vec4): Vec4;
sOr(inV1: Vec4, inV2: Vec4): Vec4;
sXor(inV1: Vec4, inV2: Vec4): Vec4;
sAnd(inV1: Vec4, inV2: Vec4): Vec4;
GetX(): number;
GetY(): number;
GetZ(): number;
GetW(): number;
SetX(inX: number): void;
SetY(inY: number): void;
SetZ(inZ: number): void;
SetW(inW: number): void;
Set(inX: number, inY: number, inZ: number, inW: number): void;
GetComponent(inCoordinate: number): number;
IsClose(inV: Vec4, inMaxDistSq?: number): boolean;
IsNearZero(inMaxDistSq?: number): boolean;
IsNormalized(inTolerance?: number): boolean;
GetLowestComponentIndex(): number;
GetHighestComponentIndex(): number;
Add(inV: Vec4): Vec4;
Sub(inV: Vec4): Vec4;
Mul(inV: number): Vec4;
Div(inV: number): Vec4;
MulVec4(inV: Vec4): Vec4;
MulFloat(inV: number): Vec4;
DivVec4(inV: Vec4): Vec4;
DivFloat(inV: number): Vec4;
AddVec4(inV: Vec4): Vec4;
SubVec4(inV: Vec4): Vec4;
}
class Vector2 {
constructor();
SetZero(): void;
IsZero(): void;
IsClose(inV: Vector2, inMaxDistSq?: number): void;
IsNormalized(inTolerance?: number): void;
Normalized(): Vector2;
GetComponent(inCoordinate: number): number;
Add(inV: Vector2): Vector2;
Sub(inV: Vector2): Vector2;
Mul(inV: number): Vector2;
Div(inV: number): Vector2;
MulFloat(inV: number): Vector2;
DivFloat(inV: number): Vector2;
AddVector2(inV: Vector2): Vector2;
SubVector2(inV: Vector2): Vector2;
Dot(inRHS: Vector2): number;
}
class Quat {
constructor();
constructor(inX: number, inY: number, inZ: number, inW: number);
sZero(): Quat;
sIdentity(): Quat;
sRotation(inRotation: Vec3, inAngle: number): Quat;
sFromTo(inFrom: Vec3, inTo: Vec3): Quat;
Equals(inQ: Quat): boolean;
NotEquals(inQ: Quat): boolean;
MulQuat(inQ: Quat): Quat;
MulVec3(inV: Vec3): Vec3;
MulFloat(inV: number): Quat;
IsClose(inQ: Quat, inMaxDistSq?: number): boolean;
IsNormalized(inTolerance?: number): boolean;
Length(): number;
LengthSq(): number;
Normalized(): Quat;
sEulerAngles(inInput: Vec3): Quat;
GetEulerAngles(): Vec3;
GetX(): number;
GetY(): number;
GetZ(): number;
GetW(): number;
GetXYZ(): Vec3;
SetX(inX: number): void;
SetY(inY: number): void;
SetZ(inZ: number): void;
SetW(inW: number): void;
Set(inX: number, inY: number, inZ: number, inW: number): void;
sMultiplyImaginary(inLHS: Vec3, inRHS: Quat): Quat;
InverseRotate(inV: Vec3): Vec3;
RotateAxisX(): Vec3;
RotateAxisY(): Vec3;
RotateAxisZ(): Vec3;
Dot(inQ: Quat): number;
Conjugated(): Quat;
Inversed(): Quat;
EnsureWPositive(): Quat;
GetPerpendicular(): Quat;
GetRotationAngle(inAxis: Vec3): number;
GetTwist(inAxis: Vec3): Quat;
GetSwingTwist(outSwing: Quat, outTwist: Quat): void;
LERP(inDestination: Quat, inFraction: number): Quat;
SLERP(inDestination: Quat, inFraction: number): Quat;
}
class Float3 {
constructor(inX: number, inY: number, inZ: number);
Equals(inV: Float3): boolean;
NotEquals(inV: Float3): boolean;
get_x(): number;
set_x(x: number): void;
x: number;
get_y(): number;
set_y(y: number): void;
y: number;
get_z(): number;
set_z(z: number): void;
z: number;
}
class Mat44 {
constructor();
sZero(): Mat44;
sIdentity(): Mat44;
sRotationX(inX: number): Mat44;
sRotationY(inY: number): Mat44;
sRotationZ(inZ: number): Mat44;
sRotation(inQ: Quat): Mat44;
sRotationAxisAngle(inAxis: Vec3, inAngle: number): Mat44;
sTranslation(inTranslation: Vec3): Mat44;
sRotationTranslation(inRotation: Quat, inTranslation: Vec3): Mat44;
sInverseRotationTranslation(inRotation: Quat, inTranslation: Vec3): Mat44;
sScale(inScale: number): Mat44;
sScaleVec3(inScale: Vec3): Mat44;
sOuterProduct(inV1: Vec3, inV2: Vec3): Mat44;
sCrossProduct(inV: Vec3): Mat44;
sQuatLeftMultiply(inQ: Quat): Mat44;
sQuatRightMultiply(inQ: Quat): Mat44;
sLookAt(inPos: Vec3, inTarget: Vec3, inUp: Vec3): Mat44;
sPerspective(
inFovY: number,
inAspect: number,
inNear: number,
inFar: number
): Mat44;
GetAxisX(): Vec3;
GetAxisY(): Vec3;
GetAxisZ(): Vec3;
GetDiagonal3(): Vec3;
GetDiagonal4(): Vec4;
GetRotation(): Mat44;
GetRotationSafe(): Mat44;
GetQuaternion(): Quat;
GetTranslation(): Vec3;
Equals(inV: Mat44): boolean;
NotEquals(inV: Mat44): boolean;
IsClose(inM: Mat44, inMaxDistSq?: number): boolean;
Add(inM: Mat44): Mat44;
MulFloat(inV: number): Mat44;
MulMat44(inM: Mat44): Mat44;
MulVec3(inV: Vec3): Vec3;
MulVec4(inV: Vec4): Vec4;
AddMat44(inM: Mat44): Mat44;
SubMat44(inM: Mat44): Mat44;
Multiply3x3(inV: Vec3): Vec3;
Multiply3x3Transposed(inV: Vec3): Vec3;
Multiply3x3LeftTransposed(inM: Mat44): Mat44;
Multiply3x3RightTransposed(inM: Mat44): Mat44;
Transposed(): Mat44;
Transposed3x3(): Mat44;
Inversed(): Mat44;
InversedRotationTranslation(): Mat44;
Adjointed3x3(): Mat44;
SetInversed3x3(inM: Mat44): boolean;
GetDeterminant3x3(): number;
Inversed3x3(): Mat44;
GetDirectionPreservingMatrix(): Mat44;
PreTranslated(inTranslation: Vec3): Mat44;
PostTranslated(inTranslation: Vec3): Mat44;
PreScaled(inScale: Vec3): Mat44;
PostScaled(inScale: Vec3): Mat44;
Decompose(outScale: Vec3): Mat44;
SetColumn3(inCol: number, inV: Vec3): void;
SetColumn4(inCol: number, inV: Vec4): void;
SetAxisX(inV: Vec3): void;
SetAxisY(inV: Vec3): void;
SetAxisZ(inV: Vec3): void;
SetDiagonal3(inV: Vec3): void;
SetDiagonal4(inV: Vec4): void;
SetTranslation(inV: Vec3): void;
GetColumn3(inCol: number): Vec3;
GetColumn4(inCol: number): Vec4;
}
class RMat44 {
constructor();
sZero(): RMat44;
sIdentity(): RMat44;
sRotation(inQ: Quat): RMat44;
sTranslation(inTranslation: RVec3): RMat44;
sRotationTranslation(inRotation: Quat, inTranslation: RVec3): RMat44;
sInverseRotationTranslation(inRotation: Quat, inTranslation: RVec3): RMat44;
ToMat44(): Mat44;
Equals(inV: RMat44): boolean;
NotEquals(inV: RMat44): boolean;
MulVec3(inV: Vec3): RVec3;
MulRVec3(inV: RVec3): RVec3;
MulMat44(inM: Mat44): RMat44;
MulRMat44(inM: RMat44): RMat44;
GetAxisX(): Vec3;
GetAxisY(): Vec3;
GetAxisZ(): Vec3;
GetRotation(): Mat44;
SetRotation(inRotation: Mat44): void;
GetQuaternion(): Quat;
GetTranslation(): RVec3;
IsClose(inM: RMat44, inMaxDistSq?: number): boolean;
Multiply3x3(inV: Vec3): Vec3;
Multiply3x3Transposed(inV: Vec3): Vec3;
Transposed3x3(): Mat44;
Inversed(): RMat44;
InversedRotationTranslation(): RMat44;
PreTranslated(inTranslation: Vec3): RMat44;
PostTranslated(inTranslation: Vec3): RMat44;
PreScaled(inScale: Vec3): RMat44;
PostScaled(inScale: Vec3): RMat44;
GetDirectionPreservingMatrix(): Mat44;
SetColumn3(inCol: number, inV: Vec3): void;
GetColumn3(inCol: number): Vec3;
SetAxisX(inV: Vec3): void;
SetAxisY(inV: Vec3): void;
SetAxisZ(inV: Vec3): void;
SetTranslation(inV: RVec3): void;
SetColumn4(inCol: number, inV: Vec4): void;
GetColumn4(inCol: number): Vec4;
Decompose(outScale: Vec3): RMat44;
}
class AABox {
constructor();
constructor(inMin: Vec3, inMax: Vec3);
sBiggest(): AABox;
sFromTwoPoints(inP1: Vec3, inP2: Vec3): AABox;
sFromTriangle(inVertices: VertexList, inTriangle: IndexedTriangle): AABox;
Equals(inB: AABox): boolean;
NotEquals(inB: AABox): boolean;
SetEmpty(): void;
IsValid(): boolean;
EncapsulateVec3(inV: Vec3): void;
EncapsulateAABox(inBox: AABox): void;
EncapsulateTriangle(inTriangle: Triangle): void;
EncapsulateIndexedTriangle(
inVertices: VertexList,
inTriangle: IndexedTriangle
): void;
Intersect(inOther: AABox): AABox;
EnsureMinimalEdgeLength(inMinEdgeLength: number): void;
ExpandBy(inV: Vec3): void;
GetCenter(): Vec3;
GetExtent(): Vec3;
GetSize(): Vec3;
GetSurfaceArea(): number;
GetVolume(): number;
ContainsVec3(inOther: Vec3): boolean;
ContainsRVec3(inOther: RVec3): boolean;
OverlapsAABox(inOther: AABox): boolean;
OverlapsPlane(inOther: AABox): boolean;
TranslateVec3(inOther: Vec3): void;
TranslateRVec3(inOther: RVec3): void;
TransformedMat44(inOther: Mat44): AABox;
TransformedRMat44(inOther: RMat44): AABox;
Scaled(inScale: Vec3): AABox;
GetClosestPoint(inV: Vec3): Vec3;
GetSqDistanceTo(inV: Vec3): number;
get_mMin(): Vec3;
set_mMin(mMin: Vec3): void;
mMin: Vec3;
get_mMax(): Vec3;
set_mMax(mMax: Vec3): void;
mMax: Vec3;
}
class OrientedBox {
constructor();
constructor(inOrientation: Mat44, inHalfExtents: Vec3);
get_mOrientation(): Mat44;
set_mOrientation(mOrientation: Mat44): void;
mOrientation: Mat44;
get_mHalfExtents(): Vec3;
set_mHalfExtents(mHalfExtents: Vec3): void;
mHalfExtents: Vec3;
}
class RayCast {
constructor();
constructor(inOrigin: Vec3, inDirection: Vec3);
Transformed(inTransform: Mat44): RayCast;
Translated(inTranslation: Vec3): RayCast;
GetPointOnRay(inFraction: number): Vec3;
get_mOrigin(): Vec3;
set_mOrigin(mOrigin: Vec3): void;
mOrigin: Vec3;
get_mDirection(): Vec3;
set_mDirection(mDirection: Vec3): void;
mDirection: Vec3;
}
class RRayCast {
constructor();
constructor(inOrigin: RVec3, inDirection: Vec3);
Transformed(inTransform: RMat44): RRayCast;
Translated(inTranslation: RVec3): RRayCast;
GetPointOnRay(inFraction: number): RVec3;
get_mOrigin(): RVec3;
set_mOrigin(mOrigin: RVec3): void;
mOrigin: RVec3;
get_mDirection(): Vec3;
set_mDirection(mDirection: Vec3): void;
mDirection: Vec3;
}
class BroadPhaseCastResult {
constructor();
Reset(): void;
get_mBodyID(): BodyID;
set_mBodyID(mBodyID: BodyID): void;
mBodyID: BodyID;
get_mFraction(): number;
set_mFraction(mFraction: number): void;
mFraction: number;
}
class RayCastResult extends BroadPhaseCastResult {
constructor();
get_mSubShapeID2(): SubShapeID;
set_mSubShapeID2(mSubShapeID2: SubShapeID): void;
mSubShapeID2: SubShapeID;
}
class AABoxCast {
constructor();
get_mBox(): AABox;
set_mBox(mBox: AABox): void;
mBox: AABox;
get_mDirection(): Vec3;
set_mDirection(mDirection: Vec3): void;
mDirection: Vec3;
}
class ShapeCast {
constructor(
inShape: Shape,
inScale: Vec3,
inCenterOfMassStart: Mat44,
inDirection: Vec3
);
get_mShape(): Shape;
set_mShape(mShape: Shape): void;
readonly mShape: Shape;
get_mScale(): Vec3;
set_mScale(mScale: Vec3): void;
readonly mScale: Vec3;
get_mCenterOfMassStart(): Mat44;
set_mCenterOfMassStart(mCenterOfMassStart: Mat44): void;
readonly mCenterOfMassStart: Mat44;
get_mDirection(): Vec3;
set_mDirection(mDirection: Vec3): void;
readonly mDirection: Vec3;
GetPointOnRay(inFraction: number): Vec3;
}
class RShapeCast {
constructor(
inShape: Shape,
inScale: Vec3,
inCenterOfMassStart: RMat44,
inDirection: Vec3
);
get_mShape(): Shape;
set_mShape(mShape: Shape): void;
readonly mShape: Shape;
get_mScale(): Vec3;
set_mScale(mScale: Vec3): void;
readonly mScale: Vec3;
get_mCenterOfMassStart(): RMat44;
set_mCenterOfMassStart(mCenterOfMassStart: RMat44): void;
readonly mCenterOfMassStart: RMat44;
get_mDirection(): Vec3;
set_mDirection(mDirection: Vec3): void;
readonly mDirection: Vec3;
GetPointOnRay(inFraction: number): RVec3;
}
class Plane {
constructor(inNormal: Vec3, inConstant: number);
GetNormal(): Vec3;
SetNormal(inNormal: Vec3): void;
GetConstant(): number;
SetConstant(inConstant: number): void;
sFromPointAndNormal(inPoint: Vec3, inNormal: Vec3): Plane;
sFromPointsCCW(inPoint1: Vec3, inPoint2: Vec3, inPoint3: Vec3): Plane;
Offset(inDistance: number): Plane;
Scaled(inScale: Vec3): Plane;
GetTransformed(inTransform: Mat44): Plane;
ProjectPointOnPlane(inPoint: Vec3): Vec3;
SignedDistance(inPoint: Vec3): number;
}
class TransformedShape {
constructor();
CastRay(inRay: RRayCast, ioHit: RayCastResult): void;
CastRay(
inRay: RRayCast,
inRayCastSettings: RayCastSettings,
ioCollector: CastRayCollector,
inShapeFilter: ShapeFilter
): void;
CollidePoint(
inPoint: RVec3,
ioCollector: CollidePointCollector,
inShapeFilter: ShapeFilter
): void;
CollideShape(
inShape: Shape,
inShapeScale: Vec3,
inCenterOfMassTransform: RMat44,
inCollideShapeSettings: CollideShapeSettings,
inBaseOffset: RVec3,
ioCollector: CollideShapeCollector,
inShapeFilter: ShapeFilter
): void;
CastShape(
inShapeCast: RShapeCast,
inShapeCastSettings: ShapeCastSettings,
inBaseOffset: RVec3,
ioCollector: CastShapeCollector,
inShapeFilter: ShapeFilter
): void;
CollectTransformedShapes(
inBox: AABox,
ioCollector: TransformedShapeCollector,
inShapeFilter: ShapeFilter
): void;
GetShapeScale(): Vec3;
SetShapeScale(inScale: Vec3): void;
GetCenterOfMassTransform(): RMat44;
GetInverseCenterOfMassTransform(): RMat44;
SetWorldTransform(inPosition: RVec3, inRotation: Quat, inScale: Vec3): void;
SetWorldTransform(inTransform: RMat44): void;
GetWorldTransform(): RMat44;
GetWorldSpaceBounds(): AABox;
GetWorldSpaceSurfaceNormal(
inSubShapeID: SubShapeID,
inPosition: RVec3
): Vec3;
GetMaterial(inSubShapeID: SubShapeID): PhysicsMaterial;
get_mShapePositionCOM(): RVec3;
set_mShapePositionCOM(mShapePositionCOM: RVec3): void;
mShapePositionCOM: RVec3;
get_mShapeRotation(): Quat;
set_mShapeRotation(mShapeRotation: Quat): void;
mShapeRotation: Quat;
get_mShape(): Shape;
set_mShape(mShape: Shape): void;
mShape: Shape;
get_mShapeScale(): Float3;
set_mShapeScale(mShapeScale: Float3): void;
mShapeScale: Float3;
get_mBodyID(): BodyID;
set_mBodyID(mBodyID: BodyID): void;
mBodyID: BodyID;
}
class PhysicsMaterial {
constructor();
GetRefCount(): number;
AddRef(): void;
Release(): void;
}
class PhysicsMaterialList {
constructor();
empty(): boolean;
size(): number;
at(inIndex: number): PhysicsMaterial;
push_back(inMaterial: PhysicsMaterial): void;
reserve(inSize: number): void;
resize(inSize: number): void;
clear(): void;
}
class Triangle {
constructor();
constructor(
inV1: Vec3,
inV2: Vec3,
inV3: Vec3,
inMaterialIndex?: number,
inUserData?: number
);
get_mV(index: number): Float3;
set_mV(index: number, mV: Float3): void;
mV: Float3;
get_mMaterialIndex(): number;
set_mMaterialIndex(mMaterialIndex: number): void;
mMaterialIndex: number;
get_mUserData(): number;
set_mUserData(mUserData: number): void;
mUserData: number;
}
class TriangleList {
constructor();
empty(): boolean;
size(): number;
at(inIndex: number): Triangle;
push_back(inTriangle: Triangle): void;
reserve(inSize: number): void;
resize(inSize: number): void;
clear(): void;
}
class VertexList {
constructor();
empty(): boolean;
size(): number;
at(inIndex: number): Float3;
push_back(inVertex: Float3): void;
reserve(inSize: number): void;
resize(inSize: number): void;
clear(): void;
}
class IndexedTriangle {
constructor();
constructor(
inI1: number,
inI2: number,
inI3: number,
inMaterialIndex: number,
inUserData?: number
);
get_mIdx(index: number): number;
set_mIdx(index: number, mIdx: number): void;
mIdx: number;
get_mMaterialIndex(): number;
set_mMaterialIndex(mMaterialIndex: number): void;
mMaterialIndex: number;
get_mUserData(): number;
set_mUserData(mUserData: number): void;
mUserData: number;
}
class IndexedTriangleList {
constructor();
empty(): boolean;
size(): number;
at(inIndex: number): IndexedTriangle;
push_back(inTriangle: IndexedTriangle): void;
reserve(inSize: number): void;
resize(inSize: number): void;
clear(): void;
}
class ShapeResult {
IsValid(): boolean;
HasError(): boolean;
GetError(): JPHString;
Get(): Shape;
Clear(): void;
}
class ShapeSettings {
GetRefCount(): number;
AddRef(): void;
Release(): void;
Create(): ShapeResult;
ClearCachedResult(): void;
get_mUserData(): number;
set_mUserData(mUserData: number): void;
mUserData: number;
}
class Shape {
GetRefCount(): number;
AddRef(): void;
Release(): void;
GetType(): EShapeType;
GetSubType(): EShapeSubType;
MustBeStatic(): boolean;
GetLocalBounds(): AABox;
GetWorldSpaceBounds(inCenterOfMassTransform: Mat44, inScale: Vec3): AABox;
GetCenterOfMass(): Vec3;
GetUserData(): number;
SetUserData(inUserData: number): void;
GetSubShapeIDBitsRecursive(): number;
GetInnerRadius(): number;
GetMassProperties(): MassProperties;
GetLeafShape(inSubShapeID: SubShapeID, outRemainder: SubShapeID): Shape;
GetMaterial(inSubShapeID: SubShapeID): PhysicsMaterial;
GetSurfaceNormal(
inSubShapeID: SubShapeID,
inLocalSurfacePosition: Vec3
): Vec3;
GetSubShapeUserData(inSubShapeID: SubShapeID): number;
GetSubShapeTransformedShape(
inSubShapeID: SubShapeID,
inPositionCOM: Vec3,
inRotation: Quat,
inScale: Vec3,
outRemainder: SubShapeID
): TransformedShape;
GetVolume(): number;
IsValidScale(inScale: Vec3): boolean;
MakeScaleValid(inScale: Vec3): Vec3;
ScaleShape(inScale: Vec3): ShapeResult;
}
class ShapeGetTriangles {
constructor(
inShape: Shape,
inBox: AABox,
inPositionCOM: Vec3,
inRotation: Quat,
inScale: Vec3
);
GetNumTriangles(): number;
GetVerticesSize(): number;
GetVerticesData(): any;
GetMaterial(inTriangle: number): PhysicsMaterial;
}
class ConvexShapeSettings extends ShapeSettings {
get_mMaterial(): PhysicsMaterial;
set_mMaterial(mMaterial: PhysicsMaterial): void;
mMaterial: PhysicsMaterial;
get_mDensity(): number;
set_mDensity(mDensity: number): void;
mDensity: number;
}
class ConvexShape extends Shape {
SetMaterial(inMaterial: PhysicsMaterial): void;
GetDensity(): number;
SetDensity(inDensity: number): void;
}
class SphereShapeSettings extends ConvexShapeSettings {
constructor(inRadius: number, inMaterial?: PhysicsMaterial);
get_mRadius(): number;
set_mRadius(mRadius: number): void;
mRadius: number;
}
class SphereShape extends ConvexShape {
constructor(inRadius: number, inMaterial?: PhysicsMaterial);
GetRadius(): number;
}
class BoxShapeSettings extends ConvexShapeSettings {
constructor(
inHalfExtent: Vec3,
inConvexRadius?: number,
inMaterial?: PhysicsMaterial
);
get_mHalfExtent(): Vec3;
set_mHalfExtent(mHalfExtent: Vec3): void;
mHalfExtent: Vec3;
get_mConvexRadius(): number;
set_mConvexRadius(mConvexRadius: number): void;
mConvexRadius: number;
}
class BoxShape extends ConvexShape {
constructor(
inHalfExtent: Vec3,
inConvexRadius?: number,
inMaterial?: PhysicsMaterial
);
GetHalfExtent(): Vec3;
}
class CylinderShapeSettings extends ConvexShapeSettings {
constructor(
inHalfHeight: number,
inRadius: number,
inConvexRadius?: number,
inMaterial?: PhysicsMaterial
);
get_mHalfHeight(): number;
set_mHalfHeight(mHalfHeight: number): void;
mHalfHeight: number;
get_mRadius(): number;
set_mRadius(mRadius: number): void;
mRadius: number;
get_mConvexRadius(): number;
set_mConvexRadius(mConvexRadius: number): void;
mConvexRadius: number;
}
class CylinderShape extends ConvexShape {
constructor(
inHalfHeight: number,
inRadius: number,
inConvexRadius: number,
inMaterial?: PhysicsMaterial
);
GetRadius(): number;
GetHalfHeight(): number;
}
class TaperedCylinderShapeSettings extends ConvexShapeSettings {
constructor(
inHalfHeightOfTaperedCylinder: number,
inTopRadius: number,
inBottomRadius: number,
inConvexRadius?: number,
inMaterial?: PhysicsMaterial
);
get_mHalfHeight(): number;
set_mHalfHeight(mHalfHeight: number): void;
mHalfHeight: number;
get_mTopRadius(): number;
set_mTopRadius(mTopRadius: number): void;
mTopRadius: number;
get_mBottomRadius(): number;
set_mBottomRadius(mBottomRadius: number): void;
mBottomRadius: number;
get_mConvexRadius(): number;
set_mConvexRadius(mConvexRadius: number): void;
mConvexRadius: number;
}
class TaperedCylinderShape extends ConvexShape {
GetHalfHeight(): number;
GetTopRadius(): number;
GetBottomRadius(): number;
GetConvexRadius(): number;
}
class CapsuleShapeSettings extends ConvexShapeSettings {
constructor(
inHalfHeight: number,
inRadius: number,
inMaterial?: PhysicsMaterial
);
get_mRadius(): number;
set_mRadius(mRadius: number): void;
mRadius: number;
get_mHalfHeightOfCylinder(): number;
set_mHalfHeightOfCylinder(mHalfHeightOfCylinder: number): void;
mHalfHeightOfCylinder: number;
}
class CapsuleShape extends ConvexShape {
constructor(
inHalfHeight: number,
inRadius: number,
inMaterial?: PhysicsMaterial
);
GetRadius(): number;
GetHalfHeightOfCylinder(): number;
}
class TaperedCapsuleShapeSettings extends ConvexShapeSettings {
constructor(
inHalfHeightOfTaperedCylinder: number,
inTopRadius: number,
inBottomRadius: number,
inMaterial?: PhysicsMaterial
);
get_mHalfHeightOfTaperedCylinder(): number;
set_mHalfHeightOfTaperedCylinder(
mHalfHeightOfTaperedCylinder: number
): void;
mHalfHeightOfTaperedCylinder: number;
get_mTopRadius(): number;
set_mTopRadius(mTopRadius: number): void;
mTopRadius: number;
get_mBottomRadius(): number;
set_mBottomRadius(mBottomRadius: number): void;
mBottomRadius: number;
}
class TaperedCapsuleShape extends ConvexShape {
GetHalfHeight(): number;
GetTopRadius(): number;
GetBottomRadius(): number;
}
class ConvexHullShapeSettings extends ConvexShapeSettings {
constructor();
get_mPoints(): ArrayVec3;
set_mPoints(mPoints: ArrayVec3): void;
mPoints: ArrayVec3;
get_mMaxConvexRadius(): number;
set_mMaxConvexRadius(mMaxConvexRadius: number): void;
mMaxConvexRadius: number;
get_mMaxErrorConvexRadius(): number;
set_mMaxErrorConvexRadius(mMaxErrorConvexRadius: number): void;
mMaxErrorConvexRadius: number;
get_mHullTolerance(): number;
set_mHullTolerance(mHullTolerance: number): void;
mHullTolerance: number;
}
class ConvexHullShape extends ConvexShape {}
class CompoundShapeSettings extends ShapeSettings {
AddShape(
inPosition: Vec3,
inRotation: Quat,
inShape: ShapeSettings,
inUserData: number
): void;
AddShapeShapeSettings(
inPosition: Vec3,
inRotation: Quat,
inShape: ShapeSettings,
inUserData: number
): void;
AddShapeShape(
inPosition: Vec3,
inRotation: Quat,
inShape: Shape,
inUserData: number
): void;
}
class CompoundShapeSubShape {
GetPositionCOM(): Vec3;
GetRotation(): Quat;
get_mShape(): Shape;
set_mShape(mShape: Shape): void;
mShape: Shape;
get_mUserData(): number;
set_mUserData(mUserData: number): void;
mUserData: number;
}
class CompoundShape extends Shape {
GetNumSubShapes(): number;
GetSubShape(inIdx: number): CompoundShapeSubShape;
}
class StaticCompoundShapeSettings extends CompoundShapeSettings {
constructor();
}
class StaticCompoundShape extends CompoundShape {}
class MutableCompoundShapeSettings extends CompoundShapeSettings {
constructor();
}
class MutableCompoundShape extends CompoundShape {
AddShape(
inPosition: Vec3,
inRotation: Quat,
inShape: Shape,
inUserData: number,
inIndex?: number
): number;
RemoveShape(inIndex: number): void;
ModifyShape(inIndex: number, inPosition: Vec3, inRotation: Quat): void;
ModifyShape(
inIndex: number,
inPosition: Vec3,
inRotation: Quat,
inShape: Shape
): void;
ModifyShapes(
inStartIndex: number,
inNumber: number,
inPositions: Vec3MemRef,
inRotations: QuatMemRef
): void;
AdjustCenterOfMass(): void;
}
class DecoratedShapeSettings extends ShapeSettings {}
class DecoratedShape extends Shape {
GetInnerShape(): Shape;
}
class ScaledShapeSettings extends DecoratedShapeSettings {
constructor(inShape: ShapeSettings, inScale: Vec3);
get_mScale(): Vec3;
set_mScale(mScale: Vec3): void;
mScale: Vec3;
}
class ScaledShape extends DecoratedShape {
constructor(inShape: Shape, inScale: Vec3);
GetScale(): Vec3;
}
class OffsetCenterOfMassShapeSettings extends DecoratedShapeSettings {
constructor(inOffset: Vec3, inShape: ShapeSettings);
get_mOffset(): Vec3;
set_mOffset(mOffset: Vec3): void;
mOffset: Vec3;
}
class OffsetCenterOfMassShape extends DecoratedShape {
constructor(inShape: Shape, inOffset: Vec3);
}
class RotatedTranslatedShapeSettings extends DecoratedShapeSettings {
constructor(inPosition: Vec3, inRotation: Quat, inShape: ShapeSettings);
get_mPosition(): Vec3;
set_mPosition(mPosition: Vec3): void;
mPosition: Vec3;
get_mRotation(): Quat;
set_mRotation(mRotation: Quat): void;
mRotation: Quat;
}
class RotatedTranslatedShape extends DecoratedShape {
GetRotation(): Quat;
GetPosition(): Vec3;
}
class MeshShapeSettings extends ShapeSettings {
constructor();
constructor(
inTriangleList: TriangleList,
inMaterialList?: PhysicsMaterialList
);
constructor(
inVertices: VertexList,
inTriangles: IndexedTriangleList,
inMaterialList: PhysicsMaterialList
);
Sanitize(): void;
get_mTriangleVertices(): VertexList;
set_mTriangleVertices(mTriangleVertices: VertexList): void;
mTriangleVertices: VertexList;
get_mIndexedTriangles(): IndexedTriangleList;
set_mIndexedTriangles(mIndexedTriangles: IndexedTriangleList): void;
mIndexedTriangles: IndexedTriangleList;
get_mMaterials(): PhysicsMaterialList;
set_mMaterials(mMaterials: PhysicsMaterialList): void;
mMaterials: PhysicsMaterialList;
get_mMaxTrianglesPerLeaf(): number;
set_mMaxTrianglesPerLeaf(mMaxTrianglesPerLeaf: number): void;
mMaxTrianglesPerLeaf: number;
get_mActiveEdgeCosThresholdAngle(): number;
set_mActiveEdgeCosThresholdAngle(
mActiveEdgeCosThresholdAngle: number
): void;
mActiveEdgeCosThresholdAngle: number;
get_mPerTriangleUserData(): boolean;
set_mPerTriangleUserData(mPerTriangleUserData: boolean): void;
mPerTriangleUserData: boolean;
get_mBuildQuality(): MeshShapeSettings_EBuildQuality;
set_mBuildQuality(mBuildQuality: MeshShapeSettings_EBuildQuality): void;
mBuildQuality: MeshShapeSettings_EBuildQuality;
}
class MeshShape extends Shape {
GetTriangleUserData(inSubShapeID: SubShapeID): number;
}
class HeightFieldShapeConstantValues {
get_cNoCollisionValue(): number;
set_cNoCollisionValue(cNoCollisionValue: number): void;
readonly cNoCollisionValue: number;
}
class HeightFieldShapeSettings extends ShapeSettings {
constructor();
get_mOffset(): Vec3;
set_mOffset(mOffset: Vec3): void;
mOffset: Vec3;
get_mScale(): Vec3;
set_mScale(mScale: Vec3): void;
mScale: Vec3;
get_mSampleCount(): number;
set_mSampleCount(mSampleCount: number): void;
mSampleCount: number;
get_mMinHeightValue(): number;
set_mMinHeightValue(mMinHeightValue: number): void;
mMinHeightValue: number;
get_mMaxHeightValue(): number;
set_mMaxHeightValue(mMaxHeightValue: number): void;
mMaxHeightValue: number;
get_mMaterialsCapacity(): number;
set_mMaterialsCapacity(mMaterialsCapacity: number): void;
mMaterialsCapacity: number;
get_mBlockSize(): number;
set_mBlockSize(mBlockSize: number): void;
mBlockSize: number;
get_mBitsPerSample(): number;
set_mBitsPerSample(mBitsPerSample: number): void;
mBitsPerSample: number;
get_mHeightSamples(): ArrayFloat;
set_mHeightSamples(mHeightSamples: ArrayFloat): void;
mHeightSamples: ArrayFloat;
get_mMaterialIndices(): ArrayUint8;
set_mMaterialIndices(mMaterialIndices: ArrayUint8): void;
mMaterialIndices: ArrayUint8;
get_mMaterials(): PhysicsMaterialList;
set_mMaterials(mMaterials: PhysicsMaterialList): void;
mMaterials: PhysicsMaterialList;
get_mActiveEdgeCosThresholdAngle(): number;
set_mActiveEdgeCosThresholdAngle(
mActiveEdgeCosThresholdAngle: number
): void;
mActiveEdgeCosThresholdAngle: number;
}
class HeightFieldShape extends Shape {
GetSampleCount(): number;
GetBlockSize(): number;
GetPosition(inX: number, inY: number): Vec3;
IsNoCollision(inX: number, inY: number): boolean;
GetMinHeightValue(): number;
GetMaxHeightValue(): number;
GetHeights(
inX: number,
inY: number,
inSizeX: number,
inSizeY: number,
outHeights: FloatMemRef,
inHeightsStride: number
): void;
SetHeights(
inX: number,
inY: number,
inSizeX: number,
inSizeY: number,
inHeights: FloatMemRef,
inHeightsStride: number,
inAllocator: TempAllocator,
inActiveEdgeCosThresholdAngle?: number
): void;
GetMaterials(
inX: number,
inY: number,
inSizeX: number,
inSizeY: number,
outMaterials: Uint8MemRef,
inMaterialsStride: number
): void;
SetMaterials(
inX: number,
inY: number,
inSizeX: number,
inSizeY: number,
inMaterials: Uint8MemRef,
inMaterialsStride: number,
inMaterialList: PhysicsMaterialList,
inAllocator: TempAllocator
): boolean;
}
class PlaneShapeSettings extends ShapeSettings {
constructor(
inPlane: Plane,
inMaterial?: PhysicsMaterial,
inHalfExtent?: number
);
get_mPlane(): Plane;
set_mPlane(mPlane: Plane): void;
mPlane: Plane;
get_mMaterial(): PhysicsMaterial;
set_mMaterial(mMaterial: PhysicsMaterial): void;
mMaterial: PhysicsMaterial;
get_mHalfExtent(): number;
set_mHalfExtent(mHalfExtent: number): void;
mHalfExtent: number;
}
class PlaneShape extends Shape {
constructor(
inPlane: Plane,
inMaterial?: PhysicsMaterial,
inHalfExtent?: number
);
SetMaterial(inMaterial: PhysicsMaterial): void;
GetPlane(): Plane;
GetHalfExtent(): number;
}
class EmptyShapeSettings extends ShapeSettings {
constructor();
get_mCenterOfMass(): Vec3;
set_mCenterOfMass(mCenterOfMass: Vec3): void;
mCenterOfMass: Vec3;
}
class EmptyShape extends Shape {
constructor(inCenterOfMass?: Vec3);
}
class ConstraintSettings {
GetRefCount(): number;
AddRef(): void;
Release(): void;
get_mEnabled(): boolean;
set_mEnabled(mEnabled: boolean): void;
mEnabled: boolean;
get_mNumVelocityStepsOverride(): number;
set_mNumVelocityStepsOverride(mNumVelocityStepsOverride: number): void;
mNumVelocityStepsOverride: number;
get_mNumPositionStepsOverride(): number;
set_mNumPositionStepsOverride(mNumPositionStepsOverride: number): void;
mNumPositionStepsOverride: number;
}
class Constraint {
GetRefCount(): number;
AddRef(): void;
Release(): void;
GetType(): EConstraintType;
GetSubType(): EConstraintSubType;
GetConstraintPriority(): number;
SetConstraintPriority(inPriority: number): void;
SetNumVelocityStepsOverride(inN: number): void;
GetNumVelocityStepsOverride(): number;
SetNumPositionStepsOverride(inN: number): void;
GetNumPositionStepsOverride(): number;
SetEnabled(inEnabled: boolean): void;
GetEnabled(): boolean;
IsActive(): boolean;
GetUserData(): number;
SetUserData(inUserData: number): void;
ResetWarmStart(): void;
SaveState(inStream: StateRecorder): void;
RestoreState(inStream: StateRecorder): void;
}
class TwoBodyConstraintSettings extends ConstraintSettings {
Create(inBody1: Body, inBody2: Body): Constraint;
}
class TwoBodyConstraint extends Constraint {
GetBody1(): Body;
GetBody2(): Body;
GetConstraintToBody1Matrix(): Mat44;
GetConstraintToBody2Matrix(): Mat44;
}
class FixedConstraintSettings extends TwoBodyConstraintSettings {
constructor();
get_mSpace(): EConstraintSpace;
set_mSpace(mSpace: EConstraintSpace): void;
mSpace: EConstraintSpace;
get_mAutoDetectPoint(): boolean;
set_mAutoDetectPoint(mAutoDetectPoint: boolean): void;
mAutoDetectPoint: boolean;
get_mPoint1(): RVec3;
set_mPoint1(mPoint1: RVec3): void;
mPoint1: RVec3;
get_mAxisX1(): Vec3;
set_mAxisX1(mAxisX1: Vec3): void;
mAxisX1: Vec3;
get_mAxisY1(): Vec3;
set_mAxisY1(mAxisY1: Vec3): void;
mAxisY1: Vec3;
get_mPoint2(): RVec3;
set_mPoint2(mPoint2: RVec3): void;
mPoint2: RVec3;
get_mAxisX2(): Vec3;
set_mAxisX2(mAxisX2: Vec3): void;
mAxisX2: Vec3;
get_mAxisY2(): Vec3;
set_mAxisY2(mAxisY2: Vec3): void;
mAxisY2: Vec3;
}
class SpringSettings {
constructor();
HasStiffness(): boolean;
get_mMode(): ESpringMode;
set_mMode(mMode: ESpringMode): void;
mMode: ESpringMode;
get_mFrequency(): number;
set_mFrequency(mFrequency: number): void;
mFrequency: number;
get_mStiffness(): number;
set_mStiffness(mStiffness: number): void;
mStiffness: number;
get_mDamping(): number;
set_mDamping(mDamping: number): void;
mDamping: number;
}
class MotorSettings {
constructor();
get_mSpringSettings(): SpringSettings;
set_mSpringSettings(mSpringSettings: SpringSettings): void;
mSpringSettings: SpringSettings;
get_mMinForceLimit(): number;
set_mMinForceLimit(mMinForceLimit: number): void;
mMinForceLimit: number;
get_mMaxForceLimit(): number;
set_mMaxForceLimit(mMaxForceLimit: number): void;
mMaxForceLimit: number;
get_mMinTorqueLimit(): number;
set_mMinTorqueLimit(mMinTorqueLimit: number): void;
mMinTorqueLimit: number;
get_mMaxTorqueLimit(): number;
set_mMaxTorqueLimit(mMaxTorqueLimit: number): void;
mMaxTorqueLimit: number;
}
class DistanceConstraintSettings extends TwoBodyConstraintSettings {
constructor();
get_mSpace(): EConstraintSpace;
set_mSpace(mSpace: EConstraintSpace): void;
mSpace: EConstraintSpace;
get_mPoint1(): RVec3;
set_mPoint1(mPoint1: RVec3): void;
mPoint1: RVec3;
get_mPoint2(): RVec3;
set_mPoint2(mPoint2: RVec3): void;
mPoint2: RVec3;
get_mMinDistance(): number;
set_mMinDistance(mMinDistance: number): void;
mMinDistance: number;
get_mMaxDistance(): number;
set_mMaxDistance(mMaxDistance: number): void;
mMaxDistance: number;
get_mLimitsSpringSettings(): SpringSettings;
set_mLimitsSpringSettings(mLimitsSpringSettings: SpringSettings): void;
mLimitsSpringSettings: SpringSettings;
}
class DistanceConstraint extends TwoBodyConstraint {
SetDistance(inMinDistance: number, inMaxDistance: number): void;
GetMinDistance(): number;
GetMaxDistance(): number;
GetLimitsSpringSettings(): SpringSettings;
SetLimitsSpringSettings(inSettings: SpringSettings): void;
GetTotalLambdaPosition(): number;
}
class PointConstraintSettings extends TwoBodyConstraintSettings {
constructor();
get_mSpace(): EConstraintSpace;
set_mSpace(mSpace: EConstraintSpace): void;
mSpace: EConstraintSpace;
get_mPoint1(): RVec3;
set_mPoint1(mPoint1: RVec3): void;
mPoint1: RVec3;
get_mPoint2(): RVec3;
set_mPoint2(mPoint2: RVec3): void;
mPoint2: RVec3;
}
class PointConstraint extends TwoBodyConstraint {
GetLocalSpacePoint1(): Vec3;
GetLocalSpacePoint2(): Vec3;
GetTotalLambdaPosition(): Vec3;
}
class HingeConstraintSettings extends TwoBodyConstraintSettings {
constructor();
get_mSpace(): EConstraintSpace;
set_mSpace(mSpace: EConstraintSpace): void;
mSpace: EConstraintSpace;
get_mPoint1(): RVec3;
set_mPoint1(mPoint1: RVec3): void;
mPoint1: RVec3;
get_mHingeAxis1(): Vec3;
set_mHingeAxis1(mHingeAxis1: Vec3): void;
mHingeAxis1: Vec3;
get_mNormalAxis1(): Vec3;
set_mNormalAxis1(mNormalAxis1: Vec3): void;
mNormalAxis1: Vec3;
get_mPoint2(): RVec3;
set_mPoint2(mPoint2: RVec3): void;
mPoint2: RVec3;
get_mHingeAxis2(): Vec3;
set_mHingeAxis2(mHingeAxis2: Vec3): void;
mHingeAxis2: Vec3;
get_mNormalAxis2(): Vec3;
set_mNormalAxis2(mNormalAxis2: Vec3): void;
mNormalAxis2: Vec3;
get_mLimitsMin(): number;
set_mLimitsMin(mLimitsMin: number): void;
mLimitsMin: number;
get_mLimitsMax(): number;
set_mLimitsMax(mLimitsMax: number): void;
mLimitsMax: number;
get_mLimitsSpringSettings(): SpringSettings;
set_mLimitsSpringSettings(mLimitsSpringSettings: SpringSettings): void;
mLimitsSpringSettings: SpringSettings;
get_mMaxFrictionTorque(): number;
set_mMaxFrictionTorque(mMaxFrictionTorque: number): void;
mMaxFrictionTorque: number;
get_mMotorSettings(): MotorSettings;
set_mMotorSettings(mMotorSettings: MotorSettings): void;
mMotorSettings: MotorSettings;
}
class HingeConstraint extends TwoBodyConstraint {
GetLocalSpacePoint1(): Vec3;
GetLocalSpacePoint2(): Vec3;
GetLocalSpaceHingeAxis1(): Vec3;
GetLocalSpaceHingeAxis2(): Vec3;
GetLocalSpaceNormalAxis1(): Vec3;
GetLocalSpaceNormalAxis2(): Vec3;
GetCurrentAngle(): number;
SetMaxFrictionTorque(inFrictionTorque: number): void;
GetMaxFrictionTorque(): number;
GetMotorSettings(): MotorSettings;
SetMotorState(inState: EMotorState): void;
GetMotorState(): EMotorState;
SetTargetAngularVelocity(inAngularVelocity: number): void;
GetTargetAngularVelocity(): number;
SetTargetAngle(inAngle: number): void;
GetTargetAngle(): number;
SetTargetOrientationBS(inOrientation: Quat): void;
SetLimits(inLimitsMin: number, inLimitsMax: number): void;
GetLimitsMin(): number;
GetLimitsMax(): number;
HasLimits(): boolean;
GetLimitsSpringSettings(): SpringSettings;
SetLimitsSpringSettings(inLimitsSpringSettings: SpringSettings): void;
GetTotalLambdaPosition(): Vec3;
GetTotalLambdaRotation(): Vector2;
GetTotalLambdaRotationLimits(): number;
GetTotalLambdaMotor(): number;
}
class ConeConstraintSettings extends TwoBodyConstraintSettings {
constructor();
get_mSpace(): EConstraintSpace;
set_mSpace(mSpace: EConstraintSpace): void;
mSpace: EConstraintSpace;
get_mPoint1(): RVec3;
set_mPoint1(mPoint1: RVec3): void;
mPoint1: RVec3;
get_mTwistAxis1(): Vec3;
set_mTwistAxis1(mTwistAxis1: Vec3): void;
mTwistAxis1: Vec3;
get_mPoint2(): RVec3;
set_mPoint2(mPoint2: RVec3): void;
mPoint2: RVec3;
get_mTwistAxis2(): Vec3;
set_mTwistAxis2(mTwistAxis2: Vec3): void;
mTwistAxis2: Vec3;
get_mHalfConeAngle(): number;
set_mHalfConeAngle(mHalfConeAngle: number): void;
mHalfConeAngle: number;
}
class ConeConstraint extends TwoBodyConstraint {
SetHalfConeAngle(inHalfConeAngle: number): void;
GetCosHalfConeAngle(): number;
GetTotalLambdaPosition(): Vec3;
GetTotalLambdaRotation(): number;
}
class SliderConstraintSettings extends TwoBodyConstraintSettings {
constructor();
get_mSpace(): EConstraintSpace;
set_mSpace(mSpace: EConstraintSpace): void;
mSpace: EConstraintSpace;
get_mAutoDetectPoint(): boolean;
set_mAutoDetectPoint(mAutoDetectPoint: boolean): void;
mAutoDetectPoint: boolean;
get_mPoint1(): RVec3;
set_mPoint1(mPoint1: RVec3): void;
mPoint1: RVec3;
get_mSliderAxis1(): Vec3;
set_mSliderAxis1(mSliderAxis1: Vec3): void;
mSliderAxis1: Vec3;
get_mNormalAxis1(): Vec3;
set_mNormalAxis1(mNormalAxis1: Vec3): void;
mNormalAxis1: Vec3;
get_mPoint2(): RVec3;
set_mPoint2(mPoint2: RVec3): void;
mPoint2: RVec3;
get_mSliderAxis2(): Vec3;
set_mSliderAxis2(mSliderAxis2: Vec3): void;
mSliderAxis2: Vec3;
get_mNormalAxis2(): Vec3;
set_mNormalAxis2(mNormalAxis2: Vec3): void;
mNormalAxis2: Vec3;
get_mLimitsMin(): number;
set_mLimitsMin(mLimitsMin: number): void;
mLimitsMin: number;
get_mLimitsMax(): number;
set_mLimitsMax(mLimitsMax: number): void;
mLimitsMax: number;
get_mLimitsSpringSettings(): SpringSettings;
set_mLimitsSpringSettings(mLimitsSpringSettings: SpringSettings): void;
mLimitsSpringSettings: SpringSettings;
get_mMaxFrictionForce(): number;
set_mMaxFrictionForce(mMaxFrictionForce: number): void;
mMaxFrictionForce: number;
get_mMotorSettings(): MotorSettings;
set_mMotorSettings(mMotorSettings: MotorSettings): void;
mMotorSettings: MotorSettings;
}
class SliderConstraint extends TwoBodyConstraint {
GetCurrentPosition(): number;
SetMaxFrictionForce(inFrictionForce: number): void;
GetMaxFrictionForce(): number;
GetMotorSettings(): MotorSettings;
SetMotorState(inState: EMotorState): void;
GetMotorState(): EMotorState;
SetTargetVelocity(inVelocity: number): void;
GetTargetVelocity(): number;
SetTargetPosition(inPosition: number): void;
GetTargetPosition(): number;
SetLimits(inLimitsMin: number, inLimitsMax: number): void;
GetLimitsMin(): number;
GetLimitsMax(): number;
HasLimits(): boolean;
GetLimitsSpringSettings(): SpringSettings;
SetLimitsSpringSettings(inLimitsSpringSettings: SpringSettings): void;
GetTotalLambdaPosition(): Vector2;
GetTotalLambdaPositionLimits(): number;
GetTotalLambdaRotation(): Vec3;
GetTotalLambdaMotor(): number;
}
class SwingTwistConstraintSettings extends TwoBodyConstraintSettings {
constructor();
get_mSpace(): EConstraintSpace;
set_mSpace(mSpace: EConstraintSpace): void;
mSpace: EConstraintSpace;
get_mPosition1(): RVec3;
set_mPosition1(mPosition1: RVec3): void;
mPosition1: RVec3;
get_mTwistAxis1(): Vec3;
set_mTwistAxis1(mTwistAxis1: Vec3): void;
mTwistAxis1: Vec3;
get_mPlaneAxis1(): Vec3;
set_mPlaneAxis1(mPlaneAxis1: Vec3): void;
mPlaneAxis1: Vec3;
get_mPosition2(): RVec3;
set_mPosition2(mPosition2: RVec3): void;
mPosition2: RVec3;
get_mTwistAxis2(): Vec3;
set_mTwistAxis2(mTwistAxis2: Vec3): void;
mTwistAxis2: Vec3;
get_mPlaneAxis2(): Vec3;
set_mPlaneAxis2(mPlaneAxis2: Vec3): void;
mPlaneAxis2: Vec3;
get_mSwingType(): ESwingType;
set_mSwingType(mSwingType: ESwingType): void;
mSwingType: ESwingType;
get_mNormalHalfConeAngle(): number;
set_mNormalHalfConeAngle(mNormalHalfConeAngle: number): void;
mNormalHalfConeAngle: number;
get_mPlaneHalfConeAngle(): number;
set_mPlaneHalfConeAngle(mPlaneHalfConeAngle: number): void;
mPlaneHalfConeAngle: number;
get_mTwistMinAngle(): number;
set_mTwistMinAngle(mTwistMinAngle: number): void;
mTwistMinAngle: number;
get_mTwistMaxAngle(): number;
set_mTwistMaxAngle(mTwistMaxAngle: number): void;
mTwistMaxAngle: number;
get_mMaxFrictionTorque(): number;
set_mMaxFrictionTorque(mMaxFrictionTorque: number): void;
mMaxFrictionTorque: number;
get_mSwingMotorSettings(): MotorSettings;
set_mSwingMotorSettings(mSwingMotorSettings: MotorSettings): void;
mSwingMotorSettings: MotorSettings;
get_mTwistMotorSettings(): MotorSettings;
set_mTwistMotorSettings(mTwistMotorSettings: MotorSettings): void;
mTwistMotorSettings: MotorSettings;
}
class SwingTwistConstraint extends TwoBodyConstraint {
GetLocalSpacePosition1(): Vec3;
GetLocalSpacePosition2(): Vec3;
GetConstraintToBody1(): Quat;
GetConstraintToBody2(): Quat;
GetNormalHalfConeAngle(): number;
SetNormalHalfConeAngle(inAngle: number): void;
GetPlaneHalfConeAngle(): number;
SetPlaneHalfConeAngle(inAngle: number): void;
GetTwistMinAngle(): number;
SetTwistMinAngle(inAngle: number): void;
GetTwistMaxAngle(): number;
SetTwistMaxAngle(inAngle: number): void;
GetSwingMotorSettings(): MotorSettings;
GetTwistMotorSettings(): MotorSettings;
SetMaxFrictionTorque(inFrictionTorque: number): void;
GetMaxFrictionTorque(): number;
SetSwingMotorState(inState: EMotorState): void;
GetSwingMotorState(): EMotorState;
SetTwistMotorState(inState: EMotorState): void;
GetTwistMotorState(): EMotorState;
SetTargetAngularVelocityCS(inAngularVelocity: Vec3): void;
GetTargetAngularVelocityCS(): Vec3;
SetTargetOrientationCS(inOrientation: Quat): void;
GetTargetOrientationCS(): Quat;
SetTargetOrientationBS(inOrientation: Quat): void;
GetRotationInConstraintSpace(): Quat;
GetTotalLambdaPosition(): Vec3;
GetTotalLambdaTwist(): number;
GetTotalLambdaSwingY(): number;
GetTotalLambdaSwingZ(): number;
GetTotalLambdaMotor(): Vec3;
}
class SixDOFConstraintSettings extends TwoBodyConstraintSettings {
constructor();
MakeFreeAxis(inAxis: SixDOFConstraintSettings_EAxis): void;
IsFreeAxis(inAxis: SixDOFConstraintSettings_EAxis): boolean;
MakeFixedAxis(inAxis: SixDOFConstraintSettings_EAxis): void;
IsFixedAxis(inAxis: SixDOFConstraintSettings_EAxis): boolean;
SetLimitedAxis(
inAxis: SixDOFConstraintSettings_EAxis,
inMin: number,
inMax: number
): void;
get_mSpace(): EConstraintSpace;
set_mSpace(mSpace: EConstraintSpace): void;
mSpace: EConstraintSpace;
get_mPosition1(): RVec3;
set_mPosition1(mPosition1: RVec3): void;
mPosition1: RVec3;
get_mAxisX1(): Vec3;
set_mAxisX1(mAxisX1: Vec3): void;
mAxisX1: Vec3;
get_mAxisY1(): Vec3;
set_mAxisY1(mAxisY1: Vec3): void;
mAxisY1: Vec3;
get_mPosition2(): RVec3;
set_mPosition2(mPosition2: RVec3): void;
mPosition2: RVec3;
get_mAxisX2(): Vec3;
set_mAxisX2(mAxisX2: Vec3): void;
mAxisX2: Vec3;
get_mAxisY2(): Vec3;
set_mAxisY2(mAxisY2: Vec3): void;
mAxisY2: Vec3;
get_mMaxFriction(index: number): number;
set_mMaxFriction(index: number, mMaxFriction: number): void;
mMaxFriction: number;
get_mSwingType(): ESwingType;
set_mSwingType(mSwingType: ESwingType): void;
mSwingType: ESwingType;
get_mLimitMin(index: number): number;
set_mLimitMin(index: number, mLimitMin: number): void;
mLimitMin: number;
get_mLimitMax(index: number): number;
set_mLimitMax(index: number, mLimitMax: number): void;
mLimitMax: number;
get_mLimitsSpringSettings(index: number): SpringSettings;
set_mLimitsSpringSettings(
index: number,
mLimitsSpringSettings: SpringSettings
): void;
mLimitsSpringSettings: SpringSettings;
get_mMotorSettings(index: number): MotorSettings;
set_mMotorSettings(index: number, mMotorSettings: MotorSettings): void;
mMotorSettings: MotorSettings;
}
class SixDOFConstraint extends TwoBodyConstraint {
SetTranslationLimits(inLimitMin: Vec3, inLimitMax: Vec3): void;
SetRotationLimits(inLimitMin: Vec3, inLimitMax: Vec3): void;
GetLimitsMin(inAxis: SixDOFConstraintSettings_EAxis): number;
GetLimitsMax(inAxis: SixDOFConstraintSettings_EAxis): number;
GetTranslationLimitsMin(): Vec3;
GetTranslationLimitsMax(): Vec3;
GetRotationLimitsMin(): Vec3;
GetRotationLimitsMax(): Vec3;
IsFixedAxis(inAxis: SixDOFConstraintSettings_EAxis): boolean;
IsFreeAxis(inAxis: SixDOFConstraintSettings_EAxis): boolean;
GetLimitsSpringSettings(
inAxis: SixDOFConstraintSettings_EAxis
): SpringSettings;
SetLimitsSpringSettings(
inAxis: SixDOFConstraintSettings_EAxis,
inLimitsSpringSettings: SpringSettings
): void;
SetMaxFriction(
inAxis: SixDOFConstraintSettings_EAxis,
inFriction: number
): void;
GetMaxFriction(inAxis: SixDOFConstraintSettings_EAxis): number;
GetRotationInConstraintSpace(): Quat;
GetMotorSettings(inAxis: SixDOFConstraintSettings_EAxis): MotorSettings;
SetMotorState(
inAxis: SixDOFConstraintSettings_EAxis,
inState: EMotorState
): void;
GetMotorState(inAxis: SixDOFConstraintSettings_EAxis): EMotorState;
GetTargetVelocityCS(): Vec3;
SetTargetVelocityCS(inVelocity: Vec3): void;
SetTargetAngularVelocityCS(inAngularVelocity: Vec3): void;
GetTargetAngularVelocityCS(): Vec3;
GetTargetPositionCS(): Vec3;
SetTargetPositionCS(inPosition: Vec3): void;
SetTargetOrientationCS(inOrientation: Quat): void;
GetTargetOrientationCS(): Quat;
SetTargetOrientationBS(inOrientation: Quat): void;
GetTotalLambdaPosition(): Vec3;
GetTotalLambdaRotation(): Vec3;
GetTotalLambdaMotorTranslation(): Vec3;
GetTotalLambdaMotorRotation(): Vec3;
}
class PathConstraintSettings extends TwoBodyConstraintSettings {
constructor();
get_mPath(): PathConstraintPath;
set_mPath(mPath: PathConstraintPath): void;
mPath: PathConstraintPath;
get_mPathPosition(): Vec3;
set_mPathPosition(mPathPosition: Vec3): void;
mPathPosition: Vec3;
get_mPathRotation(): Quat;
set_mPathRotation(mPathRotation: Quat): void;
mPathRotation: Quat;
get_mPathFraction(): number;
set_mPathFraction(mPathFraction: number): void;
mPathFraction: number;
get_mMaxFrictionForce(): number;
set_mMaxFrictionForce(mMaxFrictionForce: number): void;
mMaxFrictionForce: number;
get_mRotationConstraintType(): EPathRotationConstraintType;
set_mRotationConstraintType(
mRotationConstraintType: EPathRotationConstraintType
): void;
mRotationConstraintType: EPathRotationConstraintType;
get_mPositionMotorSettings(): MotorSettings;
set_mPositionMotorSettings(mPositionMotorSettings: MotorSettings): void;
mPositionMotorSettings: MotorSettings;
}
class PathConstraintPath {
IsLooping(): boolean;
SetIsLooping(inIsLooping: boolean): void;
GetRefCount(): number;
AddRef(): void;
Release(): void;
}
class PathConstraintPathHermite extends PathConstraintPath {
AddPoint(inPosition: Vec3, inTangent: Vec3, inNormal: Vec3): void;
}
class PathConstraintPathEm extends PathConstraintPath {}
class PathConstraintPathJS extends PathConstraintPathEm {
constructor();
GetPathMaxFraction(): number;
GetClosestPoint(inPosition: number, inFractionHint: number): number;
GetPointOnPath(
inFraction: number,
outPathPosition: number,
outPathTangent: number,
outPathNormal: number,
outPathBinormal: number
): void;
}
class PathConstraint extends TwoBodyConstraint {
SetPath(inPath: PathConstraintPath, inPathFraction: number): void;
GetPath(): PathConstraintPath;
GetPathFraction(): number;
SetMaxFrictionForce(inFrictionForce: number): void;
GetMaxFrictionForce(): number;
GetPositionMotorSettings(): MotorSettings;
SetPositionMotorState(inState: EMotorState): void;
GetPositionMotorState(): EMotorState;
SetTargetVelocity(inVelocity: number): void;
GetTargetVelocity(): number;
SetTargetPathFraction(inFraction: number): void;
GetTargetPathFraction(): number;
}
class PulleyConstraintSettings extends TwoBodyConstraintSettings {
constructor();
get_mSpace(): EConstraintSpace;
set_mSpace(mSpace: EConstraintSpace): void;
mSpace: EConstraintSpace;
get_mBodyPoint1(): RVec3;
set_mBodyPoint1(mBodyPoint1: RVec3): void;
mBodyPoint1: RVec3;
get_mFixedPoint1(): RVec3;
set_mFixedPoint1(mFixedPoint1: RVec3): void;
mFixedPoint1: RVec3;
get_mBodyPoint2(): RVec3;
set_mBodyPoint2(mBodyPoint2: RVec3): void;
mBodyPoint2: RVec3;
get_mFixedPoint2(): RVec3;
set_mFixedPoint2(mFixedPoint2: RVec3): void;
mFixedPoint2: RVec3;
get_mRatio(): number;
set_mRatio(mRatio: number): void;
mRatio: number;
get_mMinLength(): number;
set_mMinLength(mMinLength: number): void;
mMinLength: number;
get_mMaxLength(): number;
set_mMaxLength(mMaxLength: number): void;
mMaxLength: number;
}
class PulleyConstraint extends TwoBodyConstraint {
SetLength(inMinLength: number, inMaxLength: number): void;
GetMinLength(): number;
GetMaxLength(): number;
GetCurrentLength(): number;
}
class GearConstraintSettings extends TwoBodyConstraintSettings {
constructor();
SetRatio(inNumTeethGear1: number, inNumTeethGear2: number): void;
get_mSpace(): EConstraintSpace;
set_mSpace(mSpace: EConstraintSpace): void;
mSpace: EConstraintSpace;
get_mHingeAxis1(): Vec3;
set_mHingeAxis1(mHingeAxis1: Vec3): void;
mHingeAxis1: Vec3;
get_mHingeAxis2(): Vec3;
set_mHingeAxis2(mHingeAxis2: Vec3): void;
mHingeAxis2: Vec3;
get_mRatio(): number;
set_mRatio(mRatio: number): void;
mRatio: number;
}
class GearConstraint extends TwoBodyConstraint {
SetConstraints(inGear1: Constraint, inGear2: Constraint): void;
GetTotalLambda(): number;
}
class RackAndPinionConstraintSettings extends TwoBodyConstraintSettings {
constructor();
SetRatio(
inNumTeethRack: number,
inRackLength: number,
inNumTeethPinion: number
): void;
get_mSpace(): EConstraintSpace;
set_mSpace(mSpace: EConstraintSpace): void;
mSpace: EConstraintSpace;
get_mHingeAxis(): Vec3;
set_mHingeAxis(mHingeAxis: Vec3): void;
mHingeAxis: Vec3;
get_mSliderAxis(): Vec3;
set_mSliderAxis(mSliderAxis: Vec3): void;
mSliderAxis: Vec3;
get_mRatio(): number;
set_mRatio(mRatio: number): void;
mRatio: number;
}
class RackAndPinionConstraint extends TwoBodyConstraint {
SetConstraints(inPinion: Constraint, inRack: Constraint): void;
GetTotalLambda(): number;
}
class BodyID {
constructor();
constructor(inIndexAndSequenceNumber: number);
GetIndex(): number;
GetIndexAndSequenceNumber(): number;
}
class SubShapeID {
constructor();
GetValue(): number;
SetValue(inValue: number): void;
}
class MotionProperties {
GetMotionQuality(): EMotionQuality;
GetAllowedDOFs(): EAllowedDOFs;
GetAllowSleeping(): boolean;
GetLinearVelocity(): Vec3;
SetLinearVelocity(inVelocity: Vec3): void;
SetLinearVelocityClamped(inVelocity: Vec3): void;
GetAngularVelocity(): Vec3;
SetAngularVelocity(inVelocity: Vec3): void;
SetAngularVelocityClamped(inVelocity: Vec3): void;
MoveKinematic(
inPosition: Vec3,
inRotation: Quat,
inDeltaTime: number
): void;
GetMaxLinearVelocity(): number;
SetMaxLinearVelocity(inVelocity: number): void;
GetMaxAngularVelocity(): number;
SetMaxAngularVelocity(inVelocity: number): void;
ClampLinearVelocity(): void;
ClampAngularVelocity(): void;
GetLinearDamping(): number;
SetLinearDamping(inDamping: number): void;
GetAngularDamping(): number;
SetAngularDamping(inDamping: number): void;
GetGravityFactor(): number;
SetGravityFactor(inFactor: number): void;
SetMassProperties(
inAllowedDOFs: EAllowedDOFs,
inMassProperties: MassProperties
): void;
GetInverseMass(): number;
GetInverseMassUnchecked(): number;
SetInverseMass(inInvM: number): void;
GetInverseInertiaDiagonal(): Vec3;
GetInertiaRotation(): Quat;
SetInverseInertia(inInvI: Vec3, inRotation: Quat): void;
ScaleToMass(inMass: number): void;
GetLocalSpaceInverseInertia(): Mat44;
GetInverseInertiaForRotation(inRotation: Mat44): Mat44;
MultiplyWorldSpaceInverseInertiaByVector(inRotation: Quat, inV: Vec3): Vec3;
GetPointVelocityCOM(inPointRelativeToCOM: Vec3): Vec3;
GetAccumulatedForce(): Vec3;
GetAccumulatedTorque(): Vec3;
ResetForce(): void;
ResetTorque(): void;
ResetMotion(): void;
LockTranslation(inV: Vec3): Vec3;
LockAngular(inV: Vec3): Vec3;
SetNumVelocityStepsOverride(inN: number): void;
GetNumVelocityStepsOverride(): number;
SetNumPositionStepsOverride(inN: number): void;
GetNumPositionStepsOverride(): number;
}
class GroupFilter {
GetRefCount(): number;
AddRef(): void;
Release(): void;
}
class GroupFilterJS extends GroupFilter {
constructor();
CanCollide(inGroup1: number, inGroup2: number): boolean;
}
class GroupFilterTable extends GroupFilter {
constructor(inNumGroups: number);
DisableCollision(inSubGroup1: number, inSubGroup2: number): void;
EnableCollision(inSubGroup1: number, inSubGroup2: number): void;
IsCollisionEnabled(inSubGroup1: number, inSubGroup2: number): boolean;
}
class CollisionGroup {
constructor();
constructor(inFilter: GroupFilter, inGroupID: number, inSubGroupID: number);
SetGroupFilter(inFilter: GroupFilter): void;
GetGroupFilter(): GroupFilter;
SetGroupID(inGroupID: number): void;
GetGroupID(): number;
SetSubGroupID(inSubGroupID: number): void;
GetSubGroupID(): number;
}
class Body {
GetID(): BodyID;
IsActive(): boolean;
IsRigidBody(): boolean;
IsSoftBody(): boolean;
IsStatic(): boolean;
IsKinematic(): boolean;
IsDynamic(): boolean;
CanBeKinematicOrDynamic(): boolean;
GetBodyType(): EBodyType;
GetMotionType(): EMotionType;
SetIsSensor(inIsSensor: boolean): void;
IsSensor(): boolean;
SetCollideKinematicVsNonDynamic(inCollide: boolean): void;
GetCollideKinematicVsNonDynamic(): boolean;
SetUseManifoldReduction(inUseReduction: boolean): void;
GetUseManifoldReduction(): boolean;
SetApplyGyroscopicForce(inApply: boolean): void;
GetApplyGyroscopicForce(): boolean;
SetEnhancedInternalEdgeRemoval(inApply: boolean): void;
GetEnhancedInternalEdgeRemoval(): boolean;
GetObjectLayer(): number;
GetCollisionGroup(): CollisionGroup;
GetAllowSleeping(): boolean;
SetAllowSleeping(inAllow: boolean): void;
ResetSleepTimer(): void;
GetFriction(): number;
SetFriction(inFriction: number): void;
GetRestitution(): number;
SetRestitution(inRestitution: number): void;
GetLinearVelocity(): Vec3;
SetLinearVelocity(inVelocity: Vec3): void;
SetLinearVelocityClamped(inVelocity: Vec3): void;
GetAngularVelocity(): Vec3;
SetAngularVelocity(inVelocity: Vec3): void;
SetAngularVelocityClamped(inVelocity: Vec3): void;
AddForce(inForce: Vec3): void;
AddForce(inForce: Vec3, inPosition: RVec3): void;
AddTorque(inTorque: Vec3): void;
GetAccumulatedForce(): Vec3;
GetAccumulatedTorque(): Vec3;
ResetForce(): void;
ResetTorque(): void;
ResetMotion(): void;
AddImpulse(inImpulse: Vec3): void;
AddImpulse(inImpulse: Vec3, inPosition: RVec3): void;
AddAngularImpulse(inAngularImpulse: Vec3): void;
MoveKinematic(
inPosition: RVec3,
inRotation: Quat,
inDeltaTime: number
): void;
ApplyBuoyancyImpulse(
inSurfacePosition: RVec3,
inSurfaceNormal: Vec3,
inBuoyancy: number,
inLinearDrag: number,
inAngularDrag: number,
inFluidVelocity: Vec3,
inGravity: Vec3,
inDeltaTime: number
): boolean;
IsInBroadPhase(): boolean;
GetInverseInertia(): Mat44;
GetShape(): Shape;
GetPosition(): RVec3;
GetRotation(): Quat;
GetWorldTransform(): RMat44;
GetCenterOfMassPosition(): RVec3;
GetCenterOfMassTransform(): RMat44;
GetInverseCenterOfMassTransform(): RMat44;
GetWorldSpaceBounds(): AABox;
GetTransformedShape(): TransformedShape;
GetBodyCreationSettings(): BodyCreationSettings;
GetSoftBodyCreationSettings(): SoftBodyCreationSettings;
GetMotionProperties(): MotionProperties;
GetWorldSpaceSurfaceNormal(
inSubShapeID: SubShapeID,
inPosition: RVec3
): Vec3;
GetUserData(): number;
SetUserData(inUserData: number): void;
SaveState(inStream: StateRecorder): void;
RestoreState(inStream: StateRecorder): void;
}
class BodyInterface_AddState {}
class BodyInterface {
CreateBody(inSettings: BodyCreationSettings): Body;
CreateSoftBody(inSettings: SoftBodyCreationSettings): Body;
CreateBodyWithID(inBodyID: BodyID, inSettings: BodyCreationSettings): Body;
CreateSoftBodyWithID(
inBodyID: BodyID,
inSettings: SoftBodyCreationSettings
): Body;
CreateBodyWithoutID(inSettings: BodyCreationSettings): Body;
CreateSoftBodyWithoutID(inSettings: SoftBodyCreationSettings): Body;
DestroyBodyWithoutID(inBody: Body): void;
AssignBodyID(ioBody: Body): boolean;
AssignBodyID(ioBody: Body, inBodyID: BodyID): boolean;
UnassignBodyID(inBodyID: BodyID): Body;
UnassignBodyIDs(
inBodyIDs: BodyIDMemRef,
inNumber: number,
outBodies: BodyPtrMemRef
): void;
DestroyBody(inBodyID: BodyID): void;
DestroyBodies(inBodyIDs: BodyIDMemRef, inNumber: number): void;
AddBody(inBodyID: BodyID, inActivationMode: EActivation): void;
RemoveBody(inBodyID: BodyID): void;
IsAdded(inBodyID: BodyID): boolean;
CreateAndAddBody(
inSettings: BodyCreationSettings,
inActivationMode: EActivation
): BodyID;
CreateAndAddSoftBody(
inSettings: SoftBodyCreationSettings,
inActivationMode: EActivation
): BodyID;
AddBodiesPrepare(
ioBodies: BodyIDMemRef,
inNumber: number
): BodyInterface_AddState;
AddBodiesFinalize(
ioBodies: BodyIDMemRef,
inNumber: number,
inAddState: BodyInterface_AddState,
inActivationMode: EActivation
): void;
AddBodiesAbort(
ioBodies: BodyIDMemRef,
inNumber: number,
inAddState: BodyInterface_AddState
): void;
RemoveBodies(ioBodies: BodyIDMemRef, inNumber: number): void;
CreateConstraint(
inSettings: TwoBodyConstraintSettings,
inBodyID1: BodyID,
inBodyID2: BodyID
): TwoBodyConstraint;
ActivateConstraint(inConstraint: TwoBodyConstraint): void;
GetShape(inBodyID: BodyID): Shape;
SetShape(
inBodyID: BodyID,
inShape: Shape,
inUpdateMassProperties: boolean,
inActivationMode: EActivation
): void;
NotifyShapeChanged(
inBodyID: BodyID,
inPreviousCenterOfMass: Vec3,
inUpdateMassProperties: boolean,
inActivationMode: EActivation
): void;
SetObjectLayer(inBodyID: BodyID, inLayer: number): void;
GetObjectLayer(inBodyID: BodyID): number;
SetPositionAndRotation(
inBodyID: BodyID,
inPosition: RVec3,
inRotation: Quat,
inActivationMode: EActivation
): void;
SetPositionAndRotationWhenChanged(
inBodyID: BodyID,
inPosition: RVec3,
inRotation: Quat,
inActivationMode: EActivation
): void;
GetPositionAndRotation(
inBodyID: BodyID,
outPosition: RVec3,
outRotation: Quat
): void;
SetPosition(
inBodyID: BodyID,
inPosition: RVec3,
inActivationMode: EActivation
): void;
GetPosition(inBodyID: BodyID): RVec3;
SetRotation(
inBodyID: BodyID,
inRotation: Quat,
inActivationMode: EActivation
): void;
GetRotation(inBodyID: BodyID): Quat;
GetWorldTransform(inBodyID: BodyID): RMat44;
GetCenterOfMassTransform(inBodyID: BodyID): RMat44;
SetLinearAndAngularVelocity(
inBodyID: BodyID,
inLinearVelocity: Vec3,
inAngularVelocity: Vec3
): void;
GetLinearAndAngularVelocity(
inBodyID: BodyID,
outLinearVelocity: Vec3,
outAngularVelocity: Vec3
): void;
SetLinearVelocity(inBodyID: BodyID, inLinearVelocity: Vec3): void;
GetLinearVelocity(inBodyID: BodyID): Vec3;
AddLinearVelocity(inBodyID: BodyID, inLinearVelocity: Vec3): void;
AddLinearAndAngularVelocity(
inBodyID: BodyID,
inLinearVelocity: Vec3,
inAngularVelocity: Vec3
): void;
SetAngularVelocity(inBodyID: BodyID, inAngularVelocity: Vec3): void;
GetAngularVelocity(inBodyID: BodyID): Vec3;
GetPointVelocity(inBodyID: BodyID, inPoint: RVec3): Vec3;
SetPositionRotationAndVelocity(
inBodyID: BodyID,
inPosition: RVec3,
inRotation: Quat,
inLinearVelocity: Vec3,
inAngularVelocity: Vec3
): void;
MoveKinematic(
inBodyID: BodyID,
inPosition: RVec3,
inRotation: Quat,
inDeltaTime: number
): void;
ActivateBody(inBodyID: BodyID): void;
ActivateBodies(inBodyIDs: BodyIDMemRef, inNumber: number): void;
ActivateBodiesInAABox(
inBox: AABox,
inBroadPhaseLayerFilter: BroadPhaseLayerFilter,
inObjectLayerFilter: ObjectLayerFilter
): void;
DeactivateBody(inBodyID: BodyID): void;
DeactivateBodies(inBodyIDs: BodyIDMemRef, inNumber: number): void;
IsActive(inBodyID: BodyID): boolean;
ResetSleepTimer(inBodyID: BodyID): void;
GetBodyType(inBodyID: BodyID): EBodyType;
SetMotionType(
inBodyID: BodyID,
inMotionType: EMotionType,
inActivationMode: EActivation
): void;
GetMotionType(inBodyID: BodyID): EMotionType;
SetMotionQuality(inBodyID: BodyID, inMotionQuality: EMotionQuality): void;
GetMotionQuality(inBodyID: BodyID): EMotionQuality;
GetInverseInertia(inBodyID: BodyID): Mat44;
SetRestitution(inBodyID: BodyID, inRestitution: number): void;
GetRestitution(inBodyID: BodyID): number;
SetFriction(inBodyID: BodyID, inFriction: number): void;
GetFriction(inBodyID: BodyID): number;
SetGravityFactor(inBodyID: BodyID, inFactor: number): void;
GetGravityFactor(inBodyID: BodyID): number;
SetMaxLinearVelocity(inBodyID: BodyID, inLinearVelocity: number): void;
GetMaxLinearVelocity(inBodyID: BodyID): number;
SetMaxAngularVelocity(inBodyID: BodyID, inAngularVelocity: number): void;
GetMaxAngularVelocity(inBodyID: BodyID): number;
SetUseManifoldReduction(inBodyID: BodyID, inUseReduction: boolean): void;
GetUseManifoldReduction(inBodyID: BodyID): boolean;
SetIsSensor(inBodyID: BodyID, inIsSensor: boolean): void;
IsSensor(inBodyID: BodyID): boolean;
SetCollisionGroup(inBodyID: BodyID, inCollisionGroup: CollisionGroup): void;
GetCollisionGroup(inBodyID: BodyID): CollisionGroup;
AddForce(
inBodyID: BodyID,
inForce: Vec3,
inActivationMode: EActivation
): void;
AddForce(
inBodyID: BodyID,
inForce: Vec3,
inPoint: RVec3,
inActivationMode: EActivation
): void;
AddTorque(
inBodyID: BodyID,
inTorque: Vec3,
inActivationMode: EActivation
): void;
AddForceAndTorque(
inBodyID: BodyID,
inForce: Vec3,
inTorque: Vec3,
inActivationMode: EActivation
): void;
ApplyBuoyancyImpulse(
inBodyID: BodyID,
inSurfacePosition: RVec3,
inSurfaceNormal: Vec3,
inBuoyancy: number,
inLinearDrag: number,
inAngularDrag: number,
inFluidVelocity: Vec3,
inGravity: Vec3,
inDeltaTime: number
): boolean;
AddImpulse(inBodyID: BodyID, inImpulse: Vec3): void;
AddImpulse(inBodyID: BodyID, inImpulse: Vec3, inPosition: RVec3): void;
AddAngularImpulse(inBodyID: BodyID, inAngularImpulse: Vec3): void;
GetTransformedShape(inBodyID: BodyID): TransformedShape;
GetUserData(inBodyID: BodyID): number;
SetUserData(inBodyID: BodyID, inUserData: number): void;
GetMaterial(inBodyID: BodyID, inSubShapeID: SubShapeID): PhysicsMaterial;
InvalidateContactCache(inBodyID: BodyID): void;
}
class StateRecorderFilter {}
class StateRecorderFilterJS extends StateRecorderFilter {
constructor();
ShouldSaveBody(inBody: number): boolean;
ShouldSaveConstraint(inConstraint: number): boolean;
ShouldSaveContact(inBody1: number, inBody2: number): boolean;
ShouldRestoreContact(inBody1: number, inBody2: number): boolean;
}
class StateRecorder {
SetValidating(inValidating: boolean): void;
IsValidating(): boolean;
SetIsLastPart(inIsLastPart: boolean): void;
IsLastPart(): boolean;
}
class StateRecorderEm extends StateRecorder {}
class StateRecorderJS extends StateRecorderEm {
constructor();
ReadBytes(outData: number, inNumBytes: number): void;
WriteBytes(inData: number, inNumBytes: number): void;
IsEOF(): boolean;
IsFailed(): boolean;
}
class StateRecorderImpl extends StateRecorder {
constructor();
Clear(): void;
Rewind(): void;
IsEqual(inReference: StateRecorderImpl): boolean;
}
class BodyLockInterface {
TryGetBody(inBodyID: BodyID): Body;
}
class BodyLockInterfaceNoLock extends BodyLockInterface {}
class BodyLockInterfaceLocking extends BodyLockInterface {}
class PhysicsSettings {
constructor();
get_mMaxInFlightBodyPairs(): number;
set_mMaxInFlightBodyPairs(mMaxInFlightBodyPairs: number): void;
mMaxInFlightBodyPairs: number;
get_mStepListenersBatchSize(): number;
set_mStepListenersBatchSize(mStepListenersBatchSize: number): void;
mStepListenersBatchSize: number;
get_mStepListenerBatchesPerJob(): number;
set_mStepListenerBatchesPerJob(mStepListenerBatchesPerJob: number): void;
mStepListenerBatchesPerJob: number;
get_mBaumgarte(): number;
set_mBaumgarte(mBaumgarte: number): void;
mBaumgarte: number;
get_mSpeculativeContactDistance(): number;
set_mSpeculativeContactDistance(mSpeculativeContactDistance: number): void;
mSpeculativeContactDistance: number;
get_mPenetrationSlop(): number;
set_mPenetrationSlop(mPenetrationSlop: number): void;
mPenetrationSlop: number;
get_mLinearCastThreshold(): number;
set_mLinearCastThreshold(mLinearCastThreshold: number): void;
mLinearCastThreshold: number;
get_mLinearCastMaxPenetration(): number;
set_mLinearCastMaxPenetration(mLinearCastMaxPenetration: number): void;
mLinearCastMaxPenetration: number;
get_mManifoldTolerance(): number;
set_mManifoldTolerance(mManifoldTolerance: number): void;
mManifoldTolerance: number;
get_mMaxPenetrationDistance(): number;
set_mMaxPenetrationDistance(mMaxPenetrationDistance: number): void;
mMaxPenetrationDistance: number;
get_mBodyPairCacheMaxDeltaPositionSq(): number;
set_mBodyPairCacheMaxDeltaPositionSq(
mBodyPairCacheMaxDeltaPositionSq: number
): void;
mBodyPairCacheMaxDeltaPositionSq: number;
get_mBodyPairCacheCosMaxDeltaRotationDiv2(): number;
set_mBodyPairCacheCosMaxDeltaRotationDiv2(
mBodyPairCacheCosMaxDeltaRotationDiv2: number
): void;
mBodyPairCacheCosMaxDeltaRotationDiv2: number;
get_mContactNormalCosMaxDeltaRotation(): number;
set_mContactNormalCosMaxDeltaRotation(
mContactNormalCosMaxDeltaRotation: number
): void;
mContactNormalCosMaxDeltaRotation: number;
get_mContactPointPreserveLambdaMaxDistSq(): number;
set_mContactPointPreserveLambdaMaxDistSq(
mContactPointPreserveLambdaMaxDistSq: number
): void;
mContactPointPreserveLambdaMaxDistSq: number;
get_mNumVelocitySteps(): number;
set_mNumVelocitySteps(mNumVelocitySteps: number): void;
mNumVelocitySteps: number;
get_mNumPositionSteps(): number;
set_mNumPositionSteps(mNumPositionSteps: number): void;
mNumPositionSteps: number;
get_mMinVelocityForRestitution(): number;
set_mMinVelocityForRestitution(mMinVelocityForRestitution: number): void;
mMinVelocityForRestitution: number;
get_mTimeBeforeSleep(): number;
set_mTimeBeforeSleep(mTimeBeforeSleep: number): void;
mTimeBeforeSleep: number;
get_mPointVelocitySleepThreshold(): number;
set_mPointVelocitySleepThreshold(
mPointVelocitySleepThreshold: number
): void;
mPointVelocitySleepThreshold: number;
get_mDeterministicSimulation(): boolean;
set_mDeterministicSimulation(mDeterministicSimulation: boolean): void;
mDeterministicSimulation: boolean;
get_mConstraintWarmStart(): boolean;
set_mConstraintWarmStart(mConstraintWarmStart: boolean): void;
mConstraintWarmStart: boolean;
get_mUseBodyPairContactCache(): boolean;
set_mUseBodyPairContactCache(mUseBodyPairContactCache: boolean): void;
mUseBodyPairContactCache: boolean;
get_mUseManifoldReduction(): boolean;
set_mUseManifoldReduction(mUseManifoldReduction: boolean): void;
mUseManifoldReduction: boolean;
get_mUseLargeIslandSplitter(): boolean;
set_mUseLargeIslandSplitter(mUseLargeIslandSplitter: boolean): void;
mUseLargeIslandSplitter: boolean;
get_mAllowSleeping(): boolean;
set_mAllowSleeping(mAllowSleeping: boolean): void;
mAllowSleeping: boolean;
get_mCheckActiveEdges(): boolean;
set_mCheckActiveEdges(mCheckActiveEdges: boolean): void;
mCheckActiveEdges: boolean;
}
class CollideShapeResultFace {
empty(): boolean;
size(): number;
at(inIndex: number): Vec3;
push_back(inValue: Vec3): void;
resize(inSize: number): void;
clear(): void;
}
class CollideShapeResult {
constructor();
get_mContactPointOn1(): Vec3;
set_mContactPointOn1(mContactPointOn1: Vec3): void;
mContactPointOn1: Vec3;
get_mContactPointOn2(): Vec3;
set_mContactPointOn2(mContactPointOn2: Vec3): void;
mContactPointOn2: Vec3;
get_mPenetrationAxis(): Vec3;
set_mPenetrationAxis(mPenetrationAxis: Vec3): void;
mPenetrationAxis: Vec3;
get_mPenetrationDepth(): number;
set_mPenetrationDepth(mPenetrationDepth: number): void;
mPenetrationDepth: number;
get_mSubShapeID1(): SubShapeID;
set_mSubShapeID1(mSubShapeID1: SubShapeID): void;
mSubShapeID1: SubShapeID;
get_mSubShapeID2(): SubShapeID;
set_mSubShapeID2(mSubShapeID2: SubShapeID): void;
mSubShapeID2: SubShapeID;
get_mBodyID2(): BodyID;
set_mBodyID2(mBodyID2: BodyID): void;
mBodyID2: BodyID;
get_mShape1Face(): CollideShapeResultFace;
set_mShape1Face(mShape1Face: CollideShapeResultFace): void;
mShape1Face: CollideShapeResultFace;
get_mShape2Face(): CollideShapeResultFace;
set_mShape2Face(mShape2Face: CollideShapeResultFace): void;
mShape2Face: CollideShapeResultFace;
}
class ContactPoints {
empty(): boolean;
size(): number;
at(inIndex: number): Vec3;
push_back(inValue: Vec3): void;
resize(inSize: number): void;
clear(): void;
}
class ContactManifold {
constructor();
SwapShapes(): ContactManifold;
GetWorldSpaceContactPointOn1(inIndex: number): RVec3;
GetWorldSpaceContactPointOn2(inIndex: number): RVec3;
get_mBaseOffset(): RVec3;
set_mBaseOffset(mBaseOffset: RVec3): void;
mBaseOffset: RVec3;
get_mWorldSpaceNormal(): Vec3;
set_mWorldSpaceNormal(mWorldSpaceNormal: Vec3): void;
mWorldSpaceNormal: Vec3;
get_mPenetrationDepth(): number;
set_mPenetrationDepth(mPenetrationDepth: number): void;
mPenetrationDepth: number;
get_mSubShapeID1(): SubShapeID;
set_mSubShapeID1(mSubShapeID1: SubShapeID): void;
mSubShapeID1: SubShapeID;
get_mSubShapeID2(): SubShapeID;
set_mSubShapeID2(mSubShapeID2: SubShapeID): void;
mSubShapeID2: SubShapeID;
get_mRelativeContactPointsOn1(): ContactPoints;
set_mRelativeContactPointsOn1(
mRelativeContactPointsOn1: ContactPoints
): void;
mRelativeContactPointsOn1: ContactPoints;
get_mRelativeContactPointsOn2(): ContactPoints;
set_mRelativeContactPointsOn2(
mRelativeContactPointsOn2: ContactPoints
): void;
mRelativeContactPointsOn2: ContactPoints;
}
class ContactSettings {
constructor();
get_mCombinedFriction(): number;
set_mCombinedFriction(mCombinedFriction: number): void;
mCombinedFriction: number;
get_mCombinedRestitution(): number;
set_mCombinedRestitution(mCombinedRestitution: number): void;
mCombinedRestitution: number;
get_mInvMassScale1(): number;
set_mInvMassScale1(mInvMassScale1: number): void;
mInvMassScale1: number;
get_mInvInertiaScale1(): number;
set_mInvInertiaScale1(mInvInertiaScale1: number): void;
mInvInertiaScale1: number;
get_mInvMassScale2(): number;
set_mInvMassScale2(mInvMassScale2: number): void;
mInvMassScale2: number;
get_mInvInertiaScale2(): number;
set_mInvInertiaScale2(mInvInertiaScale2: number): void;
mInvInertiaScale2: number;
get_mIsSensor(): boolean;
set_mIsSensor(mIsSensor: boolean): void;
mIsSensor: boolean;
get_mRelativeLinearSurfaceVelocity(): Vec3;
set_mRelativeLinearSurfaceVelocity(
mRelativeLinearSurfaceVelocity: Vec3
): void;
mRelativeLinearSurfaceVelocity: Vec3;
get_mRelativeAngularSurfaceVelocity(): Vec3;
set_mRelativeAngularSurfaceVelocity(
mRelativeAngularSurfaceVelocity: Vec3
): void;
mRelativeAngularSurfaceVelocity: Vec3;
}
class SubShapeIDPair {
constructor();
GetBody1ID(): BodyID;
GetSubShapeID1(): SubShapeID;
GetBody2ID(): BodyID;
GetSubShapeID2(): SubShapeID;
}
class ContactListener {}
class ContactListenerEm extends ContactListener {}
class ContactListenerJS extends ContactListenerEm {
constructor();
OnContactValidate(
inBody1: number,
inBody2: number,
inBaseOffset: number,
inCollisionResult: number
): number;
OnContactAdded(
inBody1: number,
inBody2: number,
inManifold: number,
ioSettings: number
): void;
OnContactPersisted(
inBody1: number,
inBody2: number,
inManifold: number,
ioSettings: number
): void;
OnContactRemoved(inSubShapePair: number): void;
}
class SoftBodyManifold {
GetVertices(): ArraySoftBodyVertex;
HasContact(inVertex: SoftBodyVertex): boolean;
GetLocalContactPoint(inVertex: SoftBodyVertex): Vec3;
GetContactNormal(inVertex: SoftBodyVertex): Vec3;
GetContactBodyID(inVertex: SoftBodyVertex): BodyID;
GetNumSensorContacts(): number;
GetSensorContactBodyID(inIndex: number): BodyID;
}
class SoftBodyContactSettings {
get_mInvMassScale1(): number;
set_mInvMassScale1(mInvMassScale1: number): void;
mInvMassScale1: number;
get_mInvMassScale2(): number;
set_mInvMassScale2(mInvMassScale2: number): void;
mInvMassScale2: number;
get_mInvInertiaScale2(): number;
set_mInvInertiaScale2(mInvInertiaScale2: number): void;
mInvInertiaScale2: number;
get_mIsSensor(): boolean;
set_mIsSensor(mIsSensor: boolean): void;
mIsSensor: boolean;
}
class SoftBodyContactListener {}
class SoftBodyContactListenerEm extends SoftBodyContactListener {}
class SoftBodyContactListenerJS extends SoftBodyContactListenerEm {
constructor();
OnSoftBodyContactValidate(
inSoftBody: number,
inOtherBody: number,
ioSettings: number
): number;
OnSoftBodyContactAdded(inSoftBody: number, inManifold: number): void;
}
class RayCastBodyCollector {
Reset(): void;
SetContext(inContext: TransformedShape): void;
GetContext(): TransformedShape;
UpdateEarlyOutFraction(inFraction: number): void;
ResetEarlyOutFraction(inFraction?: number): void;
ForceEarlyOut(): void;
ShouldEarlyOut(): boolean;
GetEarlyOutFraction(): number;
GetPositiveEarlyOutFraction(): number;
}
class RayCastBodyCollectorJS extends RayCastBodyCollector {
constructor();
Reset(): void;
AddHit(inResult: number): void;
}
class CollideShapeBodyCollector {
Reset(): void;
SetContext(inContext: TransformedShape): void;
GetContext(): TransformedShape;
UpdateEarlyOutFraction(inFraction: number): void;
ResetEarlyOutFraction(inFraction?: number): void;
ForceEarlyOut(): void;
ShouldEarlyOut(): boolean;
GetEarlyOutFraction(): number;
GetPositiveEarlyOutFraction(): number;
}
class CollideShapeBodyCollectorJS extends CollideShapeBodyCollector {
constructor();
Reset(): void;
AddHit(inResult: number): void;
}
class CastShapeBodyCollector {
Reset(): void;
SetContext(inContext: TransformedShape): void;
GetContext(): TransformedShape;
UpdateEarlyOutFraction(inFraction: number): void;
ResetEarlyOutFraction(inFraction?: number): void;
ForceEarlyOut(): void;
ShouldEarlyOut(): boolean;
GetEarlyOutFraction(): number;
GetPositiveEarlyOutFraction(): number;
}
class CastShapeBodyCollectorJS extends CastShapeBodyCollector {
constructor();
Reset(): void;
AddHit(inResult: number): void;
}
class BroadPhaseQuery {
CastRay(
inRay: RayCast,
ioCollector: RayCastBodyCollector,
inBroadPhaseFilter: BroadPhaseLayerFilter,
inObjectLayerFilter: ObjectLayerFilter
): void;
CollideAABox(
inBox: AABox,
ioCollector: CollideShapeBodyCollector,
inBroadPhaseFilter: BroadPhaseLayerFilter,
inObjectLayerFilter: ObjectLayerFilter
): void;
CollideSphere(
inCenter: Vec3,
inRadius: number,
ioCollector: CollideShapeBodyCollector,
inBroadPhaseLayerFilter: BroadPhaseLayerFilter,
inObjectLayerFilter: ObjectLayerFilter
): void;
CollidePoint(
inPoint: Vec3,
ioCollector: CollideShapeBodyCollector,
inBroadPhaseFilter: BroadPhaseLayerFilter,
inObjectLayerFilter: ObjectLayerFilter
): void;
CollideOrientedBox(
inBox: OrientedBox,
ioCollector: CollideShapeBodyCollector,
inBroadPhaseFilter: BroadPhaseLayerFilter,
inObjectLayerFilter: ObjectLayerFilter
): void;
CastAABox(
inBox: AABoxCast,
ioCollector: CastShapeBodyCollector,
inBroadPhaseFilter: BroadPhaseLayerFilter,
inObjectLayerFilter: ObjectLayerFilter
): void;
}
class RayCastSettings {
constructor();
SetBackFaceMode(inBackFaceMode: EBackFaceMode): void;
get_mBackFaceModeTriangles(): EBackFaceMode;
set_mBackFaceModeTriangles(mBackFaceModeTriangles: EBackFaceMode): void;
mBackFaceModeTriangles: EBackFaceMode;
get_mBackFaceModeConvex(): EBackFaceMode;
set_mBackFaceModeConvex(mBackFaceModeConvex: EBackFaceMode): void;
mBackFaceModeConvex: EBackFaceMode;
get_mTreatConvexAsSolid(): boolean;
set_mTreatConvexAsSolid(mTreatConvexAsSolid: boolean): void;
mTreatConvexAsSolid: boolean;
}
class CastRayCollector {
Reset(): void;
SetContext(inContext: TransformedShape): void;
GetContext(): TransformedShape;
UpdateEarlyOutFraction(inFraction: number): void;
ResetEarlyOutFraction(inFraction?: number): void;
ForceEarlyOut(): void;
ShouldEarlyOut(): boolean;
GetEarlyOutFraction(): number;
GetPositiveEarlyOutFraction(): number;
}
class CastRayCollectorJS extends CastRayCollector {
constructor();
Reset(): void;
OnBody(inBody: number): void;
AddHit(inResult: number): void;
}
class ArrayRayCastResult {
constructor();
empty(): boolean;
size(): number;
at(inIndex: number): RayCastResult;
push_back(inValue: RayCastResult): void;
reserve(inSize: number): void;
resize(inSize: number): void;
clear(): void;
}
class CastRayAllHitCollisionCollector extends CastRayCollector {
constructor();
Sort(): void;
HadHit(): boolean;
get_mHits(): ArrayRayCastResult;
set_mHits(mHits: ArrayRayCastResult): void;
mHits: ArrayRayCastResult;
}
class CastRayClosestHitCollisionCollector extends CastRayCollector {
constructor();
HadHit(): boolean;
get_mHit(): RayCastResult;
set_mHit(mHit: RayCastResult): void;
mHit: RayCastResult;
}
class CastRayAnyHitCollisionCollector extends CastRayCollector {
constructor();
HadHit(): boolean;
get_mHit(): RayCastResult;
set_mHit(mHit: RayCastResult): void;
mHit: RayCastResult;
}
class CollidePointResult {
constructor();
get_mBodyID(): BodyID;
set_mBodyID(mBodyID: BodyID): void;
mBodyID: BodyID;
get_mSubShapeID2(): SubShapeID;
set_mSubShapeID2(mSubShapeID2: SubShapeID): void;
mSubShapeID2: SubShapeID;
}
class CollidePointCollector {
Reset(): void;
SetContext(inContext: TransformedShape): void;
GetContext(): TransformedShape;
UpdateEarlyOutFraction(inFraction: number): void;
ResetEarlyOutFraction(inFraction?: number): void;
ForceEarlyOut(): void;
ShouldEarlyOut(): boolean;
GetEarlyOutFraction(): number;
GetPositiveEarlyOutFraction(): number;
}
class CollidePointCollectorJS extends CollidePointCollector {
constructor();
Reset(): void;
OnBody(inBody: number): void;
AddHit(inResult: number): void;
}
class ArrayCollidePointResult {
constructor();
empty(): boolean;
size(): number;
at(inIndex: number): CollidePointResult;
push_back(inValue: CollidePointResult): void;
reserve(inSize: number): void;
resize(inSize: number): void;
clear(): void;
}
class CollidePointAllHitCollisionCollector extends CollidePointCollector {
constructor();
Sort(): void;
HadHit(): boolean;
get_mHits(): ArrayCollidePointResult;
set_mHits(mHits: ArrayCollidePointResult): void;
mHits: ArrayCollidePointResult;
}
class CollidePointClosestHitCollisionCollector extends CollidePointCollector {
constructor();
HadHit(): boolean;
get_mHit(): CollidePointResult;
set_mHit(mHit: CollidePointResult): void;
mHit: CollidePointResult;
}
class CollidePointAnyHitCollisionCollector extends CollidePointCollector {
constructor();
HadHit(): boolean;
get_mHit(): CollidePointResult;
set_mHit(mHit: CollidePointResult): void;
mHit: CollidePointResult;
}
class CollideSettingsBase {
get_mActiveEdgeMode(): EActiveEdgeMode;
set_mActiveEdgeMode(mActiveEdgeMode: EActiveEdgeMode): void;
mActiveEdgeMode: EActiveEdgeMode;
get_mCollectFacesMode(): ECollectFacesMode;
set_mCollectFacesMode(mCollectFacesMode: ECollectFacesMode): void;
mCollectFacesMode: ECollectFacesMode;
get_mCollisionTolerance(): number;
set_mCollisionTolerance(mCollisionTolerance: number): void;
mCollisionTolerance: number;
get_mPenetrationTolerance(): number;
set_mPenetrationTolerance(mPenetrationTolerance: number): void;
mPenetrationTolerance: number;
get_mActiveEdgeMovementDirection(): Vec3;
set_mActiveEdgeMovementDirection(mActiveEdgeMovementDirection: Vec3): void;
mActiveEdgeMovementDirection: Vec3;
}
class CollideShapeSettings extends CollideSettingsBase {
constructor();
get_mMaxSeparationDistance(): number;
set_mMaxSeparationDistance(mMaxSeparationDistance: number): void;
mMaxSeparationDistance: number;
get_mBackFaceMode(): EBackFaceMode;
set_mBackFaceMode(mBackFaceMode: EBackFaceMode): void;
mBackFaceMode: EBackFaceMode;
}
class CollideShapeCollector {
Reset(): void;
SetContext(inContext: TransformedShape): void;
GetContext(): TransformedShape;
UpdateEarlyOutFraction(inFraction: number): void;
ResetEarlyOutFraction(inFraction?: number): void;
ForceEarlyOut(): void;
ShouldEarlyOut(): boolean;
GetEarlyOutFraction(): number;
GetPositiveEarlyOutFraction(): number;
}
class CollideShapeCollectorJS extends CollideShapeCollector {
constructor();
Reset(): void;
OnBody(inBody: number): void;
AddHit(inResult: number): void;
}
class ArrayCollideShapeResult {
constructor();
empty(): boolean;
size(): number;
at(inIndex: number): CollideShapeResult;
push_back(inValue: CollideShapeResult): void;
reserve(inSize: number): void;
resize(inSize: number): void;
clear(): void;
}
class CollideShapeAllHitCollisionCollector extends CollideShapeCollector {
constructor();
Sort(): void;
HadHit(): boolean;
get_mHits(): ArrayCollideShapeResult;
set_mHits(mHits: ArrayCollideShapeResult): void;
mHits: ArrayCollideShapeResult;
}
class CollideShapeClosestHitCollisionCollector extends CollideShapeCollector {
constructor();
HadHit(): boolean;
get_mHit(): CollideShapeResult;
set_mHit(mHit: CollideShapeResult): void;
mHit: CollideShapeResult;
}
class CollideShapeAnyHitCollisionCollector extends CollideShapeCollector {
constructor();
HadHit(): boolean;
get_mHit(): CollideShapeResult;
set_mHit(mHit: CollideShapeResult): void;
mHit: CollideShapeResult;
}
class ShapeCastSettings extends CollideSettingsBase {
constructor();
get_mBackFaceModeTriangles(): EBackFaceMode;
set_mBackFaceModeTriangles(mBackFaceModeTriangles: EBackFaceMode): void;
mBackFaceModeTriangles: EBackFaceMode;
get_mBackFaceModeConvex(): EBackFaceMode;
set_mBackFaceModeConvex(mBackFaceModeConvex: EBackFaceMode): void;
mBackFaceModeConvex: EBackFaceMode;
get_mUseShrunkenShapeAndConvexRadius(): boolean;
set_mUseShrunkenShapeAndConvexRadius(
mUseShrunkenShapeAndConvexRadius: boolean
): void;
mUseShrunkenShapeAndConvexRadius: boolean;
get_mReturnDeepestPoint(): boolean;
set_mReturnDeepestPoint(mReturnDeepestPoint: boolean): void;
mReturnDeepestPoint: boolean;
}
class ShapeCastResult extends CollideShapeResult {
constructor();
get_mFraction(): number;
set_mFraction(mFraction: number): void;
mFraction: number;
get_mIsBackFaceHit(): boolean;
set_mIsBackFaceHit(mIsBackFaceHit: boolean): void;
mIsBackFaceHit: boolean;
}
class CastShapeCollector {
Reset(): void;
SetContext(inContext: TransformedShape): void;
GetContext(): TransformedShape;
UpdateEarlyOutFraction(inFraction: number): void;
ResetEarlyOutFraction(inFraction?: number): void;
ForceEarlyOut(): void;
ShouldEarlyOut(): boolean;
GetEarlyOutFraction(): number;
GetPositiveEarlyOutFraction(): number;
}
class CastShapeCollectorJS extends CastShapeCollector {
constructor();
Reset(): void;
OnBody(inBody: number): void;
AddHit(inResult: number): void;
}
class ArrayShapeCastResult {
constructor();
empty(): boolean;
size(): number;
at(inIndex: number): ShapeCastResult;
push_back(inValue: ShapeCastResult): void;
reserve(inSize: number): void;
resize(inSize: number): void;
clear(): void;
}
class CastShapeAllHitCollisionCollector extends CastShapeCollector {
constructor();
Sort(): void;
HadHit(): boolean;
get_mHits(): ArrayShapeCastResult;
set_mHits(mHits: ArrayShapeCastResult): void;
mHits: ArrayShapeCastResult;
}
class CastShapeClosestHitCollisionCollector extends CastShapeCollector {
constructor();
HadHit(): boolean;
get_mHit(): ShapeCastResult;
set_mHit(mHit: ShapeCastResult): void;
mHit: ShapeCastResult;
}
class CastShapeAnyHitCollisionCollector extends CastShapeCollector {
constructor();
HadHit(): boolean;
get_mHit(): ShapeCastResult;
set_mHit(mHit: ShapeCastResult): void;
mHit: ShapeCastResult;
}
class TransformedShapeCollector {
Reset(): void;
SetContext(inContext: TransformedShape): void;
GetContext(): TransformedShape;
UpdateEarlyOutFraction(inFraction: number): void;
ResetEarlyOutFraction(inFraction?: number): void;
ForceEarlyOut(): void;
ShouldEarlyOut(): boolean;
GetEarlyOutFraction(): number;
GetPositiveEarlyOutFraction(): number;
}
class TransformedShapeCollectorJS extends TransformedShapeCollector {
constructor();
Reset(): void;
OnBody(inBody: number): void;
AddHit(inResult: number): void;
}
class NarrowPhaseQuery {
CastRay(
inRay: RRayCast,
inRayCastSettings: RayCastSettings,
ioCollector: CastRayCollector,
inBroadPhaseLayerFilter: BroadPhaseLayerFilter,
inObjectLayerFilter: ObjectLayerFilter,
inBodyFilter: BodyFilter,
inShapeFilter: ShapeFilter
): void;
CollidePoint(
inPoint: RVec3,
ioCollector: CollidePointCollector,
inBroadPhaseLayerFilter: BroadPhaseLayerFilter,
inObjectLayerFilter: ObjectLayerFilter,
inBodyFilter: BodyFilter,
inShapeFilter: ShapeFilter
): void;
CollideShape(
inShape: Shape,
inShapeScale: Vec3,
inCenterOfMassTransform: RMat44,
inCollideShapeSettings: CollideShapeSettings,
inBaseOffset: RVec3,
ioCollector: CollideShapeCollector,
inBroadPhaseLayerFilter: BroadPhaseLayerFilter,
inObjectLayerFilter: ObjectLayerFilter,
inBodyFilter: BodyFilter,
inShapeFilter: ShapeFilter
): void;
CollideShapeWithInternalEdgeRemoval(
inShape: Shape,
inShapeScale: Vec3,
inCenterOfMassTransform: RMat44,
inCollideShapeSettings: CollideShapeSettings,
inBaseOffset: RVec3,
ioCollector: CollideShapeCollector,
inBroadPhaseLayerFilter: BroadPhaseLayerFilter,
inObjectLayerFilter: ObjectLayerFilter,
inBodyFilter: BodyFilter,
inShapeFilter: ShapeFilter
): void;
CastShape(
inShapeCast: RShapeCast,
inShapeCastSettings: ShapeCastSettings,
inBaseOffset: RVec3,
ioCollector: CastShapeCollector,
inBroadPhaseLayerFilter: BroadPhaseLayerFilter,
inObjectLayerFilter: ObjectLayerFilter,
inBodyFilter: BodyFilter,
inShapeFilter: ShapeFilter
): void;
CollectTransformedShapes(
inBox: AABox,
ioCollector: TransformedShapeCollector,
inBroadPhaseLayerFilter: BroadPhaseLayerFilter,
inObjectLayerFilter: ObjectLayerFilter,
inBodyFilter: BodyFilter,
inShapeFilter: ShapeFilter
): void;
}
class PhysicsStepListenerContext {
get_mDeltaTime(): number;
set_mDeltaTime(mDeltaTime: number): void;
mDeltaTime: number;
get_mIsFirstStep(): boolean;
set_mIsFirstStep(mIsFirstStep: boolean): void;
mIsFirstStep: boolean;
get_mIsLastStep(): boolean;
set_mIsLastStep(mIsLastStep: boolean): void;
mIsLastStep: boolean;
get_mPhysicsSystem(): PhysicsSystem;
set_mPhysicsSystem(mPhysicsSystem: PhysicsSystem): void;
mPhysicsSystem: PhysicsSystem;
}
class PhysicsStepListener {}
class PhysicsStepListenerJS extends PhysicsStepListener {
constructor();
OnStep(inContext: number): void;
}
class BodyActivationListener {}
class BodyActivationListenerEm extends BodyActivationListener {}
class BodyActivationListenerJS extends BodyActivationListenerEm {
constructor();
OnBodyActivated(inBodyID: number, inBodyUserData: number): void;
OnBodyDeactivated(inBodyID: number, inBodyUserData: number): void;
}
class BodyIDVector {
constructor();
empty(): boolean;
size(): number;
at(inIndex: number): BodyID;
push_back(inBodyID: BodyID): void;
reserve(inSize: number): void;
resize(inSize: number): void;
clear(): void;
}
class PhysicsSystem {
SetGravity(inGravity: Vec3): void;
GetGravity(): Vec3;
GetPhysicsSettings(): PhysicsSettings;
SetPhysicsSettings(inPhysicsSettings: PhysicsSettings): void;
GetNumBodies(): number;
GetNumActiveBodies(inBodyType: EBodyType): number;
GetMaxBodies(): number;
GetBodies(outBodies: BodyIDVector): void;
GetActiveBodies(inBodyType: EBodyType, outBodies: BodyIDVector): void;
GetBounds(): AABox;
AddConstraint(inConstraint: Constraint): void;
RemoveConstraint(inConstraint: Constraint): void;
SetContactListener(inListener: ContactListener): void;
GetContactListener(): ContactListener;
SetSoftBodyContactListener(inListener: SoftBodyContactListener): void;
GetSoftBodyContactListener(): SoftBodyContactListener;
OptimizeBroadPhase(): void;
GetBodyInterface(): BodyInterface;
GetBodyInterfaceNoLock(): BodyInterface;
GetBodyLockInterfaceNoLock(): BodyLockInterfaceNoLock;
GetBodyLockInterface(): BodyLockInterfaceLocking;
GetBroadPhaseQuery(): BroadPhaseQuery;
GetNarrowPhaseQuery(): NarrowPhaseQuery;
GetNarrowPhaseQueryNoLock(): NarrowPhaseQuery;
SaveState(
inStream: StateRecorder,
inState?: EStateRecorderState,
inFilter?: StateRecorderFilter
): void;
RestoreState(
inStream: StateRecorder,
inFilter?: StateRecorderFilter
): boolean;
AddStepListener(inListener: PhysicsStepListener): void;
RemoveStepListener(inListener: PhysicsStepListener): void;
SetBodyActivationListener(inListener: BodyActivationListener): void;
GetBodyActivationListener(): BodyActivationListener;
WereBodiesInContact(inBodyID1: BodyID, inBodyID2: BodyID): boolean;
SetSimShapeFilter(inShapeFilter: SimShapeFilter): void;
GetSimShapeFilter(): SimShapeFilter;
}
class MassProperties {
constructor();
SetMassAndInertiaOfSolidBox(inBoxSize: Vec3, inDensity: number): void;
ScaleToMass(inMass: number): void;
sGetEquivalentSolidBoxSize(inMass: number, inInertiaDiagonal: Vec3): Vec3;
Rotate(inRotation: Mat44): void;
Translate(inTranslation: Vec3): void;
Scale(inScale: Vec3): void;
get_mMass(): number;
set_mMass(mMass: number): void;
mMass: number;
get_mInertia(): Mat44;
set_mInertia(mInertia: Mat44): void;
mInertia: Mat44;
}
class BodyCreationSettings {
constructor();
constructor(
inShape: Shape,
inPosition: RVec3,
inRotation: Quat,
inMotionType: EMotionType,
inObjectLayer: number
);
GetShapeSettings(): ShapeSettings;
SetShapeSettings(inShape: ShapeSettings): void;
ConvertShapeSettings(): ShapeResult;
GetShape(): Shape;
SetShape(inShape: Shape): void;
HasMassProperties(): boolean;
GetMassProperties(): MassProperties;
get_mPosition(): RVec3;
set_mPosition(mPosition: RVec3): void;
mPosition: RVec3;
get_mRotation(): Quat;
set_mRotation(mRotation: Quat): void;
mRotation: Quat;
get_mLinearVelocity(): Vec3;
set_mLinearVelocity(mLinearVelocity: Vec3): void;
mLinearVelocity: Vec3;
get_mAngularVelocity(): Vec3;
set_mAngularVelocity(mAngularVelocity: Vec3): void;
mAngularVelocity: Vec3;
get_mUserData(): number;
set_mUserData(mUserData: number): void;
mUserData: number;
get_mObjectLayer(): number;
set_mObjectLayer(mObjectLayer: number): void;
mObjectLayer: number;
get_mCollisionGroup(): CollisionGroup;
set_mCollisionGroup(mCollisionGroup: CollisionGroup): void;
mCollisionGroup: CollisionGroup;
get_mMotionType(): EMotionType;
set_mMotionType(mMotionType: EMotionType): void;
mMotionType: EMotionType;
get_mAllowedDOFs(): EAllowedDOFs;
set_mAllowedDOFs(mAllowedDOFs: EAllowedDOFs): void;
mAllowedDOFs: EAllowedDOFs;
get_mAllowDynamicOrKinematic(): boolean;
set_mAllowDynamicOrKinematic(mAllowDynamicOrKinematic: boolean): void;
mAllowDynamicOrKinematic: boolean;
get_mIsSensor(): boolean;
set_mIsSensor(mIsSensor: boolean): void;
mIsSensor: boolean;
get_mUseManifoldReduction(): boolean;
set_mUseManifoldReduction(mUseManifoldReduction: boolean): void;
mUseManifoldReduction: boolean;
get_mCollideKinematicVsNonDynamic(): boolean;
set_mCollideKinematicVsNonDynamic(
mCollideKinematicVsNonDynamic: boolean
): void;
mCollideKinematicVsNonDynamic: boolean;
get_mApplyGyroscopicForce(): boolean;
set_mApplyGyroscopicForce(mApplyGyroscopicForce: boolean): void;
mApplyGyroscopicForce: boolean;
get_mMotionQuality(): EMotionQuality;
set_mMotionQuality(mMotionQuality: EMotionQuality): void;
mMotionQuality: EMotionQuality;
get_mEnhancedInternalEdgeRemoval(): boolean;
set_mEnhancedInternalEdgeRemoval(
mEnhancedInternalEdgeRemoval: boolean
): void;
mEnhancedInternalEdgeRemoval: boolean;
get_mAllowSleeping(): boolean;
set_mAllowSleeping(mAllowSleeping: boolean): void;
mAllowSleeping: boolean;
get_mFriction(): number;
set_mFriction(mFriction: number): void;
mFriction: number;
get_mRestitution(): number;
set_mRestitution(mRestitution: number): void;
mRestitution: number;
get_mLinearDamping(): number;
set_mLinearDamping(mLinearDamping: number): void;
mLinearDamping: number;
get_mAngularDamping(): number;
set_mAngularDamping(mAngularDamping: number): void;
mAngularDamping: number;
get_mMaxLinearVelocity(): number;
set_mMaxLinearVelocity(mMaxLinearVelocity: number): void;
mMaxLinearVelocity: number;
get_mMaxAngularVelocity(): number;
set_mMaxAngularVelocity(mMaxAngularVelocity: number): void;
mMaxAngularVelocity: number;
get_mGravityFactor(): number;
set_mGravityFactor(mGravityFactor: number): void;
mGravityFactor: number;
get_mNumVelocityStepsOverride(): number;
set_mNumVelocityStepsOverride(mNumVelocityStepsOverride: number): void;
mNumVelocityStepsOverride: number;
get_mNumPositionStepsOverride(): number;
set_mNumPositionStepsOverride(mNumPositionStepsOverride: number): void;
mNumPositionStepsOverride: number;
get_mOverrideMassProperties(): EOverrideMassProperties;
set_mOverrideMassProperties(
mOverrideMassProperties: EOverrideMassProperties
): void;
mOverrideMassProperties: EOverrideMassProperties;
get_mInertiaMultiplier(): number;
set_mInertiaMultiplier(mInertiaMultiplier: number): void;
mInertiaMultiplier: number;
get_mMassPropertiesOverride(): MassProperties;
set_mMassPropertiesOverride(mMassPropertiesOverride: MassProperties): void;
mMassPropertiesOverride: MassProperties;
}
class SoftBodySharedSettingsVertex {
constructor();
get_mPosition(): Float3;
set_mPosition(mPosition: Float3): void;
mPosition: Float3;
get_mVelocity(): Float3;
set_mVelocity(mVelocity: Float3): void;
mVelocity: Float3;
get_mInvMass(): number;
set_mInvMass(mInvMass: number): void;
mInvMass: number;
}
class SoftBodySharedSettingsFace {
constructor(
inVertex1: number,
inVertex2: number,
inVertex3: number,
inMaterialIndex: number
);
get_mVertex(index: number): number;
set_mVertex(index: number, mVertex: number): void;
mVertex: number;
get_mMaterialIndex(): number;
set_mMaterialIndex(mMaterialIndex: number): void;
mMaterialIndex: number;
}
class SoftBodySharedSettingsEdge {
constructor(inVertex1: number, inVertex2: number, inCompliance: number);
get_mVertex(index: number): number;
set_mVertex(index: number, mVertex: number): void;
mVertex: number;
get_mRestLength(): number;
set_mRestLength(mRestLength: number): void;
mRestLength: number;
get_mCompliance(): number;
set_mCompliance(mCompliance: number): void;
mCompliance: number;
}
class SoftBodySharedSettingsDihedralBend {
constructor(
inVertex1: number,
inVertex2: number,
inVertex3: number,
inVertex4: number,
inCompliance: number
);
get_mVertex(index: number): number;
set_mVertex(index: number, mVertex: number): void;
mVertex: number;
get_mCompliance(): number;
set_mCompliance(mCompliance: number): void;
mCompliance: number;
get_mInitialAngle(): number;
set_mInitialAngle(mInitialAngle: number): void;
mInitialAngle: number;
}
class SoftBodySharedSettingsVolume {
constructor(
inVertex1: number,
inVertex2: number,
inVertex3: number,
inVertex4: number,
inCompliance: number
);
get_mVertex(index: number): number;
set_mVertex(index: number, mVertex: number): void;
mVertex: number;
get_mSixRestVolume(): number;
set_mSixRestVolume(mSixRestVolume: number): void;
mSixRestVolume: number;
get_mCompliance(): number;
set_mCompliance(mCompliance: number): void;
mCompliance: number;
}
class SoftBodySharedSettingsInvBind {
get_mJointIndex(): number;
set_mJointIndex(mJointIndex: number): void;
mJointIndex: number;
get_mInvBind(): Mat44;
set_mInvBind(mInvBind: Mat44): void;
mInvBind: Mat44;
}
class SoftBodySharedSettingsSkinWeight {
get_mInvBindIndex(): number;
set_mInvBindIndex(mInvBindIndex: number): void;
mInvBindIndex: number;
get_mWeight(): number;
set_mWeight(mWeight: number): void;
mWeight: number;
}
class SoftBodySharedSettingsSkinned {
get_mVertex(): number;
set_mVertex(mVertex: number): void;
mVertex: number;
get_mWeights(index: number): SoftBodySharedSettingsSkinWeight;
set_mWeights(
index: number,
mWeights: SoftBodySharedSettingsSkinWeight
): void;
mWeights: SoftBodySharedSettingsSkinWeight;
get_mMaxDistance(): number;
set_mMaxDistance(mMaxDistance: number): void;
mMaxDistance: number;
get_mBackStopDistance(): number;
set_mBackStopDistance(mBackStopDistance: number): void;
mBackStopDistance: number;
get_mBackStopRadius(): number;
set_mBackStopRadius(mBackStopRadius: number): void;
mBackStopRadius: number;
}
class SoftBodySharedSettingsLRA {
constructor(inVertex1: number, inVertex2: number, inMaxDistance: number);
get_mVertex(index: number): number;
set_mVertex(index: number, mVertex: number): void;
mVertex: number;
get_mMaxDistance(): number;
set_mMaxDistance(mMaxDistance: number): void;
mMaxDistance: number;
}
class SoftBodySharedSettingsRodStretchShear {
constructor(inVertex1: number, inVertex2: number, inCompliance: number);
get_mVertex(index: number): number;
set_mVertex(index: number, mVertex: number): void;
mVertex: number;
get_mLength(): number;
set_mLength(mLength: number): void;
mLength: number;
get_mInvMass(): number;
set_mInvMass(mInvMass: number): void;
mInvMass: number;
get_mCompliance(): number;
set_mCompliance(mCompliance: number): void;
mCompliance: number;
get_mBishop(): Quat;
set_mBishop(mBishop: Quat): void;
mBishop: Quat;
}
class SoftBodySharedSettingsRodBendTwist {
constructor(inRod1: number, inRod2: number, inCompliance: number);
get_mRod(index: number): number;
set_mRod(index: number, mRod: number): void;
mRod: number;
get_mCompliance(): number;
set_mCompliance(mCompliance: number): void;
mCompliance: number;
get_mOmega0(): Quat;
set_mOmega0(mOmega0: Quat): void;
mOmega0: Quat;
}
class ArraySoftBodySharedSettingsVertex {
constructor();
empty(): boolean;
size(): number;
at(inIndex: number): SoftBodySharedSettingsVertex;
push_back(inValue: SoftBodySharedSettingsVertex): void;
reserve(inSize: number): void;
resize(inSize: number): void;
clear(): void;
}
class ArraySoftBodySharedSettingsFace {
constructor();
empty(): boolean;
size(): number;
at(inIndex: number): SoftBodySharedSettingsFace;
push_back(inValue: SoftBodySharedSettingsFace): void;
reserve(inSize: number): void;
resize(inSize: number): void;
clear(): void;
}
class ArraySoftBodySharedSettingsEdge {
constructor();
empty(): boolean;
size(): number;
at(inIndex: number): SoftBodySharedSettingsEdge;
push_back(inValue: SoftBodySharedSettingsEdge): void;
reserve(inSize: number): void;
resize(inSize: number): void;
clear(): void;
}
class ArraySoftBodySharedSettingsDihedralBend {
constructor();
empty(): boolean;
size(): number;
at(inIndex: number): SoftBodySharedSettingsDihedralBend;
push_back(inValue: SoftBodySharedSettingsDihedralBend): void;
reserve(inSize: number): void;
resize(inSize: number): void;
clear(): void;
}
class ArraySoftBodySharedSettingsVolume {
constructor();
empty(): boolean;
size(): number;
at(inIndex: number): SoftBodySharedSettingsVolume;
push_back(inValue: SoftBodySharedSettingsVolume): void;
reserve(inSize: number): void;
resize(inSize: number): void;
clear(): void;
}
class ArraySoftBodySharedSettingsInvBind {
constructor();
empty(): boolean;
size(): number;
at(inIndex: number): SoftBodySharedSettingsInvBind;
push_back(inValue: SoftBodySharedSettingsInvBind): void;
reserve(inSize: number): void;
resize(inSize: number): void;
clear(): void;
}
class ArraySoftBodySharedSettingsSkinned {
constructor();
empty(): boolean;
size(): number;
at(inIndex: number): SoftBodySharedSettingsSkinned;
push_back(inValue: SoftBodySharedSettingsSkinned): void;
reserve(inSize: number): void;
resize(inSize: number): void;
clear(): void;
}
class ArraySoftBodySharedSettingsLRA {
constructor();
empty(): boolean;
size(): number;
at(inIndex: number): SoftBodySharedSettingsLRA;
push_back(inValue: SoftBodySharedSettingsLRA): void;
reserve(inSize: number): void;
resize(inSize: number): void;
clear(): void;
}
class ArraySoftBodySharedSettingsRodStretchShear {
constructor();
empty(): boolean;
size(): number;
at(inIndex: number): SoftBodySharedSettingsRodStretchShear;
push_back(inValue: SoftBodySharedSettingsRodStretchShear): void;
reserve(inSize: number): void;
resize(inSize: number): void;
clear(): void;
}
class ArraySoftBodySharedSettingsRodBendTwist {
constructor();
empty(): boolean;
size(): number;
at(inIndex: number): SoftBodySharedSettingsRodBendTwist;
push_back(inValue: SoftBodySharedSettingsRodBendTwist): void;
reserve(inSize: number): void;
resize(inSize: number): void;
clear(): void;
}
class SoftBodySharedSettingsVertexAttributes {
constructor();
get_mCompliance(): number;
set_mCompliance(mCompliance: number): void;
mCompliance: number;
get_mShearCompliance(): number;
set_mShearCompliance(mShearCompliance: number): void;
mShearCompliance: number;
get_mBendCompliance(): number;
set_mBendCompliance(mBendCompliance: number): void;
mBendCompliance: number;
get_mLRAType(): SoftBodySharedSettings_ELRAType;
set_mLRAType(mLRAType: SoftBodySharedSettings_ELRAType): void;
mLRAType: SoftBodySharedSettings_ELRAType;
get_mLRAMaxDistanceMultiplier(): number;
set_mLRAMaxDistanceMultiplier(mLRAMaxDistanceMultiplier: number): void;
mLRAMaxDistanceMultiplier: number;
}
class ArraySoftBodySharedSettingsVertexAttributes {
constructor();
empty(): boolean;
size(): number;
at(inIndex: number): SoftBodySharedSettingsVertexAttributes;
push_back(inValue: SoftBodySharedSettingsVertexAttributes): void;
reserve(inSize: number): void;
resize(inSize: number): void;
clear(): void;
data(): SoftBodySharedSettingsVertexAttributes;
}
class SoftBodySharedSettings {
constructor();
GetRefCount(): number;
AddRef(): void;
Release(): void;
CreateConstraints(
inVertexAttributes: SoftBodySharedSettingsVertexAttributes,
inVertexAttributesLength: number,
inBendType?: SoftBodySharedSettings_EBendType,
inAngleTolerance?: number
): void;
AddFace(inFace: SoftBodySharedSettingsFace): void;
CalculateEdgeLengths(): void;
CalculateRodProperties(): void;
CalculateLRALengths(): void;
CalculateBendConstraintConstants(): void;
CalculateVolumeConstraintVolumes(): void;
CalculateSkinnedConstraintNormals(): void;
Optimize(): void;
Clone(): SoftBodySharedSettings;
get_mVertices(): ArraySoftBodySharedSettingsVertex;
set_mVertices(mVertices: ArraySoftBodySharedSettingsVertex): void;
mVertices: ArraySoftBodySharedSettingsVertex;
get_mFaces(): ArraySoftBodySharedSettingsFace;
set_mFaces(mFaces: ArraySoftBodySharedSettingsFace): void;
mFaces: ArraySoftBodySharedSettingsFace;
get_mEdgeConstraints(): ArraySoftBodySharedSettingsEdge;
set_mEdgeConstraints(
mEdgeConstraints: ArraySoftBodySharedSettingsEdge
): void;
mEdgeConstraints: ArraySoftBodySharedSettingsEdge;
get_mDihedralBendConstraints(): ArraySoftBodySharedSettingsDihedralBend;
set_mDihedralBendConstraints(
mDihedralBendConstraints: ArraySoftBodySharedSettingsDihedralBend
): void;
mDihedralBendConstraints: ArraySoftBodySharedSettingsDihedralBend;
get_mVolumeConstraints(): ArraySoftBodySharedSettingsVolume;
set_mVolumeConstraints(
mVolumeConstraints: ArraySoftBodySharedSettingsVolume
): void;
mVolumeConstraints: ArraySoftBodySharedSettingsVolume;
get_mSkinnedConstraints(): ArraySoftBodySharedSettingsSkinned;
set_mSkinnedConstraints(
mSkinnedConstraints: ArraySoftBodySharedSettingsSkinned
): void;
mSkinnedConstraints: ArraySoftBodySharedSettingsSkinned;
get_mInvBindMatrices(): ArraySoftBodySharedSettingsInvBind;
set_mInvBindMatrices(
mInvBindMatrices: ArraySoftBodySharedSettingsInvBind
): void;
mInvBindMatrices: ArraySoftBodySharedSettingsInvBind;
get_mLRAConstraints(): ArraySoftBodySharedSettingsLRA;
set_mLRAConstraints(mLRAConstraints: ArraySoftBodySharedSettingsLRA): void;
mLRAConstraints: ArraySoftBodySharedSettingsLRA;
get_mRodStretchShearConstraints(): ArraySoftBodySharedSettingsRodStretchShear;
set_mRodStretchShearConstraints(
mRodStretchShearConstraints: ArraySoftBodySharedSettingsRodStretchShear
): void;
mRodStretchShearConstraints: ArraySoftBodySharedSettingsRodStretchShear;
get_mRodBendTwistConstraints(): ArraySoftBodySharedSettingsRodBendTwist;
set_mRodBendTwistConstraints(
mRodBendTwistConstraints: ArraySoftBodySharedSettingsRodBendTwist
): void;
mRodBendTwistConstraints: ArraySoftBodySharedSettingsRodBendTwist;
get_mMaterials(): PhysicsMaterialList;
set_mMaterials(mMaterials: PhysicsMaterialList): void;
mMaterials: PhysicsMaterialList;
}
class SoftBodyCreationSettings {
constructor(
inSettings: SoftBodySharedSettings,
inPosition: RVec3,
inRotation: Quat,
inObjectLayer: number
);
get_mPosition(): RVec3;
set_mPosition(mPosition: RVec3): void;
mPosition: RVec3;
get_mRotation(): Quat;
set_mRotation(mRotation: Quat): void;
mRotation: Quat;
get_mUserData(): number;
set_mUserData(mUserData: number): void;
mUserData: number;
get_mObjectLayer(): number;
set_mObjectLayer(mObjectLayer: number): void;
mObjectLayer: number;
get_mCollisionGroup(): CollisionGroup;
set_mCollisionGroup(mCollisionGroup: CollisionGroup): void;
mCollisionGroup: CollisionGroup;
get_mNumIterations(): number;
set_mNumIterations(mNumIterations: number): void;
mNumIterations: number;
get_mLinearDamping(): number;
set_mLinearDamping(mLinearDamping: number): void;
mLinearDamping: number;
get_mMaxLinearVelocity(): number;
set_mMaxLinearVelocity(mMaxLinearVelocity: number): void;
mMaxLinearVelocity: number;
get_mRestitution(): number;
set_mRestitution(mRestitution: number): void;
mRestitution: number;
get_mFriction(): number;
set_mFriction(mFriction: number): void;
mFriction: number;
get_mPressure(): number;
set_mPressure(mPressure: number): void;
mPressure: number;
get_mGravityFactor(): number;
set_mGravityFactor(mGravityFactor: number): void;
mGravityFactor: number;
get_mVertexRadius(): number;
set_mVertexRadius(mVertexRadius: number): void;
mVertexRadius: number;
get_mUpdatePosition(): boolean;
set_mUpdatePosition(mUpdatePosition: boolean): void;
mUpdatePosition: boolean;
get_mMakeRotationIdentity(): boolean;
set_mMakeRotationIdentity(mMakeRotationIdentity: boolean): void;
mMakeRotationIdentity: boolean;
get_mAllowSleeping(): boolean;
set_mAllowSleeping(mAllowSleeping: boolean): void;
mAllowSleeping: boolean;
get_mFacesDoubleSided(): boolean;
set_mFacesDoubleSided(mFacesDoubleSided: boolean): void;
mFacesDoubleSided: boolean;
}
class SoftBodyVertex {
get_mPreviousPosition(): Vec3;
set_mPreviousPosition(mPreviousPosition: Vec3): void;
mPreviousPosition: Vec3;
get_mPosition(): Vec3;
set_mPosition(mPosition: Vec3): void;
mPosition: Vec3;
get_mVelocity(): Vec3;
set_mVelocity(mVelocity: Vec3): void;
mVelocity: Vec3;
get_mInvMass(): number;
set_mInvMass(mInvMass: number): void;
mInvMass: number;
}
class SoftBodyVertexTraits {
get_mPreviousPositionOffset(): number;
set_mPreviousPositionOffset(mPreviousPositionOffset: number): void;
readonly mPreviousPositionOffset: number;
get_mPositionOffset(): number;
set_mPositionOffset(mPositionOffset: number): void;
readonly mPositionOffset: number;
get_mVelocityOffset(): number;
set_mVelocityOffset(mVelocityOffset: number): void;
readonly mVelocityOffset: number;
}
class ArraySoftBodyVertex {
constructor();
empty(): boolean;
size(): number;
at(inIndex: number): SoftBodyVertex;
push_back(inValue: SoftBodyVertex): void;
reserve(inSize: number): void;
resize(inSize: number): void;
clear(): void;
}
class SoftBodyMotionProperties extends MotionProperties {
GetSettings(): SoftBodySharedSettings;
GetVertices(): ArraySoftBodyVertex;
GetVertex(inIndex: number): SoftBodyVertex;
GetRodRotation(inIndex: number): Quat;
GetRodAngularVelocity(inIndex: number): Vec3;
GetMaterials(): PhysicsMaterialList;
GetFaces(): ArraySoftBodySharedSettingsFace;
GetFace(inIndex: number): SoftBodySharedSettingsFace;
GetNumIterations(): number;
SetNumIterations(inNumIterations: number): void;
GetPressure(): number;
SetPressure(inPressure: number): void;
GetUpdatePosition(): boolean;
SetUpdatePosition(inUpdatePosition: boolean): void;
GetEnableSkinConstraints(): boolean;
SetEnableSkinConstraints(inEnableSkinConstraints: boolean): void;
GetSkinnedMaxDistanceMultiplier(): number;
SetSkinnedMaxDistanceMultiplier(
inSkinnedMaxDistanceMultiplier: number
): void;
GetVertexRadius(): number;
SetVertexRadius(inVertexRadius: number): void;
GetLocalBounds(): AABox;
CustomUpdate(
inDeltaTime: number,
ioSoftBody: Body,
inSystem: PhysicsSystem
): void;
SkinVertices(
inRootTransform: RMat44,
inJointMatrices: Mat44MemRef,
inNumJoints: number,
inHardSkinAll: boolean,
ioTempAllocator: TempAllocator
): void;
}
class SoftBodyShape extends Shape {
GetSubShapeIDBits(): number;
GetFaceIndex(inSubShapeID: SubShapeID): number;
}
class CharacterBaseSettings {
GetRefCount(): number;
AddRef(): void;
Release(): void;
get_mUp(): Vec3;
set_mUp(mUp: Vec3): void;
mUp: Vec3;
get_mSupportingVolume(): Plane;
set_mSupportingVolume(mSupportingVolume: Plane): void;
mSupportingVolume: Plane;
get_mMaxSlopeAngle(): number;
set_mMaxSlopeAngle(mMaxSlopeAngle: number): void;
mMaxSlopeAngle: number;
get_mEnhancedInternalEdgeRemoval(): boolean;
set_mEnhancedInternalEdgeRemoval(
mEnhancedInternalEdgeRemoval: boolean
): void;
mEnhancedInternalEdgeRemoval: boolean;
get_mShape(): Shape;
set_mShape(mShape: Shape): void;
mShape: Shape;
}
class CharacterID {
constructor();
GetValue(): number;
IsInvalid(): boolean;
sNextCharacterID(): CharacterID;
sSetNextCharacterID(inNextValue: number): void;
}
class CharacterVirtualSettings extends CharacterBaseSettings {
constructor();
get_mID(): CharacterID;
set_mID(mID: CharacterID): void;
mID: CharacterID;
get_mMass(): number;
set_mMass(mMass: number): void;
mMass: number;
get_mMaxStrength(): number;
set_mMaxStrength(mMaxStrength: number): void;
mMaxStrength: number;
get_mShapeOffset(): Vec3;
set_mShapeOffset(mShapeOffset: Vec3): void;
mShapeOffset: Vec3;
get_mBackFaceMode(): EBackFaceMode;
set_mBackFaceMode(mBackFaceMode: EBackFaceMode): void;
mBackFaceMode: EBackFaceMode;
get_mPredictiveContactDistance(): number;
set_mPredictiveContactDistance(mPredictiveContactDistance: number): void;
mPredictiveContactDistance: number;
get_mMaxCollisionIterations(): number;
set_mMaxCollisionIterations(mMaxCollisionIterations: number): void;
mMaxCollisionIterations: number;
get_mMaxConstraintIterations(): number;
set_mMaxConstraintIterations(mMaxConstraintIterations: number): void;
mMaxConstraintIterations: number;
get_mMinTimeRemaining(): number;
set_mMinTimeRemaining(mMinTimeRemaining: number): void;
mMinTimeRemaining: number;
get_mCollisionTolerance(): number;
set_mCollisionTolerance(mCollisionTolerance: number): void;
mCollisionTolerance: number;
get_mCharacterPadding(): number;
set_mCharacterPadding(mCharacterPadding: number): void;
mCharacterPadding: number;
get_mMaxNumHits(): number;
set_mMaxNumHits(mMaxNumHits: number): void;
mMaxNumHits: number;
get_mHitReductionCosMaxAngle(): number;
set_mHitReductionCosMaxAngle(mHitReductionCosMaxAngle: number): void;
mHitReductionCosMaxAngle: number;
get_mPenetrationRecoverySpeed(): number;
set_mPenetrationRecoverySpeed(mPenetrationRecoverySpeed: number): void;
mPenetrationRecoverySpeed: number;
get_mInnerBodyShape(): Shape;
set_mInnerBodyShape(mInnerBodyShape: Shape): void;
mInnerBodyShape: Shape;
get_mInnerBodyIDOverride(): BodyID;
set_mInnerBodyIDOverride(mInnerBodyIDOverride: BodyID): void;
mInnerBodyIDOverride: BodyID;
get_mInnerBodyLayer(): number;
set_mInnerBodyLayer(mInnerBodyLayer: number): void;
mInnerBodyLayer: number;
}
class CharacterContactSettings {
constructor();
get_mCanPushCharacter(): boolean;
set_mCanPushCharacter(mCanPushCharacter: boolean): void;
mCanPushCharacter: boolean;
get_mCanReceiveImpulses(): boolean;
set_mCanReceiveImpulses(mCanReceiveImpulses: boolean): void;
mCanReceiveImpulses: boolean;
}
class CharacterContactListener {}
class CharacterContactListenerEm extends CharacterContactListener {}
class CharacterContactListenerJS extends CharacterContactListenerEm {
constructor();
OnAdjustBodyVelocity(
inCharacter: number,
inBody2: number,
ioLinearVelocity: number,
ioAngularVelocity: number
): void;
OnContactValidate(
inCharacter: number,
inBodyID2: number,
inSubShapeID2: number
): boolean;
OnCharacterContactValidate(
inCharacter: number,
inOtherCharacter: number,
inSubShapeID2: number
): boolean;
OnContactAdded(
inCharacter: number,
inBodyID2: number,
inSubShapeID2: number,
inContactPosition: number,
inContactNormal: number,
ioSettings: number
): void;
OnContactPersisted(
inCharacter: number,
inBodyID2: number,
inSubShapeID2: number,
inContactPosition: number,
inContactNormal: number,
ioSettings: number
): void;
OnContactRemoved(
inCharacter: number,
inBodyID2: number,
inSubShapeID2: number
): void;
OnCharacterContactAdded(
inCharacter: number,
inOtherCharacter: number,
inSubShapeID2: number,
inContactPosition: number,
inContactNormal: number,
ioSettings: number
): void;
OnCharacterContactPersisted(
inCharacter: number,
inOtherCharacter: number,
inSubShapeID2: number,
inContactPosition: number,
inContactNormal: number,
ioSettings: number
): void;
OnCharacterContactRemoved(
inCharacter: number,
inOtherCharacter: number,
inSubShapeID2: number
): void;
OnContactSolve(
inCharacter: number,
inBodyID2: number,
inSubShapeID2: number,
inContactPosition: number,
inContactNormal: number,
inContactVelocity: number,
inContactMaterial: number,
inCharacterVelocity: number,
ioNewCharacterVelocity: number
): void;
OnCharacterContactSolve(
inCharacter: number,
inOtherCharacter: number,
inSubShapeID2: number,
inContactPosition: number,
inContactNormal: number,
inContactVelocity: number,
inContactMaterial: number,
inCharacterVelocity: number,
ioNewCharacterVelocity: number
): void;
}
class CharacterVsCharacterCollision {}
class CharacterVsCharacterCollisionSimple extends CharacterVsCharacterCollision {
constructor();
Add(inCharacter: CharacterVirtual): void;
Remove(inCharacter: CharacterVirtual): void;
}
class ExtendedUpdateSettings {
constructor();
get_mStickToFloorStepDown(): Vec3;
set_mStickToFloorStepDown(mStickToFloorStepDown: Vec3): void;
mStickToFloorStepDown: Vec3;
get_mWalkStairsStepUp(): Vec3;
set_mWalkStairsStepUp(mWalkStairsStepUp: Vec3): void;
mWalkStairsStepUp: Vec3;
get_mWalkStairsMinStepForward(): number;
set_mWalkStairsMinStepForward(mWalkStairsMinStepForward: number): void;
mWalkStairsMinStepForward: number;
get_mWalkStairsStepForwardTest(): number;
set_mWalkStairsStepForwardTest(mWalkStairsStepForwardTest: number): void;
mWalkStairsStepForwardTest: number;
get_mWalkStairsCosAngleForwardContact(): number;
set_mWalkStairsCosAngleForwardContact(
mWalkStairsCosAngleForwardContact: number
): void;
mWalkStairsCosAngleForwardContact: number;
get_mWalkStairsStepDownExtra(): Vec3;
set_mWalkStairsStepDownExtra(mWalkStairsStepDownExtra: Vec3): void;
mWalkStairsStepDownExtra: Vec3;
}
class CharacterVirtualContact {
IsSameBody(inOther: CharacterVirtualContact): boolean;
get_mPosition(): RVec3;
set_mPosition(mPosition: RVec3): void;
mPosition: RVec3;
get_mLinearVelocity(): Vec3;
set_mLinearVelocity(mLinearVelocity: Vec3): void;
mLinearVelocity: Vec3;
get_mContactNormal(): Vec3;
set_mContactNormal(mContactNormal: Vec3): void;
mContactNormal: Vec3;
get_mSurfaceNormal(): Vec3;
set_mSurfaceNormal(mSurfaceNormal: Vec3): void;
mSurfaceNormal: Vec3;
get_mDistance(): number;
set_mDistance(mDistance: number): void;
mDistance: number;
get_mFraction(): number;
set_mFraction(mFraction: number): void;
mFraction: number;
get_mBodyB(): BodyID;
set_mBodyB(mBodyB: BodyID): void;
mBodyB: BodyID;
get_mCharacterIDB(): CharacterID;
set_mCharacterIDB(mCharacterIDB: CharacterID): void;
mCharacterIDB: CharacterID;
get_mSubShapeIDB(): SubShapeID;
set_mSubShapeIDB(mSubShapeIDB: SubShapeID): void;
mSubShapeIDB: SubShapeID;
get_mMotionTypeB(): EMotionType;
set_mMotionTypeB(mMotionTypeB: EMotionType): void;
mMotionTypeB: EMotionType;
get_mIsSensorB(): boolean;
set_mIsSensorB(mIsSensorB: boolean): void;
mIsSensorB: boolean;
get_mCharacterB(): CharacterVirtual;
set_mCharacterB(mCharacterB: CharacterVirtual): void;
mCharacterB: CharacterVirtual;
get_mUserData(): number;
set_mUserData(mUserData: number): void;
mUserData: number;
get_mMaterial(): PhysicsMaterial;
set_mMaterial(mMaterial: PhysicsMaterial): void;
mMaterial: PhysicsMaterial;
get_mHadCollision(): boolean;
set_mHadCollision(mHadCollision: boolean): void;
mHadCollision: boolean;
get_mWasDiscarded(): boolean;
set_mWasDiscarded(mWasDiscarded: boolean): void;
mWasDiscarded: boolean;
get_mCanPushCharacter(): boolean;
set_mCanPushCharacter(mCanPushCharacter: boolean): void;
mCanPushCharacter: boolean;
}
class ArrayCharacterVirtualContact {
constructor();
empty(): boolean;
size(): number;
at(inIndex: number): CharacterVirtualContact;
}
class TempAllocator {}
class BroadPhaseLayerFilter {
constructor();
}
class ObjectVsBroadPhaseLayerFilter {
constructor();
}
class ObjectVsBroadPhaseLayerFilterEm extends ObjectVsBroadPhaseLayerFilter {}
class ObjectVsBroadPhaseLayerFilterJS extends ObjectVsBroadPhaseLayerFilterEm {
constructor();
ShouldCollide(inLayer1: number, inLayer2: number): boolean;
}
class DefaultBroadPhaseLayerFilter extends ObjectLayerFilter {
constructor(inFilter: ObjectVsBroadPhaseLayerFilter, inObjectLayer: number);
}
class ObjectLayerFilter {
constructor();
}
class ObjectLayerFilterJS extends ObjectLayerFilter {
constructor();
ShouldCollide(inLayer: number): boolean;
}
class ObjectLayerPairFilter {
constructor();
ShouldCollide(inLayer1: number, inLayer2: number): boolean;
}
class ObjectLayerPairFilterJS extends ObjectLayerPairFilter {
constructor();
ShouldCollide(inLayer1: number, inLayer2: number): boolean;
}
class DefaultObjectLayerFilter extends ObjectLayerFilter {
constructor(inFilter: ObjectLayerPairFilter, inObjectLayer: number);
}
class SpecifiedObjectLayerFilter extends ObjectLayerFilter {
constructor(inObjectLayer: number);
}
class BodyFilter {
constructor();
}
class BodyFilterJS extends BodyFilter {
constructor();
ShouldCollide(inBodyID: number): boolean;
ShouldCollideLocked(inBody: number): boolean;
}
class IgnoreSingleBodyFilter extends BodyFilter {
constructor(inBodyID: BodyID);
}
class IgnoreMultipleBodiesFilter extends BodyFilter {
constructor();
Clear(): void;
Reserve(inSize: number): void;
IgnoreBody(inBodyID: BodyID): void;
}
class ShapeFilter {
constructor();
}
class ShapeFilterJS extends ShapeFilter {
constructor();
ShouldCollide(inShape2: number, inSubShapeIDOfShape2: number): boolean;
}
class ShapeFilterJS2 extends ShapeFilter {
constructor();
ShouldCollide(
inShape1: number,
inSubShapeIDOfShape1: number,
inShape2: number,
inSubShapeIDOfShape2: number
): boolean;
}
class SimShapeFilter {
constructor();
}
class SimShapeFilterJS extends SimShapeFilter {
constructor();
ShouldCollide(
inBody1: number,
inShape1: number,
inSubShapeIDOfShape1: number,
inBody2: number,
inShape2: number,
inSubShapeIDOfShape2: number
): boolean;
}
class CharacterBase {
GetRefCount(): number;
AddRef(): void;
Release(): void;
SetMaxSlopeAngle(inMaxSlopeAngle: number): void;
GetCosMaxSlopeAngle(): number;
SetUp(inUp: Vec3): void;
GetUp(): Vec3;
GetShape(): Shape;
GetGroundState(): EGroundState;
IsSlopeTooSteep(inNormal: Vec3): boolean;
IsSupported(): boolean;
GetGroundPosition(): RVec3;
GetGroundNormal(): Vec3;
GetGroundVelocity(): Vec3;
GetGroundMaterial(): PhysicsMaterial;
GetGroundBodyID(): BodyID;
SaveState(inStream: StateRecorder): void;
RestoreState(inStream: StateRecorder): void;
}
class CharacterVirtual extends CharacterBase {
constructor(
inSettings: CharacterVirtualSettings,
inPosition: RVec3,
inRotation: Quat,
inSystem: PhysicsSystem
);
GetID(): CharacterID;
SetListener(inListener: CharacterContactListener): void;
SetCharacterVsCharacterCollision(
inCharacterVsCharacterCollision: CharacterVsCharacterCollision
): void;
GetListener(): CharacterContactListener;
GetLinearVelocity(): Vec3;
SetLinearVelocity(inLinearVelocity: Vec3): void;
GetPosition(): RVec3;
SetPosition(inPosition: RVec3): void;
GetRotation(): Quat;
SetRotation(inRotation: Quat): void;
GetCenterOfMassPosition(): RVec3;
GetWorldTransform(): RMat44;
GetCenterOfMassTransform(): RMat44;
GetMass(): number;
SetMass(inMass: number): void;
GetMaxStrength(): number;
SetMaxStrength(inMaxStrength: number): void;
GetPenetrationRecoverySpeed(): number;
SetPenetrationRecoverySpeed(inSpeed: number): void;
GetCharacterPadding(): number;
GetMaxNumHits(): number;
SetMaxNumHits(inMaxHits: number): void;
GetHitReductionCosMaxAngle(): number;
SetHitReductionCosMaxAngle(inCosMaxAngle: number): void;
GetMaxHitsExceeded(): boolean;
GetShapeOffset(): Vec3;
SetShapeOffset(inShapeOffset: Vec3): void;
GetUserData(): number;
SetUserData(inUserData: number): void;
GetInnerBodyID(): BodyID;
StartTrackingContactChanges(): void;
FinishTrackingContactChanges(): void;
CancelVelocityTowardsSteepSlopes(inDesiredVelocity: Vec3): Vec3;
Update(
inDeltaTime: number,
inGravity: Vec3,
inBroadPhaseLayerFilter: BroadPhaseLayerFilter,
inObjectLayerFilter: ObjectLayerFilter,
inBodyFilter: BodyFilter,
inShapeFilter: ShapeFilter,
inAllocator: TempAllocator
): void;
CanWalkStairs(inLinearVelocity: Vec3): boolean;
WalkStairs(
inDeltaTime: number,
inStepUp: Vec3,
inStepForward: Vec3,
inStepForwardTest: Vec3,
inStepDownExtra: Vec3,
inBroadPhaseLayerFilter: BroadPhaseLayerFilter,
inObjectLayerFilter: ObjectLayerFilter,
inBodyFilter: BodyFilter,
inShapeFilter: ShapeFilter,
inAllocator: TempAllocator
): boolean;
StickToFloor(
inStepDown: Vec3,
inBroadPhaseLayerFilter: BroadPhaseLayerFilter,
inObjectLayerFilter: ObjectLayerFilter,
inBodyFilter: BodyFilter,
inShapeFilter: ShapeFilter,
inAllocator: TempAllocator
): boolean;
ExtendedUpdate(
inDeltaTime: number,
inGravity: Vec3,
inSettings: ExtendedUpdateSettings,
inBroadPhaseLayerFilter: BroadPhaseLayerFilter,
inObjectLayerFilter: ObjectLayerFilter,
inBodyFilter: BodyFilter,
inShapeFilter: ShapeFilter,
inAllocator: TempAllocator
): void;
RefreshContacts(
inBroadPhaseLayerFilter: BroadPhaseLayerFilter,
inObjectLayerFilter: ObjectLayerFilter,
inBodyFilter: BodyFilter,
inShapeFilter: ShapeFilter,
inAllocator: TempAllocator
): void;
UpdateGroundVelocity(): void;
SetShape(
inShape: Shape,
inMaxPenetrationDepth: number,
inBroadPhaseLayerFilter: BroadPhaseLayerFilter,
inObjectLayerFilter: ObjectLayerFilter,
inBodyFilter: BodyFilter,
inShapeFilter: ShapeFilter,
inAllocator: TempAllocator
): boolean;
SetInnerBodyShape(inShape: Shape): void;
GetTransformedShape(): TransformedShape;
HasCollidedWith(inBodyID: BodyID): boolean;
HasCollidedWithCharacterID(inCharacterID: CharacterID): boolean;
HasCollidedWithCharacter(inCharacter: CharacterVirtual): boolean;
GetActiveContacts(): ArrayCharacterVirtualContact;
}
class LinearCurve {
constructor();
Clear(): void;
Reserve(inSize: number): void;
AddPoint(inX: number, inY: number): void;
Sort(): void;
GetMinX(): number;
GetMaxX(): number;
GetValue(inX: number): number;
}
class ArrayFloat {
constructor();
empty(): boolean;
size(): number;
at(inIndex: number): number;
push_back(inValue: number): void;
reserve(inSize: number): void;
resize(inSize: number): void;
clear(): void;
data(): FloatMemRef;
}
class ArrayUint {
constructor();
empty(): boolean;
size(): number;
at(inIndex: number): number;
push_back(inValue: number): void;
reserve(inSize: number): void;
resize(inSize: number): void;
clear(): void;
data(): UintMemRef;
}
class ArrayUint8 {
constructor();
empty(): boolean;
size(): number;
at(inIndex: number): number;
push_back(inValue: number): void;
reserve(inSize: number): void;
resize(inSize: number): void;
clear(): void;
data(): Uint8MemRef;
}
class ArrayVehicleAntiRollBar {
constructor();
empty(): boolean;
size(): number;
at(inIndex: number): VehicleAntiRollBar;
push_back(inValue: VehicleAntiRollBar): void;
resize(inSize: number): void;
clear(): void;
}
class ArrayWheelSettings {
constructor();
empty(): boolean;
size(): number;
at(inIndex: number): WheelSettings;
push_back(inValue: WheelSettings): void;
resize(inSize: number): void;
clear(): void;
}
class ArrayVehicleDifferentialSettings {
constructor();
empty(): boolean;
size(): number;
at(inIndex: number): VehicleDifferentialSettings;
push_back(inValue: VehicleDifferentialSettings): void;
resize(inSize: number): void;
clear(): void;
}
class VehicleCollisionTester {
GetRefCount(): number;
AddRef(): void;
Release(): void;
}
class VehicleCollisionTesterRay extends VehicleCollisionTester {
constructor(inObjectLayer: number, inUp?: Vec3, inMaxSlopeAngle?: number);
}
class VehicleCollisionTesterCastSphere extends VehicleCollisionTester {
constructor(
inObjectLayer: number,
inRadius: number,
inUp?: Vec3,
inMaxSlopeAngle?: number
);
}
class VehicleCollisionTesterCastCylinder extends VehicleCollisionTester {
constructor(inObjectLayer: number, inConvexRadiusFraction?: number);
}
class VehicleConstraintSettings extends ConstraintSettings {
constructor();
get_mUp(): Vec3;
set_mUp(mUp: Vec3): void;
mUp: Vec3;
get_mForward(): Vec3;
set_mForward(mForward: Vec3): void;
mForward: Vec3;
get_mMaxPitchRollAngle(): number;
set_mMaxPitchRollAngle(mMaxPitchRollAngle: number): void;
mMaxPitchRollAngle: number;
get_mWheels(): ArrayWheelSettings;
set_mWheels(mWheels: ArrayWheelSettings): void;
mWheels: ArrayWheelSettings;
get_mAntiRollBars(): ArrayVehicleAntiRollBar;
set_mAntiRollBars(mAntiRollBars: ArrayVehicleAntiRollBar): void;
mAntiRollBars: ArrayVehicleAntiRollBar;
get_mController(): VehicleControllerSettings;
set_mController(mController: VehicleControllerSettings): void;
mController: VehicleControllerSettings;
}
class VehicleConstraint extends Constraint {
constructor(inVehicleBody: Body, inSettings: VehicleConstraintSettings);
SetMaxPitchRollAngle(inMaxPitchRollAngle: number): void;
GetMaxPitchRollAngle(): number;
SetVehicleCollisionTester(inTester: VehicleCollisionTester): void;
GetVehicleCollisionTester(): VehicleCollisionTester;
OverrideGravity(inGravity: Vec3): void;
IsGravityOverridden(): boolean;
GetGravityOverride(): Vec3;
ResetGravityOverride(): void;
GetLocalUp(): Vec3;
GetLocalForward(): Vec3;
GetWorldUp(): Vec3;
GetVehicleBody(): Body;
GetController(): VehicleController;
GetWheel(inIdx: number): Wheel;
GetWheelLocalTransform(
inWheelIndex: number,
inWheelRight: Vec3,
inWheelUp: Vec3
): Mat44;
GetWheelWorldTransform(
inWheelIndex: number,
inWheelRight: Vec3,
inWheelUp: Vec3
): RMat44;
GetAntiRollBars(): ArrayVehicleAntiRollBar;
SetNumStepsBetweenCollisionTestActive(inSteps: number): void;
GetNumStepsBetweenCollisionTestActive(): number;
SetNumStepsBetweenCollisionTestInactive(inSteps: number): void;
GetNumStepsBetweenCollisionTestInactive(): number;
}
class VehicleConstraintStepListener extends PhysicsStepListener {
constructor(inConstraint: VehicleConstraint);
}
class VehicleConstraintCallbacksEm {
SetVehicleConstraint(inConstraint: VehicleConstraint): void;
}
class VehicleConstraintCallbacksJS extends VehicleConstraintCallbacksEm {
constructor();
GetCombinedFriction(
inWheelIndex: number,
inTireFrictionDirection: number,
inTireFriction: number,
inBody2: number,
inSubShapeID2: number
): number;
OnPreStepCallback(inVehicle: number, inContext: number): void;
OnPostCollideCallback(inVehicle: number, inContext: number): void;
OnPostStepCallback(inVehicle: number, inContext: number): void;
}
class TireMaxImpulseCallbackResult {
get_mLongitudinalImpulse(): number;
set_mLongitudinalImpulse(mLongitudinalImpulse: number): void;
mLongitudinalImpulse: number;
get_mLateralImpulse(): number;
set_mLateralImpulse(mLateralImpulse: number): void;
mLateralImpulse: number;
}
class WheeledVehicleControllerCallbacksEm {
SetWheeledVehicleController(inController: WheeledVehicleController): void;
}
class WheeledVehicleControllerCallbacksJS extends WheeledVehicleControllerCallbacksEm {
constructor();
OnTireMaxImpulseCallback(
inWheelIndex: number,
outResult: number,
inSuspensionImpulse: number,
inLongitudinalFriction: number,
inLateralFriction: number,
inLongitudinalSlip: number,
inLateralSlip: number,
inDeltaTime: number
): void;
}
class WheelSettings {
constructor();
GetRefCount(): number;
AddRef(): void;
Release(): void;
get_mPosition(): Vec3;
set_mPosition(mPosition: Vec3): void;
mPosition: Vec3;
get_mSuspensionForcePoint(): Vec3;
set_mSuspensionForcePoint(mSuspensionForcePoint: Vec3): void;
mSuspensionForcePoint: Vec3;
get_mSuspensionDirection(): Vec3;
set_mSuspensionDirection(mSuspensionDirection: Vec3): void;
mSuspensionDirection: Vec3;
get_mSteeringAxis(): Vec3;
set_mSteeringAxis(mSteeringAxis: Vec3): void;
mSteeringAxis: Vec3;
get_mWheelUp(): Vec3;
set_mWheelUp(mWheelUp: Vec3): void;
mWheelUp: Vec3;
get_mWheelForward(): Vec3;
set_mWheelForward(mWheelForward: Vec3): void;
mWheelForward: Vec3;
get_mSuspensionSpring(): SpringSettings;
set_mSuspensionSpring(mSuspensionSpring: SpringSettings): void;
mSuspensionSpring: SpringSettings;
get_mSuspensionMinLength(): number;
set_mSuspensionMinLength(mSuspensionMinLength: number): void;
mSuspensionMinLength: number;
get_mSuspensionMaxLength(): number;
set_mSuspensionMaxLength(mSuspensionMaxLength: number): void;
mSuspensionMaxLength: number;
get_mSuspensionPreloadLength(): number;
set_mSuspensionPreloadLength(mSuspensionPreloadLength: number): void;
mSuspensionPreloadLength: number;
get_mRadius(): number;
set_mRadius(mRadius: number): void;
mRadius: number;
get_mWidth(): number;
set_mWidth(mWidth: number): void;
mWidth: number;
get_mEnableSuspensionForcePoint(): boolean;
set_mEnableSuspensionForcePoint(mEnableSuspensionForcePoint: boolean): void;
mEnableSuspensionForcePoint: boolean;
}
class VehicleAntiRollBar {
constructor();
get_mLeftWheel(): number;
set_mLeftWheel(mLeftWheel: number): void;
mLeftWheel: number;
get_mRightWheel(): number;
set_mRightWheel(mRightWheel: number): void;
mRightWheel: number;
get_mStiffness(): number;
set_mStiffness(mStiffness: number): void;
mStiffness: number;
}
class Wheel {
constructor(inSettings: WheelSettings);
GetSettings(): WheelSettings;
GetAngularVelocity(): number;
SetAngularVelocity(inVel: number): void;
GetRotationAngle(): number;
SetRotationAngle(inAngle: number): void;
GetSteerAngle(): number;
SetSteerAngle(inAngle: number): void;
HasContact(): boolean;
GetContactBodyID(): BodyID;
GetContactPosition(): RVec3;
GetContactPointVelocity(): Vec3;
GetContactNormal(): Vec3;
GetContactLongitudinal(): Vec3;
GetContactLateral(): Vec3;
GetSuspensionLength(): number;
HasHitHardPoint(): boolean;
GetSuspensionLambda(): number;
GetLongitudinalLambda(): number;
GetLateralLambda(): number;
}
class WheelSettingsWV extends WheelSettings {
constructor();
get_mInertia(): number;
set_mInertia(mInertia: number): void;
mInertia: number;
get_mAngularDamping(): number;
set_mAngularDamping(mAngularDamping: number): void;
mAngularDamping: number;
get_mMaxSteerAngle(): number;
set_mMaxSteerAngle(mMaxSteerAngle: number): void;
mMaxSteerAngle: number;
get_mLongitudinalFriction(): LinearCurve;
set_mLongitudinalFriction(mLongitudinalFriction: LinearCurve): void;
mLongitudinalFriction: LinearCurve;
get_mLateralFriction(): LinearCurve;
set_mLateralFriction(mLateralFriction: LinearCurve): void;
mLateralFriction: LinearCurve;
get_mMaxBrakeTorque(): number;
set_mMaxBrakeTorque(mMaxBrakeTorque: number): void;
mMaxBrakeTorque: number;
get_mMaxHandBrakeTorque(): number;
set_mMaxHandBrakeTorque(mMaxHandBrakeTorque: number): void;
mMaxHandBrakeTorque: number;
}
class WheelWV extends Wheel {
constructor(inWheel: WheelSettingsWV);
GetSettings(): WheelSettingsWV;
get_mLongitudinalSlip(): number;
set_mLongitudinalSlip(mLongitudinalSlip: number): void;
mLongitudinalSlip: number;
get_mLateralSlip(): number;
set_mLateralSlip(mLateralSlip: number): void;
mLateralSlip: number;
get_mCombinedLongitudinalFriction(): number;
set_mCombinedLongitudinalFriction(
mCombinedLongitudinalFriction: number
): void;
mCombinedLongitudinalFriction: number;
get_mCombinedLateralFriction(): number;
set_mCombinedLateralFriction(mCombinedLateralFriction: number): void;
mCombinedLateralFriction: number;
get_mBrakeImpulse(): number;
set_mBrakeImpulse(mBrakeImpulse: number): void;
mBrakeImpulse: number;
}
class WheelSettingsTV extends WheelSettings {
constructor();
get_mLongitudinalFriction(): number;
set_mLongitudinalFriction(mLongitudinalFriction: number): void;
mLongitudinalFriction: number;
get_mLateralFriction(): number;
set_mLateralFriction(mLateralFriction: number): void;
mLateralFriction: number;
}
class WheelTV extends Wheel {
constructor(inWheel: WheelSettingsTV);
GetSettings(): WheelSettingsTV;
get_mTrackIndex(): number;
set_mTrackIndex(mTrackIndex: number): void;
mTrackIndex: number;
get_mCombinedLongitudinalFriction(): number;
set_mCombinedLongitudinalFriction(
mCombinedLongitudinalFriction: number
): void;
mCombinedLongitudinalFriction: number;
get_mCombinedLateralFriction(): number;
set_mCombinedLateralFriction(mCombinedLateralFriction: number): void;
mCombinedLateralFriction: number;
get_mBrakeImpulse(): number;
set_mBrakeImpulse(mBrakeImpulse: number): void;
mBrakeImpulse: number;
}
class VehicleTrackSettings {
get_mDrivenWheel(): number;
set_mDrivenWheel(mDrivenWheel: number): void;
mDrivenWheel: number;
get_mWheels(): ArrayUint;
set_mWheels(mWheels: ArrayUint): void;
mWheels: ArrayUint;
get_mInertia(): number;
set_mInertia(mInertia: number): void;
mInertia: number;
get_mAngularDamping(): number;
set_mAngularDamping(mAngularDamping: number): void;
mAngularDamping: number;
get_mMaxBrakeTorque(): number;
set_mMaxBrakeTorque(mMaxBrakeTorque: number): void;
mMaxBrakeTorque: number;
get_mDifferentialRatio(): number;
set_mDifferentialRatio(mDifferentialRatio: number): void;
mDifferentialRatio: number;
}
class VehicleTrack extends VehicleTrackSettings {
get_mAngularVelocity(): number;
set_mAngularVelocity(mAngularVelocity: number): void;
mAngularVelocity: number;
}
class WheeledVehicleControllerSettings extends VehicleControllerSettings {
constructor();
get_mEngine(): VehicleEngineSettings;
set_mEngine(mEngine: VehicleEngineSettings): void;
mEngine: VehicleEngineSettings;
get_mTransmission(): VehicleTransmissionSettings;
set_mTransmission(mTransmission: VehicleTransmissionSettings): void;
mTransmission: VehicleTransmissionSettings;
get_mDifferentials(): ArrayVehicleDifferentialSettings;
set_mDifferentials(mDifferentials: ArrayVehicleDifferentialSettings): void;
mDifferentials: ArrayVehicleDifferentialSettings;
get_mDifferentialLimitedSlipRatio(): number;
set_mDifferentialLimitedSlipRatio(
mDifferentialLimitedSlipRatio: number
): void;
mDifferentialLimitedSlipRatio: number;
}
class TrackedVehicleControllerSettings extends VehicleControllerSettings {
constructor();
get_mEngine(): VehicleEngineSettings;
set_mEngine(mEngine: VehicleEngineSettings): void;
mEngine: VehicleEngineSettings;
get_mTransmission(): VehicleTransmissionSettings;
set_mTransmission(mTransmission: VehicleTransmissionSettings): void;
mTransmission: VehicleTransmissionSettings;
get_mTracks(index: number): VehicleTrackSettings;
set_mTracks(index: number, mTracks: VehicleTrackSettings): void;
mTracks: VehicleTrackSettings;
}
class TrackedVehicleController extends VehicleController {
constructor(
inSettings: TrackedVehicleControllerSettings,
inConstraint: VehicleConstraint
);
SetDriverInput(
inForward: number,
inLeftRatio: number,
inRightRatio: number,
inBrake: number
): void;
SetForwardInput(inForward: number): void;
GetForwardInput(): number;
SetLeftRatio(inLeftRatio: number): void;
GetLeftRatio(): number;
SetRightRatio(inRightRatio: number): void;
GetRightRatio(): number;
SetBrakeInput(inBrake: number): void;
GetBrakeInput(): number;
GetEngine(): VehicleEngine;
GetTransmission(): VehicleTransmission;
GetTracks(): ReadonlyArray<VehicleTrack>;
}
class VehicleEngineSettings {
get_mMaxTorque(): number;
set_mMaxTorque(mMaxTorque: number): void;
mMaxTorque: number;
get_mMinRPM(): number;
set_mMinRPM(mMinRPM: number): void;
mMinRPM: number;
get_mMaxRPM(): number;
set_mMaxRPM(mMaxRPM: number): void;
mMaxRPM: number;
get_mNormalizedTorque(): LinearCurve;
set_mNormalizedTorque(mNormalizedTorque: LinearCurve): void;
mNormalizedTorque: LinearCurve;
get_mInertia(): number;
set_mInertia(mInertia: number): void;
mInertia: number;
get_mAngularDamping(): number;
set_mAngularDamping(mAngularDamping: number): void;
mAngularDamping: number;
}
class VehicleEngine extends VehicleEngineSettings {
ClampRPM(): void;
GetCurrentRPM(): number;
SetCurrentRPM(inRPM: number): void;
GetAngularVelocity(): number;
GetTorque(inAcceleration: number): number;
}
class VehicleTransmissionSettings {
get_mMode(): ETransmissionMode;
set_mMode(mMode: ETransmissionMode): void;
mMode: ETransmissionMode;
get_mGearRatios(): ArrayFloat;
set_mGearRatios(mGearRatios: ArrayFloat): void;
mGearRatios: ArrayFloat;
get_mReverseGearRatios(): ArrayFloat;
set_mReverseGearRatios(mReverseGearRatios: ArrayFloat): void;
mReverseGearRatios: ArrayFloat;
get_mSwitchTime(): number;
set_mSwitchTime(mSwitchTime: number): void;
mSwitchTime: number;
get_mClutchReleaseTime(): number;
set_mClutchReleaseTime(mClutchReleaseTime: number): void;
mClutchReleaseTime: number;
get_mSwitchLatency(): number;
set_mSwitchLatency(mSwitchLatency: number): void;
mSwitchLatency: number;
get_mShiftUpRPM(): number;
set_mShiftUpRPM(mShiftUpRPM: number): void;
mShiftUpRPM: number;
get_mShiftDownRPM(): number;
set_mShiftDownRPM(mShiftDownRPM: number): void;
mShiftDownRPM: number;
get_mClutchStrength(): number;
set_mClutchStrength(mClutchStrength: number): void;
mClutchStrength: number;
}
class VehicleTransmission extends VehicleTransmissionSettings {
Set(inCurrentGear: number, inClutchFriction: number): void;
GetCurrentGear(): number;
GetClutchFriction(): number;
IsSwitchingGear(): boolean;
GetCurrentRatio(): number;
}
class VehicleDifferentialSettings {
constructor();
get_mLeftWheel(): number;
set_mLeftWheel(mLeftWheel: number): void;
mLeftWheel: number;
get_mRightWheel(): number;
set_mRightWheel(mRightWheel: number): void;
mRightWheel: number;
get_mDifferentialRatio(): number;
set_mDifferentialRatio(mDifferentialRatio: number): void;
mDifferentialRatio: number;
get_mLeftRightSplit(): number;
set_mLeftRightSplit(mLeftRightSplit: number): void;
mLeftRightSplit: number;
get_mLimitedSlipRatio(): number;
set_mLimitedSlipRatio(mLimitedSlipRatio: number): void;
mLimitedSlipRatio: number;
get_mEngineTorqueRatio(): number;
set_mEngineTorqueRatio(mEngineTorqueRatio: number): void;
mEngineTorqueRatio: number;
}
class VehicleControllerSettings {}
class VehicleController {
GetConstraint(): VehicleConstraint;
}
class WheeledVehicleController extends VehicleController {
constructor(
inSettings: WheeledVehicleControllerSettings,
inConstraint: VehicleConstraint
);
SetDriverInput(
inForward: number,
inRight: number,
inBrake: number,
inHandBrake: number
): void;
SetForwardInput(inForward: number): void;
GetForwardInput(): number;
SetRightInput(inRight: number): void;
GetRightInput(): number;
SetBrakeInput(inBrake: number): void;
GetBrakeInput(): number;
SetHandBrakeInput(inHandBrake: number): void;
GetHandBrakeInput(): number;
GetEngine(): VehicleEngine;
GetTransmission(): VehicleTransmission;
GetDifferentials(): ArrayVehicleDifferentialSettings;
GetDifferentialLimitedSlipRatio(): number;
SetDifferentialLimitedSlipRatio(inV: number): void;
GetWheelSpeedAtClutch(): number;
}
class MotorcycleControllerSettings extends WheeledVehicleControllerSettings {
constructor();
get_mMaxLeanAngle(): number;
set_mMaxLeanAngle(mMaxLeanAngle: number): void;
mMaxLeanAngle: number;
get_mLeanSpringConstant(): number;
set_mLeanSpringConstant(mLeanSpringConstant: number): void;
mLeanSpringConstant: number;
get_mLeanSpringDamping(): number;
set_mLeanSpringDamping(mLeanSpringDamping: number): void;
mLeanSpringDamping: number;
get_mLeanSpringIntegrationCoefficient(): number;
set_mLeanSpringIntegrationCoefficient(
mLeanSpringIntegrationCoefficient: number
): void;
mLeanSpringIntegrationCoefficient: number;
get_mLeanSpringIntegrationCoefficientDecay(): number;
set_mLeanSpringIntegrationCoefficientDecay(
mLeanSpringIntegrationCoefficientDecay: number
): void;
mLeanSpringIntegrationCoefficientDecay: number;
get_mLeanSmoothingFactor(): number;
set_mLeanSmoothingFactor(mLeanSmoothingFactor: number): void;
mLeanSmoothingFactor: number;
}
class MotorcycleController extends WheeledVehicleController {
constructor(
inSettings: MotorcycleControllerSettings,
inConstraint: VehicleConstraint
);
GetWheelBase(): number;
EnableLeanController(inEnable: boolean): void;
IsLeanControllerEnabled(): boolean;
}
class Skeleton {
constructor();
AddJoint(inName: JPHString, inParentIndex: number): number;
GetJointCount(): number;
AreJointsCorrectlyOrdered(): boolean;
CalculateParentJointIndices(): void;
}
class SkeletalAnimationJointState {
FromMatrix(inMatrix: Mat44): void;
ToMatrix(): Mat44;
get_mTranslation(): Vec3;
set_mTranslation(mTranslation: Vec3): void;
mTranslation: Vec3;
get_mRotation(): Quat;
set_mRotation(mRotation: Quat): void;
mRotation: Quat;
}
class SkeletalAnimationKeyframe extends SkeletalAnimationJointState {
constructor();
get_mTime(): number;
set_mTime(mTime: number): void;
mTime: number;
}
class ArraySkeletonKeyframe {
constructor();
empty(): boolean;
size(): number;
at(inIndex: number): SkeletalAnimationKeyframe;
push_back(inValue: SkeletalAnimationKeyframe): void;
reserve(inSize: number): void;
resize(inSize: number): void;
clear(): void;
}
class SkeletalAnimationAnimatedJoint {
constructor();
get_mJointName(): JPHString;
set_mJointName(mJointName: JPHString): void;
mJointName: JPHString;
get_mKeyframes(): ArraySkeletonKeyframe;
set_mKeyframes(mKeyframes: ArraySkeletonKeyframe): void;
mKeyframes: ArraySkeletonKeyframe;
}
class ArraySkeletonAnimatedJoint {
constructor();
empty(): boolean;
size(): number;
at(inIndex: number): SkeletalAnimationAnimatedJoint;
push_back(inValue: SkeletalAnimationAnimatedJoint): void;
reserve(inSize: number): void;
resize(inSize: number): void;
clear(): void;
}
class SkeletalAnimation {
constructor();
SetIsLooping(inLooping: boolean): void;
IsLooping(): boolean;
GetDuration(): number;
ScaleJoints(inScale: number): void;
Sample(inTime: number, ioPose: SkeletonPose): void;
GetAnimatedJoints(): ArraySkeletonAnimatedJoint;
}
class SkeletonPose {
constructor();
SetSkeleton(inSkeleton: Skeleton): void;
GetSkeleton(): Skeleton;
SetRootOffset(inOffset: RVec3): void;
GetRootOffset(): RVec3;
GetJointCount(): number;
GetJoint(inJoint: number): SkeletalAnimationJointState;
GetJointMatrices(): ArrayMat44;
GetJointMatrix(inJoint: number): Mat44;
CalculateJointMatrices(): void;
CalculateJointStates(): void;
}
class RagdollPart extends BodyCreationSettings {
get_mToParent(): TwoBodyConstraintSettings;
set_mToParent(mToParent: TwoBodyConstraintSettings): void;
mToParent: TwoBodyConstraintSettings;
}
class ArrayRagdollPart {
constructor();
empty(): boolean;
size(): number;
at(inIndex: number): RagdollPart;
push_back(inValue: RagdollPart): void;
reserve(inSize: number): void;
resize(inSize: number): void;
clear(): void;
}
class RagdollAdditionalConstraint {
get_mBodyIdx(index: number): number;
set_mBodyIdx(index: number, mBodyIdx: number): void;
mBodyIdx: number;
get_mConstraint(): TwoBodyConstraintSettings;
set_mConstraint(mConstraint: TwoBodyConstraintSettings): void;
mConstraint: TwoBodyConstraintSettings;
}
class ArrayRagdollAdditionalConstraint {
constructor();
empty(): boolean;
size(): number;
at(inIndex: number): RagdollAdditionalConstraint;
push_back(inValue: RagdollAdditionalConstraint): void;
reserve(inSize: number): void;
resize(inSize: number): void;
clear(): void;
}
class RagdollSettings {
constructor();
Stabilize(): boolean;
CreateRagdoll(
inCollisionGroup: number,
inUserData: number,
inSystem: PhysicsSystem
): Ragdoll;
GetSkeleton(): Skeleton;
DisableParentChildCollisions(
inJointMatrices?: Mat44MemRef,
inMinSeparationDistance?: number
): void;
CalculateBodyIndexToConstraintIndex(): void;
CalculateConstraintIndexToBodyIdxPair(): void;
get_mSkeleton(): Skeleton;
set_mSkeleton(mSkeleton: Skeleton): void;
mSkeleton: Skeleton;
get_mParts(): ArrayRagdollPart;
set_mParts(mParts: ArrayRagdollPart): void;
mParts: ArrayRagdollPart;
get_mAdditionalConstraints(): ArrayRagdollAdditionalConstraint;
set_mAdditionalConstraints(
mAdditionalConstraints: ArrayRagdollAdditionalConstraint
): void;
mAdditionalConstraints: ArrayRagdollAdditionalConstraint;
}
class Ragdoll {
constructor(inSystem: PhysicsSystem);
AddToPhysicsSystem(
inActivationMode: EActivation,
inLockBodies?: boolean
): void;
RemoveFromPhysicsSystem(inLockBodies?: boolean): void;
Activate(inLockBodies?: boolean): void;
IsActive(inLockBodies?: boolean): boolean;
SetGroupID(inGroupID: number, inLockBodies?: boolean): void;
SetPose(inPose: SkeletonPose, inLockBodies?: boolean): void;
GetPose(outPose: SkeletonPose, inLockBodies?: boolean): void;
ResetWarmStart(): void;
DriveToPoseUsingKinematics(
inPose: SkeletonPose,
inDeltaTime: number,
inLockBodies?: boolean
): void;
DriveToPoseUsingMotors(inPose: SkeletonPose): void;
SetLinearAndAngularVelocity(
inLinearVelocity: Vec3,
inAngularVelocity: Vec3,
inLockBodies?: boolean
): void;
SetLinearVelocity(inLinearVelocity: Vec3, inLockBodies?: boolean): void;
AddLinearVelocity(inLinearVelocity: Vec3, inLockBodies?: boolean): void;
AddImpulse(inImpulse: Vec3, inLockBodies?: boolean): void;
GetRootTransform(
outPosition: RVec3,
outRotation: Quat,
inLockBodies?: boolean
): void;
GetBodyCount(): number;
GetBodyID(inBodyIndex: number): BodyID;
GetBodyIDs(): BodyIDVector;
GetConstraintCount(): number;
GetWorldSpaceBounds(inLockBodies?: boolean): AABox;
GetConstraint(inConstraintIndex: number): TwoBodyConstraint;
GetRagdollSettings(): RagdollSettings;
}
class BroadPhaseLayerInterface {
GetNumBroadPhaseLayers(): number;
}
class BroadPhaseLayer {
constructor(inLayer: number);
GetValue(): number;
}
class BroadPhaseLayerInterfaceEm extends BroadPhaseLayerInterface {}
class BroadPhaseLayerInterfaceJS extends BroadPhaseLayerInterfaceEm {
constructor();
GetNumBroadPhaseLayers(): number;
GetBPLayer(inLayer: number): number;
}
class BroadPhaseLayerInterfaceTable extends BroadPhaseLayerInterface {
constructor(inNumObjectLayers: number, inNumBroadPhaseLayers: number);
MapObjectToBroadPhaseLayer(
inObjectLayer: number,
inBroadPhaseLayer: BroadPhaseLayer
): void;
}
class ObjectVsBroadPhaseLayerFilterTable extends ObjectVsBroadPhaseLayerFilter {
constructor(
inBroadPhaseLayerInterface: BroadPhaseLayerInterface,
inNumBroadPhaseLayers: number,
inObjectLayerPairFilter: ObjectLayerPairFilter,
inNumObjectLayers: number
);
}
class ObjectLayerPairFilterTable extends ObjectLayerPairFilter {
constructor(inNumObjectLayers: number);
GetNumObjectLayers(): number;
DisableCollision(inLayer1: number, inLayer2: number): void;
EnableCollision(inLayer1: number, inLayer2: number): void;
}
class BroadPhaseLayerInterfaceMask extends BroadPhaseLayerInterface {
constructor(inNumBroadPhaseLayers: number);
ConfigureLayer(
inBroadPhaseLayer: BroadPhaseLayer,
inGroupsToInclude: number,
inGroupsToExclude: number
): void;
}
class ObjectVsBroadPhaseLayerFilterMask extends ObjectVsBroadPhaseLayerFilter {
constructor(inBroadPhaseLayerInterface: BroadPhaseLayerInterfaceMask);
}
class ObjectLayerPairFilterMask extends ObjectLayerPairFilter {
constructor();
sGetObjectLayer(inGroup: number, inMask: number): number;
sGetGroup(inObjectLayer: number): number;
sGetMask(inObjectLayer: number): number;
}
class JoltSettings {
constructor();
get_mMaxBodies(): number;
set_mMaxBodies(mMaxBodies: number): void;
mMaxBodies: number;
get_mMaxBodyPairs(): number;
set_mMaxBodyPairs(mMaxBodyPairs: number): void;
mMaxBodyPairs: number;
get_mMaxContactConstraints(): number;
set_mMaxContactConstraints(mMaxContactConstraints: number): void;
mMaxContactConstraints: number;
get_mMaxWorkerThreads(): number;
set_mMaxWorkerThreads(mMaxWorkerThreads: number): void;
mMaxWorkerThreads: number;
get_mBroadPhaseLayerInterface(): BroadPhaseLayerInterface;
set_mBroadPhaseLayerInterface(
mBroadPhaseLayerInterface: BroadPhaseLayerInterface
): void;
mBroadPhaseLayerInterface: BroadPhaseLayerInterface;
get_mObjectVsBroadPhaseLayerFilter(): ObjectVsBroadPhaseLayerFilter;
set_mObjectVsBroadPhaseLayerFilter(
mObjectVsBroadPhaseLayerFilter: ObjectVsBroadPhaseLayerFilter
): void;
mObjectVsBroadPhaseLayerFilter: ObjectVsBroadPhaseLayerFilter;
get_mObjectLayerPairFilter(): ObjectLayerPairFilter;
set_mObjectLayerPairFilter(
mObjectLayerPairFilter: ObjectLayerPairFilter
): void;
mObjectLayerPairFilter: ObjectLayerPairFilter;
}
class JoltInterface {
constructor(inSettings: JoltSettings);
Step(inDeltaTime: number, inCollisionSteps: number): void;
GetPhysicsSystem(): PhysicsSystem;
GetTempAllocator(): TempAllocator;
GetObjectLayerPairFilter(): ObjectLayerPairFilter;
GetObjectVsBroadPhaseLayerFilter(): ObjectVsBroadPhaseLayerFilter;
sGetTotalMemory(): number;
sGetFreeMemory(): number;
}
}
Reference in New Issue View Git Blame Copy Permalink