joltc.h (176302B)
1 // Copyright (c) Amer Koleci and Contributors. 2 // Licensed under the MIT License (MIT). See LICENSE in the repository root for more information. 3 4 #ifndef JOLT_C_H_ 5 #define JOLT_C_H_ 1 6 7 #if defined(JPH_SHARED_LIBRARY_BUILD) 8 # if defined(_MSC_VER) 9 # define _JPH_EXPORT __declspec(dllexport) 10 # elif defined(__GNUC__) 11 # define _JPH_EXPORT __attribute__((visibility("default"))) 12 # else 13 # define _JPH_EXPORT 14 # pragma warning "Unknown dynamic link import/export semantics." 15 # endif 16 #elif defined(JPH_SHARED_LIBRARY_INCLUDE) 17 # if defined(_MSC_VER) 18 # define _JPH_EXPORT __declspec(dllimport) 19 # else 20 # define _JPH_EXPORT 21 # endif 22 #else 23 # define _JPH_EXPORT 24 #endif 25 26 #ifdef __cplusplus 27 # define _JPH_EXTERN extern "C" 28 #else 29 # define _JPH_EXTERN extern 30 #endif 31 32 #ifdef _WIN32 33 # define JPH_API_CALL __cdecl 34 #else 35 # define JPH_API_CALL 36 #endif 37 38 #define JPH_CAPI _JPH_EXTERN _JPH_EXPORT 39 40 #include <stdbool.h> 41 #include <stdint.h> 42 #include <stddef.h> 43 44 #define JPH_DEFAULT_COLLISION_TOLERANCE (1.0e-4f) // float cDefaultCollisionTolerance = 1.0e-4f 45 #define JPH_DEFAULT_PENETRATION_TOLERANCE (1.0e-4f) // float cDefaultPenetrationTolerance = 1.0e-4f 46 #define JPH_DEFAULT_CONVEX_RADIUS (0.05f) // float cDefaultConvexRadius = 0.05f 47 #define JPH_CAPSULE_PROJECTION_SLOP (0.02f) // float cCapsuleProjectionSlop = 0.02f 48 #define JPH_MAX_PHYSICS_JOBS (2048) // int cMaxPhysicsJobs = 2048 49 #define JPH_MAX_PHYSICS_BARRIERS (8) // int cMaxPhysicsBarriers = 8 50 #define JPH_INVALID_COLLISION_GROUP_ID (~0U) 51 #define JPH_INVALID_COLLISION_SUBGROUP_ID (~0U) 52 #define JPH_M_PI (3.14159265358979323846f) // To avoid collision with JPH_PI 53 54 typedef uint32_t JPH_Bool; 55 typedef uint32_t JPH_BodyID; 56 typedef uint32_t JPH_SubShapeID; 57 typedef uint32_t JPH_ObjectLayer; 58 typedef uint8_t JPH_BroadPhaseLayer; 59 typedef uint32_t JPH_CollisionGroupID; 60 typedef uint32_t JPH_CollisionSubGroupID; 61 typedef uint32_t JPH_CharacterID; 62 63 /* Forward declarations */ 64 typedef struct JPH_BroadPhaseLayerInterface JPH_BroadPhaseLayerInterface; 65 typedef struct JPH_ObjectVsBroadPhaseLayerFilter JPH_ObjectVsBroadPhaseLayerFilter; 66 typedef struct JPH_ObjectLayerPairFilter JPH_ObjectLayerPairFilter; 67 68 typedef struct JPH_BroadPhaseLayerFilter JPH_BroadPhaseLayerFilter; 69 typedef struct JPH_ObjectLayerFilter JPH_ObjectLayerFilter; 70 typedef struct JPH_BodyFilter JPH_BodyFilter; 71 typedef struct JPH_ShapeFilter JPH_ShapeFilter; 72 73 typedef struct JPH_SimShapeFilter JPH_SimShapeFilter; 74 75 typedef struct JPH_PhysicsStepListener JPH_PhysicsStepListener; 76 typedef struct JPH_PhysicsSystem JPH_PhysicsSystem; 77 typedef struct JPH_PhysicsMaterial JPH_PhysicsMaterial; 78 79 /* ShapeSettings */ 80 typedef struct JPH_ShapeSettings JPH_ShapeSettings; 81 typedef struct JPH_ConvexShapeSettings JPH_ConvexShapeSettings; 82 typedef struct JPH_SphereShapeSettings JPH_SphereShapeSettings; 83 typedef struct JPH_BoxShapeSettings JPH_BoxShapeSettings; 84 typedef struct JPH_PlaneShapeSettings JPH_PlaneShapeSettings; 85 typedef struct JPH_TriangleShapeSettings JPH_TriangleShapeSettings; 86 typedef struct JPH_CapsuleShapeSettings JPH_CapsuleShapeSettings; 87 typedef struct JPH_TaperedCapsuleShapeSettings JPH_TaperedCapsuleShapeSettings; 88 typedef struct JPH_CylinderShapeSettings JPH_CylinderShapeSettings; 89 typedef struct JPH_TaperedCylinderShapeSettings JPH_TaperedCylinderShapeSettings; 90 typedef struct JPH_ConvexHullShapeSettings JPH_ConvexHullShapeSettings; 91 typedef struct JPH_CompoundShapeSettings JPH_CompoundShapeSettings; 92 typedef struct JPH_StaticCompoundShapeSettings JPH_StaticCompoundShapeSettings; 93 typedef struct JPH_MutableCompoundShapeSettings JPH_MutableCompoundShapeSettings; 94 typedef struct JPH_MeshShapeSettings JPH_MeshShapeSettings; 95 typedef struct JPH_HeightFieldShapeSettings JPH_HeightFieldShapeSettings; 96 typedef struct JPH_RotatedTranslatedShapeSettings JPH_RotatedTranslatedShapeSettings; 97 typedef struct JPH_ScaledShapeSettings JPH_ScaledShapeSettings; 98 typedef struct JPH_OffsetCenterOfMassShapeSettings JPH_OffsetCenterOfMassShapeSettings; 99 typedef struct JPH_EmptyShapeSettings JPH_EmptyShapeSettings; 100 101 /* Shape */ 102 typedef struct JPH_Shape JPH_Shape; 103 typedef struct JPH_ConvexShape JPH_ConvexShape; 104 typedef struct JPH_SphereShape JPH_SphereShape; 105 typedef struct JPH_BoxShape JPH_BoxShape; 106 typedef struct JPH_PlaneShape JPH_PlaneShape; 107 typedef struct JPH_CapsuleShape JPH_CapsuleShape; 108 typedef struct JPH_CylinderShape JPH_CylinderShape; 109 typedef struct JPH_TaperedCylinderShape JPH_TaperedCylinderShape; 110 typedef struct JPH_TriangleShape JPH_TriangleShape; 111 typedef struct JPH_TaperedCapsuleShape JPH_TaperedCapsuleShape; 112 typedef struct JPH_ConvexHullShape JPH_ConvexHullShape; 113 typedef struct JPH_CompoundShape JPH_CompoundShape; 114 typedef struct JPH_StaticCompoundShape JPH_StaticCompoundShape; 115 typedef struct JPH_MutableCompoundShape JPH_MutableCompoundShape; 116 typedef struct JPH_MeshShape JPH_MeshShape; 117 typedef struct JPH_HeightFieldShape JPH_HeightFieldShape; 118 typedef struct JPH_DecoratedShape JPH_DecoratedShape; 119 typedef struct JPH_RotatedTranslatedShape JPH_RotatedTranslatedShape; 120 typedef struct JPH_ScaledShape JPH_ScaledShape; 121 typedef struct JPH_OffsetCenterOfMassShape JPH_OffsetCenterOfMassShape; 122 typedef struct JPH_EmptyShape JPH_EmptyShape; 123 124 typedef struct JPH_BodyCreationSettings JPH_BodyCreationSettings; 125 typedef struct JPH_SoftBodyCreationSettings JPH_SoftBodyCreationSettings; 126 typedef struct JPH_BodyInterface JPH_BodyInterface; 127 typedef struct JPH_BodyLockInterface JPH_BodyLockInterface; 128 typedef struct JPH_BroadPhaseQuery JPH_BroadPhaseQuery; 129 typedef struct JPH_NarrowPhaseQuery JPH_NarrowPhaseQuery; 130 typedef struct JPH_MotionProperties JPH_MotionProperties; 131 typedef struct JPH_MassProperties JPH_MassProperties; 132 typedef struct JPH_Body JPH_Body; 133 134 typedef struct JPH_CollideShapeResult JPH_CollideShapeResult; 135 typedef struct JPH_ContactListener JPH_ContactListener; 136 typedef struct JPH_ContactManifold JPH_ContactManifold; 137 138 typedef struct JPH_GroupFilter JPH_GroupFilter; 139 typedef struct JPH_GroupFilterTable JPH_GroupFilterTable; /* Inherits JPH_GroupFilter */ 140 141 /* Enums */ 142 typedef enum JPH_PhysicsUpdateError { 143 JPH_PhysicsUpdateError_None = 0, 144 JPH_PhysicsUpdateError_ManifoldCacheFull = 1 << 0, 145 JPH_PhysicsUpdateError_BodyPairCacheFull = 1 << 1, 146 JPH_PhysicsUpdateError_ContactConstraintsFull = 1 << 2, 147 148 _JPH_PhysicsUpdateError_Count, 149 _JPH_PhysicsUpdateError_Force32 = 0x7fffffff 150 } JPH_PhysicsUpdateError; 151 152 typedef enum JPH_BodyType { 153 JPH_BodyType_Rigid = 0, 154 JPH_BodyType_Soft = 1, 155 156 _JPH_BodyType_Count, 157 _JPH_BodyType_Force32 = 0x7fffffff 158 } JPH_BodyType; 159 160 typedef enum JPH_MotionType { 161 JPH_MotionType_Static = 0, 162 JPH_MotionType_Kinematic = 1, 163 JPH_MotionType_Dynamic = 2, 164 165 _JPH_MotionType_Count, 166 _JPH_MotionType_Force32 = 0x7fffffff 167 } JPH_MotionType; 168 169 typedef enum JPH_Activation 170 { 171 JPH_Activation_Activate = 0, 172 JPH_Activation_DontActivate = 1, 173 174 _JPH_Activation_Count, 175 _JPH_Activation_Force32 = 0x7fffffff 176 } JPH_Activation; 177 178 typedef enum JPH_ValidateResult { 179 JPH_ValidateResult_AcceptAllContactsForThisBodyPair = 0, 180 JPH_ValidateResult_AcceptContact = 1, 181 JPH_ValidateResult_RejectContact = 2, 182 JPH_ValidateResult_RejectAllContactsForThisBodyPair = 3, 183 184 _JPH_ValidateResult_Count, 185 _JPH_ValidateResult_Force32 = 0x7fffffff 186 } JPH_ValidateResult; 187 188 typedef enum JPH_ShapeType { 189 JPH_ShapeType_Convex = 0, 190 JPH_ShapeType_Compound = 1, 191 JPH_ShapeType_Decorated = 2, 192 JPH_ShapeType_Mesh = 3, 193 JPH_ShapeType_HeightField = 4, 194 JPH_ShapeType_SoftBody = 5, 195 196 JPH_ShapeType_User1 = 6, 197 JPH_ShapeType_User2 = 7, 198 JPH_ShapeType_User3 = 8, 199 JPH_ShapeType_User4 = 9, 200 201 _JPH_ShapeType_Count, 202 _JPH_ShapeType_Force32 = 0x7fffffff 203 } JPH_ShapeType; 204 205 typedef enum JPH_ShapeSubType { 206 JPH_ShapeSubType_Sphere = 0, 207 JPH_ShapeSubType_Box = 1, 208 JPH_ShapeSubType_Triangle = 2, 209 JPH_ShapeSubType_Capsule = 3, 210 JPH_ShapeSubType_TaperedCapsule = 4, 211 JPH_ShapeSubType_Cylinder = 5, 212 JPH_ShapeSubType_ConvexHull = 6, 213 JPH_ShapeSubType_StaticCompound = 7, 214 JPH_ShapeSubType_MutableCompound = 8, 215 JPH_ShapeSubType_RotatedTranslated = 9, 216 JPH_ShapeSubType_Scaled = 10, 217 JPH_ShapeSubType_OffsetCenterOfMass = 11, 218 JPH_ShapeSubType_Mesh = 12, 219 JPH_ShapeSubType_HeightField = 13, 220 JPH_ShapeSubType_SoftBody = 14, 221 222 _JPH_ShapeSubType_Count, 223 _JPH_ShapeSubType_Force32 = 0x7fffffff 224 } JPH_ShapeSubType; 225 226 typedef enum JPH_ConstraintType { 227 JPH_ConstraintType_Constraint = 0, 228 JPH_ConstraintType_TwoBodyConstraint = 1, 229 230 _JPH_ConstraintType_Count, 231 _JPH_ConstraintType_Force32 = 0x7fffffff 232 } JPH_ConstraintType; 233 234 typedef enum JPH_ConstraintSubType { 235 JPH_ConstraintSubType_Fixed = 0, 236 JPH_ConstraintSubType_Point = 1, 237 JPH_ConstraintSubType_Hinge = 2, 238 JPH_ConstraintSubType_Slider = 3, 239 JPH_ConstraintSubType_Distance = 4, 240 JPH_ConstraintSubType_Cone = 5, 241 JPH_ConstraintSubType_SwingTwist = 6, 242 JPH_ConstraintSubType_SixDOF = 7, 243 JPH_ConstraintSubType_Path = 8, 244 JPH_ConstraintSubType_Vehicle = 9, 245 JPH_ConstraintSubType_RackAndPinion = 10, 246 JPH_ConstraintSubType_Gear = 11, 247 JPH_ConstraintSubType_Pulley = 12, 248 249 JPH_ConstraintSubType_User1 = 13, 250 JPH_ConstraintSubType_User2 = 14, 251 JPH_ConstraintSubType_User3 = 15, 252 JPH_ConstraintSubType_User4 = 16, 253 254 _JPH_ConstraintSubType_Count, 255 _JPH_ConstraintSubType_Force32 = 0x7fffffff 256 } JPH_ConstraintSubType; 257 258 typedef enum JPH_ConstraintSpace { 259 JPH_ConstraintSpace_LocalToBodyCOM = 0, 260 JPH_ConstraintSpace_WorldSpace = 1, 261 262 _JPH_ConstraintSpace_Count, 263 _JPH_ConstraintSpace_Force32 = 0x7fffffff 264 } JPH_ConstraintSpace; 265 266 typedef enum JPH_MotionQuality { 267 JPH_MotionQuality_Discrete = 0, 268 JPH_MotionQuality_LinearCast = 1, 269 270 _JPH_MotionQuality_Count, 271 _JPH_MotionQuality_Force32 = 0x7fffffff 272 } JPH_MotionQuality; 273 274 typedef enum JPH_OverrideMassProperties { 275 JPH_OverrideMassProperties_CalculateMassAndInertia, 276 JPH_OverrideMassProperties_CalculateInertia, 277 JPH_OverrideMassProperties_MassAndInertiaProvided, 278 279 _JPH_JPH_OverrideMassProperties_Count, 280 _JPH_JPH_OverrideMassProperties_Force32 = 0x7FFFFFFF 281 } JPH_OverrideMassProperties; 282 283 typedef enum JPH_AllowedDOFs { 284 JPH_AllowedDOFs_All = 0b111111, 285 JPH_AllowedDOFs_TranslationX = 0b000001, 286 JPH_AllowedDOFs_TranslationY = 0b000010, 287 JPH_AllowedDOFs_TranslationZ = 0b000100, 288 JPH_AllowedDOFs_RotationX = 0b001000, 289 JPH_AllowedDOFs_RotationY = 0b010000, 290 JPH_AllowedDOFs_RotationZ = 0b100000, 291 JPH_AllowedDOFs_Plane2D = JPH_AllowedDOFs_TranslationX | JPH_AllowedDOFs_TranslationY | JPH_AllowedDOFs_RotationZ, 292 293 _JPH_AllowedDOFs_Count, 294 _JPH_AllowedDOFs_Force32 = 0x7FFFFFFF 295 } JPH_AllowedDOFs; 296 297 typedef enum JPH_GroundState { 298 JPH_GroundState_OnGround = 0, 299 JPH_GroundState_OnSteepGround = 1, 300 JPH_GroundState_NotSupported = 2, 301 JPH_GroundState_InAir = 3, 302 303 _JPH_GroundState_Count, 304 _JPH_GroundState_Force32 = 0x7FFFFFFF 305 } JPH_GroundState; 306 307 typedef enum JPH_BackFaceMode { 308 JPH_BackFaceMode_IgnoreBackFaces, 309 JPH_BackFaceMode_CollideWithBackFaces, 310 311 _JPH_BackFaceMode_Count, 312 _JPH_BackFaceMode_Force32 = 0x7FFFFFFF 313 } JPH_BackFaceMode; 314 315 typedef enum JPH_ActiveEdgeMode { 316 JPH_ActiveEdgeMode_CollideOnlyWithActive, 317 JPH_ActiveEdgeMode_CollideWithAll, 318 319 _JPH_ActiveEdgeMode_Count, 320 _JPH_ActiveEdgeMode_Force32 = 0x7FFFFFFF 321 } JPH_ActiveEdgeMode; 322 323 typedef enum JPH_CollectFacesMode { 324 JPH_CollectFacesMode_CollectFaces, 325 JPH_CollectFacesMode_NoFaces, 326 327 _JPH_CollectFacesMode_Count, 328 _JPH_CollectFacesMode_Force32 = 0x7FFFFFFF 329 } JPH_CollectFacesMode; 330 331 typedef enum JPH_MotorState { 332 JPH_MotorState_Off = 0, 333 JPH_MotorState_Velocity = 1, 334 JPH_MotorState_Position = 2, 335 336 _JPH_MotorState_Count, 337 _JPH_MotorState_Force32 = 0x7FFFFFFF 338 } JPH_MotorState; 339 340 typedef enum JPH_CollisionCollectorType { 341 JPH_CollisionCollectorType_AllHit = 0, 342 JPH_CollisionCollectorType_AllHitSorted = 1, 343 JPH_CollisionCollectorType_ClosestHit = 2, 344 JPH_CollisionCollectorType_AnyHit = 3, 345 346 _JPH_CollisionCollectorType_Count, 347 _JPH_CollisionCollectorType_Force32 = 0x7FFFFFFF 348 } JPH_CollisionCollectorType; 349 350 typedef enum JPH_SwingType { 351 JPH_SwingType_Cone, 352 JPH_SwingType_Pyramid, 353 354 _JPH_SwingType_Count, 355 _JPH_SwingType_Force32 = 0x7FFFFFFF 356 } JPH_SwingType; 357 358 typedef enum JPH_SixDOFConstraintAxis { 359 JPH_SixDOFConstraintAxis_TranslationX, 360 JPH_SixDOFConstraintAxis_TranslationY, 361 JPH_SixDOFConstraintAxis_TranslationZ, 362 363 JPH_SixDOFConstraintAxis_RotationX, 364 JPH_SixDOFConstraintAxis_RotationY, 365 JPH_SixDOFConstraintAxis_RotationZ, 366 367 _JPH_SixDOFConstraintAxis_Num, 368 _JPH_SixDOFConstraintAxis_NumTranslation = JPH_SixDOFConstraintAxis_TranslationZ + 1, 369 _JPH_SixDOFConstraintAxis_Force32 = 0x7FFFFFFF 370 } JPH_SixDOFConstraintAxis; 371 372 typedef enum JPH_SpringMode { 373 JPH_SpringMode_FrequencyAndDamping = 0, 374 JPH_SpringMode_StiffnessAndDamping = 1, 375 376 _JPH_SpringMode_Count, 377 _JPH_SpringMode_Force32 = 0x7FFFFFFF 378 } JPH_SpringMode; 379 380 /// Defines how to color soft body constraints 381 typedef enum JPH_SoftBodyConstraintColor 382 { 383 JPH_SoftBodyConstraintColor_ConstraintType, /// Draw different types of constraints in different colors 384 JPH_SoftBodyConstraintColor_ConstraintGroup, /// Draw constraints in the same group in the same color, non-parallel group will be red 385 JPH_SoftBodyConstraintColor_ConstraintOrder, /// Draw constraints in the same group in the same color, non-parallel group will be red, and order within each group will be indicated with gradient 386 387 _JPH_SoftBodyConstraintColor_Count, 388 _JPH_SoftBodyConstraintColor_Force32 = 0x7FFFFFFF 389 } JPH_SoftBodyConstraintColor; 390 391 typedef enum JPH_BodyManager_ShapeColor 392 { 393 JPH_BodyManager_ShapeColor_InstanceColor, ///< Random color per instance 394 JPH_BodyManager_ShapeColor_ShapeTypeColor, ///< Convex = green, scaled = yellow, compound = orange, mesh = red 395 JPH_BodyManager_ShapeColor_MotionTypeColor, ///< Static = grey, keyframed = green, dynamic = random color per instance 396 JPH_BodyManager_ShapeColor_SleepColor, ///< Static = grey, keyframed = green, dynamic = yellow, sleeping = red 397 JPH_BodyManager_ShapeColor_IslandColor, ///< Static = grey, active = random color per island, sleeping = light grey 398 JPH_BodyManager_ShapeColor_MaterialColor, ///< Color as defined by the PhysicsMaterial of the shape 399 400 _JPH_BodyManager_ShapeColor_Count, 401 _JPH_BodyManager_ShapeColor_Force32 = 0x7FFFFFFF 402 } JPH_BodyManager_ShapeColor; 403 404 typedef enum JPH_DebugRenderer_CastShadow { 405 JPH_DebugRenderer_CastShadow_On = 0, ///< This shape should cast a shadow 406 JPH_DebugRenderer_CastShadow_Off = 1, ///< This shape should not cast a shadow 407 408 _JPH_DebugRenderer_CastShadow_Count, 409 _JPH_DebugRenderer_CastShadow_Force32 = 0x7FFFFFFF 410 } JPH_DebugRenderer_CastShadow; 411 412 typedef enum JPH_DebugRenderer_DrawMode { 413 JPH_DebugRenderer_DrawMode_Solid = 0, ///< Draw as a solid shape 414 JPH_DebugRenderer_DrawMode_Wireframe = 1, ///< Draw as wireframe 415 416 _JPH_DebugRenderer_DrawMode_Count, 417 _JPH_DebugRenderer_DrawMode_Force32 = 0x7FFFFFFF 418 } JPH_DebugRenderer_DrawMode; 419 420 typedef enum JPH_Mesh_Shape_BuildQuality { 421 JPH_Mesh_Shape_BuildQuality_FavorRuntimePerformance = 0, 422 JPH_Mesh_Shape_BuildQuality_FavorBuildSpeed = 1, 423 424 _JPH_Mesh_Shape_BuildQuality_Count, 425 _JPH_Mesh_Shape_BuildQuality_Force32 = 0x7FFFFFFF 426 } JPH_Mesh_Shape_BuildQuality; 427 428 typedef enum JPH_TransmissionMode { 429 JPH_TransmissionMode_Auto = 0, 430 JPH_TransmissionMode_Manual = 1, 431 432 _JPH_TransmissionMode_Count, 433 _JPH_TransmissionMode_Force32 = 0x7FFFFFFF 434 } JPH_TransmissionMode; 435 436 typedef struct JPH_Vec3 { 437 float x; 438 float y; 439 float z; 440 } JPH_Vec3; 441 442 typedef struct JPH_Vec4 { 443 float x; 444 float y; 445 float z; 446 float w; 447 } JPH_Vec4; 448 449 typedef struct JPH_Quat { 450 float x; 451 float y; 452 float z; 453 float w; 454 } JPH_Quat; 455 456 typedef struct JPH_Plane { 457 JPH_Vec3 normal; 458 float distance; 459 } JPH_Plane; 460 461 typedef struct JPH_Mat4 { 462 JPH_Vec4 column[4]; 463 } JPH_Mat4; 464 465 #if defined(JPH_DOUBLE_PRECISION) 466 typedef struct JPH_RVec3 { 467 double x; 468 double y; 469 double z; 470 } JPH_RVec3; 471 472 typedef struct JPH_RMat4 { 473 JPH_Vec4 column[3]; 474 JPH_RVec3 column3; 475 } JPH_RMat4; 476 #else 477 typedef JPH_Vec3 JPH_RVec3; 478 typedef JPH_Mat4 JPH_RMat4; 479 #endif 480 481 typedef uint32_t JPH_Color; 482 483 typedef struct JPH_AABox { 484 JPH_Vec3 min; 485 JPH_Vec3 max; 486 } JPH_AABox; 487 488 typedef struct JPH_Triangle { 489 JPH_Vec3 v1; 490 JPH_Vec3 v2; 491 JPH_Vec3 v3; 492 uint32_t materialIndex; 493 } JPH_Triangle; 494 495 typedef struct JPH_IndexedTriangleNoMaterial { 496 uint32_t i1; 497 uint32_t i2; 498 uint32_t i3; 499 } JPH_IndexedTriangleNoMaterial; 500 501 typedef struct JPH_IndexedTriangle { 502 uint32_t i1; 503 uint32_t i2; 504 uint32_t i3; 505 uint32_t materialIndex; 506 uint32_t userData; 507 } JPH_IndexedTriangle; 508 509 typedef struct JPH_MassProperties { 510 float mass; 511 JPH_Mat4 inertia; 512 } JPH_MassProperties; 513 514 typedef struct JPH_ContactSettings { 515 float combinedFriction; 516 float combinedRestitution; 517 float invMassScale1; 518 float invInertiaScale1; 519 float invMassScale2; 520 float invInertiaScale2; 521 JPH_Bool isSensor; 522 JPH_Vec3 relativeLinearSurfaceVelocity; 523 JPH_Vec3 relativeAngularSurfaceVelocity; 524 } JPH_ContactSettings; 525 526 typedef struct JPH_CollideSettingsBase { 527 /// How active edges (edges that a moving object should bump into) are handled 528 JPH_ActiveEdgeMode activeEdgeMode/* = JPH_ActiveEdgeMode_CollideOnlyWithActive*/; 529 530 /// If colliding faces should be collected or only the collision point 531 JPH_CollectFacesMode collectFacesMode/* = JPH_CollectFacesMode_NoFaces*/; 532 533 /// If objects are closer than this distance, they are considered to be colliding (used for GJK) (unit: meter) 534 float collisionTolerance/* = JPH_DEFAULT_COLLISION_TOLERANCE*/; 535 536 /// A factor that determines the accuracy of the penetration depth calculation. If the change of the squared distance is less than tolerance * current_penetration_depth^2 the algorithm will terminate. (unit: dimensionless) 537 float penetrationTolerance/* = JPH_DEFAULT_PENETRATION_TOLERANCE*/; 538 539 /// When mActiveEdgeMode is CollideOnlyWithActive a movement direction can be provided. When hitting an inactive edge, the system will select the triangle normal as penetration depth only if it impedes the movement less than with the calculated penetration depth. 540 JPH_Vec3 activeEdgeMovementDirection/* = Vec3::sZero()*/; 541 } JPH_CollideSettingsBase; 542 543 /* CollideShapeSettings */ 544 typedef struct JPH_CollideShapeSettings { 545 JPH_CollideSettingsBase base; /* Inherits JPH_CollideSettingsBase */ 546 /// When > 0 contacts in the vicinity of the query shape can be found. All nearest contacts that are not further away than this distance will be found (unit: meter) 547 float maxSeparationDistance/* = 0.0f*/; 548 549 /// How backfacing triangles should be treated 550 JPH_BackFaceMode backFaceMode/* = JPH_BackFaceMode_IgnoreBackFaces*/; 551 } JPH_CollideShapeSettings; 552 553 /* ShapeCastSettings */ 554 typedef struct JPH_ShapeCastSettings { 555 JPH_CollideSettingsBase base; /* Inherits JPH_CollideSettingsBase */ 556 557 /// How backfacing triangles should be treated (should we report moving from back to front for triangle based shapes, e.g. for MeshShape/HeightFieldShape?) 558 JPH_BackFaceMode backFaceModeTriangles/* = JPH_BackFaceMode_IgnoreBackFaces*/; 559 560 /// How backfacing convex objects should be treated (should we report starting inside an object and moving out?) 561 JPH_BackFaceMode backFaceModeConvex/* = JPH_BackFaceMode_IgnoreBackFaces*/; 562 563 /// Indicates if we want to shrink the shape by the convex radius and then expand it again. This speeds up collision detection and gives a more accurate normal at the cost of a more 'rounded' shape. 564 bool useShrunkenShapeAndConvexRadius/* = false*/; 565 566 /// When true, and the shape is intersecting at the beginning of the cast (fraction = 0) then this will calculate the deepest penetration point (costing additional CPU time) 567 bool returnDeepestPoint/* = false*/; 568 } JPH_ShapeCastSettings; 569 570 typedef struct JPH_RayCastSettings { 571 /// How backfacing triangles should be treated (should we report back facing hits for triangle based shapes, e.g. MeshShape/HeightFieldShape?) 572 JPH_BackFaceMode backFaceModeTriangles/* = JPH_BackFaceMode_IgnoreBackFaces*/; 573 574 /// How backfacing convex objects should be treated (should we report back facing hits for convex shapes?) 575 JPH_BackFaceMode backFaceModeConvex/* = JPH_BackFaceMode_IgnoreBackFaces*/; 576 577 /// If convex shapes should be treated as solid. When true, a ray starting inside a convex shape will generate a hit at fraction 0. 578 bool treatConvexAsSolid/* = true*/; 579 } JPH_RayCastSettings; 580 581 typedef struct JPH_SpringSettings { 582 JPH_SpringMode mode; 583 float frequencyOrStiffness; 584 float damping; 585 } JPH_SpringSettings; 586 587 typedef struct JPH_MotorSettings { 588 JPH_SpringSettings springSettings; 589 float minForceLimit; 590 float maxForceLimit; 591 float minTorqueLimit; 592 float maxTorqueLimit; 593 } JPH_MotorSettings; 594 595 typedef struct JPH_SubShapeIDPair { 596 JPH_BodyID Body1ID; 597 JPH_SubShapeID subShapeID1; 598 JPH_BodyID Body2ID; 599 JPH_SubShapeID subShapeID2; 600 } JPH_SubShapeIDPair; 601 602 typedef struct JPH_BroadPhaseCastResult { 603 JPH_BodyID bodyID; 604 float fraction; 605 } JPH_BroadPhaseCastResult; 606 607 typedef struct JPH_RayCastResult { 608 JPH_BodyID bodyID; 609 float fraction; 610 JPH_SubShapeID subShapeID2; 611 } JPH_RayCastResult; 612 613 typedef struct JPH_CollidePointResult { 614 JPH_BodyID bodyID; 615 JPH_SubShapeID subShapeID2; 616 } JPH_CollidePointResult; 617 618 typedef struct JPH_CollideShapeResult { 619 JPH_Vec3 contactPointOn1; 620 JPH_Vec3 contactPointOn2; 621 JPH_Vec3 penetrationAxis; 622 float penetrationDepth; 623 JPH_SubShapeID subShapeID1; 624 JPH_SubShapeID subShapeID2; 625 JPH_BodyID bodyID2; 626 uint32_t shape1FaceCount; 627 JPH_Vec3* shape1Faces; 628 uint32_t shape2FaceCount; 629 JPH_Vec3* shape2Faces; 630 } JPH_CollideShapeResult; 631 632 typedef struct JPH_ShapeCastResult { 633 JPH_Vec3 contactPointOn1; 634 JPH_Vec3 contactPointOn2; 635 JPH_Vec3 penetrationAxis; 636 float penetrationDepth; 637 JPH_SubShapeID subShapeID1; 638 JPH_SubShapeID subShapeID2; 639 JPH_BodyID bodyID2; 640 float fraction; 641 bool isBackFaceHit; 642 } JPH_ShapeCastResult; 643 644 typedef struct JPH_DrawSettings { 645 bool drawGetSupportFunction; ///< Draw the GetSupport() function, used for convex collision detection 646 bool drawSupportDirection; ///< When drawing the support function, also draw which direction mapped to a specific support point 647 bool drawGetSupportingFace; ///< Draw the faces that were found colliding during collision detection 648 bool drawShape; ///< Draw the shapes of all bodies 649 bool drawShapeWireframe; ///< When mDrawShape is true and this is true, the shapes will be drawn in wireframe instead of solid. 650 JPH_BodyManager_ShapeColor drawShapeColor; ///< Coloring scheme to use for shapes 651 bool drawBoundingBox; ///< Draw a bounding box per body 652 bool drawCenterOfMassTransform; ///< Draw the center of mass for each body 653 bool drawWorldTransform; ///< Draw the world transform (which may differ from its center of mass) of each body 654 bool drawVelocity; ///< Draw the velocity vector for each body 655 bool drawMassAndInertia; ///< Draw the mass and inertia (as the box equivalent) for each body 656 bool drawSleepStats; ///< Draw stats regarding the sleeping algorithm of each body 657 bool drawSoftBodyVertices; ///< Draw the vertices of soft bodies 658 bool drawSoftBodyVertexVelocities; ///< Draw the velocities of the vertices of soft bodies 659 bool drawSoftBodyEdgeConstraints; ///< Draw the edge constraints of soft bodies 660 bool drawSoftBodyBendConstraints; ///< Draw the bend constraints of soft bodies 661 bool drawSoftBodyVolumeConstraints; ///< Draw the volume constraints of soft bodies 662 bool drawSoftBodySkinConstraints; ///< Draw the skin constraints of soft bodies 663 bool drawSoftBodyLRAConstraints; ///< Draw the LRA constraints of soft bodies 664 bool drawSoftBodyPredictedBounds; ///< Draw the predicted bounds of soft bodies 665 JPH_SoftBodyConstraintColor drawSoftBodyConstraintColor; ///< Coloring scheme to use for soft body constraints 666 } JPH_DrawSettings; 667 668 typedef struct JPH_SupportingFace { 669 uint32_t count; 670 JPH_Vec3 vertices[32]; 671 } JPH_SupportingFace; 672 673 typedef struct JPH_CollisionGroup { 674 const JPH_GroupFilter* groupFilter; 675 JPH_CollisionGroupID groupID; 676 JPH_CollisionSubGroupID subGroupID; 677 } JPH_CollisionGroup; 678 679 typedef void JPH_CastRayResultCallback(void* context, const JPH_RayCastResult* result); 680 typedef void JPH_RayCastBodyResultCallback(void* context, const JPH_BroadPhaseCastResult* result); 681 typedef void JPH_CollideShapeBodyResultCallback(void* context, const JPH_BodyID result); 682 typedef void JPH_CollidePointResultCallback(void* context, const JPH_CollidePointResult* result); 683 typedef void JPH_CollideShapeResultCallback(void* context, const JPH_CollideShapeResult* result); 684 typedef void JPH_CastShapeResultCallback(void* context, const JPH_ShapeCastResult* result); 685 686 typedef float JPH_CastRayCollectorCallback(void* context, const JPH_RayCastResult* result); 687 typedef float JPH_RayCastBodyCollectorCallback(void* context, const JPH_BroadPhaseCastResult* result); 688 typedef float JPH_CollideShapeBodyCollectorCallback(void* context, const JPH_BodyID result); 689 typedef float JPH_CollidePointCollectorCallback(void* context, const JPH_CollidePointResult* result); 690 typedef float JPH_CollideShapeCollectorCallback(void* context, const JPH_CollideShapeResult* result); 691 typedef float JPH_CastShapeCollectorCallback(void* context, const JPH_ShapeCastResult* result); 692 693 typedef struct JPH_CollisionEstimationResultImpulse { 694 float contactImpulse; 695 float frictionImpulse1; 696 float frictionImpulse2; 697 } JPH_CollisionEstimationResultImpulse; 698 699 typedef struct JPH_CollisionEstimationResult { 700 JPH_Vec3 linearVelocity1; 701 JPH_Vec3 angularVelocity1; 702 JPH_Vec3 linearVelocity2; 703 JPH_Vec3 angularVelocity2; 704 705 JPH_Vec3 tangent1; 706 JPH_Vec3 tangent2; 707 708 uint32_t impulseCount; 709 JPH_CollisionEstimationResultImpulse* impulses; 710 } JPH_CollisionEstimationResult; 711 712 typedef struct JPH_BodyActivationListener JPH_BodyActivationListener; 713 typedef struct JPH_BodyDrawFilter JPH_BodyDrawFilter; 714 715 typedef struct JPH_SharedMutex JPH_SharedMutex; 716 717 typedef struct JPH_DebugRenderer JPH_DebugRenderer; 718 719 /* Constraint */ 720 typedef struct JPH_Constraint JPH_Constraint; 721 typedef struct JPH_TwoBodyConstraint JPH_TwoBodyConstraint; 722 typedef struct JPH_FixedConstraint JPH_FixedConstraint; 723 typedef struct JPH_DistanceConstraint JPH_DistanceConstraint; 724 typedef struct JPH_PointConstraint JPH_PointConstraint; 725 typedef struct JPH_HingeConstraint JPH_HingeConstraint; 726 typedef struct JPH_SliderConstraint JPH_SliderConstraint; 727 typedef struct JPH_ConeConstraint JPH_ConeConstraint; 728 typedef struct JPH_SwingTwistConstraint JPH_SwingTwistConstraint; 729 typedef struct JPH_SixDOFConstraint JPH_SixDOFConstraint; 730 typedef struct JPH_GearConstraint JPH_GearConstraint; 731 732 /* Character, CharacterVirtual */ 733 typedef struct JPH_CharacterBase JPH_CharacterBase; 734 typedef struct JPH_Character JPH_Character; /* Inherits JPH_CharacterBase */ 735 typedef struct JPH_CharacterVirtual JPH_CharacterVirtual; /* Inherits JPH_CharacterBase */ 736 typedef struct JPH_CharacterContactListener JPH_CharacterContactListener; 737 typedef struct JPH_CharacterVsCharacterCollision JPH_CharacterVsCharacterCollision; 738 739 /* Skeleton/Ragdoll */ 740 typedef struct JPH_Skeleton JPH_Skeleton; 741 typedef struct JPH_RagdollSettings JPH_RagdollSettings; 742 typedef struct JPH_Ragdoll JPH_Ragdoll; 743 744 typedef struct JPH_ConstraintSettings { 745 bool enabled; 746 uint32_t constraintPriority; 747 uint32_t numVelocityStepsOverride; 748 uint32_t numPositionStepsOverride; 749 float drawConstraintSize; 750 uint64_t userData; 751 } JPH_ConstraintSettings; 752 753 typedef struct JPH_FixedConstraintSettings { 754 JPH_ConstraintSettings base; /* Inherits JPH_ConstraintSettings */ 755 756 JPH_ConstraintSpace space; 757 bool autoDetectPoint; 758 JPH_RVec3 point1; 759 JPH_Vec3 axisX1; 760 JPH_Vec3 axisY1; 761 JPH_RVec3 point2; 762 JPH_Vec3 axisX2; 763 JPH_Vec3 axisY2; 764 } JPH_FixedConstraintSettings; 765 766 typedef struct JPH_DistanceConstraintSettings { 767 JPH_ConstraintSettings base; /* Inherits JPH_ConstraintSettings */ 768 769 JPH_ConstraintSpace space; 770 JPH_RVec3 point1; 771 JPH_RVec3 point2; 772 float minDistance; 773 float maxDistance; 774 JPH_SpringSettings limitsSpringSettings; 775 } JPH_DistanceConstraintSettings; 776 777 typedef struct JPH_PointConstraintSettings { 778 JPH_ConstraintSettings base; /* Inherits JPH_ConstraintSettings */ 779 780 JPH_ConstraintSpace space; 781 JPH_RVec3 point1; 782 JPH_RVec3 point2; 783 } JPH_PointConstraintSettings; 784 785 typedef struct JPH_HingeConstraintSettings { 786 JPH_ConstraintSettings base; /* Inherits JPH_ConstraintSettings */ 787 788 JPH_ConstraintSpace space; 789 JPH_RVec3 point1; 790 JPH_Vec3 hingeAxis1; 791 JPH_Vec3 normalAxis1; 792 JPH_RVec3 point2; 793 JPH_Vec3 hingeAxis2; 794 JPH_Vec3 normalAxis2; 795 float limitsMin; 796 float limitsMax; 797 JPH_SpringSettings limitsSpringSettings; 798 float maxFrictionTorque; 799 JPH_MotorSettings motorSettings; 800 } JPH_HingeConstraintSettings; 801 802 typedef struct JPH_SliderConstraintSettings { 803 JPH_ConstraintSettings base; /* Inherits JPH_ConstraintSettings */ 804 805 JPH_ConstraintSpace space; 806 bool autoDetectPoint; 807 JPH_RVec3 point1; 808 JPH_Vec3 sliderAxis1; 809 JPH_Vec3 normalAxis1; 810 JPH_RVec3 point2; 811 JPH_Vec3 sliderAxis2; 812 JPH_Vec3 normalAxis2; 813 float limitsMin; 814 float limitsMax; 815 JPH_SpringSettings limitsSpringSettings; 816 float maxFrictionForce; 817 JPH_MotorSettings motorSettings; 818 } JPH_SliderConstraintSettings; 819 820 typedef struct JPH_ConeConstraintSettings { 821 JPH_ConstraintSettings base; /* Inherits JPH_ConstraintSettings */ 822 823 JPH_ConstraintSpace space; 824 JPH_RVec3 point1; 825 JPH_Vec3 twistAxis1; 826 JPH_RVec3 point2; 827 JPH_Vec3 twistAxis2; 828 float halfConeAngle; 829 } JPH_ConeConstraintSettings; 830 831 typedef struct JPH_SwingTwistConstraintSettings { 832 JPH_ConstraintSettings base; /* Inherits JPH_ConstraintSettings */ 833 834 JPH_ConstraintSpace space; 835 JPH_RVec3 position1; 836 JPH_Vec3 twistAxis1; 837 JPH_Vec3 planeAxis1; 838 JPH_RVec3 position2; 839 JPH_Vec3 twistAxis2; 840 JPH_Vec3 planeAxis2; 841 JPH_SwingType swingType; 842 float normalHalfConeAngle; 843 float planeHalfConeAngle; 844 float twistMinAngle; 845 float twistMaxAngle; 846 float maxFrictionTorque; 847 JPH_MotorSettings swingMotorSettings; 848 JPH_MotorSettings twistMotorSettings; 849 } JPH_SwingTwistConstraintSettings; 850 851 typedef struct JPH_SixDOFConstraintSettings { 852 JPH_ConstraintSettings base; /* Inherits JPH_ConstraintSettings */ 853 854 JPH_ConstraintSpace space; 855 JPH_RVec3 position1; 856 JPH_Vec3 axisX1; 857 JPH_Vec3 axisY1; 858 JPH_RVec3 position2; 859 JPH_Vec3 axisX2; 860 JPH_Vec3 axisY2; 861 float maxFriction[_JPH_SixDOFConstraintAxis_Num]; 862 JPH_SwingType swingType; 863 float limitMin[_JPH_SixDOFConstraintAxis_Num]; 864 float limitMax[_JPH_SixDOFConstraintAxis_Num]; 865 866 JPH_SpringSettings limitsSpringSettings[_JPH_SixDOFConstraintAxis_NumTranslation]; 867 JPH_MotorSettings motorSettings[_JPH_SixDOFConstraintAxis_Num]; 868 } JPH_SixDOFConstraintSettings; 869 870 typedef struct JPH_GearConstraintSettings { 871 JPH_ConstraintSettings base; /* Inherits JPH_ConstraintSettings */ 872 873 JPH_ConstraintSpace space; 874 JPH_Vec3 hingeAxis1; 875 JPH_Vec3 hingeAxis2; 876 float ratio; 877 } JPH_GearConstraintSettings; 878 879 typedef struct JPH_BodyLockRead { 880 const JPH_BodyLockInterface* lockInterface; 881 JPH_SharedMutex* mutex; 882 const JPH_Body* body; 883 } JPH_BodyLockRead; 884 885 typedef struct JPH_BodyLockWrite { 886 const JPH_BodyLockInterface* lockInterface; 887 JPH_SharedMutex* mutex; 888 JPH_Body* body; 889 } JPH_BodyLockWrite; 890 891 typedef struct JPH_BodyLockMultiRead JPH_BodyLockMultiRead; 892 typedef struct JPH_BodyLockMultiWrite JPH_BodyLockMultiWrite; 893 894 typedef struct JPH_ExtendedUpdateSettings { 895 JPH_Vec3 stickToFloorStepDown; 896 JPH_Vec3 walkStairsStepUp; 897 float walkStairsMinStepForward; 898 float walkStairsStepForwardTest; 899 float walkStairsCosAngleForwardContact; 900 JPH_Vec3 walkStairsStepDownExtra; 901 } JPH_ExtendedUpdateSettings; 902 903 typedef struct JPH_CharacterBaseSettings { 904 JPH_Vec3 up; 905 JPH_Plane supportingVolume; 906 float maxSlopeAngle; 907 bool enhancedInternalEdgeRemoval; 908 const JPH_Shape* shape; 909 } JPH_CharacterBaseSettings; 910 911 /* Character */ 912 typedef struct JPH_CharacterSettings { 913 JPH_CharacterBaseSettings base; /* Inherits JPH_CharacterBaseSettings */ 914 JPH_ObjectLayer layer; 915 float mass; 916 float friction; 917 float gravityFactor; 918 JPH_AllowedDOFs allowedDOFs; 919 } JPH_CharacterSettings; 920 921 /* CharacterVirtual */ 922 typedef struct JPH_CharacterVirtualSettings { 923 JPH_CharacterBaseSettings base; /* Inherits JPH_CharacterBaseSettings */ 924 JPH_CharacterID ID; 925 float mass; 926 float maxStrength; 927 JPH_Vec3 shapeOffset; 928 JPH_BackFaceMode backFaceMode; 929 float predictiveContactDistance; 930 uint32_t maxCollisionIterations; 931 uint32_t maxConstraintIterations; 932 float minTimeRemaining; 933 float collisionTolerance; 934 float characterPadding; 935 uint32_t maxNumHits; 936 float hitReductionCosMaxAngle; 937 float penetrationRecoverySpeed; 938 const JPH_Shape* innerBodyShape; 939 JPH_BodyID innerBodyIDOverride; 940 JPH_ObjectLayer innerBodyLayer; 941 } JPH_CharacterVirtualSettings; 942 943 typedef struct JPH_CharacterContactSettings { 944 bool canPushCharacter; 945 bool canReceiveImpulses; 946 } JPH_CharacterContactSettings; 947 948 typedef struct JPH_CharacterVirtualContact { 949 uint64_t hash; 950 JPH_BodyID bodyB; 951 JPH_CharacterID characterIDB; 952 JPH_SubShapeID subShapeIDB; 953 JPH_RVec3 position; 954 JPH_Vec3 linearVelocity; 955 JPH_Vec3 contactNormal; 956 JPH_Vec3 surfaceNormal; 957 float distance; 958 float fraction; 959 JPH_MotionType motionTypeB; 960 bool isSensorB; 961 const JPH_CharacterVirtual* characterB; 962 uint64_t userData; 963 const JPH_PhysicsMaterial* material; 964 bool hadCollision; 965 bool wasDiscarded; 966 bool canPushCharacter; 967 } JPH_CharacterVirtualContact; 968 969 typedef void(JPH_API_CALL* JPH_TraceFunc)(const char* message); 970 typedef bool(JPH_API_CALL* JPH_AssertFailureFunc)(const char* expression, const char* message, const char* file, uint32_t line); 971 972 typedef void JPH_JobFunction(void* arg); 973 typedef void JPH_QueueJobCallback(void* context, JPH_JobFunction* job, void* arg); 974 typedef void JPH_QueueJobsCallback(void* context, JPH_JobFunction* job, void** args, uint32_t count); 975 976 typedef struct JobSystemThreadPoolConfig { 977 uint32_t maxJobs; 978 uint32_t maxBarriers; 979 int32_t numThreads; 980 } JobSystemThreadPoolConfig; 981 982 typedef struct JPH_JobSystemConfig { 983 void* context; 984 JPH_QueueJobCallback* queueJob; 985 JPH_QueueJobsCallback* queueJobs; 986 uint32_t maxConcurrency; 987 uint32_t maxBarriers; 988 } JPH_JobSystemConfig; 989 990 typedef struct JPH_JobSystem JPH_JobSystem; 991 992 JPH_CAPI JPH_JobSystem* JPH_JobSystemThreadPool_Create(const JobSystemThreadPoolConfig* config); 993 JPH_CAPI JPH_JobSystem* JPH_JobSystemCallback_Create(const JPH_JobSystemConfig* config); 994 JPH_CAPI void JPH_JobSystem_Destroy(JPH_JobSystem* jobSystem); 995 996 JPH_CAPI bool JPH_Init(void); 997 JPH_CAPI void JPH_Shutdown(void); 998 JPH_CAPI void JPH_SetTraceHandler(JPH_TraceFunc handler); 999 JPH_CAPI void JPH_SetAssertFailureHandler(JPH_AssertFailureFunc handler); 1000 1001 /* Structs free members */ 1002 JPH_CAPI void JPH_CollideShapeResult_FreeMembers(JPH_CollideShapeResult* result); 1003 JPH_CAPI void JPH_CollisionEstimationResult_FreeMembers(JPH_CollisionEstimationResult* result); 1004 1005 /* JPH_BroadPhaseLayerInterface */ 1006 JPH_CAPI JPH_BroadPhaseLayerInterface* JPH_BroadPhaseLayerInterfaceMask_Create(uint32_t numBroadPhaseLayers); 1007 JPH_CAPI void JPH_BroadPhaseLayerInterfaceMask_ConfigureLayer(JPH_BroadPhaseLayerInterface* bpInterface, JPH_BroadPhaseLayer broadPhaseLayer, uint32_t groupsToInclude, uint32_t groupsToExclude); 1008 1009 JPH_CAPI JPH_BroadPhaseLayerInterface* JPH_BroadPhaseLayerInterfaceTable_Create(uint32_t numObjectLayers, uint32_t numBroadPhaseLayers); 1010 JPH_CAPI void JPH_BroadPhaseLayerInterfaceTable_MapObjectToBroadPhaseLayer(JPH_BroadPhaseLayerInterface* bpInterface, JPH_ObjectLayer objectLayer, JPH_BroadPhaseLayer broadPhaseLayer); 1011 1012 /* JPH_ObjectLayerPairFilter */ 1013 JPH_CAPI JPH_ObjectLayerPairFilter* JPH_ObjectLayerPairFilterMask_Create(void); 1014 JPH_CAPI JPH_ObjectLayer JPH_ObjectLayerPairFilterMask_GetObjectLayer(uint32_t group, uint32_t mask); 1015 JPH_CAPI uint32_t JPH_ObjectLayerPairFilterMask_GetGroup(JPH_ObjectLayer layer); 1016 JPH_CAPI uint32_t JPH_ObjectLayerPairFilterMask_GetMask(JPH_ObjectLayer layer); 1017 1018 JPH_CAPI JPH_ObjectLayerPairFilter* JPH_ObjectLayerPairFilterTable_Create(uint32_t numObjectLayers); 1019 JPH_CAPI void JPH_ObjectLayerPairFilterTable_DisableCollision(JPH_ObjectLayerPairFilter* objectFilter, JPH_ObjectLayer layer1, JPH_ObjectLayer layer2); 1020 JPH_CAPI void JPH_ObjectLayerPairFilterTable_EnableCollision(JPH_ObjectLayerPairFilter* objectFilter, JPH_ObjectLayer layer1, JPH_ObjectLayer layer2); 1021 JPH_CAPI bool JPH_ObjectLayerPairFilterTable_ShouldCollide(JPH_ObjectLayerPairFilter* objectFilter, JPH_ObjectLayer layer1, JPH_ObjectLayer layer2); 1022 1023 /* JPH_ObjectVsBroadPhaseLayerFilter */ 1024 JPH_CAPI JPH_ObjectVsBroadPhaseLayerFilter* JPH_ObjectVsBroadPhaseLayerFilterMask_Create(const JPH_BroadPhaseLayerInterface* broadPhaseLayerInterface); 1025 1026 JPH_CAPI JPH_ObjectVsBroadPhaseLayerFilter* JPH_ObjectVsBroadPhaseLayerFilterTable_Create( 1027 JPH_BroadPhaseLayerInterface* broadPhaseLayerInterface, uint32_t numBroadPhaseLayers, 1028 JPH_ObjectLayerPairFilter* objectLayerPairFilter, uint32_t numObjectLayers); 1029 1030 JPH_CAPI void JPH_DrawSettings_InitDefault(JPH_DrawSettings* settings); 1031 1032 /* JPH_PhysicsSystem */ 1033 typedef struct JPH_PhysicsSystemSettings { 1034 uint32_t maxBodies; /* 10240 */ 1035 uint32_t numBodyMutexes; /* 0 */ 1036 uint32_t maxBodyPairs; /* 65536 */ 1037 uint32_t maxContactConstraints; /* 10240 */ 1038 uint32_t _padding; 1039 JPH_BroadPhaseLayerInterface* broadPhaseLayerInterface; 1040 JPH_ObjectLayerPairFilter* objectLayerPairFilter; 1041 JPH_ObjectVsBroadPhaseLayerFilter* objectVsBroadPhaseLayerFilter; 1042 } JPH_PhysicsSystemSettings; 1043 1044 typedef struct JPH_PhysicsSettings { 1045 int maxInFlightBodyPairs; 1046 int stepListenersBatchSize; 1047 int stepListenerBatchesPerJob; 1048 float baumgarte; 1049 float speculativeContactDistance; 1050 float penetrationSlop; 1051 float linearCastThreshold; 1052 float linearCastMaxPenetration; 1053 float manifoldTolerance; 1054 float maxPenetrationDistance; 1055 float bodyPairCacheMaxDeltaPositionSq; 1056 float bodyPairCacheCosMaxDeltaRotationDiv2; 1057 float contactNormalCosMaxDeltaRotation; 1058 float contactPointPreserveLambdaMaxDistSq; 1059 uint32_t numVelocitySteps; 1060 uint32_t numPositionSteps; 1061 float minVelocityForRestitution; 1062 float timeBeforeSleep; 1063 float pointVelocitySleepThreshold; 1064 bool deterministicSimulation; 1065 bool constraintWarmStart; 1066 bool useBodyPairContactCache; 1067 bool useManifoldReduction; 1068 bool useLargeIslandSplitter; 1069 bool allowSleeping; 1070 bool checkActiveEdges; 1071 } JPH_PhysicsSettings; 1072 1073 JPH_CAPI JPH_PhysicsSystem* JPH_PhysicsSystem_Create(const JPH_PhysicsSystemSettings* settings); 1074 JPH_CAPI void JPH_PhysicsSystem_Destroy(JPH_PhysicsSystem* system); 1075 1076 JPH_CAPI void JPH_PhysicsSystem_SetPhysicsSettings(JPH_PhysicsSystem* system, JPH_PhysicsSettings* settings); 1077 JPH_CAPI void JPH_PhysicsSystem_GetPhysicsSettings(JPH_PhysicsSystem* system, JPH_PhysicsSettings* result); 1078 1079 JPH_CAPI void JPH_PhysicsSystem_OptimizeBroadPhase(JPH_PhysicsSystem* system); 1080 JPH_CAPI JPH_PhysicsUpdateError JPH_PhysicsSystem_Update(JPH_PhysicsSystem* system, float deltaTime, int collisionSteps, JPH_JobSystem* jobSystem); 1081 1082 JPH_CAPI JPH_BodyInterface* JPH_PhysicsSystem_GetBodyInterface(JPH_PhysicsSystem* system); 1083 JPH_CAPI JPH_BodyInterface* JPH_PhysicsSystem_GetBodyInterfaceNoLock(JPH_PhysicsSystem* system); 1084 1085 JPH_CAPI const JPH_BodyLockInterface* JPH_PhysicsSystem_GetBodyLockInterface(const JPH_PhysicsSystem* system); 1086 JPH_CAPI const JPH_BodyLockInterface* JPH_PhysicsSystem_GetBodyLockInterfaceNoLock(const JPH_PhysicsSystem* system); 1087 1088 JPH_CAPI const JPH_BroadPhaseQuery* JPH_PhysicsSystem_GetBroadPhaseQuery(const JPH_PhysicsSystem* system); 1089 1090 JPH_CAPI const JPH_NarrowPhaseQuery* JPH_PhysicsSystem_GetNarrowPhaseQuery(const JPH_PhysicsSystem* system); 1091 JPH_CAPI const JPH_NarrowPhaseQuery* JPH_PhysicsSystem_GetNarrowPhaseQueryNoLock(const JPH_PhysicsSystem* system); 1092 1093 JPH_CAPI void JPH_PhysicsSystem_SetContactListener(JPH_PhysicsSystem* system, JPH_ContactListener* listener); 1094 JPH_CAPI void JPH_PhysicsSystem_SetBodyActivationListener(JPH_PhysicsSystem* system, JPH_BodyActivationListener* listener); 1095 JPH_CAPI void JPH_PhysicsSystem_SetSimShapeFilter(JPH_PhysicsSystem* system, const JPH_SimShapeFilter* filter); 1096 1097 JPH_CAPI bool JPH_PhysicsSystem_WereBodiesInContact(const JPH_PhysicsSystem* system, JPH_BodyID body1, JPH_BodyID body2); 1098 1099 JPH_CAPI uint32_t JPH_PhysicsSystem_GetNumBodies(const JPH_PhysicsSystem* system); 1100 JPH_CAPI uint32_t JPH_PhysicsSystem_GetNumActiveBodies(const JPH_PhysicsSystem* system, JPH_BodyType type); 1101 JPH_CAPI uint32_t JPH_PhysicsSystem_GetMaxBodies(const JPH_PhysicsSystem* system); 1102 JPH_CAPI uint32_t JPH_PhysicsSystem_GetNumConstraints(const JPH_PhysicsSystem* system); 1103 1104 JPH_CAPI void JPH_PhysicsSystem_SetGravity(JPH_PhysicsSystem* system, const JPH_Vec3* value); 1105 JPH_CAPI void JPH_PhysicsSystem_GetGravity(JPH_PhysicsSystem* system, JPH_Vec3* result); 1106 1107 JPH_CAPI void JPH_PhysicsSystem_AddConstraint(JPH_PhysicsSystem* system, JPH_Constraint* constraint); 1108 JPH_CAPI void JPH_PhysicsSystem_RemoveConstraint(JPH_PhysicsSystem* system, JPH_Constraint* constraint); 1109 1110 JPH_CAPI void JPH_PhysicsSystem_AddConstraints(JPH_PhysicsSystem* system, JPH_Constraint** constraints, uint32_t count); 1111 JPH_CAPI void JPH_PhysicsSystem_RemoveConstraints(JPH_PhysicsSystem* system, JPH_Constraint** constraints, uint32_t count); 1112 1113 JPH_CAPI void JPH_PhysicsSystem_AddStepListener(JPH_PhysicsSystem* system, JPH_PhysicsStepListener* listener); 1114 JPH_CAPI void JPH_PhysicsSystem_RemoveStepListener(JPH_PhysicsSystem* system, JPH_PhysicsStepListener* listener); 1115 1116 JPH_CAPI void JPH_PhysicsSystem_GetBodies(const JPH_PhysicsSystem* system, JPH_BodyID* ids, uint32_t count); 1117 JPH_CAPI void JPH_PhysicsSystem_GetConstraints(const JPH_PhysicsSystem* system, const JPH_Constraint** constraints, uint32_t count); 1118 1119 JPH_CAPI void JPH_PhysicsSystem_ActivateBodiesInAABox(JPH_PhysicsSystem* system, const JPH_AABox* box, JPH_ObjectLayer layer); 1120 1121 JPH_CAPI void JPH_PhysicsSystem_DrawBodies(JPH_PhysicsSystem* system, const JPH_DrawSettings* settings, JPH_DebugRenderer* renderer, const JPH_BodyDrawFilter* bodyFilter /* = nullptr */); 1122 JPH_CAPI void JPH_PhysicsSystem_DrawConstraints(JPH_PhysicsSystem* system, JPH_DebugRenderer* renderer); 1123 JPH_CAPI void JPH_PhysicsSystem_DrawConstraintLimits(JPH_PhysicsSystem* system, JPH_DebugRenderer* renderer); 1124 JPH_CAPI void JPH_PhysicsSystem_DrawConstraintReferenceFrame(JPH_PhysicsSystem* system, JPH_DebugRenderer* renderer); 1125 1126 /* PhysicsStepListener */ 1127 typedef struct JPH_PhysicsStepListenerContext { 1128 float deltaTime; 1129 JPH_Bool isFirstStep; 1130 JPH_Bool isLastStep; 1131 JPH_PhysicsSystem* physicsSystem; 1132 } JPH_PhysicsStepListenerContext; 1133 1134 1135 typedef struct JPH_PhysicsStepListener_Procs { 1136 void(JPH_API_CALL* OnStep)(void* userData, const JPH_PhysicsStepListenerContext* context); 1137 } JPH_PhysicsStepListener_Procs; 1138 1139 JPH_CAPI void JPH_PhysicsStepListener_SetProcs(const JPH_PhysicsStepListener_Procs* procs); 1140 JPH_CAPI JPH_PhysicsStepListener* JPH_PhysicsStepListener_Create(void* userData); 1141 JPH_CAPI void JPH_PhysicsStepListener_Destroy(JPH_PhysicsStepListener* listener); 1142 1143 /* Math */ 1144 JPH_CAPI float JPH_Math_Sin(float value); 1145 JPH_CAPI float JPH_Math_Cos(float value); 1146 1147 JPH_CAPI void JPH_Quat_FromTo(const JPH_Vec3* from, const JPH_Vec3* to, JPH_Quat* quat); 1148 JPH_CAPI void JPH_Quat_GetAxisAngle(const JPH_Quat* quat, JPH_Vec3* outAxis, float* outAngle); 1149 JPH_CAPI void JPH_Quat_GetEulerAngles(const JPH_Quat* quat, JPH_Vec3* result); 1150 JPH_CAPI void JPH_Quat_RotateAxisX(const JPH_Quat* quat, JPH_Vec3* result); 1151 JPH_CAPI void JPH_Quat_RotateAxisY(const JPH_Quat* quat, JPH_Vec3* result); 1152 JPH_CAPI void JPH_Quat_RotateAxisZ(const JPH_Quat* quat, JPH_Vec3* result); 1153 JPH_CAPI void JPH_Quat_Inversed(const JPH_Quat* quat, JPH_Quat* result); 1154 JPH_CAPI void JPH_Quat_GetPerpendicular(const JPH_Quat* quat, JPH_Quat* result); 1155 JPH_CAPI float JPH_Quat_GetRotationAngle(const JPH_Quat* quat, const JPH_Vec3* axis); 1156 JPH_CAPI void JPH_Quat_FromEulerAngles(const JPH_Vec3* angles, JPH_Quat* result); 1157 1158 JPH_CAPI void JPH_Quat_Add(const JPH_Quat* q1, const JPH_Quat* q2, JPH_Quat* result); 1159 JPH_CAPI void JPH_Quat_Subtract(const JPH_Quat* q1, const JPH_Quat* q2, JPH_Quat* result); 1160 JPH_CAPI void JPH_Quat_Multiply(const JPH_Quat* q1, const JPH_Quat* q2, JPH_Quat* result); 1161 JPH_CAPI void JPH_Quat_MultiplyScalar(const JPH_Quat* q, float scalar, JPH_Quat* result); 1162 JPH_CAPI void JPH_Quat_DivideScalar(const JPH_Quat* q, float scalar, JPH_Quat* result); 1163 JPH_CAPI void JPH_Quat_Dot(const JPH_Quat* q1, const JPH_Quat* q2, float* result); 1164 1165 JPH_CAPI void JPH_Quat_Conjugated(const JPH_Quat* quat, JPH_Quat* result); 1166 JPH_CAPI void JPH_Quat_GetTwist(const JPH_Quat* quat, const JPH_Vec3* axis, JPH_Quat* result); 1167 JPH_CAPI void JPH_Quat_GetSwingTwist(const JPH_Quat* quat, JPH_Quat* outSwing, JPH_Quat* outTwist); 1168 JPH_CAPI void JPH_Quat_Lerp(const JPH_Quat* from, const JPH_Quat* to, float fraction, JPH_Quat* result); 1169 JPH_CAPI void JPH_Quat_Slerp(const JPH_Quat* from, const JPH_Quat* to, float fraction, JPH_Quat* result); 1170 JPH_CAPI void JPH_Quat_Rotate(const JPH_Quat* quat, const JPH_Vec3* vec, JPH_Vec3* result); 1171 JPH_CAPI void JPH_Quat_InverseRotate(const JPH_Quat* quat, const JPH_Vec3* vec, JPH_Vec3* result); 1172 1173 JPH_CAPI void JPH_Vec3_AxisX(JPH_Vec3* result); 1174 JPH_CAPI void JPH_Vec3_AxisY(JPH_Vec3* result); 1175 JPH_CAPI void JPH_Vec3_AxisZ(JPH_Vec3* result); 1176 JPH_CAPI bool JPH_Vec3_IsClose(const JPH_Vec3* v1, const JPH_Vec3* v2, float maxDistSq); 1177 JPH_CAPI bool JPH_Vec3_IsNearZero(const JPH_Vec3* v, float maxDistSq); 1178 JPH_CAPI bool JPH_Vec3_IsNormalized(const JPH_Vec3* v, float tolerance); 1179 JPH_CAPI bool JPH_Vec3_IsNaN(const JPH_Vec3* v); 1180 1181 JPH_CAPI void JPH_Vec3_Negate(const JPH_Vec3* v, JPH_Vec3* result); 1182 JPH_CAPI void JPH_Vec3_Normalized(const JPH_Vec3* v, JPH_Vec3* result); 1183 JPH_CAPI void JPH_Vec3_Cross(const JPH_Vec3* v1, const JPH_Vec3* v2, JPH_Vec3* result); 1184 JPH_CAPI void JPH_Vec3_Abs(const JPH_Vec3* v, JPH_Vec3* result); 1185 1186 JPH_CAPI float JPH_Vec3_Length(const JPH_Vec3* v); 1187 JPH_CAPI float JPH_Vec3_LengthSquared(const JPH_Vec3* v); 1188 1189 JPH_CAPI void JPH_Vec3_DotProduct(const JPH_Vec3* v1, const JPH_Vec3* v2, float* result); 1190 JPH_CAPI void JPH_Vec3_Normalize(const JPH_Vec3* v, JPH_Vec3* result); 1191 1192 JPH_CAPI void JPH_Vec3_Add(const JPH_Vec3* v1, const JPH_Vec3* v2, JPH_Vec3* result); 1193 JPH_CAPI void JPH_Vec3_Subtract(const JPH_Vec3* v1, const JPH_Vec3* v2, JPH_Vec3* result); 1194 JPH_CAPI void JPH_Vec3_Multiply(const JPH_Vec3* v1, const JPH_Vec3* v2, JPH_Vec3* result); 1195 JPH_CAPI void JPH_Vec3_MultiplyScalar(const JPH_Vec3* v, float scalar, JPH_Vec3* result); 1196 JPH_CAPI void JPH_Vec3_MultiplyMatrix(const JPH_Mat4* left, const JPH_Vec3* right, JPH_Vec3* result); 1197 1198 JPH_CAPI void JPH_Vec3_Divide(const JPH_Vec3* v1, const JPH_Vec3* v2, JPH_Vec3* result); 1199 JPH_CAPI void JPH_Vec3_DivideScalar(const JPH_Vec3* v, float scalar, JPH_Vec3* result); 1200 1201 JPH_CAPI void JPH_Mat4_Add(const JPH_Mat4* m1, const JPH_Mat4* m2, JPH_Mat4* result); 1202 JPH_CAPI void JPH_Mat4_Subtract(const JPH_Mat4* m1, const JPH_Mat4* m2, JPH_Mat4* result); 1203 JPH_CAPI void JPH_Mat4_Multiply(const JPH_Mat4* m1, const JPH_Mat4* m2, JPH_Mat4* result); 1204 JPH_CAPI void JPH_Mat4_MultiplyScalar(const JPH_Mat4* m, float scalar, JPH_Mat4* result); 1205 1206 JPH_CAPI void JPH_Mat4_Zero(JPH_Mat4* result); 1207 JPH_CAPI void JPH_Mat4_Identity(JPH_Mat4* result); 1208 JPH_CAPI void JPH_Mat4_Rotation(JPH_Mat4* result, const JPH_Quat* rotation); 1209 JPH_CAPI void JPH_Mat4_Rotation2(JPH_Mat4* result, const JPH_Vec3* axis, float angle); 1210 JPH_CAPI void JPH_Mat4_Translation(JPH_Mat4* result, const JPH_Vec3* translation); 1211 JPH_CAPI void JPH_Mat4_RotationTranslation(JPH_Mat4* result, const JPH_Quat* rotation, const JPH_Vec3* translation); 1212 JPH_CAPI void JPH_Mat4_InverseRotationTranslation(JPH_Mat4* result, const JPH_Quat* rotation, const JPH_Vec3* translation); 1213 JPH_CAPI void JPH_Mat4_Scale(JPH_Mat4* result, const JPH_Vec3* scale); 1214 JPH_CAPI void JPH_Mat4_Transposed(const JPH_Mat4* m, JPH_Mat4* result); 1215 JPH_CAPI void JPH_Mat4_Inversed(const JPH_Mat4* matrix, JPH_Mat4* result); 1216 1217 JPH_CAPI void JPH_Mat4_GetAxisX(const JPH_Mat4* matrix, JPH_Vec3* result); 1218 JPH_CAPI void JPH_Mat4_GetAxisY(const JPH_Mat4* matrix, JPH_Vec3* result); 1219 JPH_CAPI void JPH_Mat4_GetAxisZ(const JPH_Mat4* matrix, JPH_Vec3* result); 1220 JPH_CAPI void JPH_Mat4_GetTranslation(const JPH_Mat4* matrix, JPH_Vec3* result); 1221 JPH_CAPI void JPH_Mat4_GetQuaternion(const JPH_Mat4* matrix, JPH_Quat* result); 1222 1223 #if defined(JPH_DOUBLE_PRECISION) 1224 JPH_CAPI void JPH_RMat4_Zero(JPH_RMat4* result); 1225 JPH_CAPI void JPH_RMat4_Identity(JPH_RMat4* result); 1226 JPH_CAPI void JPH_RMat4_Rotation(JPH_RMat4* result, const JPH_Quat* rotation); 1227 JPH_CAPI void JPH_RMat4_Translation(JPH_RMat4* result, const JPH_RVec3* translation); 1228 JPH_CAPI void JPH_RMat4_RotationTranslation(JPH_RMat4* result, const JPH_Quat* rotation, const JPH_RVec3* translation); 1229 JPH_CAPI void JPH_RMat4_InverseRotationTranslation(JPH_RMat4* result, const JPH_Quat* rotation, const JPH_RVec3* translation); 1230 JPH_CAPI void JPH_RMat4_Scale(JPH_RMat4* result, const JPH_Vec3* scale); 1231 JPH_CAPI void JPH_RMat4_Inversed(const JPH_RMat4* m, JPH_RMat4* result); 1232 #endif /* defined(JPH_DOUBLE_PRECISION) */ 1233 1234 /* Material */ 1235 JPH_CAPI JPH_PhysicsMaterial* JPH_PhysicsMaterial_Create(const char* name, uint32_t color); 1236 JPH_CAPI void JPH_PhysicsMaterial_Destroy(JPH_PhysicsMaterial* material); 1237 JPH_CAPI const char* JPH_PhysicsMaterial_GetDebugName(const JPH_PhysicsMaterial* material); 1238 JPH_CAPI uint32_t JPH_PhysicsMaterial_GetDebugColor(const JPH_PhysicsMaterial* material); 1239 1240 /* GroupFilter/GroupFilterTable */ 1241 JPH_CAPI void JPH_GroupFilter_Destroy(JPH_GroupFilter* groupFilter); 1242 JPH_CAPI bool JPH_GroupFilter_CanCollide(JPH_GroupFilter* groupFilter, const JPH_CollisionGroup* group1, const JPH_CollisionGroup* group2); 1243 1244 JPH_CAPI JPH_GroupFilterTable* JPH_GroupFilterTable_Create(uint32_t numSubGroups/* = 0*/); 1245 JPH_CAPI void JPH_GroupFilterTable_DisableCollision(JPH_GroupFilterTable* table, JPH_CollisionSubGroupID subGroup1, JPH_CollisionSubGroupID subGroup2); 1246 JPH_CAPI void JPH_GroupFilterTable_EnableCollision(JPH_GroupFilterTable* table, JPH_CollisionSubGroupID subGroup1, JPH_CollisionSubGroupID subGroup2); 1247 JPH_CAPI bool JPH_GroupFilterTable_IsCollisionEnabled(JPH_GroupFilterTable* table, JPH_CollisionSubGroupID subGroup1, JPH_CollisionSubGroupID subGroup2); 1248 1249 /* ShapeSettings */ 1250 JPH_CAPI void JPH_ShapeSettings_Destroy(JPH_ShapeSettings* settings); 1251 JPH_CAPI uint64_t JPH_ShapeSettings_GetUserData(const JPH_ShapeSettings* settings); 1252 JPH_CAPI void JPH_ShapeSettings_SetUserData(JPH_ShapeSettings* settings, uint64_t userData); 1253 1254 /* Shape */ 1255 JPH_CAPI void JPH_Shape_Destroy(JPH_Shape* shape); 1256 JPH_CAPI JPH_ShapeType JPH_Shape_GetType(const JPH_Shape* shape); 1257 JPH_CAPI JPH_ShapeSubType JPH_Shape_GetSubType(const JPH_Shape* shape); 1258 JPH_CAPI uint64_t JPH_Shape_GetUserData(const JPH_Shape* shape); 1259 JPH_CAPI void JPH_Shape_SetUserData(JPH_Shape* shape, uint64_t userData); 1260 JPH_CAPI bool JPH_Shape_MustBeStatic(const JPH_Shape* shape); 1261 JPH_CAPI void JPH_Shape_GetCenterOfMass(const JPH_Shape* shape, JPH_Vec3* result); 1262 JPH_CAPI void JPH_Shape_GetLocalBounds(const JPH_Shape* shape, JPH_AABox* result); 1263 JPH_CAPI uint32_t JPH_Shape_GetSubShapeIDBitsRecursive(const JPH_Shape* shape); 1264 JPH_CAPI void JPH_Shape_GetWorldSpaceBounds(const JPH_Shape* shape, JPH_RMat4* centerOfMassTransform, JPH_Vec3* scale, JPH_AABox* result); 1265 JPH_CAPI float JPH_Shape_GetInnerRadius(const JPH_Shape* shape); 1266 JPH_CAPI void JPH_Shape_GetMassProperties(const JPH_Shape* shape, JPH_MassProperties* result); 1267 JPH_CAPI const JPH_Shape* JPH_Shape_GetLeafShape(const JPH_Shape* shape, JPH_SubShapeID subShapeID, JPH_SubShapeID* remainder); 1268 JPH_CAPI const JPH_PhysicsMaterial* JPH_Shape_GetMaterial(const JPH_Shape* shape, JPH_SubShapeID subShapeID); 1269 JPH_CAPI void JPH_Shape_GetSurfaceNormal(const JPH_Shape* shape, JPH_SubShapeID subShapeID, JPH_Vec3* localPosition, JPH_Vec3* normal); 1270 JPH_CAPI void JPH_Shape_GetSupportingFace(const JPH_Shape* shape, const JPH_SubShapeID subShapeID, const JPH_Vec3* direction, const JPH_Vec3* scale, const JPH_Mat4* centerOfMassTransform, JPH_SupportingFace* outVertices); 1271 JPH_CAPI float JPH_Shape_GetVolume(const JPH_Shape* shape); 1272 JPH_CAPI bool JPH_Shape_IsValidScale(const JPH_Shape* shape, const JPH_Vec3* scale); 1273 JPH_CAPI void JPH_Shape_MakeScaleValid(const JPH_Shape* shape, const JPH_Vec3* scale, JPH_Vec3* result); 1274 JPH_CAPI JPH_Shape* JPH_Shape_ScaleShape(const JPH_Shape* shape, const JPH_Vec3* scale); 1275 JPH_CAPI bool JPH_Shape_CastRay(const JPH_Shape* shape, const JPH_Vec3* origin, const JPH_Vec3* direction, JPH_RayCastResult* hit); 1276 JPH_CAPI bool JPH_Shape_CastRay2(const JPH_Shape* shape, const JPH_Vec3* origin, const JPH_Vec3* direction, const JPH_RayCastSettings* rayCastSettings, JPH_CollisionCollectorType collectorType, JPH_CastRayResultCallback* callback, void* userData, const JPH_ShapeFilter* shapeFilter); 1277 JPH_CAPI bool JPH_Shape_CollidePoint(const JPH_Shape* shape, const JPH_Vec3* point, const JPH_ShapeFilter* shapeFilter); 1278 JPH_CAPI bool JPH_Shape_CollidePoint2(const JPH_Shape* shape, const JPH_Vec3* point, JPH_CollisionCollectorType collectorType, JPH_CollidePointResultCallback* callback, void* userData, const JPH_ShapeFilter* shapeFilter); 1279 1280 /* JPH_ConvexShape */ 1281 JPH_CAPI float JPH_ConvexShapeSettings_GetDensity(const JPH_ConvexShapeSettings* shape); 1282 JPH_CAPI void JPH_ConvexShapeSettings_SetDensity(JPH_ConvexShapeSettings* shape, float value); 1283 JPH_CAPI float JPH_ConvexShape_GetDensity(const JPH_ConvexShape* shape); 1284 JPH_CAPI void JPH_ConvexShape_SetDensity(JPH_ConvexShape* shape, float inDensity); 1285 1286 /* BoxShape */ 1287 JPH_CAPI JPH_BoxShapeSettings* JPH_BoxShapeSettings_Create(const JPH_Vec3* halfExtent, float convexRadius); 1288 JPH_CAPI JPH_BoxShape* JPH_BoxShapeSettings_CreateShape(const JPH_BoxShapeSettings* settings); 1289 1290 JPH_CAPI JPH_BoxShape* JPH_BoxShape_Create(const JPH_Vec3* halfExtent, float convexRadius); 1291 JPH_CAPI void JPH_BoxShape_GetHalfExtent(const JPH_BoxShape* shape, JPH_Vec3* halfExtent); 1292 JPH_CAPI float JPH_BoxShape_GetConvexRadius(const JPH_BoxShape* shape); 1293 1294 /* SphereShape */ 1295 JPH_CAPI JPH_SphereShapeSettings* JPH_SphereShapeSettings_Create(float radius); 1296 JPH_CAPI JPH_SphereShape* JPH_SphereShapeSettings_CreateShape(const JPH_SphereShapeSettings* settings); 1297 1298 JPH_CAPI float JPH_SphereShapeSettings_GetRadius(const JPH_SphereShapeSettings* settings); 1299 JPH_CAPI void JPH_SphereShapeSettings_SetRadius(JPH_SphereShapeSettings* settings, float radius); 1300 JPH_CAPI JPH_SphereShape* JPH_SphereShape_Create(float radius); 1301 JPH_CAPI float JPH_SphereShape_GetRadius(const JPH_SphereShape* shape); 1302 1303 /* PlaneShape */ 1304 JPH_CAPI JPH_PlaneShapeSettings* JPH_PlaneShapeSettings_Create(const JPH_Plane* plane, const JPH_PhysicsMaterial* material, float halfExtent); 1305 JPH_CAPI JPH_PlaneShape* JPH_PlaneShapeSettings_CreateShape(const JPH_PlaneShapeSettings* settings); 1306 JPH_CAPI JPH_PlaneShape* JPH_PlaneShape_Create(const JPH_Plane* plane, const JPH_PhysicsMaterial* material, float halfExtent); 1307 JPH_CAPI void JPH_PlaneShape_GetPlane(const JPH_PlaneShape* shape, JPH_Plane* result); 1308 JPH_CAPI float JPH_PlaneShape_GetHalfExtent(const JPH_PlaneShape* shape); 1309 1310 /* TriangleShape */ 1311 JPH_CAPI JPH_TriangleShapeSettings* JPH_TriangleShapeSettings_Create(const JPH_Vec3* v1, const JPH_Vec3* v2, const JPH_Vec3* v3, float convexRadius); 1312 JPH_CAPI JPH_TriangleShape* JPH_TriangleShapeSettings_CreateShape(const JPH_TriangleShapeSettings* settings); 1313 1314 JPH_CAPI JPH_TriangleShape* JPH_TriangleShape_Create(const JPH_Vec3* v1, const JPH_Vec3* v2, const JPH_Vec3* v3, float convexRadius); 1315 JPH_CAPI float JPH_TriangleShape_GetConvexRadius(const JPH_TriangleShape* shape); 1316 JPH_CAPI void JPH_TriangleShape_GetVertex1(const JPH_TriangleShape* shape, JPH_Vec3* result); 1317 JPH_CAPI void JPH_TriangleShape_GetVertex2(const JPH_TriangleShape* shape, JPH_Vec3* result); 1318 JPH_CAPI void JPH_TriangleShape_GetVertex3(const JPH_TriangleShape* shape, JPH_Vec3* result); 1319 1320 /* CapsuleShape */ 1321 JPH_CAPI JPH_CapsuleShapeSettings* JPH_CapsuleShapeSettings_Create(float halfHeightOfCylinder, float radius); 1322 JPH_CAPI JPH_CapsuleShape* JPH_CapsuleShapeSettings_CreateShape(const JPH_CapsuleShapeSettings* settings); 1323 JPH_CAPI JPH_CapsuleShape* JPH_CapsuleShape_Create(float halfHeightOfCylinder, float radius); 1324 JPH_CAPI float JPH_CapsuleShape_GetRadius(const JPH_CapsuleShape* shape); 1325 JPH_CAPI float JPH_CapsuleShape_GetHalfHeightOfCylinder(const JPH_CapsuleShape* shape); 1326 1327 /* CylinderShape */ 1328 JPH_CAPI JPH_CylinderShapeSettings* JPH_CylinderShapeSettings_Create(float halfHeight, float radius, float convexRadius); 1329 JPH_CAPI JPH_CylinderShape* JPH_CylinderShapeSettings_CreateShape(const JPH_CylinderShapeSettings* settings); 1330 1331 JPH_CAPI JPH_CylinderShape* JPH_CylinderShape_Create(float halfHeight, float radius); 1332 JPH_CAPI float JPH_CylinderShape_GetRadius(const JPH_CylinderShape* shape); 1333 JPH_CAPI float JPH_CylinderShape_GetHalfHeight(const JPH_CylinderShape* shape); 1334 1335 /* TaperedCylinderShape */ 1336 JPH_CAPI JPH_TaperedCylinderShapeSettings* JPH_TaperedCylinderShapeSettings_Create(float halfHeightOfTaperedCylinder, float topRadius, float bottomRadius, float convexRadius/* = cDefaultConvexRadius*/, const JPH_PhysicsMaterial* material /* = NULL*/); 1337 JPH_CAPI JPH_TaperedCylinderShape* JPH_TaperedCylinderShapeSettings_CreateShape(const JPH_TaperedCylinderShapeSettings* settings); 1338 JPH_CAPI float JPH_TaperedCylinderShape_GetTopRadius(const JPH_TaperedCylinderShape* shape); 1339 JPH_CAPI float JPH_TaperedCylinderShape_GetBottomRadius(const JPH_TaperedCylinderShape* shape); 1340 JPH_CAPI float JPH_TaperedCylinderShape_GetConvexRadius(const JPH_TaperedCylinderShape* shape); 1341 JPH_CAPI float JPH_TaperedCylinderShape_GetHalfHeight(const JPH_TaperedCylinderShape* shape); 1342 1343 /* ConvexHullShape */ 1344 JPH_CAPI JPH_ConvexHullShapeSettings* JPH_ConvexHullShapeSettings_Create(const JPH_Vec3* points, uint32_t pointsCount, float maxConvexRadius); 1345 JPH_CAPI JPH_ConvexHullShape* JPH_ConvexHullShapeSettings_CreateShape(const JPH_ConvexHullShapeSettings* settings); 1346 JPH_CAPI uint32_t JPH_ConvexHullShape_GetNumPoints(const JPH_ConvexHullShape* shape); 1347 JPH_CAPI void JPH_ConvexHullShape_GetPoint(const JPH_ConvexHullShape* shape, uint32_t index, JPH_Vec3* result); 1348 JPH_CAPI uint32_t JPH_ConvexHullShape_GetNumFaces(const JPH_ConvexHullShape* shape); 1349 JPH_CAPI uint32_t JPH_ConvexHullShape_GetNumVerticesInFace(const JPH_ConvexHullShape* shape, uint32_t faceIndex); 1350 JPH_CAPI uint32_t JPH_ConvexHullShape_GetFaceVertices(const JPH_ConvexHullShape* shape, uint32_t faceIndex, uint32_t maxVertices, uint32_t* vertices); 1351 1352 /* MeshShape */ 1353 JPH_CAPI JPH_MeshShapeSettings* JPH_MeshShapeSettings_Create(const JPH_Triangle* triangles, uint32_t triangleCount); 1354 JPH_CAPI JPH_MeshShapeSettings* JPH_MeshShapeSettings_Create2(const JPH_Vec3* vertices, uint32_t verticesCount, const JPH_IndexedTriangle* triangles, uint32_t triangleCount); 1355 JPH_CAPI uint32_t JPH_MeshShapeSettings_GetMaxTrianglesPerLeaf(const JPH_MeshShapeSettings* settings); 1356 JPH_CAPI void JPH_MeshShapeSettings_SetMaxTrianglesPerLeaf(JPH_MeshShapeSettings* settings, uint32_t value); 1357 JPH_CAPI float JPH_MeshShapeSettings_GetActiveEdgeCosThresholdAngle(const JPH_MeshShapeSettings* settings); 1358 JPH_CAPI void JPH_MeshShapeSettings_SetActiveEdgeCosThresholdAngle(JPH_MeshShapeSettings* settings, float value); 1359 JPH_CAPI bool JPH_MeshShapeSettings_GetPerTriangleUserData(const JPH_MeshShapeSettings* settings); 1360 JPH_CAPI void JPH_MeshShapeSettings_SetPerTriangleUserData(JPH_MeshShapeSettings* settings, bool value); 1361 JPH_CAPI JPH_Mesh_Shape_BuildQuality JPH_MeshShapeSettings_GetBuildQuality(const JPH_MeshShapeSettings* settings); 1362 JPH_CAPI void JPH_MeshShapeSettings_SetBuildQuality(JPH_MeshShapeSettings* settings, JPH_Mesh_Shape_BuildQuality value); 1363 1364 JPH_CAPI void JPH_MeshShapeSettings_Sanitize(JPH_MeshShapeSettings* settings); 1365 JPH_CAPI JPH_MeshShape* JPH_MeshShapeSettings_CreateShape(const JPH_MeshShapeSettings* settings); 1366 JPH_CAPI uint32_t JPH_MeshShape_GetTriangleUserData(const JPH_MeshShape* shape, JPH_SubShapeID id); 1367 1368 /* HeightFieldShape */ 1369 JPH_CAPI JPH_HeightFieldShapeSettings* JPH_HeightFieldShapeSettings_Create(const float* samples, const JPH_Vec3* offset, const JPH_Vec3* scale, uint32_t sampleCount, const uint8_t* materialIndices); 1370 JPH_CAPI void JPH_HeightFieldShapeSettings_DetermineMinAndMaxSample(const JPH_HeightFieldShapeSettings* settings, float* pOutMinValue, float* pOutMaxValue, float* pOutQuantizationScale); 1371 JPH_CAPI uint32_t JPH_HeightFieldShapeSettings_CalculateBitsPerSampleForError(const JPH_HeightFieldShapeSettings* settings, float maxError); 1372 JPH_CAPI void JPH_HeightFieldShapeSettings_GetOffset(const JPH_HeightFieldShapeSettings* shape, JPH_Vec3* result); 1373 JPH_CAPI void JPH_HeightFieldShapeSettings_SetOffset(JPH_HeightFieldShapeSettings* settings, const JPH_Vec3* value); 1374 JPH_CAPI void JPH_HeightFieldShapeSettings_GetScale(const JPH_HeightFieldShapeSettings* shape, JPH_Vec3* result); 1375 JPH_CAPI void JPH_HeightFieldShapeSettings_SetScale(JPH_HeightFieldShapeSettings* settings, const JPH_Vec3* value); 1376 JPH_CAPI uint32_t JPH_HeightFieldShapeSettings_GetSampleCount(const JPH_HeightFieldShapeSettings* settings); 1377 JPH_CAPI void JPH_HeightFieldShapeSettings_SetSampleCount(JPH_HeightFieldShapeSettings* settings, uint32_t value); 1378 JPH_CAPI float JPH_HeightFieldShapeSettings_GetMinHeightValue(const JPH_HeightFieldShapeSettings* settings); 1379 JPH_CAPI void JPH_HeightFieldShapeSettings_SetMinHeightValue(JPH_HeightFieldShapeSettings* settings, float value); 1380 JPH_CAPI float JPH_HeightFieldShapeSettings_GetMaxHeightValue(const JPH_HeightFieldShapeSettings* settings); 1381 JPH_CAPI void JPH_HeightFieldShapeSettings_SetMaxHeightValue(JPH_HeightFieldShapeSettings* settings, float value); 1382 JPH_CAPI uint32_t JPH_HeightFieldShapeSettings_GetBlockSize(const JPH_HeightFieldShapeSettings* settings); 1383 JPH_CAPI void JPH_HeightFieldShapeSettings_SetBlockSize(JPH_HeightFieldShapeSettings* settings, uint32_t value); 1384 JPH_CAPI uint32_t JPH_HeightFieldShapeSettings_GetBitsPerSample(const JPH_HeightFieldShapeSettings* settings); 1385 JPH_CAPI void JPH_HeightFieldShapeSettings_SetBitsPerSample(JPH_HeightFieldShapeSettings* settings, uint32_t value); 1386 JPH_CAPI float JPH_HeightFieldShapeSettings_GetActiveEdgeCosThresholdAngle(const JPH_HeightFieldShapeSettings* settings); 1387 JPH_CAPI void JPH_HeightFieldShapeSettings_SetActiveEdgeCosThresholdAngle(JPH_HeightFieldShapeSettings* settings, float value); 1388 JPH_CAPI JPH_HeightFieldShape* JPH_HeightFieldShapeSettings_CreateShape(JPH_HeightFieldShapeSettings* settings); 1389 1390 JPH_CAPI uint32_t JPH_HeightFieldShape_GetSampleCount(const JPH_HeightFieldShape* shape); 1391 JPH_CAPI uint32_t JPH_HeightFieldShape_GetBlockSize(const JPH_HeightFieldShape* shape); 1392 JPH_CAPI const JPH_PhysicsMaterial* JPH_HeightFieldShape_GetMaterial(const JPH_HeightFieldShape* shape, uint32_t x, uint32_t y); 1393 JPH_CAPI void JPH_HeightFieldShape_GetPosition(const JPH_HeightFieldShape* shape, uint32_t x, uint32_t y, JPH_Vec3* result); 1394 JPH_CAPI bool JPH_HeightFieldShape_IsNoCollision(const JPH_HeightFieldShape* shape, uint32_t x, uint32_t y); 1395 JPH_CAPI bool JPH_HeightFieldShape_ProjectOntoSurface(const JPH_HeightFieldShape* shape, const JPH_Vec3* localPosition, JPH_Vec3* outSurfacePosition, JPH_SubShapeID* outSubShapeID); 1396 JPH_CAPI float JPH_HeightFieldShape_GetMinHeightValue(const JPH_HeightFieldShape* shape); 1397 JPH_CAPI float JPH_HeightFieldShape_GetMaxHeightValue(const JPH_HeightFieldShape* shape); 1398 1399 /* TaperedCapsuleShape */ 1400 JPH_CAPI JPH_TaperedCapsuleShapeSettings* JPH_TaperedCapsuleShapeSettings_Create(float halfHeightOfTaperedCylinder, float topRadius, float bottomRadius); 1401 JPH_CAPI JPH_TaperedCapsuleShape* JPH_TaperedCapsuleShapeSettings_CreateShape(JPH_TaperedCapsuleShapeSettings* settings); 1402 1403 JPH_CAPI float JPH_TaperedCapsuleShape_GetTopRadius(const JPH_TaperedCapsuleShape* shape); 1404 JPH_CAPI float JPH_TaperedCapsuleShape_GetBottomRadius(const JPH_TaperedCapsuleShape* shape); 1405 JPH_CAPI float JPH_TaperedCapsuleShape_GetHalfHeight(const JPH_TaperedCapsuleShape* shape); 1406 1407 /* CompoundShape */ 1408 JPH_CAPI void JPH_CompoundShapeSettings_AddShape(JPH_CompoundShapeSettings* settings, const JPH_Vec3* position, const JPH_Quat* rotation, const JPH_ShapeSettings* shapeSettings, uint32_t userData); 1409 JPH_CAPI void JPH_CompoundShapeSettings_AddShape2(JPH_CompoundShapeSettings* settings, const JPH_Vec3* position, const JPH_Quat* rotation, const JPH_Shape* shape, uint32_t userData); 1410 JPH_CAPI uint32_t JPH_CompoundShape_GetNumSubShapes(const JPH_CompoundShape* shape); 1411 JPH_CAPI void JPH_CompoundShape_GetSubShape(const JPH_CompoundShape* shape, uint32_t index, const JPH_Shape** subShape, JPH_Vec3* positionCOM, JPH_Quat* rotation, uint32_t* userData); 1412 JPH_CAPI uint32_t JPH_CompoundShape_GetSubShapeIndexFromID(const JPH_CompoundShape* shape, JPH_SubShapeID id, JPH_SubShapeID* remainder); 1413 1414 /* StaticCompoundShape */ 1415 JPH_CAPI JPH_StaticCompoundShapeSettings* JPH_StaticCompoundShapeSettings_Create(void); 1416 JPH_CAPI JPH_StaticCompoundShape* JPH_StaticCompoundShape_Create(const JPH_StaticCompoundShapeSettings* settings); 1417 1418 /* MutableCompoundShape */ 1419 JPH_CAPI JPH_MutableCompoundShapeSettings* JPH_MutableCompoundShapeSettings_Create(void); 1420 JPH_CAPI JPH_MutableCompoundShape* JPH_MutableCompoundShape_Create(const JPH_MutableCompoundShapeSettings* settings); 1421 1422 JPH_CAPI uint32_t JPH_MutableCompoundShape_AddShape(JPH_MutableCompoundShape* shape, const JPH_Vec3* position, const JPH_Quat* rotation, const JPH_Shape* child, uint32_t userData /* = 0 */, uint32_t index /* = UINT32_MAX */); 1423 JPH_CAPI void JPH_MutableCompoundShape_RemoveShape(JPH_MutableCompoundShape* shape, uint32_t index); 1424 JPH_CAPI void JPH_MutableCompoundShape_ModifyShape(JPH_MutableCompoundShape* shape, uint32_t index, const JPH_Vec3* position, const JPH_Quat* rotation); 1425 JPH_CAPI void JPH_MutableCompoundShape_ModifyShape2(JPH_MutableCompoundShape* shape, uint32_t index, const JPH_Vec3* position, const JPH_Quat* rotation, const JPH_Shape* newShape); 1426 JPH_CAPI void JPH_MutableCompoundShape_AdjustCenterOfMass(JPH_MutableCompoundShape* shape); 1427 1428 /* DecoratedShape */ 1429 JPH_CAPI const JPH_Shape* JPH_DecoratedShape_GetInnerShape(const JPH_DecoratedShape* shape); 1430 1431 /* RotatedTranslatedShape */ 1432 JPH_CAPI JPH_RotatedTranslatedShapeSettings* JPH_RotatedTranslatedShapeSettings_Create(const JPH_Vec3* position, const JPH_Quat* rotation, const JPH_ShapeSettings* shapeSettings); 1433 JPH_CAPI JPH_RotatedTranslatedShapeSettings* JPH_RotatedTranslatedShapeSettings_Create2(const JPH_Vec3* position, const JPH_Quat* rotation, const JPH_Shape* shape); 1434 JPH_CAPI JPH_RotatedTranslatedShape* JPH_RotatedTranslatedShapeSettings_CreateShape(const JPH_RotatedTranslatedShapeSettings* settings); 1435 JPH_CAPI JPH_RotatedTranslatedShape* JPH_RotatedTranslatedShape_Create(const JPH_Vec3* position, const JPH_Quat* rotation, const JPH_Shape* shape); 1436 JPH_CAPI void JPH_RotatedTranslatedShape_GetPosition(const JPH_RotatedTranslatedShape* shape, JPH_Vec3* position); 1437 JPH_CAPI void JPH_RotatedTranslatedShape_GetRotation(const JPH_RotatedTranslatedShape* shape, JPH_Quat* rotation); 1438 1439 /* ScaledShape */ 1440 JPH_CAPI JPH_ScaledShapeSettings* JPH_ScaledShapeSettings_Create(const JPH_ShapeSettings* shapeSettings, const JPH_Vec3* scale); 1441 JPH_CAPI JPH_ScaledShapeSettings* JPH_ScaledShapeSettings_Create2(const JPH_Shape* shape, const JPH_Vec3* scale); 1442 JPH_CAPI JPH_ScaledShape* JPH_ScaledShapeSettings_CreateShape(const JPH_ScaledShapeSettings* settings); 1443 JPH_CAPI JPH_ScaledShape* JPH_ScaledShape_Create(const JPH_Shape* shape, const JPH_Vec3* scale); 1444 JPH_CAPI void JPH_ScaledShape_GetScale(const JPH_ScaledShape* shape, JPH_Vec3* result); 1445 1446 /* OffsetCenterOfMassShape */ 1447 JPH_CAPI JPH_OffsetCenterOfMassShapeSettings* JPH_OffsetCenterOfMassShapeSettings_Create(const JPH_Vec3* offset, const JPH_ShapeSettings* shapeSettings); 1448 JPH_CAPI JPH_OffsetCenterOfMassShapeSettings* JPH_OffsetCenterOfMassShapeSettings_Create2(const JPH_Vec3* offset, const JPH_Shape* shape); 1449 JPH_CAPI JPH_OffsetCenterOfMassShape* JPH_OffsetCenterOfMassShapeSettings_CreateShape(const JPH_OffsetCenterOfMassShapeSettings* settings); 1450 1451 JPH_CAPI JPH_OffsetCenterOfMassShape* JPH_OffsetCenterOfMassShape_Create(const JPH_Vec3* offset, const JPH_Shape* shape); 1452 JPH_CAPI void JPH_OffsetCenterOfMassShape_GetOffset(const JPH_OffsetCenterOfMassShape* shape, JPH_Vec3* result); 1453 1454 /* EmptyShape */ 1455 JPH_CAPI JPH_EmptyShapeSettings* JPH_EmptyShapeSettings_Create(const JPH_Vec3* centerOfMass); 1456 JPH_CAPI JPH_EmptyShape* JPH_EmptyShapeSettings_CreateShape(const JPH_EmptyShapeSettings* settings); 1457 1458 /* JPH_BodyCreationSettings */ 1459 JPH_CAPI JPH_BodyCreationSettings* JPH_BodyCreationSettings_Create(void); 1460 JPH_CAPI JPH_BodyCreationSettings* JPH_BodyCreationSettings_Create2(const JPH_ShapeSettings* settings, 1461 const JPH_RVec3* position, 1462 const JPH_Quat* rotation, 1463 JPH_MotionType motionType, 1464 JPH_ObjectLayer objectLayer); 1465 JPH_CAPI JPH_BodyCreationSettings* JPH_BodyCreationSettings_Create3(const JPH_Shape* shape, 1466 const JPH_RVec3* position, 1467 const JPH_Quat* rotation, 1468 JPH_MotionType motionType, 1469 JPH_ObjectLayer objectLayer); 1470 JPH_CAPI void JPH_BodyCreationSettings_Destroy(JPH_BodyCreationSettings* settings); 1471 1472 JPH_CAPI void JPH_BodyCreationSettings_GetPosition(JPH_BodyCreationSettings* settings, JPH_RVec3* result); 1473 JPH_CAPI void JPH_BodyCreationSettings_SetPosition(JPH_BodyCreationSettings* settings, const JPH_RVec3* value); 1474 1475 JPH_CAPI void JPH_BodyCreationSettings_GetRotation(JPH_BodyCreationSettings* settings, JPH_Quat* result); 1476 JPH_CAPI void JPH_BodyCreationSettings_SetRotation(JPH_BodyCreationSettings* settings, const JPH_Quat* value); 1477 1478 JPH_CAPI void JPH_BodyCreationSettings_GetLinearVelocity(JPH_BodyCreationSettings* settings, JPH_Vec3* velocity); 1479 JPH_CAPI void JPH_BodyCreationSettings_SetLinearVelocity(JPH_BodyCreationSettings* settings, const JPH_Vec3* velocity); 1480 1481 JPH_CAPI void JPH_BodyCreationSettings_GetAngularVelocity(JPH_BodyCreationSettings* settings, JPH_Vec3* velocity); 1482 JPH_CAPI void JPH_BodyCreationSettings_SetAngularVelocity(JPH_BodyCreationSettings* settings, const JPH_Vec3* velocity); 1483 1484 JPH_CAPI uint64_t JPH_BodyCreationSettings_GetUserData(const JPH_BodyCreationSettings* settings); 1485 JPH_CAPI void JPH_BodyCreationSettings_SetUserData(JPH_BodyCreationSettings* settings, uint64_t value); 1486 1487 JPH_CAPI JPH_ObjectLayer JPH_BodyCreationSettings_GetObjectLayer(const JPH_BodyCreationSettings* settings); 1488 JPH_CAPI void JPH_BodyCreationSettings_SetObjectLayer(JPH_BodyCreationSettings* settings, JPH_ObjectLayer value); 1489 1490 JPH_CAPI void JPH_BodyCreationSettings_GetCollisionGroup(const JPH_BodyCreationSettings* settings, JPH_CollisionGroup* result); 1491 JPH_CAPI void JPH_BodyCreationSettings_SetCollisionGroup(JPH_BodyCreationSettings* settings, const JPH_CollisionGroup* value); 1492 1493 JPH_CAPI JPH_MotionType JPH_BodyCreationSettings_GetMotionType(const JPH_BodyCreationSettings* settings); 1494 JPH_CAPI void JPH_BodyCreationSettings_SetMotionType(JPH_BodyCreationSettings* settings, JPH_MotionType value); 1495 1496 JPH_CAPI JPH_AllowedDOFs JPH_BodyCreationSettings_GetAllowedDOFs(const JPH_BodyCreationSettings* settings); 1497 JPH_CAPI void JPH_BodyCreationSettings_SetAllowedDOFs(JPH_BodyCreationSettings* settings, JPH_AllowedDOFs value); 1498 1499 JPH_CAPI bool JPH_BodyCreationSettings_GetAllowDynamicOrKinematic(const JPH_BodyCreationSettings* settings); 1500 JPH_CAPI void JPH_BodyCreationSettings_SetAllowDynamicOrKinematic(JPH_BodyCreationSettings* settings, bool value); 1501 1502 JPH_CAPI bool JPH_BodyCreationSettings_GetIsSensor(const JPH_BodyCreationSettings* settings); 1503 JPH_CAPI void JPH_BodyCreationSettings_SetIsSensor(JPH_BodyCreationSettings* settings, bool value); 1504 1505 JPH_CAPI bool JPH_BodyCreationSettings_GetCollideKinematicVsNonDynamic(const JPH_BodyCreationSettings* settings); 1506 JPH_CAPI void JPH_BodyCreationSettings_SetCollideKinematicVsNonDynamic(JPH_BodyCreationSettings* settings, bool value); 1507 1508 JPH_CAPI bool JPH_BodyCreationSettings_GetUseManifoldReduction(const JPH_BodyCreationSettings* settings); 1509 JPH_CAPI void JPH_BodyCreationSettings_SetUseManifoldReduction(JPH_BodyCreationSettings* settings, bool value); 1510 1511 JPH_CAPI bool JPH_BodyCreationSettings_GetApplyGyroscopicForce(const JPH_BodyCreationSettings* settings); 1512 JPH_CAPI void JPH_BodyCreationSettings_SetApplyGyroscopicForce(JPH_BodyCreationSettings* settings, bool value); 1513 1514 JPH_CAPI JPH_MotionQuality JPH_BodyCreationSettings_GetMotionQuality(const JPH_BodyCreationSettings* settings); 1515 JPH_CAPI void JPH_BodyCreationSettings_SetMotionQuality(JPH_BodyCreationSettings* settings, JPH_MotionQuality value); 1516 1517 JPH_CAPI bool JPH_BodyCreationSettings_GetEnhancedInternalEdgeRemoval(const JPH_BodyCreationSettings* settings); 1518 JPH_CAPI void JPH_BodyCreationSettings_SetEnhancedInternalEdgeRemoval(JPH_BodyCreationSettings* settings, bool value); 1519 1520 JPH_CAPI bool JPH_BodyCreationSettings_GetAllowSleeping(const JPH_BodyCreationSettings* settings); 1521 JPH_CAPI void JPH_BodyCreationSettings_SetAllowSleeping(JPH_BodyCreationSettings* settings, bool value); 1522 1523 JPH_CAPI float JPH_BodyCreationSettings_GetFriction(const JPH_BodyCreationSettings* settings); 1524 JPH_CAPI void JPH_BodyCreationSettings_SetFriction(JPH_BodyCreationSettings* settings, float value); 1525 1526 JPH_CAPI float JPH_BodyCreationSettings_GetRestitution(const JPH_BodyCreationSettings* settings); 1527 JPH_CAPI void JPH_BodyCreationSettings_SetRestitution(JPH_BodyCreationSettings* settings, float value); 1528 1529 JPH_CAPI float JPH_BodyCreationSettings_GetLinearDamping(const JPH_BodyCreationSettings* settings); 1530 JPH_CAPI void JPH_BodyCreationSettings_SetLinearDamping(JPH_BodyCreationSettings* settings, float value); 1531 1532 JPH_CAPI float JPH_BodyCreationSettings_GetAngularDamping(const JPH_BodyCreationSettings* settings); 1533 JPH_CAPI void JPH_BodyCreationSettings_SetAngularDamping(JPH_BodyCreationSettings* settings, float value); 1534 1535 JPH_CAPI float JPH_BodyCreationSettings_GetMaxLinearVelocity(const JPH_BodyCreationSettings* settings); 1536 JPH_CAPI void JPH_BodyCreationSettings_SetMaxLinearVelocity(JPH_BodyCreationSettings* settings, float value); 1537 1538 JPH_CAPI float JPH_BodyCreationSettings_GetMaxAngularVelocity(const JPH_BodyCreationSettings* settings); 1539 JPH_CAPI void JPH_BodyCreationSettings_SetMaxAngularVelocity(JPH_BodyCreationSettings* settings, float value); 1540 1541 JPH_CAPI float JPH_BodyCreationSettings_GetGravityFactor(const JPH_BodyCreationSettings* settings); 1542 JPH_CAPI void JPH_BodyCreationSettings_SetGravityFactor(JPH_BodyCreationSettings* settings, float value); 1543 1544 JPH_CAPI uint32_t JPH_BodyCreationSettings_GetNumVelocityStepsOverride(const JPH_BodyCreationSettings* settings); 1545 JPH_CAPI void JPH_BodyCreationSettings_SetNumVelocityStepsOverride(JPH_BodyCreationSettings* settings, uint32_t value); 1546 1547 JPH_CAPI uint32_t JPH_BodyCreationSettings_GetNumPositionStepsOverride(const JPH_BodyCreationSettings* settings); 1548 JPH_CAPI void JPH_BodyCreationSettings_SetNumPositionStepsOverride(JPH_BodyCreationSettings* settings, uint32_t value); 1549 1550 JPH_CAPI JPH_OverrideMassProperties JPH_BodyCreationSettings_GetOverrideMassProperties(const JPH_BodyCreationSettings* settings); 1551 JPH_CAPI void JPH_BodyCreationSettings_SetOverrideMassProperties(JPH_BodyCreationSettings* settings, JPH_OverrideMassProperties value); 1552 1553 JPH_CAPI float JPH_BodyCreationSettings_GetInertiaMultiplier(const JPH_BodyCreationSettings* settings); 1554 JPH_CAPI void JPH_BodyCreationSettings_SetInertiaMultiplier(JPH_BodyCreationSettings* settings, float value); 1555 1556 JPH_CAPI void JPH_BodyCreationSettings_GetMassPropertiesOverride(const JPH_BodyCreationSettings* settings, JPH_MassProperties* result); 1557 JPH_CAPI void JPH_BodyCreationSettings_SetMassPropertiesOverride(JPH_BodyCreationSettings* settings, const JPH_MassProperties* massProperties); 1558 1559 /* JPH_SoftBodyCreationSettings */ 1560 JPH_CAPI JPH_SoftBodyCreationSettings* JPH_SoftBodyCreationSettings_Create(void); 1561 JPH_CAPI void JPH_SoftBodyCreationSettings_Destroy(JPH_SoftBodyCreationSettings* settings); 1562 1563 /* JPH_Constraint */ 1564 JPH_CAPI void JPH_Constraint_Destroy(JPH_Constraint* constraint); 1565 JPH_CAPI JPH_ConstraintType JPH_Constraint_GetType(const JPH_Constraint* constraint); 1566 JPH_CAPI JPH_ConstraintSubType JPH_Constraint_GetSubType(const JPH_Constraint* constraint); 1567 JPH_CAPI uint32_t JPH_Constraint_GetConstraintPriority(const JPH_Constraint* constraint); 1568 JPH_CAPI void JPH_Constraint_SetConstraintPriority(JPH_Constraint* constraint, uint32_t priority); 1569 JPH_CAPI uint32_t JPH_Constraint_GetNumVelocityStepsOverride(const JPH_Constraint* constraint); 1570 JPH_CAPI void JPH_Constraint_SetNumVelocityStepsOverride(JPH_Constraint* constraint, uint32_t value); 1571 JPH_CAPI uint32_t JPH_Constraint_GetNumPositionStepsOverride(const JPH_Constraint* constraint); 1572 JPH_CAPI void JPH_Constraint_SetNumPositionStepsOverride(JPH_Constraint* constraint, uint32_t value); 1573 JPH_CAPI bool JPH_Constraint_GetEnabled(const JPH_Constraint* constraint); 1574 JPH_CAPI void JPH_Constraint_SetEnabled(JPH_Constraint* constraint, bool enabled); 1575 JPH_CAPI uint64_t JPH_Constraint_GetUserData(const JPH_Constraint* constraint); 1576 JPH_CAPI void JPH_Constraint_SetUserData(JPH_Constraint* constraint, uint64_t userData); 1577 JPH_CAPI void JPH_Constraint_NotifyShapeChanged(JPH_Constraint* constraint, JPH_BodyID bodyID, JPH_Vec3* deltaCOM); 1578 JPH_CAPI void JPH_Constraint_ResetWarmStart(JPH_Constraint* constraint); 1579 JPH_CAPI bool JPH_Constraint_IsActive(const JPH_Constraint* constraint); 1580 JPH_CAPI void JPH_Constraint_SetupVelocityConstraint(JPH_Constraint* constraint, float deltaTime); 1581 JPH_CAPI void JPH_Constraint_WarmStartVelocityConstraint(JPH_Constraint* constraint, float warmStartImpulseRatio); 1582 JPH_CAPI bool JPH_Constraint_SolveVelocityConstraint(JPH_Constraint* constraint, float deltaTime); 1583 JPH_CAPI bool JPH_Constraint_SolvePositionConstraint(JPH_Constraint* constraint, float deltaTime, float baumgarte); 1584 1585 /* JPH_TwoBodyConstraint */ 1586 JPH_CAPI JPH_Body* JPH_TwoBodyConstraint_GetBody1(const JPH_TwoBodyConstraint* constraint); 1587 JPH_CAPI JPH_Body* JPH_TwoBodyConstraint_GetBody2(const JPH_TwoBodyConstraint* constraint); 1588 JPH_CAPI void JPH_TwoBodyConstraint_GetConstraintToBody1Matrix(const JPH_TwoBodyConstraint* constraint, JPH_Mat4* result); 1589 JPH_CAPI void JPH_TwoBodyConstraint_GetConstraintToBody2Matrix(const JPH_TwoBodyConstraint* constraint, JPH_Mat4* result); 1590 1591 /* JPH_FixedConstraint */ 1592 JPH_CAPI void JPH_FixedConstraintSettings_Init(JPH_FixedConstraintSettings* settings); 1593 JPH_CAPI JPH_FixedConstraint* JPH_FixedConstraint_Create(const JPH_FixedConstraintSettings* settings, JPH_Body* body1, JPH_Body* body2); 1594 JPH_CAPI void JPH_FixedConstraint_GetSettings(const JPH_FixedConstraint* constraint, JPH_FixedConstraintSettings* settings); 1595 JPH_CAPI void JPH_FixedConstraint_GetTotalLambdaPosition(const JPH_FixedConstraint* constraint, JPH_Vec3* result); 1596 JPH_CAPI void JPH_FixedConstraint_GetTotalLambdaRotation(const JPH_FixedConstraint* constraint, JPH_Vec3* result); 1597 1598 /* JPH_DistanceConstraint */ 1599 JPH_CAPI void JPH_DistanceConstraintSettings_Init(JPH_DistanceConstraintSettings* settings); 1600 JPH_CAPI JPH_DistanceConstraint* JPH_DistanceConstraint_Create(const JPH_DistanceConstraintSettings* settings, JPH_Body* body1, JPH_Body* body2); 1601 JPH_CAPI void JPH_DistanceConstraint_GetSettings(const JPH_DistanceConstraint* constraint, JPH_DistanceConstraintSettings* settings); 1602 JPH_CAPI void JPH_DistanceConstraint_SetDistance(JPH_DistanceConstraint* constraint, float minDistance, float maxDistance); 1603 JPH_CAPI float JPH_DistanceConstraint_GetMinDistance(JPH_DistanceConstraint* constraint); 1604 JPH_CAPI float JPH_DistanceConstraint_GetMaxDistance(JPH_DistanceConstraint* constraint); 1605 JPH_CAPI void JPH_DistanceConstraint_GetLimitsSpringSettings(JPH_DistanceConstraint* constraint, JPH_SpringSettings* result); 1606 JPH_CAPI void JPH_DistanceConstraint_SetLimitsSpringSettings(JPH_DistanceConstraint* constraint, JPH_SpringSettings* settings); 1607 JPH_CAPI float JPH_DistanceConstraint_GetTotalLambdaPosition(const JPH_DistanceConstraint* constraint); 1608 1609 /* JPH_PointConstraint */ 1610 JPH_CAPI void JPH_PointConstraintSettings_Init(JPH_PointConstraintSettings* settings); 1611 JPH_CAPI JPH_PointConstraint* JPH_PointConstraint_Create(const JPH_PointConstraintSettings* settings, JPH_Body* body1, JPH_Body* body2); 1612 JPH_CAPI void JPH_PointConstraint_GetSettings(const JPH_PointConstraint* constraint, JPH_PointConstraintSettings* settings); 1613 JPH_CAPI void JPH_PointConstraint_SetPoint1(JPH_PointConstraint* constraint, JPH_ConstraintSpace space, JPH_RVec3* value); 1614 JPH_CAPI void JPH_PointConstraint_SetPoint2(JPH_PointConstraint* constraint, JPH_ConstraintSpace space, JPH_RVec3* value); 1615 JPH_CAPI void JPH_PointConstraint_GetLocalSpacePoint1(const JPH_PointConstraint* constraint, JPH_Vec3* result); 1616 JPH_CAPI void JPH_PointConstraint_GetLocalSpacePoint2(const JPH_PointConstraint* constraint, JPH_Vec3* result); 1617 JPH_CAPI void JPH_PointConstraint_GetTotalLambdaPosition(const JPH_PointConstraint* constraint, JPH_Vec3* result); 1618 1619 /* JPH_HingeConstraint */ 1620 JPH_CAPI void JPH_HingeConstraintSettings_Init(JPH_HingeConstraintSettings* settings); 1621 JPH_CAPI JPH_HingeConstraint* JPH_HingeConstraint_Create(const JPH_HingeConstraintSettings* settings, JPH_Body* body1, JPH_Body* body2); 1622 JPH_CAPI void JPH_HingeConstraint_GetSettings(JPH_HingeConstraint* constraint, JPH_HingeConstraintSettings* settings); 1623 JPH_CAPI void JPH_HingeConstraint_GetLocalSpacePoint1(const JPH_HingeConstraint* constraint, JPH_Vec3* result); 1624 JPH_CAPI void JPH_HingeConstraint_GetLocalSpacePoint2(const JPH_HingeConstraint* constraint, JPH_Vec3* result); 1625 JPH_CAPI void JPH_HingeConstraint_GetLocalSpaceHingeAxis1(const JPH_HingeConstraint* constraint, JPH_Vec3* result); 1626 JPH_CAPI void JPH_HingeConstraint_GetLocalSpaceHingeAxis2(const JPH_HingeConstraint* constraint, JPH_Vec3* result); 1627 JPH_CAPI void JPH_HingeConstraint_GetLocalSpaceNormalAxis1(const JPH_HingeConstraint* constraint, JPH_Vec3* result); 1628 JPH_CAPI void JPH_HingeConstraint_GetLocalSpaceNormalAxis2(const JPH_HingeConstraint* constraint, JPH_Vec3* result); 1629 JPH_CAPI float JPH_HingeConstraint_GetCurrentAngle(JPH_HingeConstraint* constraint); 1630 JPH_CAPI void JPH_HingeConstraint_SetMaxFrictionTorque(JPH_HingeConstraint* constraint, float frictionTorque); 1631 JPH_CAPI float JPH_HingeConstraint_GetMaxFrictionTorque(JPH_HingeConstraint* constraint); 1632 JPH_CAPI void JPH_HingeConstraint_SetMotorSettings(JPH_HingeConstraint* constraint, JPH_MotorSettings* settings); 1633 JPH_CAPI void JPH_HingeConstraint_GetMotorSettings(JPH_HingeConstraint* constraint, JPH_MotorSettings* result); 1634 JPH_CAPI void JPH_HingeConstraint_SetMotorState(JPH_HingeConstraint* constraint, JPH_MotorState state); 1635 JPH_CAPI JPH_MotorState JPH_HingeConstraint_GetMotorState(JPH_HingeConstraint* constraint); 1636 JPH_CAPI void JPH_HingeConstraint_SetTargetAngularVelocity(JPH_HingeConstraint* constraint, float angularVelocity); 1637 JPH_CAPI float JPH_HingeConstraint_GetTargetAngularVelocity(JPH_HingeConstraint* constraint); 1638 JPH_CAPI void JPH_HingeConstraint_SetTargetAngle(JPH_HingeConstraint* constraint, float angle); 1639 JPH_CAPI float JPH_HingeConstraint_GetTargetAngle(JPH_HingeConstraint* constraint); 1640 JPH_CAPI void JPH_HingeConstraint_SetLimits(JPH_HingeConstraint* constraint, float inLimitsMin, float inLimitsMax); 1641 JPH_CAPI float JPH_HingeConstraint_GetLimitsMin(JPH_HingeConstraint* constraint); 1642 JPH_CAPI float JPH_HingeConstraint_GetLimitsMax(JPH_HingeConstraint* constraint); 1643 JPH_CAPI bool JPH_HingeConstraint_HasLimits(JPH_HingeConstraint* constraint); 1644 JPH_CAPI void JPH_HingeConstraint_GetLimitsSpringSettings(JPH_HingeConstraint* constraint, JPH_SpringSettings* result); 1645 JPH_CAPI void JPH_HingeConstraint_SetLimitsSpringSettings(JPH_HingeConstraint* constraint, JPH_SpringSettings* settings); 1646 JPH_CAPI void JPH_HingeConstraint_GetTotalLambdaPosition(const JPH_HingeConstraint* constraint, JPH_Vec3* result); 1647 JPH_CAPI void JPH_HingeConstraint_GetTotalLambdaRotation(const JPH_HingeConstraint* constraint, float rotation[2]); 1648 JPH_CAPI float JPH_HingeConstraint_GetTotalLambdaRotationLimits(const JPH_HingeConstraint* constraint); 1649 JPH_CAPI float JPH_HingeConstraint_GetTotalLambdaMotor(const JPH_HingeConstraint* constraint); 1650 1651 /* JPH_SliderConstraint */ 1652 JPH_CAPI void JPH_SliderConstraintSettings_Init(JPH_SliderConstraintSettings* settings); 1653 JPH_CAPI void JPH_SliderConstraintSettings_SetSliderAxis(JPH_SliderConstraintSettings* settings, const JPH_Vec3* axis); 1654 1655 JPH_CAPI JPH_SliderConstraint* JPH_SliderConstraint_Create(const JPH_SliderConstraintSettings* settings, JPH_Body* body1, JPH_Body* body2); 1656 JPH_CAPI void JPH_SliderConstraint_GetSettings(JPH_SliderConstraint* constraint, JPH_SliderConstraintSettings* settings); 1657 JPH_CAPI float JPH_SliderConstraint_GetCurrentPosition(JPH_SliderConstraint* constraint); 1658 JPH_CAPI void JPH_SliderConstraint_SetMaxFrictionForce(JPH_SliderConstraint* constraint, float frictionForce); 1659 JPH_CAPI float JPH_SliderConstraint_GetMaxFrictionForce(JPH_SliderConstraint* constraint); 1660 JPH_CAPI void JPH_SliderConstraint_SetMotorSettings(JPH_SliderConstraint* constraint, JPH_MotorSettings* settings); 1661 JPH_CAPI void JPH_SliderConstraint_GetMotorSettings(const JPH_SliderConstraint* constraint, JPH_MotorSettings* result); 1662 JPH_CAPI void JPH_SliderConstraint_SetMotorState(JPH_SliderConstraint* constraint, JPH_MotorState state); 1663 JPH_CAPI JPH_MotorState JPH_SliderConstraint_GetMotorState(JPH_SliderConstraint* constraint); 1664 JPH_CAPI void JPH_SliderConstraint_SetTargetVelocity(JPH_SliderConstraint* constraint, float velocity); 1665 JPH_CAPI float JPH_SliderConstraint_GetTargetVelocity(JPH_SliderConstraint* constraint); 1666 JPH_CAPI void JPH_SliderConstraint_SetTargetPosition(JPH_SliderConstraint* constraint, float position); 1667 JPH_CAPI float JPH_SliderConstraint_GetTargetPosition(JPH_SliderConstraint* constraint); 1668 JPH_CAPI void JPH_SliderConstraint_SetLimits(JPH_SliderConstraint* constraint, float inLimitsMin, float inLimitsMax); 1669 JPH_CAPI float JPH_SliderConstraint_GetLimitsMin(JPH_SliderConstraint* constraint); 1670 JPH_CAPI float JPH_SliderConstraint_GetLimitsMax(JPH_SliderConstraint* constraint); 1671 JPH_CAPI bool JPH_SliderConstraint_HasLimits(JPH_SliderConstraint* constraint); 1672 JPH_CAPI void JPH_SliderConstraint_GetLimitsSpringSettings(JPH_SliderConstraint* constraint, JPH_SpringSettings* result); 1673 JPH_CAPI void JPH_SliderConstraint_SetLimitsSpringSettings(JPH_SliderConstraint* constraint, JPH_SpringSettings* settings); 1674 JPH_CAPI void JPH_SliderConstraint_GetTotalLambdaPosition(const JPH_SliderConstraint* constraint, float position[2]); 1675 JPH_CAPI float JPH_SliderConstraint_GetTotalLambdaPositionLimits(const JPH_SliderConstraint* constraint); 1676 JPH_CAPI void JPH_SliderConstraint_GetTotalLambdaRotation(const JPH_SliderConstraint* constraint, JPH_Vec3* result); 1677 JPH_CAPI float JPH_SliderConstraint_GetTotalLambdaMotor(const JPH_SliderConstraint* constraint); 1678 1679 /* JPH_ConeConstraint */ 1680 JPH_CAPI void JPH_ConeConstraintSettings_Init(JPH_ConeConstraintSettings* settings); 1681 JPH_CAPI JPH_ConeConstraint* JPH_ConeConstraint_Create(const JPH_ConeConstraintSettings* settings, JPH_Body* body1, JPH_Body* body2); 1682 JPH_CAPI void JPH_ConeConstraint_GetSettings(JPH_ConeConstraint* constraint, JPH_ConeConstraintSettings* settings); 1683 JPH_CAPI void JPH_ConeConstraint_SetHalfConeAngle(JPH_ConeConstraint* constraint, float halfConeAngle); 1684 JPH_CAPI float JPH_ConeConstraint_GetCosHalfConeAngle(const JPH_ConeConstraint* constraint); 1685 JPH_CAPI void JPH_ConeConstraint_GetTotalLambdaPosition(const JPH_ConeConstraint* constraint, JPH_Vec3* result); 1686 JPH_CAPI float JPH_ConeConstraint_GetTotalLambdaRotation(const JPH_ConeConstraint* constraint); 1687 1688 /* JPH_SwingTwistConstraint */ 1689 JPH_CAPI void JPH_SwingTwistConstraintSettings_Init(JPH_SwingTwistConstraintSettings* settings); 1690 JPH_CAPI JPH_SwingTwistConstraint* JPH_SwingTwistConstraint_Create(const JPH_SwingTwistConstraintSettings* settings, JPH_Body* body1, JPH_Body* body2); 1691 JPH_CAPI void JPH_SwingTwistConstraint_GetSettings(JPH_SwingTwistConstraint* constraint, JPH_SwingTwistConstraintSettings* settings); 1692 JPH_CAPI float JPH_SwingTwistConstraint_GetNormalHalfConeAngle(JPH_SwingTwistConstraint* constraint); 1693 JPH_CAPI void JPH_SwingTwistConstraint_GetTotalLambdaPosition(const JPH_SwingTwistConstraint* constraint, JPH_Vec3* result); 1694 JPH_CAPI float JPH_SwingTwistConstraint_GetTotalLambdaTwist(const JPH_SwingTwistConstraint* constraint); 1695 JPH_CAPI float JPH_SwingTwistConstraint_GetTotalLambdaSwingY(const JPH_SwingTwistConstraint* constraint); 1696 JPH_CAPI float JPH_SwingTwistConstraint_GetTotalLambdaSwingZ(const JPH_SwingTwistConstraint* constraint); 1697 JPH_CAPI void JPH_SwingTwistConstraint_GetTotalLambdaMotor(const JPH_SwingTwistConstraint* constraint, JPH_Vec3* result); 1698 1699 /* JPH_SixDOFConstraint */ 1700 JPH_CAPI void JPH_SixDOFConstraintSettings_Init(JPH_SixDOFConstraintSettings* settings); 1701 JPH_CAPI void JPH_SixDOFConstraintSettings_MakeFreeAxis(JPH_SixDOFConstraintSettings* settings, JPH_SixDOFConstraintAxis axis); 1702 JPH_CAPI bool JPH_SixDOFConstraintSettings_IsFreeAxis(const JPH_SixDOFConstraintSettings* settings, JPH_SixDOFConstraintAxis axis); 1703 JPH_CAPI void JPH_SixDOFConstraintSettings_MakeFixedAxis(JPH_SixDOFConstraintSettings* settings, JPH_SixDOFConstraintAxis axis); 1704 JPH_CAPI bool JPH_SixDOFConstraintSettings_IsFixedAxis(const JPH_SixDOFConstraintSettings* settings, JPH_SixDOFConstraintAxis axis); 1705 JPH_CAPI void JPH_SixDOFConstraintSettings_SetLimitedAxis(JPH_SixDOFConstraintSettings* settings, JPH_SixDOFConstraintAxis axis, float min, float max); 1706 1707 JPH_CAPI JPH_SixDOFConstraint* JPH_SixDOFConstraint_Create(const JPH_SixDOFConstraintSettings* settings, JPH_Body* body1, JPH_Body* body2); 1708 JPH_CAPI void JPH_SixDOFConstraint_GetSettings(JPH_SixDOFConstraint* constraint, JPH_SixDOFConstraintSettings* settings); 1709 JPH_CAPI float JPH_SixDOFConstraint_GetLimitsMin(JPH_SixDOFConstraint* constraint, JPH_SixDOFConstraintAxis axis); 1710 JPH_CAPI float JPH_SixDOFConstraint_GetLimitsMax(JPH_SixDOFConstraint* constraint, JPH_SixDOFConstraintAxis axis); 1711 JPH_CAPI void JPH_SixDOFConstraint_GetTotalLambdaPosition(const JPH_SixDOFConstraint* constraint, JPH_Vec3* result); 1712 JPH_CAPI void JPH_SixDOFConstraint_GetTotalLambdaRotation(const JPH_SixDOFConstraint* constraint, JPH_Vec3* result); 1713 JPH_CAPI void JPH_SixDOFConstraint_GetTotalLambdaMotorTranslation(const JPH_SixDOFConstraint* constraint, JPH_Vec3* result); 1714 JPH_CAPI void JPH_SixDOFConstraint_GetTotalLambdaMotorRotation(const JPH_SixDOFConstraint* constraint, JPH_Vec3* result); 1715 JPH_CAPI void JPH_SixDOFConstraint_GetTranslationLimitsMin(const JPH_SixDOFConstraint* constraint, JPH_Vec3* result); 1716 JPH_CAPI void JPH_SixDOFConstraint_GetTranslationLimitsMax(const JPH_SixDOFConstraint* constraint, JPH_Vec3* result); 1717 JPH_CAPI void JPH_SixDOFConstraint_GetRotationLimitsMin(const JPH_SixDOFConstraint* constraint, JPH_Vec3* result); 1718 JPH_CAPI void JPH_SixDOFConstraint_GetRotationLimitsMax(const JPH_SixDOFConstraint* constraint, JPH_Vec3* result); 1719 JPH_CAPI bool JPH_SixDOFConstraint_IsFixedAxis(const JPH_SixDOFConstraint* constraint, JPH_SixDOFConstraintAxis axis); 1720 JPH_CAPI bool JPH_SixDOFConstraint_IsFreeAxis(const JPH_SixDOFConstraint* constraint, JPH_SixDOFConstraintAxis axis); 1721 JPH_CAPI void JPH_SixDOFConstraint_GetLimitsSpringSettings(JPH_SixDOFConstraint* constraint, JPH_SpringSettings* result, JPH_SixDOFConstraintAxis axis); 1722 JPH_CAPI void JPH_SixDOFConstraint_SetLimitsSpringSettings(JPH_SixDOFConstraint* constraint, JPH_SpringSettings* settings, JPH_SixDOFConstraintAxis axis); 1723 JPH_CAPI void JPH_SixDOFConstraint_SetMaxFriction(JPH_SixDOFConstraint* constraint, JPH_SixDOFConstraintAxis axis, float inFriction); 1724 JPH_CAPI float JPH_SixDOFConstraint_GetMaxFriction(JPH_SixDOFConstraint* constraint, JPH_SixDOFConstraintAxis axis); 1725 JPH_CAPI void JPH_SixDOFConstraint_GetRotationInConstraintSpace(JPH_SixDOFConstraint* constraint, JPH_Quat* result); 1726 JPH_CAPI void JPH_SixDOFConstraint_GetMotorSettings(JPH_SixDOFConstraint* constraint, JPH_SixDOFConstraintAxis axis, JPH_MotorSettings* settings); 1727 JPH_CAPI void JPH_SixDOFConstraint_SetMotorState(JPH_SixDOFConstraint* constraint, JPH_SixDOFConstraintAxis axis, JPH_MotorState state); 1728 JPH_CAPI JPH_MotorState JPH_SixDOFConstraint_GetMotorState(JPH_SixDOFConstraint* constraint, JPH_SixDOFConstraintAxis axis); 1729 JPH_CAPI void JPH_SixDOFConstraint_SetTargetVelocityCS(JPH_SixDOFConstraint* constraint, JPH_Vec3* inVelocity); 1730 JPH_CAPI void JPH_SixDOFConstraint_GetTargetVelocityCS(JPH_SixDOFConstraint* constraint, JPH_Vec3* result); 1731 JPH_CAPI void JPH_SixDOFConstraint_SetTargetAngularVelocityCS(JPH_SixDOFConstraint* constraint, JPH_Vec3* inAngularVelocity); 1732 JPH_CAPI void JPH_SixDOFConstraint_GetTargetAngularVelocityCS(JPH_SixDOFConstraint* constraint, JPH_Vec3* result); 1733 JPH_CAPI void JPH_SixDOFConstraint_SetTargetPositionCS(JPH_SixDOFConstraint* constraint, JPH_Vec3* inPosition); 1734 JPH_CAPI void JPH_SixDOFConstraint_GetTargetPositionCS(JPH_SixDOFConstraint* constraint, JPH_Vec3* result); 1735 JPH_CAPI void JPH_SixDOFConstraint_SetTargetOrientationCS(JPH_SixDOFConstraint* constraint, JPH_Quat* inOrientation); 1736 JPH_CAPI void JPH_SixDOFConstraint_GetTargetOrientationCS(JPH_SixDOFConstraint* constraint, JPH_Quat* result); 1737 JPH_CAPI void JPH_SixDOFConstraint_SetTargetOrientationBS(JPH_SixDOFConstraint* constraint, JPH_Quat* inOrientation); 1738 1739 /* JPH_GearConstraint */ 1740 JPH_CAPI void JPH_GearConstraintSettings_Init(JPH_GearConstraintSettings* settings); 1741 JPH_CAPI JPH_GearConstraint* JPH_GearConstraint_Create(const JPH_GearConstraintSettings* settings, JPH_Body* body1, JPH_Body* body2); 1742 JPH_CAPI void JPH_GearConstraint_GetSettings(JPH_GearConstraint* constraint, JPH_GearConstraintSettings* settings); 1743 JPH_CAPI void JPH_GearConstraint_SetConstraints(JPH_GearConstraint* constraint, const JPH_Constraint* gear1, const JPH_Constraint* gear2); 1744 JPH_CAPI float JPH_GearConstraint_GetTotalLambda(const JPH_GearConstraint* constraint); 1745 1746 /* BodyInterface */ 1747 JPH_CAPI void JPH_BodyInterface_DestroyBody(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyID); 1748 JPH_CAPI JPH_BodyID JPH_BodyInterface_CreateAndAddBody(JPH_BodyInterface* bodyInterface, const JPH_BodyCreationSettings* settings, JPH_Activation activationMode); 1749 JPH_CAPI JPH_Body* JPH_BodyInterface_CreateBody(JPH_BodyInterface* bodyInterface, const JPH_BodyCreationSettings* settings); 1750 JPH_CAPI JPH_Body* JPH_BodyInterface_CreateBodyWithID(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyID, const JPH_BodyCreationSettings* settings); 1751 JPH_CAPI JPH_Body* JPH_BodyInterface_CreateBodyWithoutID(JPH_BodyInterface* bodyInterface, const JPH_BodyCreationSettings* settings); 1752 JPH_CAPI void JPH_BodyInterface_DestroyBodyWithoutID(JPH_BodyInterface* bodyInterface, JPH_Body* body); 1753 JPH_CAPI bool JPH_BodyInterface_AssignBodyID(JPH_BodyInterface* bodyInterface, JPH_Body* body); 1754 JPH_CAPI bool JPH_BodyInterface_AssignBodyID2(JPH_BodyInterface* bodyInterface, JPH_Body* body, JPH_BodyID bodyID); 1755 JPH_CAPI JPH_Body* JPH_BodyInterface_UnassignBodyID(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyID); 1756 1757 JPH_CAPI JPH_Body* JPH_BodyInterface_CreateSoftBody(JPH_BodyInterface* bodyInterface, const JPH_SoftBodyCreationSettings* settings); 1758 JPH_CAPI JPH_Body* JPH_BodyInterface_CreateSoftBodyWithID(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyID, const JPH_SoftBodyCreationSettings* settings); 1759 JPH_CAPI JPH_Body* JPH_BodyInterface_CreateSoftBodyWithoutID(JPH_BodyInterface* bodyInterface, const JPH_SoftBodyCreationSettings* settings); 1760 JPH_CAPI JPH_BodyID JPH_BodyInterface_CreateAndAddSoftBody(JPH_BodyInterface* bodyInterface, const JPH_SoftBodyCreationSettings* settings, JPH_Activation activationMode); 1761 1762 JPH_CAPI void JPH_BodyInterface_AddBody(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyID, JPH_Activation activationMode); 1763 JPH_CAPI void JPH_BodyInterface_RemoveBody(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyID); 1764 JPH_CAPI void JPH_BodyInterface_RemoveAndDestroyBody(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyID); 1765 JPH_CAPI bool JPH_BodyInterface_IsAdded(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyID); 1766 JPH_CAPI JPH_BodyType JPH_BodyInterface_GetBodyType(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyID); 1767 1768 JPH_CAPI void JPH_BodyInterface_SetLinearVelocity(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyID, const JPH_Vec3* velocity); 1769 JPH_CAPI void JPH_BodyInterface_GetLinearVelocity(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyID, JPH_Vec3* velocity); 1770 JPH_CAPI void JPH_BodyInterface_GetCenterOfMassPosition(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyID, JPH_RVec3* position); 1771 1772 JPH_CAPI JPH_MotionType JPH_BodyInterface_GetMotionType(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyID); 1773 JPH_CAPI void JPH_BodyInterface_SetMotionType(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyID, JPH_MotionType motionType, JPH_Activation activationMode); 1774 1775 JPH_CAPI float JPH_BodyInterface_GetRestitution(const JPH_BodyInterface* bodyInterface, JPH_BodyID bodyID); 1776 JPH_CAPI void JPH_BodyInterface_SetRestitution(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyID, float restitution); 1777 1778 JPH_CAPI float JPH_BodyInterface_GetFriction(const JPH_BodyInterface* bodyInterface, JPH_BodyID bodyID); 1779 JPH_CAPI void JPH_BodyInterface_SetFriction(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyID, float friction); 1780 1781 JPH_CAPI void JPH_BodyInterface_SetPosition(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyId, JPH_RVec3* position, JPH_Activation activationMode); 1782 JPH_CAPI void JPH_BodyInterface_GetPosition(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyId, JPH_RVec3* result); 1783 1784 JPH_CAPI void JPH_BodyInterface_SetRotation(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyId, JPH_Quat* rotation, JPH_Activation activationMode); 1785 JPH_CAPI void JPH_BodyInterface_GetRotation(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyId, JPH_Quat* result); 1786 1787 JPH_CAPI void JPH_BodyInterface_SetPositionAndRotation(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyId, const JPH_RVec3* position, const JPH_Quat* rotation, JPH_Activation activationMode); 1788 JPH_CAPI void JPH_BodyInterface_SetPositionAndRotationWhenChanged(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyId, const JPH_RVec3* position, const JPH_Quat* rotation, JPH_Activation activationMode); 1789 JPH_CAPI void JPH_BodyInterface_GetPositionAndRotation(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyId, JPH_RVec3* position, JPH_Quat* rotation); 1790 JPH_CAPI void JPH_BodyInterface_SetPositionRotationAndVelocity(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyId, JPH_RVec3* position, JPH_Quat* rotation, JPH_Vec3* linearVelocity, JPH_Vec3* angularVelocity); 1791 1792 JPH_CAPI void JPH_BodyInterface_GetCollisionGroup(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyId, JPH_CollisionGroup* result); 1793 JPH_CAPI void JPH_BodyInterface_SetCollisionGroup(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyId, const JPH_CollisionGroup* group); 1794 1795 JPH_CAPI const JPH_Shape* JPH_BodyInterface_GetShape(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyId); 1796 JPH_CAPI void JPH_BodyInterface_SetShape(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyId, const JPH_Shape* shape, bool updateMassProperties, JPH_Activation activationMode); 1797 JPH_CAPI void JPH_BodyInterface_NotifyShapeChanged(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyId, JPH_Vec3* previousCenterOfMass, bool updateMassProperties, JPH_Activation activationMode); 1798 1799 JPH_CAPI void JPH_BodyInterface_ActivateBody(JPH_BodyInterface* bodyInterface, const JPH_BodyID bodyId); 1800 JPH_CAPI void JPH_BodyInterface_ActivateBodies(JPH_BodyInterface* bodyInterface, const JPH_BodyID* bodyIDs, uint32_t count); 1801 JPH_CAPI void JPH_BodyInterface_ActivateBodiesInAABox(JPH_BodyInterface* bodyInterface, const JPH_AABox* box, const JPH_BroadPhaseLayerFilter* broadPhaseLayerFilter, const JPH_ObjectLayerFilter* objectLayerFilter); 1802 JPH_CAPI void JPH_BodyInterface_DeactivateBody(JPH_BodyInterface* bodyInterface, const JPH_BodyID bodyId); 1803 JPH_CAPI void JPH_BodyInterface_DeactivateBodies(JPH_BodyInterface* bodyInterface, const JPH_BodyID* bodyIDs, uint32_t count); 1804 JPH_CAPI bool JPH_BodyInterface_IsActive(const JPH_BodyInterface* bodyInterface, const JPH_BodyID bodyID); 1805 JPH_CAPI void JPH_BodyInterface_ResetSleepTimer(JPH_BodyInterface* bodyInterface, const JPH_BodyID bodyID); 1806 1807 JPH_CAPI JPH_ObjectLayer JPH_BodyInterface_GetObjectLayer(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyId); 1808 JPH_CAPI void JPH_BodyInterface_SetObjectLayer(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyId, JPH_ObjectLayer layer); 1809 1810 JPH_CAPI void JPH_BodyInterface_GetWorldTransform(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyId, JPH_RMat4* result); 1811 JPH_CAPI void JPH_BodyInterface_GetCenterOfMassTransform(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyId, JPH_RMat4* result); 1812 1813 JPH_CAPI void JPH_BodyInterface_MoveKinematic(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyId, JPH_RVec3* targetPosition, JPH_Quat* targetRotation, float deltaTime); 1814 JPH_CAPI bool JPH_BodyInterface_ApplyBuoyancyImpulse(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyId, const JPH_RVec3* surfacePosition, const JPH_Vec3* surfaceNormal, float buoyancy, float linearDrag, float angularDrag, const JPH_Vec3* fluidVelocity, const JPH_Vec3* gravity, float deltaTime); 1815 1816 JPH_CAPI void JPH_BodyInterface_SetLinearAndAngularVelocity(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyId, JPH_Vec3* linearVelocity, JPH_Vec3* angularVelocity); 1817 JPH_CAPI void JPH_BodyInterface_GetLinearAndAngularVelocity(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyId, JPH_Vec3* linearVelocity, JPH_Vec3* angularVelocity); 1818 1819 JPH_CAPI void JPH_BodyInterface_AddLinearVelocity(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyId, JPH_Vec3* linearVelocity); 1820 JPH_CAPI void JPH_BodyInterface_AddLinearAndAngularVelocity(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyId, JPH_Vec3* linearVelocity, JPH_Vec3* angularVelocity); 1821 1822 JPH_CAPI void JPH_BodyInterface_SetAngularVelocity(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyId, JPH_Vec3* angularVelocity); 1823 JPH_CAPI void JPH_BodyInterface_GetAngularVelocity(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyId, JPH_Vec3* angularVelocity); 1824 1825 JPH_CAPI void JPH_BodyInterface_GetPointVelocity(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyId, JPH_RVec3* point, JPH_Vec3* velocity); 1826 1827 JPH_CAPI void JPH_BodyInterface_AddForce(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyId, JPH_Vec3* force); 1828 JPH_CAPI void JPH_BodyInterface_AddForce2(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyId, JPH_Vec3* force, JPH_RVec3* point); 1829 JPH_CAPI void JPH_BodyInterface_AddTorque(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyId, JPH_Vec3* torque); 1830 JPH_CAPI void JPH_BodyInterface_AddForceAndTorque(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyId, JPH_Vec3* force, JPH_Vec3* torque); 1831 1832 JPH_CAPI void JPH_BodyInterface_AddImpulse(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyId, JPH_Vec3* impulse); 1833 JPH_CAPI void JPH_BodyInterface_AddImpulse2(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyId, JPH_Vec3* impulse, JPH_RVec3* point); 1834 JPH_CAPI void JPH_BodyInterface_AddAngularImpulse(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyId, JPH_Vec3* angularImpulse); 1835 1836 JPH_CAPI void JPH_BodyInterface_SetMotionQuality(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyId, JPH_MotionQuality quality); 1837 JPH_CAPI JPH_MotionQuality JPH_BodyInterface_GetMotionQuality(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyId); 1838 1839 JPH_CAPI void JPH_BodyInterface_GetInverseInertia(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyId, JPH_Mat4* result); 1840 1841 JPH_CAPI void JPH_BodyInterface_SetGravityFactor(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyId, float value); 1842 JPH_CAPI float JPH_BodyInterface_GetGravityFactor(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyId); 1843 1844 JPH_CAPI void JPH_BodyInterface_SetUseManifoldReduction(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyId, bool value); 1845 JPH_CAPI bool JPH_BodyInterface_GetUseManifoldReduction(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyId); 1846 1847 JPH_CAPI void JPH_BodyInterface_SetUserData(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyId, uint64_t inUserData); 1848 JPH_CAPI uint64_t JPH_BodyInterface_GetUserData(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyId); 1849 1850 JPH_CAPI void JPH_BodyInterface_SetIsSensor(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyId, bool value); 1851 JPH_CAPI bool JPH_BodyInterface_IsSensor(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyId); 1852 1853 JPH_CAPI const JPH_PhysicsMaterial* JPH_BodyInterface_GetMaterial(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyId, JPH_SubShapeID subShapeID); 1854 1855 JPH_CAPI void JPH_BodyInterface_InvalidateContactCache(JPH_BodyInterface* bodyInterface, JPH_BodyID bodyId); 1856 1857 //-------------------------------------------------------------------------------------------------- 1858 // JPH_BodyLockInterface 1859 //-------------------------------------------------------------------------------------------------- 1860 JPH_CAPI void JPH_BodyLockInterface_LockRead(const JPH_BodyLockInterface* lockInterface, JPH_BodyID bodyID, JPH_BodyLockRead* outLock); 1861 JPH_CAPI void JPH_BodyLockInterface_UnlockRead(const JPH_BodyLockInterface* lockInterface, JPH_BodyLockRead* ioLock); 1862 1863 JPH_CAPI void JPH_BodyLockInterface_LockWrite(const JPH_BodyLockInterface* lockInterface, JPH_BodyID bodyID, JPH_BodyLockWrite* outLock); 1864 JPH_CAPI void JPH_BodyLockInterface_UnlockWrite(const JPH_BodyLockInterface* lockInterface, JPH_BodyLockWrite* ioLock); 1865 1866 JPH_CAPI JPH_BodyLockMultiRead* JPH_BodyLockInterface_LockMultiRead(const JPH_BodyLockInterface* lockInterface, const JPH_BodyID* bodyIDs, uint32_t count); 1867 JPH_CAPI void JPH_BodyLockMultiRead_Destroy(JPH_BodyLockMultiRead* ioLock); 1868 JPH_CAPI const JPH_Body* JPH_BodyLockMultiRead_GetBody(JPH_BodyLockMultiRead* ioLock, uint32_t bodyIndex); 1869 1870 JPH_CAPI JPH_BodyLockMultiWrite* JPH_BodyLockInterface_LockMultiWrite(const JPH_BodyLockInterface* lockInterface, const JPH_BodyID* bodyIDs, uint32_t count); 1871 JPH_CAPI void JPH_BodyLockMultiWrite_Destroy(JPH_BodyLockMultiWrite* ioLock); 1872 JPH_CAPI JPH_Body* JPH_BodyLockMultiWrite_GetBody(JPH_BodyLockMultiWrite* ioLock, uint32_t bodyIndex); 1873 1874 //-------------------------------------------------------------------------------------------------- 1875 // JPH_MotionProperties 1876 //-------------------------------------------------------------------------------------------------- 1877 JPH_CAPI JPH_AllowedDOFs JPH_MotionProperties_GetAllowedDOFs(const JPH_MotionProperties* properties); 1878 JPH_CAPI void JPH_MotionProperties_SetLinearDamping(JPH_MotionProperties* properties, float damping); 1879 JPH_CAPI float JPH_MotionProperties_GetLinearDamping(const JPH_MotionProperties* properties); 1880 JPH_CAPI void JPH_MotionProperties_SetAngularDamping(JPH_MotionProperties* properties, float damping); 1881 JPH_CAPI float JPH_MotionProperties_GetAngularDamping(const JPH_MotionProperties* properties); 1882 JPH_CAPI void JPH_MotionProperties_SetMassProperties(JPH_MotionProperties* properties, JPH_AllowedDOFs allowedDOFs, const JPH_MassProperties* massProperties); 1883 JPH_CAPI float JPH_MotionProperties_GetInverseMassUnchecked(JPH_MotionProperties* properties); 1884 JPH_CAPI void JPH_MotionProperties_SetInverseMass(JPH_MotionProperties* properties, float inverseMass); 1885 JPH_CAPI void JPH_MotionProperties_GetInverseInertiaDiagonal(JPH_MotionProperties* properties, JPH_Vec3* result); 1886 JPH_CAPI void JPH_MotionProperties_GetInertiaRotation(JPH_MotionProperties* properties, JPH_Quat* result); 1887 JPH_CAPI void JPH_MotionProperties_SetInverseInertia(JPH_MotionProperties* properties, JPH_Vec3* diagonal, JPH_Quat* rot); 1888 JPH_CAPI void JPH_MotionProperties_ScaleToMass(JPH_MotionProperties* properties, float mass); 1889 1890 //-------------------------------------------------------------------------------------------------- 1891 // JPH_RayCast 1892 //-------------------------------------------------------------------------------------------------- 1893 JPH_CAPI void JPH_RayCast_GetPointOnRay(const JPH_Vec3* origin, const JPH_Vec3* direction, float fraction, JPH_Vec3* result); 1894 JPH_CAPI void JPH_RRayCast_GetPointOnRay(const JPH_RVec3* origin, const JPH_Vec3* direction, float fraction, JPH_RVec3* result); 1895 1896 //-------------------------------------------------------------------------------------------------- 1897 // JPH_MassProperties 1898 //-------------------------------------------------------------------------------------------------- 1899 JPH_CAPI void JPH_MassProperties_DecomposePrincipalMomentsOfInertia(JPH_MassProperties* properties, JPH_Mat4* rotation, JPH_Vec3* diagonal); 1900 JPH_CAPI void JPH_MassProperties_ScaleToMass(JPH_MassProperties* properties, float mass); 1901 JPH_CAPI void JPH_MassProperties_GetEquivalentSolidBoxSize(float mass, const JPH_Vec3* inertiaDiagonal, JPH_Vec3* result); 1902 1903 //-------------------------------------------------------------------------------------------------- 1904 // JPH_CollideShapeSettings 1905 //-------------------------------------------------------------------------------------------------- 1906 JPH_CAPI void JPH_CollideShapeSettings_Init(JPH_CollideShapeSettings* settings); 1907 1908 //-------------------------------------------------------------------------------------------------- 1909 // JPH_ShapeCastSettings 1910 //-------------------------------------------------------------------------------------------------- 1911 JPH_CAPI void JPH_ShapeCastSettings_Init(JPH_ShapeCastSettings* settings); 1912 1913 //-------------------------------------------------------------------------------------------------- 1914 // JPH_BroadPhaseQuery 1915 //-------------------------------------------------------------------------------------------------- 1916 JPH_CAPI bool JPH_BroadPhaseQuery_CastRay(const JPH_BroadPhaseQuery* query, 1917 const JPH_Vec3* origin, const JPH_Vec3* direction, 1918 JPH_RayCastBodyCollectorCallback* callback, void* userData, 1919 const JPH_BroadPhaseLayerFilter* broadPhaseLayerFilter, 1920 const JPH_ObjectLayerFilter* objectLayerFilter); 1921 1922 JPH_CAPI bool JPH_BroadPhaseQuery_CastRay2(const JPH_BroadPhaseQuery* query, 1923 const JPH_Vec3* origin, const JPH_Vec3* direction, 1924 JPH_CollisionCollectorType collectorType, 1925 JPH_RayCastBodyResultCallback* callback, void* userData, 1926 const JPH_BroadPhaseLayerFilter* broadPhaseLayerFilter, 1927 const JPH_ObjectLayerFilter* objectLayerFilter); 1928 1929 JPH_CAPI bool JPH_BroadPhaseQuery_CollideAABox(const JPH_BroadPhaseQuery* query, 1930 const JPH_AABox* box, JPH_CollideShapeBodyCollectorCallback* callback, void* userData, 1931 const JPH_BroadPhaseLayerFilter* broadPhaseLayerFilter, 1932 const JPH_ObjectLayerFilter* objectLayerFilter); 1933 1934 JPH_CAPI bool JPH_BroadPhaseQuery_CollideSphere(const JPH_BroadPhaseQuery* query, 1935 const JPH_Vec3* center, float radius, JPH_CollideShapeBodyCollectorCallback* callback, void* userData, 1936 const JPH_BroadPhaseLayerFilter* broadPhaseLayerFilter, 1937 const JPH_ObjectLayerFilter* objectLayerFilter); 1938 1939 JPH_CAPI bool JPH_BroadPhaseQuery_CollidePoint(const JPH_BroadPhaseQuery* query, 1940 const JPH_Vec3* point, JPH_CollideShapeBodyCollectorCallback* callback, void* userData, 1941 const JPH_BroadPhaseLayerFilter* broadPhaseLayerFilter, 1942 const JPH_ObjectLayerFilter* objectLayerFilter); 1943 1944 //-------------------------------------------------------------------------------------------------- 1945 // JPH_NarrowPhaseQuery 1946 //-------------------------------------------------------------------------------------------------- 1947 JPH_CAPI bool JPH_NarrowPhaseQuery_CastRay(const JPH_NarrowPhaseQuery* query, 1948 const JPH_RVec3* origin, const JPH_Vec3* direction, 1949 JPH_RayCastResult* hit, 1950 const JPH_BroadPhaseLayerFilter* broadPhaseLayerFilter, 1951 const JPH_ObjectLayerFilter* objectLayerFilter, 1952 const JPH_BodyFilter* bodyFilter); 1953 1954 JPH_CAPI bool JPH_NarrowPhaseQuery_CastRay2(const JPH_NarrowPhaseQuery* query, 1955 const JPH_RVec3* origin, const JPH_Vec3* direction, 1956 const JPH_RayCastSettings* rayCastSettings, 1957 JPH_CastRayCollectorCallback* callback, void* userData, 1958 const JPH_BroadPhaseLayerFilter* broadPhaseLayerFilter, 1959 const JPH_ObjectLayerFilter* objectLayerFilter, 1960 const JPH_BodyFilter* bodyFilter, 1961 const JPH_ShapeFilter* shapeFilter); 1962 1963 JPH_CAPI bool JPH_NarrowPhaseQuery_CastRay3(const JPH_NarrowPhaseQuery* query, 1964 const JPH_RVec3* origin, const JPH_Vec3* direction, 1965 const JPH_RayCastSettings* rayCastSettings, 1966 JPH_CollisionCollectorType collectorType, 1967 JPH_CastRayResultCallback* callback, void* userData, 1968 const JPH_BroadPhaseLayerFilter* broadPhaseLayerFilter, 1969 const JPH_ObjectLayerFilter* objectLayerFilter, 1970 const JPH_BodyFilter* bodyFilter, 1971 const JPH_ShapeFilter* shapeFilter); 1972 1973 JPH_CAPI bool JPH_NarrowPhaseQuery_CollidePoint(const JPH_NarrowPhaseQuery* query, 1974 const JPH_RVec3* point, 1975 JPH_CollidePointCollectorCallback* callback, void* userData, 1976 const JPH_BroadPhaseLayerFilter* broadPhaseLayerFilter, 1977 const JPH_ObjectLayerFilter* objectLayerFilter, 1978 const JPH_BodyFilter* bodyFilter, 1979 const JPH_ShapeFilter* shapeFilter); 1980 1981 JPH_CAPI bool JPH_NarrowPhaseQuery_CollidePoint2(const JPH_NarrowPhaseQuery* query, 1982 const JPH_RVec3* point, 1983 JPH_CollisionCollectorType collectorType, 1984 JPH_CollidePointResultCallback* callback, void* userData, 1985 const JPH_BroadPhaseLayerFilter* broadPhaseLayerFilter, 1986 const JPH_ObjectLayerFilter* objectLayerFilter, 1987 const JPH_BodyFilter* bodyFilter, 1988 const JPH_ShapeFilter* shapeFilter); 1989 1990 JPH_CAPI bool JPH_NarrowPhaseQuery_CollideShape(const JPH_NarrowPhaseQuery* query, 1991 const JPH_Shape* shape, const JPH_Vec3* scale, const JPH_RMat4* centerOfMassTransform, 1992 const JPH_CollideShapeSettings* settings, 1993 JPH_RVec3* baseOffset, 1994 JPH_CollideShapeCollectorCallback* callback, void* userData, 1995 const JPH_BroadPhaseLayerFilter* broadPhaseLayerFilter, 1996 const JPH_ObjectLayerFilter* objectLayerFilter, 1997 const JPH_BodyFilter* bodyFilter, 1998 const JPH_ShapeFilter* shapeFilter); 1999 2000 JPH_CAPI bool JPH_NarrowPhaseQuery_CollideShape2(const JPH_NarrowPhaseQuery* query, 2001 const JPH_Shape* shape, const JPH_Vec3* scale, const JPH_RMat4* centerOfMassTransform, 2002 const JPH_CollideShapeSettings* settings, 2003 JPH_RVec3* baseOffset, 2004 JPH_CollisionCollectorType collectorType, 2005 JPH_CollideShapeResultCallback* callback, void* userData, 2006 const JPH_BroadPhaseLayerFilter* broadPhaseLayerFilter, 2007 const JPH_ObjectLayerFilter* objectLayerFilter, 2008 const JPH_BodyFilter* bodyFilter, 2009 const JPH_ShapeFilter* shapeFilter); 2010 2011 JPH_CAPI bool JPH_NarrowPhaseQuery_CastShape(const JPH_NarrowPhaseQuery* query, 2012 const JPH_Shape* shape, 2013 const JPH_RMat4* worldTransform, const JPH_Vec3* direction, 2014 const JPH_ShapeCastSettings* settings, 2015 JPH_RVec3* baseOffset, 2016 JPH_CastShapeCollectorCallback* callback, void* userData, 2017 const JPH_BroadPhaseLayerFilter* broadPhaseLayerFilter, 2018 const JPH_ObjectLayerFilter* objectLayerFilter, 2019 const JPH_BodyFilter* bodyFilter, 2020 const JPH_ShapeFilter* shapeFilter); 2021 2022 JPH_CAPI bool JPH_NarrowPhaseQuery_CastShape2(const JPH_NarrowPhaseQuery* query, 2023 const JPH_Shape* shape, 2024 const JPH_RMat4* worldTransform, const JPH_Vec3* direction, 2025 const JPH_ShapeCastSettings* settings, 2026 JPH_RVec3* baseOffset, 2027 JPH_CollisionCollectorType collectorType, 2028 JPH_CastShapeResultCallback* callback, void* userData, 2029 const JPH_BroadPhaseLayerFilter* broadPhaseLayerFilter, 2030 const JPH_ObjectLayerFilter* objectLayerFilter, 2031 const JPH_BodyFilter* bodyFilter, 2032 const JPH_ShapeFilter* shapeFilter); 2033 2034 //-------------------------------------------------------------------------------------------------- 2035 // JPH_Body 2036 //-------------------------------------------------------------------------------------------------- 2037 JPH_CAPI JPH_BodyID JPH_Body_GetID(const JPH_Body* body); 2038 JPH_CAPI JPH_BodyType JPH_Body_GetBodyType(const JPH_Body* body); 2039 JPH_CAPI bool JPH_Body_IsRigidBody(const JPH_Body* body); 2040 JPH_CAPI bool JPH_Body_IsSoftBody(const JPH_Body* body); 2041 JPH_CAPI bool JPH_Body_IsActive(const JPH_Body* body); 2042 JPH_CAPI bool JPH_Body_IsStatic(const JPH_Body* body); 2043 JPH_CAPI bool JPH_Body_IsKinematic(const JPH_Body* body); 2044 JPH_CAPI bool JPH_Body_IsDynamic(const JPH_Body* body); 2045 JPH_CAPI bool JPH_Body_CanBeKinematicOrDynamic(const JPH_Body* body); 2046 2047 JPH_CAPI void JPH_Body_SetIsSensor(JPH_Body* body, bool value); 2048 JPH_CAPI bool JPH_Body_IsSensor(const JPH_Body* body); 2049 2050 JPH_CAPI void JPH_Body_SetCollideKinematicVsNonDynamic(JPH_Body* body, bool value); 2051 JPH_CAPI bool JPH_Body_GetCollideKinematicVsNonDynamic(const JPH_Body* body); 2052 2053 JPH_CAPI void JPH_Body_SetUseManifoldReduction(JPH_Body* body, bool value); 2054 JPH_CAPI bool JPH_Body_GetUseManifoldReduction(const JPH_Body* body); 2055 JPH_CAPI bool JPH_Body_GetUseManifoldReductionWithBody(const JPH_Body* body, const JPH_Body* other); 2056 2057 JPH_CAPI void JPH_Body_SetApplyGyroscopicForce(JPH_Body* body, bool value); 2058 JPH_CAPI bool JPH_Body_GetApplyGyroscopicForce(const JPH_Body* body); 2059 2060 JPH_CAPI void JPH_Body_SetEnhancedInternalEdgeRemoval(JPH_Body* body, bool value); 2061 JPH_CAPI bool JPH_Body_GetEnhancedInternalEdgeRemoval(const JPH_Body* body); 2062 JPH_CAPI bool JPH_Body_GetEnhancedInternalEdgeRemovalWithBody(const JPH_Body* body, const JPH_Body* other); 2063 2064 JPH_CAPI JPH_MotionType JPH_Body_GetMotionType(const JPH_Body* body); 2065 JPH_CAPI void JPH_Body_SetMotionType(JPH_Body* body, JPH_MotionType motionType); 2066 2067 JPH_CAPI JPH_BroadPhaseLayer JPH_Body_GetBroadPhaseLayer(const JPH_Body* body); 2068 JPH_CAPI JPH_ObjectLayer JPH_Body_GetObjectLayer(const JPH_Body* body); 2069 2070 JPH_CAPI void JPH_Body_GetCollisionGroup(const JPH_Body* body, JPH_CollisionGroup* result); 2071 JPH_CAPI void JPH_Body_SetCollisionGroup(JPH_Body* body, const JPH_CollisionGroup* value); 2072 2073 JPH_CAPI bool JPH_Body_GetAllowSleeping(JPH_Body* body); 2074 JPH_CAPI void JPH_Body_SetAllowSleeping(JPH_Body* body, bool allowSleeping); 2075 JPH_CAPI void JPH_Body_ResetSleepTimer(JPH_Body* body); 2076 2077 JPH_CAPI float JPH_Body_GetFriction(const JPH_Body* body); 2078 JPH_CAPI void JPH_Body_SetFriction(JPH_Body* body, float friction); 2079 JPH_CAPI float JPH_Body_GetRestitution(const JPH_Body* body); 2080 JPH_CAPI void JPH_Body_SetRestitution(JPH_Body* body, float restitution); 2081 JPH_CAPI void JPH_Body_GetLinearVelocity(JPH_Body* body, JPH_Vec3* velocity); 2082 JPH_CAPI void JPH_Body_SetLinearVelocity(JPH_Body* body, const JPH_Vec3* velocity); 2083 JPH_CAPI void JPH_Body_SetLinearVelocityClamped(JPH_Body* body, const JPH_Vec3* velocity); 2084 JPH_CAPI void JPH_Body_GetAngularVelocity(JPH_Body* body, JPH_Vec3* velocity); 2085 JPH_CAPI void JPH_Body_SetAngularVelocity(JPH_Body* body, const JPH_Vec3* velocity); 2086 JPH_CAPI void JPH_Body_SetAngularVelocityClamped(JPH_Body* body, const JPH_Vec3* velocity); 2087 2088 JPH_CAPI void JPH_Body_GetPointVelocityCOM(JPH_Body* body, const JPH_Vec3* pointRelativeToCOM, JPH_Vec3* velocity); 2089 JPH_CAPI void JPH_Body_GetPointVelocity(JPH_Body* body, const JPH_RVec3* point, JPH_Vec3* velocity); 2090 2091 JPH_CAPI void JPH_Body_AddForce(JPH_Body* body, const JPH_Vec3* force); 2092 JPH_CAPI void JPH_Body_AddForceAtPosition(JPH_Body* body, const JPH_Vec3* force, const JPH_RVec3* position); 2093 JPH_CAPI void JPH_Body_AddTorque(JPH_Body* body, const JPH_Vec3* force); 2094 JPH_CAPI void JPH_Body_GetAccumulatedForce(JPH_Body* body, JPH_Vec3* force); 2095 JPH_CAPI void JPH_Body_GetAccumulatedTorque(JPH_Body* body, JPH_Vec3* force); 2096 JPH_CAPI void JPH_Body_ResetForce(JPH_Body* body); 2097 JPH_CAPI void JPH_Body_ResetTorque(JPH_Body* body); 2098 JPH_CAPI void JPH_Body_ResetMotion(JPH_Body* body); 2099 2100 JPH_CAPI void JPH_Body_GetInverseInertia(JPH_Body* body, JPH_Mat4* result); 2101 2102 JPH_CAPI void JPH_Body_AddImpulse(JPH_Body* body, const JPH_Vec3* impulse); 2103 JPH_CAPI void JPH_Body_AddImpulseAtPosition(JPH_Body* body, const JPH_Vec3* impulse, const JPH_RVec3* position); 2104 JPH_CAPI void JPH_Body_AddAngularImpulse(JPH_Body* body, const JPH_Vec3* angularImpulse); 2105 JPH_CAPI void JPH_Body_MoveKinematic(JPH_Body* body, JPH_RVec3* targetPosition, JPH_Quat* targetRotation, float deltaTime); 2106 JPH_CAPI bool JPH_Body_ApplyBuoyancyImpulse(JPH_Body* body, const JPH_RVec3* surfacePosition, const JPH_Vec3* surfaceNormal, float buoyancy, float linearDrag, float angularDrag, const JPH_Vec3* fluidVelocity, const JPH_Vec3* gravity, float deltaTime); 2107 2108 JPH_CAPI bool JPH_Body_IsInBroadPhase(JPH_Body* body); 2109 JPH_CAPI bool JPH_Body_IsCollisionCacheInvalid(JPH_Body* body); 2110 2111 JPH_CAPI const JPH_Shape* JPH_Body_GetShape(JPH_Body* body); 2112 2113 JPH_CAPI void JPH_Body_GetPosition(const JPH_Body* body, JPH_RVec3* result); 2114 JPH_CAPI void JPH_Body_GetRotation(const JPH_Body* body, JPH_Quat* result); 2115 JPH_CAPI void JPH_Body_GetWorldTransform(const JPH_Body* body, JPH_RMat4* result); 2116 JPH_CAPI void JPH_Body_GetCenterOfMassPosition(const JPH_Body* body, JPH_RVec3* result); 2117 JPH_CAPI void JPH_Body_GetCenterOfMassTransform(const JPH_Body* body, JPH_RMat4* result); 2118 JPH_CAPI void JPH_Body_GetInverseCenterOfMassTransform(const JPH_Body* body, JPH_RMat4* result); 2119 2120 JPH_CAPI void JPH_Body_GetWorldSpaceBounds(const JPH_Body* body, JPH_AABox* result); 2121 JPH_CAPI void JPH_Body_GetWorldSpaceSurfaceNormal(const JPH_Body* body, JPH_SubShapeID subShapeID, const JPH_RVec3* position, JPH_Vec3* normal); 2122 2123 JPH_CAPI JPH_MotionProperties* JPH_Body_GetMotionProperties(JPH_Body* body); 2124 JPH_CAPI JPH_MotionProperties* JPH_Body_GetMotionPropertiesUnchecked(JPH_Body* body); 2125 2126 JPH_CAPI void JPH_Body_SetUserData(JPH_Body* body, uint64_t userData); 2127 JPH_CAPI uint64_t JPH_Body_GetUserData(JPH_Body* body); 2128 2129 JPH_CAPI JPH_Body* JPH_Body_GetFixedToWorldBody(void); 2130 2131 /* JPH_BroadPhaseLayerFilter_Procs */ 2132 typedef struct JPH_BroadPhaseLayerFilter_Procs { 2133 bool(JPH_API_CALL* ShouldCollide)(void* userData, JPH_BroadPhaseLayer layer); 2134 } JPH_BroadPhaseLayerFilter_Procs; 2135 2136 JPH_CAPI void JPH_BroadPhaseLayerFilter_SetProcs(const JPH_BroadPhaseLayerFilter_Procs* procs); 2137 JPH_CAPI JPH_BroadPhaseLayerFilter* JPH_BroadPhaseLayerFilter_Create(void* userData); 2138 JPH_CAPI void JPH_BroadPhaseLayerFilter_Destroy(JPH_BroadPhaseLayerFilter* filter); 2139 2140 /* JPH_ObjectLayerFilter */ 2141 typedef struct JPH_ObjectLayerFilter_Procs { 2142 bool(JPH_API_CALL* ShouldCollide)(void* userData, JPH_ObjectLayer layer); 2143 } JPH_ObjectLayerFilter_Procs; 2144 2145 JPH_CAPI void JPH_ObjectLayerFilter_SetProcs(const JPH_ObjectLayerFilter_Procs* procs); 2146 JPH_CAPI JPH_ObjectLayerFilter* JPH_ObjectLayerFilter_Create(void* userData); 2147 JPH_CAPI void JPH_ObjectLayerFilter_Destroy(JPH_ObjectLayerFilter* filter); 2148 2149 /* JPH_BodyFilter */ 2150 typedef struct JPH_BodyFilter_Procs { 2151 bool(JPH_API_CALL* ShouldCollide)(void* userData, JPH_BodyID bodyID); 2152 bool(JPH_API_CALL* ShouldCollideLocked)(void* userData, const JPH_Body* bodyID); 2153 } JPH_BodyFilter_Procs; 2154 2155 JPH_CAPI void JPH_BodyFilter_SetProcs(const JPH_BodyFilter_Procs* procs); 2156 JPH_CAPI JPH_BodyFilter* JPH_BodyFilter_Create(void* userData); 2157 JPH_CAPI void JPH_BodyFilter_Destroy(JPH_BodyFilter* filter); 2158 2159 /* JPH_ShapeFilter */ 2160 typedef struct JPH_ShapeFilter_Procs { 2161 bool(JPH_API_CALL* ShouldCollide)(void* userData, const JPH_Shape* shape2, const JPH_SubShapeID* subShapeIDOfShape2); 2162 bool(JPH_API_CALL* ShouldCollide2)(void* userData, const JPH_Shape* shape1, const JPH_SubShapeID* subShapeIDOfShape1, const JPH_Shape* shape2, const JPH_SubShapeID* subShapeIDOfShape2); 2163 } JPH_ShapeFilter_Procs; 2164 2165 JPH_CAPI void JPH_ShapeFilter_SetProcs(const JPH_ShapeFilter_Procs* procs); 2166 JPH_CAPI JPH_ShapeFilter* JPH_ShapeFilter_Create(void* userData); 2167 JPH_CAPI void JPH_ShapeFilter_Destroy(JPH_ShapeFilter* filter); 2168 JPH_CAPI JPH_BodyID JPH_ShapeFilter_GetBodyID2(JPH_ShapeFilter* filter); 2169 JPH_CAPI void JPH_ShapeFilter_SetBodyID2(JPH_ShapeFilter* filter, JPH_BodyID id); 2170 2171 /* JPH_SimShapeFilter */ 2172 typedef struct JPH_SimShapeFilter_Procs { 2173 bool(JPH_API_CALL* ShouldCollide)(void* userData, 2174 const JPH_Body* body1, 2175 const JPH_Shape* shape1, 2176 const JPH_SubShapeID* subShapeIDOfShape1, 2177 const JPH_Body* body2, 2178 const JPH_Shape* shape2, 2179 const JPH_SubShapeID* subShapeIDOfShape2 2180 ); 2181 } JPH_SimShapeFilter_Procs; 2182 2183 JPH_CAPI void JPH_SimShapeFilter_SetProcs(const JPH_SimShapeFilter_Procs* procs); 2184 JPH_CAPI JPH_SimShapeFilter* JPH_SimShapeFilter_Create(void* userData); 2185 JPH_CAPI void JPH_SimShapeFilter_Destroy(JPH_SimShapeFilter* filter); 2186 2187 /* Contact listener */ 2188 typedef struct JPH_ContactListener_Procs { 2189 JPH_ValidateResult(JPH_API_CALL* OnContactValidate)(void* userData, 2190 const JPH_Body* body1, 2191 const JPH_Body* body2, 2192 const JPH_RVec3* baseOffset, 2193 const JPH_CollideShapeResult* collisionResult); 2194 2195 void(JPH_API_CALL* OnContactAdded)(void* userData, 2196 const JPH_Body* body1, 2197 const JPH_Body* body2, 2198 const JPH_ContactManifold* manifold, 2199 JPH_ContactSettings* settings); 2200 2201 void(JPH_API_CALL* OnContactPersisted)(void* userData, 2202 const JPH_Body* body1, 2203 const JPH_Body* body2, 2204 const JPH_ContactManifold* manifold, 2205 JPH_ContactSettings* settings); 2206 2207 void(JPH_API_CALL* OnContactRemoved)(void* userData, 2208 const JPH_SubShapeIDPair* subShapePair 2209 ); 2210 } JPH_ContactListener_Procs; 2211 2212 JPH_CAPI void JPH_ContactListener_SetProcs(const JPH_ContactListener_Procs* procs); 2213 JPH_CAPI JPH_ContactListener* JPH_ContactListener_Create(void* userData); 2214 JPH_CAPI void JPH_ContactListener_Destroy(JPH_ContactListener* listener); 2215 2216 /* BodyActivationListener */ 2217 typedef struct JPH_BodyActivationListener_Procs { 2218 void(JPH_API_CALL* OnBodyActivated)(void* userData, JPH_BodyID bodyID, uint64_t bodyUserData); 2219 void(JPH_API_CALL* OnBodyDeactivated)(void* userData, JPH_BodyID bodyID, uint64_t bodyUserData); 2220 } JPH_BodyActivationListener_Procs; 2221 2222 JPH_CAPI void JPH_BodyActivationListener_SetProcs(const JPH_BodyActivationListener_Procs* procs); 2223 JPH_CAPI JPH_BodyActivationListener* JPH_BodyActivationListener_Create(void* userData); 2224 JPH_CAPI void JPH_BodyActivationListener_Destroy(JPH_BodyActivationListener* listener); 2225 2226 /* JPH_BodyDrawFilter */ 2227 typedef struct JPH_BodyDrawFilter_Procs { 2228 bool(JPH_API_CALL* ShouldDraw)(void* userData, const JPH_Body* body); 2229 } JPH_BodyDrawFilter_Procs; 2230 2231 JPH_CAPI void JPH_BodyDrawFilter_SetProcs(const JPH_BodyDrawFilter_Procs* procs); 2232 JPH_CAPI JPH_BodyDrawFilter* JPH_BodyDrawFilter_Create(void* userData); 2233 JPH_CAPI void JPH_BodyDrawFilter_Destroy(JPH_BodyDrawFilter* filter); 2234 2235 /* ContactManifold */ 2236 JPH_CAPI void JPH_ContactManifold_GetWorldSpaceNormal(const JPH_ContactManifold* manifold, JPH_Vec3* result); 2237 JPH_CAPI float JPH_ContactManifold_GetPenetrationDepth(const JPH_ContactManifold* manifold); 2238 JPH_CAPI JPH_SubShapeID JPH_ContactManifold_GetSubShapeID1(const JPH_ContactManifold* manifold); 2239 JPH_CAPI JPH_SubShapeID JPH_ContactManifold_GetSubShapeID2(const JPH_ContactManifold* manifold); 2240 JPH_CAPI uint32_t JPH_ContactManifold_GetPointCount(const JPH_ContactManifold* manifold); 2241 JPH_CAPI void JPH_ContactManifold_GetWorldSpaceContactPointOn1(const JPH_ContactManifold* manifold, uint32_t index, JPH_RVec3* result); 2242 JPH_CAPI void JPH_ContactManifold_GetWorldSpaceContactPointOn2(const JPH_ContactManifold* manifold, uint32_t index, JPH_RVec3* result); 2243 2244 /* CharacterBase */ 2245 JPH_CAPI void JPH_CharacterBase_Destroy(JPH_CharacterBase* character); 2246 JPH_CAPI float JPH_CharacterBase_GetCosMaxSlopeAngle(JPH_CharacterBase* character); 2247 JPH_CAPI void JPH_CharacterBase_SetMaxSlopeAngle(JPH_CharacterBase* character, float maxSlopeAngle); 2248 JPH_CAPI void JPH_CharacterBase_GetUp(JPH_CharacterBase* character, JPH_Vec3* result); 2249 JPH_CAPI void JPH_CharacterBase_SetUp(JPH_CharacterBase* character, const JPH_Vec3* value); 2250 JPH_CAPI bool JPH_CharacterBase_IsSlopeTooSteep(JPH_CharacterBase* character, const JPH_Vec3* value); 2251 JPH_CAPI const JPH_Shape* JPH_CharacterBase_GetShape(JPH_CharacterBase* character); 2252 2253 JPH_CAPI JPH_GroundState JPH_CharacterBase_GetGroundState(JPH_CharacterBase* character); 2254 JPH_CAPI bool JPH_CharacterBase_IsSupported(JPH_CharacterBase* character); 2255 JPH_CAPI void JPH_CharacterBase_GetGroundPosition(JPH_CharacterBase* character, JPH_RVec3* position); 2256 JPH_CAPI void JPH_CharacterBase_GetGroundNormal(JPH_CharacterBase* character, JPH_Vec3* normal); 2257 JPH_CAPI void JPH_CharacterBase_GetGroundVelocity(JPH_CharacterBase* character, JPH_Vec3* velocity); 2258 JPH_CAPI const JPH_PhysicsMaterial* JPH_CharacterBase_GetGroundMaterial(JPH_CharacterBase* character); 2259 JPH_CAPI JPH_BodyID JPH_CharacterBase_GetGroundBodyId(JPH_CharacterBase* character); 2260 JPH_CAPI JPH_SubShapeID JPH_CharacterBase_GetGroundSubShapeId(JPH_CharacterBase* character); 2261 JPH_CAPI uint64_t JPH_CharacterBase_GetGroundUserData(JPH_CharacterBase* character); 2262 2263 /* CharacterSettings */ 2264 JPH_CAPI void JPH_CharacterSettings_Init(JPH_CharacterSettings* settings); 2265 2266 /* Character */ 2267 JPH_CAPI JPH_Character* JPH_Character_Create(const JPH_CharacterSettings* settings, 2268 const JPH_RVec3* position, 2269 const JPH_Quat* rotation, 2270 uint64_t userData, 2271 JPH_PhysicsSystem* system); 2272 2273 JPH_CAPI void JPH_Character_AddToPhysicsSystem(JPH_Character* character, JPH_Activation activationMode /*= JPH_ActivationActivate */, bool lockBodies /* = true */); 2274 JPH_CAPI void JPH_Character_RemoveFromPhysicsSystem(JPH_Character* character, bool lockBodies /* = true */); 2275 JPH_CAPI void JPH_Character_Activate(JPH_Character* character, bool lockBodies /* = true */); 2276 JPH_CAPI void JPH_Character_PostSimulation(JPH_Character* character, float maxSeparationDistance, bool lockBodies /* = true */); 2277 JPH_CAPI void JPH_Character_SetLinearAndAngularVelocity(JPH_Character* character, JPH_Vec3* linearVelocity, JPH_Vec3* angularVelocity, bool lockBodies /* = true */); 2278 JPH_CAPI void JPH_Character_GetLinearVelocity(JPH_Character* character, JPH_Vec3* result); 2279 JPH_CAPI void JPH_Character_SetLinearVelocity(JPH_Character* character, const JPH_Vec3* value, bool lockBodies /* = true */); 2280 JPH_CAPI void JPH_Character_AddLinearVelocity(JPH_Character* character, const JPH_Vec3* value, bool lockBodies /* = true */); 2281 JPH_CAPI void JPH_Character_AddImpulse(JPH_Character* character, const JPH_Vec3* value, bool lockBodies /* = true */); 2282 JPH_CAPI JPH_BodyID JPH_Character_GetBodyID(const JPH_Character* character); 2283 2284 JPH_CAPI void JPH_Character_GetPositionAndRotation(JPH_Character* character, JPH_RVec3* position, JPH_Quat* rotation, bool lockBodies /* = true */); 2285 JPH_CAPI void JPH_Character_SetPositionAndRotation(JPH_Character* character, const JPH_RVec3* position, const JPH_Quat* rotation, JPH_Activation activationMode, bool lockBodies /* = true */); 2286 JPH_CAPI void JPH_Character_GetPosition(JPH_Character* character, JPH_RVec3* position, bool lockBodies /* = true */); 2287 JPH_CAPI void JPH_Character_SetPosition(JPH_Character* character, const JPH_RVec3* position, JPH_Activation activationMode, bool lockBodies /* = true */); 2288 JPH_CAPI void JPH_Character_GetRotation(JPH_Character* character, JPH_Quat* rotation, bool lockBodies /* = true */); 2289 JPH_CAPI void JPH_Character_SetRotation(JPH_Character* character, const JPH_Quat* rotation, JPH_Activation activationMode, bool lockBodies /* = true */); 2290 JPH_CAPI void JPH_Character_GetCenterOfMassPosition(JPH_Character* character, JPH_RVec3* result, bool lockBodies /* = true */); 2291 JPH_CAPI void JPH_Character_GetWorldTransform(JPH_Character* character, JPH_RMat4* result, bool lockBodies /* = true */); 2292 JPH_CAPI JPH_ObjectLayer JPH_Character_GetLayer(const JPH_Character* character); 2293 JPH_CAPI void JPH_Character_SetLayer(JPH_Character* character, JPH_ObjectLayer value, bool lockBodies /*= true*/); 2294 JPH_CAPI void JPH_Character_SetShape(JPH_Character* character, const JPH_Shape* shape, float maxPenetrationDepth, bool lockBodies /*= true*/); 2295 2296 /* CharacterVirtualSettings */ 2297 JPH_CAPI void JPH_CharacterVirtualSettings_Init(JPH_CharacterVirtualSettings* settings); 2298 2299 /* CharacterVirtual */ 2300 JPH_CAPI JPH_CharacterVirtual* JPH_CharacterVirtual_Create(const JPH_CharacterVirtualSettings* settings, 2301 const JPH_RVec3* position, 2302 const JPH_Quat* rotation, 2303 uint64_t userData, 2304 JPH_PhysicsSystem* system); 2305 2306 JPH_CAPI JPH_CharacterID JPH_CharacterVirtual_GetID(const JPH_CharacterVirtual* character); 2307 JPH_CAPI void JPH_CharacterVirtual_SetListener(JPH_CharacterVirtual* character, JPH_CharacterContactListener* listener); 2308 JPH_CAPI void JPH_CharacterVirtual_SetCharacterVsCharacterCollision(JPH_CharacterVirtual* character, JPH_CharacterVsCharacterCollision* characterVsCharacterCollision); 2309 2310 JPH_CAPI void JPH_CharacterVirtual_GetLinearVelocity(JPH_CharacterVirtual* character, JPH_Vec3* velocity); 2311 JPH_CAPI void JPH_CharacterVirtual_SetLinearVelocity(JPH_CharacterVirtual* character, const JPH_Vec3* velocity); 2312 JPH_CAPI void JPH_CharacterVirtual_GetPosition(JPH_CharacterVirtual* character, JPH_RVec3* position); 2313 JPH_CAPI void JPH_CharacterVirtual_SetPosition(JPH_CharacterVirtual* character, const JPH_RVec3* position); 2314 JPH_CAPI void JPH_CharacterVirtual_GetRotation(JPH_CharacterVirtual* character, JPH_Quat* rotation); 2315 JPH_CAPI void JPH_CharacterVirtual_SetRotation(JPH_CharacterVirtual* character, const JPH_Quat* rotation); 2316 JPH_CAPI void JPH_CharacterVirtual_GetWorldTransform(JPH_CharacterVirtual* character, JPH_RMat4* result); 2317 JPH_CAPI void JPH_CharacterVirtual_GetCenterOfMassTransform(JPH_CharacterVirtual* character, JPH_RMat4* result); 2318 JPH_CAPI float JPH_CharacterVirtual_GetMass(JPH_CharacterVirtual* character); 2319 JPH_CAPI void JPH_CharacterVirtual_SetMass(JPH_CharacterVirtual* character, float value); 2320 JPH_CAPI float JPH_CharacterVirtual_GetMaxStrength(JPH_CharacterVirtual* character); 2321 JPH_CAPI void JPH_CharacterVirtual_SetMaxStrength(JPH_CharacterVirtual* character, float value); 2322 2323 JPH_CAPI float JPH_CharacterVirtual_GetPenetrationRecoverySpeed(JPH_CharacterVirtual* character); 2324 JPH_CAPI void JPH_CharacterVirtual_SetPenetrationRecoverySpeed(JPH_CharacterVirtual* character, float value); 2325 JPH_CAPI bool JPH_CharacterVirtual_GetEnhancedInternalEdgeRemoval(JPH_CharacterVirtual* character); 2326 JPH_CAPI void JPH_CharacterVirtual_SetEnhancedInternalEdgeRemoval(JPH_CharacterVirtual* character, bool value); 2327 JPH_CAPI float JPH_CharacterVirtual_GetCharacterPadding(JPH_CharacterVirtual* character); 2328 JPH_CAPI uint32_t JPH_CharacterVirtual_GetMaxNumHits(JPH_CharacterVirtual* character); 2329 JPH_CAPI void JPH_CharacterVirtual_SetMaxNumHits(JPH_CharacterVirtual* character, uint32_t value); 2330 JPH_CAPI float JPH_CharacterVirtual_GetHitReductionCosMaxAngle(JPH_CharacterVirtual* character); 2331 JPH_CAPI void JPH_CharacterVirtual_SetHitReductionCosMaxAngle(JPH_CharacterVirtual* character, float value); 2332 JPH_CAPI bool JPH_CharacterVirtual_GetMaxHitsExceeded(JPH_CharacterVirtual* character); 2333 JPH_CAPI void JPH_CharacterVirtual_GetShapeOffset(JPH_CharacterVirtual* character, JPH_Vec3* result); 2334 JPH_CAPI void JPH_CharacterVirtual_SetShapeOffset(JPH_CharacterVirtual* character, const JPH_Vec3* value); 2335 JPH_CAPI uint64_t JPH_CharacterVirtual_GetUserData(const JPH_CharacterVirtual* character); 2336 JPH_CAPI void JPH_CharacterVirtual_SetUserData(JPH_CharacterVirtual* character, uint64_t value); 2337 JPH_CAPI JPH_BodyID JPH_CharacterVirtual_GetInnerBodyID(const JPH_CharacterVirtual* character); 2338 2339 JPH_CAPI void JPH_CharacterVirtual_CancelVelocityTowardsSteepSlopes(JPH_CharacterVirtual* character, const JPH_Vec3* desiredVelocity, JPH_Vec3* velocity); 2340 JPH_CAPI void JPH_CharacterVirtual_StartTrackingContactChanges(JPH_CharacterVirtual* character); 2341 JPH_CAPI void JPH_CharacterVirtual_FinishTrackingContactChanges(JPH_CharacterVirtual* character); 2342 JPH_CAPI void JPH_CharacterVirtual_Update(JPH_CharacterVirtual* character, float deltaTime, JPH_ObjectLayer layer, JPH_PhysicsSystem* system, const JPH_BodyFilter* bodyFilter, const JPH_ShapeFilter* shapeFilter); 2343 2344 JPH_CAPI void JPH_CharacterVirtual_ExtendedUpdate(JPH_CharacterVirtual* character, float deltaTime, 2345 const JPH_ExtendedUpdateSettings* settings, JPH_ObjectLayer layer, JPH_PhysicsSystem* system, const JPH_BodyFilter* bodyFilter, const JPH_ShapeFilter* shapeFilter); 2346 JPH_CAPI void JPH_CharacterVirtual_RefreshContacts(JPH_CharacterVirtual* character, JPH_ObjectLayer layer, JPH_PhysicsSystem* system, const JPH_BodyFilter* bodyFilter, const JPH_ShapeFilter* shapeFilter); 2347 2348 JPH_CAPI bool JPH_CharacterVirtual_CanWalkStairs(JPH_CharacterVirtual* character, const JPH_Vec3* linearVelocity); 2349 JPH_CAPI bool JPH_CharacterVirtual_WalkStairs(JPH_CharacterVirtual* character, float deltaTime, 2350 const JPH_Vec3* stepUp, const JPH_Vec3* stepForward, const JPH_Vec3* stepForwardTest, const JPH_Vec3* stepDownExtra, 2351 JPH_ObjectLayer layer, JPH_PhysicsSystem* system, 2352 const JPH_BodyFilter* bodyFilter, const JPH_ShapeFilter* shapeFilter); 2353 2354 JPH_CAPI bool JPH_CharacterVirtual_StickToFloor(JPH_CharacterVirtual* character, const JPH_Vec3* stepDown, 2355 JPH_ObjectLayer layer, JPH_PhysicsSystem* system, 2356 const JPH_BodyFilter* bodyFilter, const JPH_ShapeFilter* shapeFilter); 2357 2358 JPH_CAPI void JPH_CharacterVirtual_UpdateGroundVelocity(JPH_CharacterVirtual* character); 2359 JPH_CAPI bool JPH_CharacterVirtual_SetShape(JPH_CharacterVirtual* character, const JPH_Shape* shape, float maxPenetrationDepth, JPH_ObjectLayer layer, JPH_PhysicsSystem* system, const JPH_BodyFilter* bodyFilter, const JPH_ShapeFilter* shapeFilter); 2360 JPH_CAPI void JPH_CharacterVirtual_SetInnerBodyShape(JPH_CharacterVirtual* character, const JPH_Shape* shape); 2361 2362 JPH_CAPI uint32_t JPH_CharacterVirtual_GetNumActiveContacts(JPH_CharacterVirtual* character); 2363 JPH_CAPI void JPH_CharacterVirtual_GetActiveContact(JPH_CharacterVirtual* character, uint32_t index, JPH_CharacterVirtualContact* result); 2364 2365 JPH_CAPI bool JPH_CharacterVirtual_HasCollidedWithBody(JPH_CharacterVirtual* character, const JPH_BodyID body); 2366 JPH_CAPI bool JPH_CharacterVirtual_HasCollidedWith(JPH_CharacterVirtual* character, const JPH_CharacterID other); 2367 JPH_CAPI bool JPH_CharacterVirtual_HasCollidedWithCharacter(JPH_CharacterVirtual* character, const JPH_CharacterVirtual* other); 2368 2369 /* CharacterContactListener */ 2370 typedef struct JPH_CharacterContactListener_Procs { 2371 void (JPH_API_CALL* OnAdjustBodyVelocity)(void* userData, 2372 const JPH_CharacterVirtual* character, 2373 const JPH_Body* body2, 2374 JPH_Vec3* ioLinearVelocity, 2375 JPH_Vec3* ioAngularVelocity); 2376 2377 bool(JPH_API_CALL* OnContactValidate)(void* userData, 2378 const JPH_CharacterVirtual* character, 2379 const JPH_BodyID bodyID2, 2380 const JPH_SubShapeID subShapeID2); 2381 2382 bool(JPH_API_CALL* OnCharacterContactValidate)(void* userData, 2383 const JPH_CharacterVirtual* character, 2384 const JPH_CharacterVirtual* otherCharacter, 2385 const JPH_SubShapeID subShapeID2); 2386 2387 void(JPH_API_CALL* OnContactAdded)(void* userData, 2388 const JPH_CharacterVirtual* character, 2389 const JPH_BodyID bodyID2, 2390 const JPH_SubShapeID subShapeID2, 2391 const JPH_RVec3* contactPosition, 2392 const JPH_Vec3* contactNormal, 2393 JPH_CharacterContactSettings* ioSettings); 2394 2395 void(JPH_API_CALL* OnContactPersisted)(void* userData, 2396 const JPH_CharacterVirtual* character, 2397 const JPH_BodyID bodyID2, 2398 const JPH_SubShapeID subShapeID2, 2399 const JPH_RVec3* contactPosition, 2400 const JPH_Vec3* contactNormal, 2401 JPH_CharacterContactSettings* ioSettings); 2402 2403 void(JPH_API_CALL* OnContactRemoved)(void* userData, 2404 const JPH_CharacterVirtual* character, 2405 const JPH_BodyID bodyID2, 2406 const JPH_SubShapeID subShapeID2); 2407 2408 void(JPH_API_CALL* OnCharacterContactAdded)(void* userData, 2409 const JPH_CharacterVirtual* character, 2410 const JPH_CharacterVirtual* otherCharacter, 2411 const JPH_SubShapeID subShapeID2, 2412 const JPH_RVec3* contactPosition, 2413 const JPH_Vec3* contactNormal, 2414 JPH_CharacterContactSettings* ioSettings); 2415 2416 void(JPH_API_CALL* OnCharacterContactPersisted)(void* userData, 2417 const JPH_CharacterVirtual* character, 2418 const JPH_CharacterVirtual* otherCharacter, 2419 const JPH_SubShapeID subShapeID2, 2420 const JPH_RVec3* contactPosition, 2421 const JPH_Vec3* contactNormal, 2422 JPH_CharacterContactSettings* ioSettings); 2423 2424 void(JPH_API_CALL* OnCharacterContactRemoved)(void* userData, 2425 const JPH_CharacterVirtual* character, 2426 const JPH_CharacterID otherCharacterID, 2427 const JPH_SubShapeID subShapeID2); 2428 2429 void(JPH_API_CALL* OnContactSolve)(void* userData, 2430 const JPH_CharacterVirtual* character, 2431 const JPH_BodyID bodyID2, 2432 const JPH_SubShapeID subShapeID2, 2433 const JPH_RVec3* contactPosition, 2434 const JPH_Vec3* contactNormal, 2435 const JPH_Vec3* contactVelocity, 2436 const JPH_PhysicsMaterial* contactMaterial, 2437 const JPH_Vec3* characterVelocity, 2438 JPH_Vec3* newCharacterVelocity 2439 ); 2440 2441 void(JPH_API_CALL* OnCharacterContactSolve)(void* userData, 2442 const JPH_CharacterVirtual* character, 2443 const JPH_CharacterVirtual* otherCharacter, 2444 const JPH_SubShapeID subShapeID2, 2445 const JPH_RVec3* contactPosition, 2446 const JPH_Vec3* contactNormal, 2447 const JPH_Vec3* contactVelocity, 2448 const JPH_PhysicsMaterial* contactMaterial, 2449 const JPH_Vec3* characterVelocity, 2450 JPH_Vec3* newCharacterVelocity 2451 ); 2452 } JPH_CharacterContactListener_Procs; 2453 2454 JPH_CAPI void JPH_CharacterContactListener_SetProcs(const JPH_CharacterContactListener_Procs* procs); 2455 JPH_CAPI JPH_CharacterContactListener* JPH_CharacterContactListener_Create(void* userData); 2456 JPH_CAPI void JPH_CharacterContactListener_Destroy(JPH_CharacterContactListener* listener); 2457 2458 /* JPH_CharacterVsCharacterCollision */ 2459 typedef struct JPH_CharacterVsCharacterCollision_Procs { 2460 void (JPH_API_CALL* CollideCharacter)(void* userData, 2461 const JPH_CharacterVirtual* character, 2462 const JPH_RMat4* centerOfMassTransform, 2463 const JPH_CollideShapeSettings* collideShapeSettings, 2464 const JPH_RVec3* baseOffset 2465 ); 2466 2467 void (JPH_API_CALL* CastCharacter)(void* userData, 2468 const JPH_CharacterVirtual* character, 2469 const JPH_RMat4* centerOfMassTransform, 2470 const JPH_Vec3* direction, 2471 const JPH_ShapeCastSettings* shapeCastSettings, 2472 const JPH_RVec3* baseOffset 2473 ); 2474 } JPH_CharacterVsCharacterCollision_Procs; 2475 2476 JPH_CAPI void JPH_CharacterVsCharacterCollision_SetProcs(const JPH_CharacterVsCharacterCollision_Procs* procs); 2477 JPH_CAPI JPH_CharacterVsCharacterCollision* JPH_CharacterVsCharacterCollision_Create(void* userData); 2478 JPH_CAPI JPH_CharacterVsCharacterCollision* JPH_CharacterVsCharacterCollision_CreateSimple(void); 2479 JPH_CAPI void JPH_CharacterVsCharacterCollisionSimple_AddCharacter(JPH_CharacterVsCharacterCollision* characterVsCharacter, JPH_CharacterVirtual* character); 2480 JPH_CAPI void JPH_CharacterVsCharacterCollisionSimple_RemoveCharacter(JPH_CharacterVsCharacterCollision* characterVsCharacter, JPH_CharacterVirtual* character); 2481 JPH_CAPI void JPH_CharacterVsCharacterCollision_Destroy(JPH_CharacterVsCharacterCollision* listener); 2482 2483 /* CollisionDispatch */ 2484 JPH_CAPI bool JPH_CollisionDispatch_CollideShapeVsShape( 2485 const JPH_Shape* shape1, const JPH_Shape* shape2, 2486 const JPH_Vec3* scale1, const JPH_Vec3* scale2, 2487 const JPH_Mat4* centerOfMassTransform1, const JPH_Mat4* centerOfMassTransform2, 2488 const JPH_CollideShapeSettings* collideShapeSettings, 2489 JPH_CollideShapeCollectorCallback* callback, void* userData, const JPH_ShapeFilter* shapeFilter); 2490 2491 JPH_CAPI bool JPH_CollisionDispatch_CastShapeVsShapeLocalSpace( 2492 const JPH_Vec3* direction, const JPH_Shape* shape1, const JPH_Shape* shape2, 2493 const JPH_Vec3* scale1InShape2LocalSpace, const JPH_Vec3* scale2, 2494 JPH_Mat4* centerOfMassTransform1InShape2LocalSpace, JPH_Mat4* centerOfMassWorldTransform2, 2495 const JPH_ShapeCastSettings* shapeCastSettings, 2496 JPH_CastShapeCollectorCallback* callback, void* userData, 2497 const JPH_ShapeFilter* shapeFilter); 2498 2499 JPH_CAPI bool JPH_CollisionDispatch_CastShapeVsShapeWorldSpace( 2500 const JPH_Vec3* direction, const JPH_Shape* shape1, const JPH_Shape* shape2, 2501 const JPH_Vec3* scale1, const JPH_Vec3* inScale2, 2502 const JPH_Mat4* centerOfMassWorldTransform1, const JPH_Mat4* centerOfMassWorldTransform2, 2503 const JPH_ShapeCastSettings* shapeCastSettings, 2504 JPH_CastShapeCollectorCallback* callback, void* userData, 2505 const JPH_ShapeFilter* shapeFilter); 2506 2507 /* DebugRenderer */ 2508 typedef struct JPH_DebugRenderer_Procs { 2509 void (JPH_API_CALL* DrawLine)(void* userData, const JPH_RVec3* from, const JPH_RVec3* to, JPH_Color color); 2510 void (JPH_API_CALL* DrawTriangle)(void* userData, const JPH_RVec3* v1, const JPH_RVec3* v2, const JPH_RVec3* v3, JPH_Color color, JPH_DebugRenderer_CastShadow castShadow); 2511 void (JPH_API_CALL* DrawText3D)(void* userData, const JPH_RVec3* position, const char* str, JPH_Color color, float height); 2512 } JPH_DebugRenderer_Procs; 2513 2514 JPH_CAPI void JPH_DebugRenderer_SetProcs(const JPH_DebugRenderer_Procs* procs); 2515 JPH_CAPI JPH_DebugRenderer* JPH_DebugRenderer_Create(void* userData); 2516 JPH_CAPI void JPH_DebugRenderer_Destroy(JPH_DebugRenderer* renderer); 2517 JPH_CAPI void JPH_DebugRenderer_NextFrame(JPH_DebugRenderer* renderer); 2518 JPH_CAPI void JPH_DebugRenderer_SetCameraPos(JPH_DebugRenderer* renderer, const JPH_RVec3* position); 2519 2520 JPH_CAPI void JPH_DebugRenderer_DrawLine(JPH_DebugRenderer* renderer, const JPH_RVec3* from, const JPH_RVec3* to, JPH_Color color); 2521 JPH_CAPI void JPH_DebugRenderer_DrawWireBox(JPH_DebugRenderer* renderer, const JPH_AABox* box, JPH_Color color); 2522 JPH_CAPI void JPH_DebugRenderer_DrawWireBox2(JPH_DebugRenderer* renderer, const JPH_RMat4* matrix, const JPH_AABox* box, JPH_Color color); 2523 JPH_CAPI void JPH_DebugRenderer_DrawMarker(JPH_DebugRenderer* renderer, const JPH_RVec3* position, JPH_Color color, float size); 2524 JPH_CAPI void JPH_DebugRenderer_DrawArrow(JPH_DebugRenderer* renderer, const JPH_RVec3* from, const JPH_RVec3* to, JPH_Color color, float size); 2525 JPH_CAPI void JPH_DebugRenderer_DrawCoordinateSystem(JPH_DebugRenderer* renderer, const JPH_RMat4* matrix, float size); 2526 JPH_CAPI void JPH_DebugRenderer_DrawPlane(JPH_DebugRenderer* renderer, const JPH_RVec3* point, const JPH_Vec3* normal, JPH_Color color, float size); 2527 JPH_CAPI void JPH_DebugRenderer_DrawWireTriangle(JPH_DebugRenderer* renderer, const JPH_RVec3* v1, const JPH_RVec3* v2, const JPH_RVec3* v3, JPH_Color color); 2528 JPH_CAPI void JPH_DebugRenderer_DrawWireSphere(JPH_DebugRenderer* renderer, const JPH_RVec3* center, float radius, JPH_Color color, int level); 2529 JPH_CAPI void JPH_DebugRenderer_DrawWireUnitSphere(JPH_DebugRenderer* renderer, const JPH_RMat4* matrix, JPH_Color color, int level); 2530 JPH_CAPI void JPH_DebugRenderer_DrawTriangle(JPH_DebugRenderer* renderer, const JPH_RVec3* v1, const JPH_RVec3* v2, const JPH_RVec3* v3, JPH_Color color, JPH_DebugRenderer_CastShadow castShadow); 2531 JPH_CAPI void JPH_DebugRenderer_DrawBox(JPH_DebugRenderer* renderer, const JPH_AABox* box, JPH_Color color, JPH_DebugRenderer_CastShadow castShadow, JPH_DebugRenderer_DrawMode drawMode); 2532 JPH_CAPI void JPH_DebugRenderer_DrawBox2(JPH_DebugRenderer* renderer, const JPH_RMat4* matrix, const JPH_AABox* box, JPH_Color color, JPH_DebugRenderer_CastShadow castShadow, JPH_DebugRenderer_DrawMode drawMode); 2533 JPH_CAPI void JPH_DebugRenderer_DrawSphere(JPH_DebugRenderer* renderer, const JPH_RVec3* center, float radius, JPH_Color color, JPH_DebugRenderer_CastShadow castShadow, JPH_DebugRenderer_DrawMode drawMode); 2534 JPH_CAPI void JPH_DebugRenderer_DrawUnitSphere(JPH_DebugRenderer* renderer, JPH_RMat4 matrix, JPH_Color color, JPH_DebugRenderer_CastShadow castShadow, JPH_DebugRenderer_DrawMode drawMode); 2535 JPH_CAPI void JPH_DebugRenderer_DrawCapsule(JPH_DebugRenderer* renderer, const JPH_RMat4* matrix, float halfHeightOfCylinder, float radius, JPH_Color color, JPH_DebugRenderer_CastShadow castShadow, JPH_DebugRenderer_DrawMode drawMode); 2536 JPH_CAPI void JPH_DebugRenderer_DrawCylinder(JPH_DebugRenderer* renderer, const JPH_RMat4* matrix, float halfHeight, float radius, JPH_Color color, JPH_DebugRenderer_CastShadow castShadow, JPH_DebugRenderer_DrawMode drawMode); 2537 JPH_CAPI void JPH_DebugRenderer_DrawOpenCone(JPH_DebugRenderer* renderer, const JPH_RVec3* top, const JPH_Vec3* axis, const JPH_Vec3* perpendicular, float halfAngle, float length, JPH_Color color, JPH_DebugRenderer_CastShadow castShadow, JPH_DebugRenderer_DrawMode drawMode); 2538 JPH_CAPI void JPH_DebugRenderer_DrawSwingConeLimits(JPH_DebugRenderer* renderer, const JPH_RMat4* matrix, float swingYHalfAngle, float swingZHalfAngle, float edgeLength, JPH_Color color, JPH_DebugRenderer_CastShadow castShadow, JPH_DebugRenderer_DrawMode drawMode); 2539 JPH_CAPI void JPH_DebugRenderer_DrawSwingPyramidLimits(JPH_DebugRenderer* renderer, const JPH_RMat4* matrix, float minSwingYAngle, float maxSwingYAngle, float minSwingZAngle, float maxSwingZAngle, float edgeLength, JPH_Color color, JPH_DebugRenderer_CastShadow castShadow, JPH_DebugRenderer_DrawMode drawMode); 2540 JPH_CAPI void JPH_DebugRenderer_DrawPie(JPH_DebugRenderer* renderer, const JPH_RVec3* center, float radius, const JPH_Vec3* normal, const JPH_Vec3* axis, float minAngle, float maxAngle, JPH_Color color, JPH_DebugRenderer_CastShadow castShadow, JPH_DebugRenderer_DrawMode drawMode); 2541 JPH_CAPI void JPH_DebugRenderer_DrawTaperedCylinder(JPH_DebugRenderer* renderer, const JPH_RMat4* inMatrix, float top, float bottom, float topRadius, float bottomRadius, JPH_Color color, JPH_DebugRenderer_CastShadow castShadow, JPH_DebugRenderer_DrawMode drawMode); 2542 2543 2544 /* Skeleton */ 2545 typedef struct JPH_SkeletonJoint { 2546 const char* name; 2547 const char* parentName; 2548 int parentJointIndex; 2549 } JPH_SkeletonJoint; 2550 2551 JPH_CAPI JPH_Skeleton* JPH_Skeleton_Create(void); 2552 JPH_CAPI void JPH_Skeleton_Destroy(JPH_Skeleton* skeleton); 2553 2554 JPH_CAPI uint32_t JPH_Skeleton_AddJoint(JPH_Skeleton* skeleton, const char* name); 2555 JPH_CAPI uint32_t JPH_Skeleton_AddJoint2(JPH_Skeleton* skeleton, const char* name, int parentIndex); 2556 JPH_CAPI uint32_t JPH_Skeleton_AddJoint3(JPH_Skeleton* skeleton, const char* name, const char* parentName); 2557 JPH_CAPI int JPH_Skeleton_GetJointCount(const JPH_Skeleton* skeleton); 2558 JPH_CAPI void JPH_Skeleton_GetJoint(const JPH_Skeleton* skeleton, int index, JPH_SkeletonJoint* joint); 2559 JPH_CAPI int JPH_Skeleton_GetJointIndex(const JPH_Skeleton* skeleton, const char* name); 2560 JPH_CAPI void JPH_Skeleton_CalculateParentJointIndices(JPH_Skeleton* skeleton); 2561 JPH_CAPI bool JPH_Skeleton_AreJointsCorrectlyOrdered(const JPH_Skeleton* skeleton); 2562 2563 /* Ragdoll */ 2564 JPH_CAPI JPH_RagdollSettings* JPH_RagdollSettings_Create(void); 2565 JPH_CAPI void JPH_RagdollSettings_Destroy(JPH_RagdollSettings* settings); 2566 2567 JPH_CAPI const JPH_Skeleton* JPH_RagdollSettings_GetSkeleton(const JPH_RagdollSettings* character); 2568 JPH_CAPI void JPH_RagdollSettings_SetSkeleton(JPH_RagdollSettings* character, JPH_Skeleton* skeleton); 2569 JPH_CAPI bool JPH_RagdollSettings_Stabilize(JPH_RagdollSettings* settings); 2570 JPH_CAPI void JPH_RagdollSettings_DisableParentChildCollisions(JPH_RagdollSettings* settings, const JPH_Mat4* jointMatrices /*=nullptr*/, float minSeparationDistance/* = 0.0f*/); 2571 JPH_CAPI void JPH_RagdollSettings_CalculateBodyIndexToConstraintIndex(JPH_RagdollSettings* settings); 2572 JPH_CAPI int JPH_RagdollSettings_GetConstraintIndexForBodyIndex(JPH_RagdollSettings* settings, int bodyIndex); 2573 JPH_CAPI void JPH_RagdollSettings_CalculateConstraintIndexToBodyIdxPair(JPH_RagdollSettings* settings); 2574 2575 JPH_CAPI JPH_Ragdoll* JPH_RagdollSettings_CreateRagdoll(JPH_RagdollSettings* settings, JPH_PhysicsSystem* system, JPH_CollisionGroupID collisionGroup /*=0*/, uint64_t userData/* = 0*/); 2576 JPH_CAPI void JPH_Ragdoll_Destroy(JPH_Ragdoll* ragdoll); 2577 JPH_CAPI void JPH_Ragdoll_AddToPhysicsSystem(JPH_Ragdoll* ragdoll, JPH_Activation activationMode /*= JPH_ActivationActivate */, bool lockBodies /* = true */); 2578 JPH_CAPI void JPH_Ragdoll_RemoveFromPhysicsSystem(JPH_Ragdoll* ragdoll, bool lockBodies /* = true */); 2579 JPH_CAPI void JPH_Ragdoll_Activate(JPH_Ragdoll* ragdoll, bool lockBodies /* = true */); 2580 JPH_CAPI bool JPH_Ragdoll_IsActive(const JPH_Ragdoll* ragdoll, bool lockBodies /* = true */); 2581 JPH_CAPI void JPH_Ragdoll_ResetWarmStart(JPH_Ragdoll* ragdoll); 2582 2583 /* JPH_EstimateCollisionResponse */ 2584 JPH_CAPI void JPH_EstimateCollisionResponse(const JPH_Body* body1, const JPH_Body* body2, const JPH_ContactManifold* manifold, float combinedFriction, float combinedRestitution, float minVelocityForRestitution, uint32_t numIterations, JPH_CollisionEstimationResult* result); 2585 2586 /* Vehicle */ 2587 typedef struct JPH_WheelSettings JPH_WheelSettings; 2588 typedef struct JPH_WheelSettingsWV JPH_WheelSettingsWV; /* Inherits JPH_WheelSettings */ 2589 typedef struct JPH_WheelSettingsTV JPH_WheelSettingsTV; /* Inherits JPH_WheelSettings */ 2590 2591 typedef struct JPH_Wheel JPH_Wheel; 2592 typedef struct JPH_WheelWV JPH_WheelWV; /* Inherits JPH_Wheel */ 2593 typedef struct JPH_WheelTV JPH_WheelTV; /* Inherits JPH_Wheel */ 2594 2595 typedef struct JPH_VehicleTransmissionSettings JPH_VehicleTransmissionSettings; 2596 typedef struct JPH_VehicleCollisionTester JPH_VehicleCollisionTester; 2597 typedef struct JPH_VehicleCollisionTesterRay JPH_VehicleCollisionTesterRay; /* Inherits JPH_VehicleCollisionTester */ 2598 typedef struct JPH_VehicleCollisionTesterCastSphere JPH_VehicleCollisionTesterCastSphere; /* Inherits JPH_VehicleCollisionTester */ 2599 typedef struct JPH_VehicleCollisionTesterCastCylinder JPH_VehicleCollisionTesterCastCylinder; /* Inherits JPH_VehicleCollisionTester */ 2600 typedef struct JPH_VehicleConstraint JPH_VehicleConstraint; /* Inherits JPH_Constraint */ 2601 2602 typedef struct JPH_VehicleControllerSettings JPH_VehicleControllerSettings; 2603 typedef struct JPH_WheeledVehicleControllerSettings JPH_WheeledVehicleControllerSettings; /* Inherits JPH_VehicleControllerSettings */ 2604 typedef struct JPH_MotorcycleControllerSettings JPH_MotorcycleControllerSettings; /* Inherits JPH_WheeledVehicleControllerSettings */ 2605 typedef struct JPH_TrackedVehicleControllerSettings JPH_TrackedVehicleControllerSettings; /* Inherits JPH_VehicleControllerSettings */ 2606 2607 typedef struct JPH_WheeledVehicleController JPH_WheeledVehicleController; /* Inherits JPH_VehicleController */ 2608 typedef struct JPH_MotorcycleController JPH_MotorcycleController; /* Inherits JPH_WheeledVehicleController */ 2609 typedef struct JPH_TrackedVehicleController JPH_TrackedVehicleController; /* Inherits JPH_VehicleController */ 2610 2611 typedef struct JPH_VehicleController JPH_VehicleController; 2612 2613 typedef struct JPH_VehicleAntiRollBar { 2614 int leftWheel; 2615 int rightWheel; 2616 float stiffness; 2617 } JPH_VehicleAntiRollBar; 2618 2619 typedef struct JPH_VehicleConstraintSettings { 2620 JPH_ConstraintSettings base; /* Inherits JPH_ConstraintSettings */ 2621 2622 JPH_Vec3 up; 2623 JPH_Vec3 forward; 2624 float maxPitchRollAngle; 2625 uint32_t wheelsCount; 2626 JPH_WheelSettings** wheels; 2627 uint32_t antiRollBarsCount; 2628 const JPH_VehicleAntiRollBar* antiRollBars; 2629 JPH_VehicleControllerSettings* controller; 2630 } JPH_VehicleConstraintSettings; 2631 2632 typedef struct JPH_VehicleEngineSettings { 2633 float maxTorque; 2634 float minRPM; 2635 float maxRPM; 2636 //LinearCurve normalizedTorque; 2637 float inertia; 2638 float angularDamping; 2639 } JPH_VehicleEngineSettings; 2640 2641 typedef struct JPH_VehicleDifferentialSettings { 2642 int leftWheel; 2643 int rightWheel; 2644 float differentialRatio; 2645 float leftRightSplit; 2646 float limitedSlipRatio; 2647 float engineTorqueRatio; 2648 } JPH_VehicleDifferentialSettings; 2649 2650 JPH_CAPI void JPH_VehicleConstraintSettings_Init(JPH_VehicleConstraintSettings* settings); 2651 2652 JPH_CAPI JPH_VehicleConstraint* JPH_VehicleConstraint_Create(JPH_Body* body, const JPH_VehicleConstraintSettings* settings); 2653 JPH_CAPI JPH_PhysicsStepListener* JPH_VehicleConstraint_AsPhysicsStepListener(JPH_VehicleConstraint* constraint); 2654 2655 JPH_CAPI void JPH_VehicleConstraint_SetMaxPitchRollAngle(JPH_VehicleConstraint* constraint, float maxPitchRollAngle); 2656 JPH_CAPI void JPH_VehicleConstraint_SetVehicleCollisionTester(JPH_VehicleConstraint* constraint, const JPH_VehicleCollisionTester* tester); 2657 2658 JPH_CAPI void JPH_VehicleConstraint_OverrideGravity(JPH_VehicleConstraint* constraint, const JPH_Vec3* value); 2659 JPH_CAPI bool JPH_VehicleConstraint_IsGravityOverridden(const JPH_VehicleConstraint* constraint); 2660 JPH_CAPI void JPH_VehicleConstraint_GetGravityOverride(const JPH_VehicleConstraint* constraint, JPH_Vec3* result); 2661 JPH_CAPI void JPH_VehicleConstraint_ResetGravityOverride(JPH_VehicleConstraint* constraint); 2662 2663 JPH_CAPI void JPH_VehicleConstraint_GetLocalForward(const JPH_VehicleConstraint* constraint, JPH_Vec3* result); 2664 JPH_CAPI void JPH_VehicleConstraint_GetLocalUp(const JPH_VehicleConstraint* constraint, JPH_Vec3* result); 2665 JPH_CAPI void JPH_VehicleConstraint_GetWorldUp(const JPH_VehicleConstraint* constraint, JPH_Vec3* result); 2666 2667 JPH_CAPI const JPH_Body* JPH_VehicleConstraint_GetVehicleBody(const JPH_VehicleConstraint* constraint); 2668 JPH_CAPI JPH_VehicleController* JPH_VehicleConstraint_GetController(JPH_VehicleConstraint* constraint); 2669 JPH_CAPI uint32_t JPH_VehicleConstraint_GetWheelsCount(JPH_VehicleConstraint* constraint); 2670 JPH_CAPI JPH_Wheel* JPH_VehicleConstraint_GetWheel(JPH_VehicleConstraint* constraint, uint32_t index); 2671 JPH_CAPI void JPH_VehicleConstraint_GetWheelLocalBasis(JPH_VehicleConstraint* constraint, const JPH_Wheel* wheel, JPH_Vec3* outForward, JPH_Vec3* outUp, JPH_Vec3* outRight); 2672 JPH_CAPI void JPH_VehicleConstraint_GetWheelLocalTransform(JPH_VehicleConstraint* constraint, uint32_t wheelIndex, const JPH_Vec3* wheelRight, const JPH_Vec3* wheelUp, JPH_Mat4* result); 2673 JPH_CAPI void JPH_VehicleConstraint_GetWheelWorldTransform(JPH_VehicleConstraint* constraint, uint32_t wheelIndex, const JPH_Vec3* wheelRight, const JPH_Vec3* wheelUp, JPH_RMat4* result); 2674 2675 /* Wheel */ 2676 JPH_CAPI JPH_WheelSettings* JPH_WheelSettings_Create(void); 2677 JPH_CAPI void JPH_WheelSettings_Destroy(JPH_WheelSettings* settings); 2678 JPH_CAPI void JPH_WheelSettings_GetPosition(const JPH_WheelSettings* settings, JPH_Vec3* result); 2679 JPH_CAPI void JPH_WheelSettings_SetPosition(JPH_WheelSettings* settings, const JPH_Vec3* value); 2680 JPH_CAPI void JPH_WheelSettings_GetSuspensionForcePoint(const JPH_WheelSettings* settings, JPH_Vec3* result); 2681 JPH_CAPI void JPH_WheelSettings_SetSuspensionForcePoint(JPH_WheelSettings* settings, const JPH_Vec3* value); 2682 JPH_CAPI void JPH_WheelSettings_GetSuspensionDirection(const JPH_WheelSettings* settings, JPH_Vec3* result); 2683 JPH_CAPI void JPH_WheelSettings_SetSuspensionDirection(JPH_WheelSettings* settings, const JPH_Vec3* value); 2684 JPH_CAPI void JPH_WheelSettings_GetSteeringAxis(const JPH_WheelSettings* settings, JPH_Vec3* result); 2685 JPH_CAPI void JPH_WheelSettings_SetSteeringAxis(JPH_WheelSettings* settings, const JPH_Vec3* value); 2686 JPH_CAPI void JPH_WheelSettings_GetWheelUp(const JPH_WheelSettings* settings, JPH_Vec3* result); 2687 JPH_CAPI void JPH_WheelSettings_SetWheelUp(JPH_WheelSettings* settings, const JPH_Vec3* value); 2688 JPH_CAPI void JPH_WheelSettings_GetWheelForward(const JPH_WheelSettings* settings, JPH_Vec3* result); 2689 JPH_CAPI void JPH_WheelSettings_SetWheelForward(JPH_WheelSettings* settings, const JPH_Vec3* value); 2690 JPH_CAPI float JPH_WheelSettings_GetSuspensionMinLength(const JPH_WheelSettings* settings); 2691 JPH_CAPI void JPH_WheelSettings_SetSuspensionMinLength(JPH_WheelSettings* settings, float value); 2692 JPH_CAPI float JPH_WheelSettings_GetSuspensionMaxLength(const JPH_WheelSettings* settings); 2693 JPH_CAPI void JPH_WheelSettings_SetSuspensionMaxLength(JPH_WheelSettings* settings, float value); 2694 JPH_CAPI float JPH_WheelSettings_GetSuspensionPreloadLength(const JPH_WheelSettings* settings); 2695 JPH_CAPI void JPH_WheelSettings_SetSuspensionPreloadLength(JPH_WheelSettings* settings, float value); 2696 JPH_CAPI void JPH_WheelSettings_GetSuspensionSpring(const JPH_WheelSettings* settings, JPH_SpringSettings* result); 2697 JPH_CAPI void JPH_WheelSettings_SetSuspensionSpring(JPH_WheelSettings* settings, JPH_SpringSettings* springSettings); 2698 JPH_CAPI float JPH_WheelSettings_GetRadius(const JPH_WheelSettings* settings); 2699 JPH_CAPI void JPH_WheelSettings_SetRadius(JPH_WheelSettings* settings, float value); 2700 JPH_CAPI float JPH_WheelSettings_GetWidth(const JPH_WheelSettings* settings); 2701 JPH_CAPI void JPH_WheelSettings_SetWidth(JPH_WheelSettings* settings, float value); 2702 JPH_CAPI bool JPH_WheelSettings_GetEnableSuspensionForcePoint(const JPH_WheelSettings* settings); 2703 JPH_CAPI void JPH_WheelSettings_SetEnableSuspensionForcePoint(JPH_WheelSettings* settings, bool value); 2704 2705 JPH_CAPI JPH_Wheel* JPH_Wheel_Create(const JPH_WheelSettings* settings); 2706 JPH_CAPI void JPH_Wheel_Destroy(JPH_Wheel* wheel); 2707 JPH_CAPI const JPH_WheelSettings* JPH_Wheel_GetSettings(const JPH_Wheel* wheel); 2708 JPH_CAPI float JPH_Wheel_GetAngularVelocity(const JPH_Wheel* wheel); 2709 JPH_CAPI void JPH_Wheel_SetAngularVelocity(JPH_Wheel* wheel, float value); 2710 JPH_CAPI float JPH_Wheel_GetRotationAngle(const JPH_Wheel* wheel); 2711 JPH_CAPI void JPH_Wheel_SetRotationAngle(JPH_Wheel* wheel, float value); 2712 JPH_CAPI float JPH_Wheel_GetSteerAngle(const JPH_Wheel* wheel); 2713 JPH_CAPI void JPH_Wheel_SetSteerAngle(JPH_Wheel* wheel, float value); 2714 JPH_CAPI bool JPH_Wheel_HasContact(const JPH_Wheel* wheel); 2715 JPH_CAPI JPH_BodyID JPH_Wheel_GetContactBodyID(const JPH_Wheel* wheel); 2716 JPH_CAPI JPH_SubShapeID JPH_Wheel_GetContactSubShapeID(const JPH_Wheel* wheel); 2717 JPH_CAPI void JPH_Wheel_GetContactPosition(const JPH_Wheel* wheel, JPH_RVec3* result); 2718 JPH_CAPI void JPH_Wheel_GetContactPointVelocity(const JPH_Wheel* wheel, JPH_Vec3* result); 2719 JPH_CAPI void JPH_Wheel_GetContactNormal(const JPH_Wheel* wheel, JPH_Vec3* result); 2720 JPH_CAPI void JPH_Wheel_GetContactLongitudinal(const JPH_Wheel* wheel, JPH_Vec3* result); 2721 JPH_CAPI void JPH_Wheel_GetContactLateral(const JPH_Wheel* wheel, JPH_Vec3* result); 2722 JPH_CAPI float JPH_Wheel_GetSuspensionLength(const JPH_Wheel* wheel); 2723 JPH_CAPI float JPH_Wheel_GetSuspensionLambda(const JPH_Wheel* wheel); 2724 JPH_CAPI float JPH_Wheel_GetLongitudinalLambda(const JPH_Wheel* wheel); 2725 JPH_CAPI float JPH_Wheel_GetLateralLambda(const JPH_Wheel* wheel); 2726 JPH_CAPI bool JPH_Wheel_HasHitHardPoint(const JPH_Wheel* wheel); 2727 2728 /* VehicleAntiRollBar */ 2729 JPH_CAPI void JPH_VehicleAntiRollBar_Init(JPH_VehicleAntiRollBar* antiRollBar); 2730 2731 /* VehicleEngine */ 2732 JPH_CAPI void JPH_VehicleEngineSettings_Init(JPH_VehicleEngineSettings* settings); 2733 2734 /* VehicleDifferentialSettings */ 2735 JPH_CAPI void JPH_VehicleDifferentialSettings_Init(JPH_VehicleDifferentialSettings* settings); 2736 2737 /* VehicleTransmission */ 2738 JPH_CAPI JPH_VehicleTransmissionSettings* JPH_VehicleTransmissionSettings_Create(void); 2739 JPH_CAPI void JPH_VehicleTransmissionSettings_Destroy(JPH_VehicleTransmissionSettings* settings); 2740 2741 JPH_CAPI JPH_TransmissionMode JPH_VehicleTransmissionSettings_GetMode(const JPH_VehicleTransmissionSettings* settings); 2742 JPH_CAPI void JPH_VehicleTransmissionSettings_SetMode(JPH_VehicleTransmissionSettings* settings, JPH_TransmissionMode value); 2743 2744 JPH_CAPI uint32_t JPH_VehicleTransmissionSettings_GetGearRatioCount(const JPH_VehicleTransmissionSettings* settings); 2745 JPH_CAPI float JPH_VehicleTransmissionSettings_GetGearRatio(const JPH_VehicleTransmissionSettings* settings, uint32_t index); 2746 JPH_CAPI void JPH_VehicleTransmissionSettings_SetGearRatio(JPH_VehicleTransmissionSettings* settings, uint32_t index, float value); 2747 JPH_CAPI const float* JPH_VehicleTransmissionSettings_GetGearRatios(const JPH_VehicleTransmissionSettings* settings); 2748 JPH_CAPI void JPH_VehicleTransmissionSettings_SetGearRatios(JPH_VehicleTransmissionSettings* settings, const float* values, uint32_t count); 2749 2750 JPH_CAPI uint32_t JPH_VehicleTransmissionSettings_GetReverseGearRatioCount(const JPH_VehicleTransmissionSettings* settings); 2751 JPH_CAPI float JPH_VehicleTransmissionSettings_GetReverseGearRatio(const JPH_VehicleTransmissionSettings* settings, uint32_t index); 2752 JPH_CAPI void JPH_VehicleTransmissionSettings_SetReverseGearRatio(JPH_VehicleTransmissionSettings* settings, uint32_t index, float value); 2753 JPH_CAPI const float* JPH_VehicleTransmissionSettings_GetReverseGearRatios(const JPH_VehicleTransmissionSettings* settings); 2754 JPH_CAPI void JPH_VehicleTransmissionSettings_SetReverseGearRatios(JPH_VehicleTransmissionSettings* settings, const float* values, uint32_t count); 2755 2756 JPH_CAPI float JPH_VehicleTransmissionSettings_GetSwitchTime(const JPH_VehicleTransmissionSettings* settings); 2757 JPH_CAPI void JPH_VehicleTransmissionSettings_SetSwitchTime(JPH_VehicleTransmissionSettings* settings, float value); 2758 JPH_CAPI float JPH_VehicleTransmissionSettings_GetClutchReleaseTime(const JPH_VehicleTransmissionSettings* settings); 2759 JPH_CAPI void JPH_VehicleTransmissionSettings_SetClutchReleaseTime(JPH_VehicleTransmissionSettings* settings, float value); 2760 JPH_CAPI float JPH_VehicleTransmissionSettings_GetSwitchLatency(const JPH_VehicleTransmissionSettings* settings); 2761 JPH_CAPI void JPH_VehicleTransmissionSettings_SetSwitchLatency(JPH_VehicleTransmissionSettings* settings, float value); 2762 JPH_CAPI float JPH_VehicleTransmissionSettings_GetShiftUpRPM(const JPH_VehicleTransmissionSettings* settings); 2763 JPH_CAPI void JPH_VehicleTransmissionSettings_SetShiftUpRPM(JPH_VehicleTransmissionSettings* settings, float value); 2764 JPH_CAPI float JPH_VehicleTransmissionSettings_GetShiftDownRPM(const JPH_VehicleTransmissionSettings* settings); 2765 JPH_CAPI void JPH_VehicleTransmissionSettings_SetShiftDownRPM(JPH_VehicleTransmissionSettings* settings, float value); 2766 JPH_CAPI float JPH_VehicleTransmissionSettings_GetClutchStrength(const JPH_VehicleTransmissionSettings* settings); 2767 JPH_CAPI void JPH_VehicleTransmissionSettings_SetClutchStrength(JPH_VehicleTransmissionSettings* settings, float value); 2768 2769 /* VehicleCollisionTester */ 2770 JPH_CAPI void JPH_VehicleCollisionTester_Destroy(JPH_VehicleCollisionTester* tester); 2771 JPH_CAPI JPH_ObjectLayer JPH_VehicleCollisionTester_GetObjectLayer(const JPH_VehicleCollisionTester* tester); 2772 JPH_CAPI void JPH_VehicleCollisionTester_SetObjectLayer(JPH_VehicleCollisionTester* tester, JPH_ObjectLayer value); 2773 2774 JPH_CAPI JPH_VehicleCollisionTesterRay* JPH_VehicleCollisionTesterRay_Create(JPH_ObjectLayer layer, const JPH_Vec3* up, float maxSlopeAngle); 2775 JPH_CAPI JPH_VehicleCollisionTesterCastSphere* JPH_VehicleCollisionTesterCastSphere_Create(JPH_ObjectLayer layer, float radius, const JPH_Vec3* up, float maxSlopeAngle); 2776 JPH_CAPI JPH_VehicleCollisionTesterCastCylinder* JPH_VehicleCollisionTesterCastCylinder_Create(JPH_ObjectLayer layer, float convexRadiusFraction); 2777 2778 /* VehicleControllerSettings/VehicleController */ 2779 JPH_CAPI void JPH_VehicleControllerSettings_Destroy(JPH_VehicleControllerSettings* settings); 2780 JPH_CAPI const JPH_VehicleConstraint* JPH_VehicleController_GetConstraint(JPH_VehicleController* controller); 2781 2782 /* ---- WheelSettingsWV - WheelWV - WheeledVehicleController ---- */ 2783 2784 JPH_CAPI JPH_WheelSettingsWV* JPH_WheelSettingsWV_Create(void); 2785 JPH_CAPI float JPH_WheelSettingsWV_GetInertia(const JPH_WheelSettingsWV* settings); 2786 JPH_CAPI void JPH_WheelSettingsWV_SetInertia(JPH_WheelSettingsWV* settings, float value); 2787 JPH_CAPI float JPH_WheelSettingsWV_GetAngularDamping(const JPH_WheelSettingsWV* settings); 2788 JPH_CAPI void JPH_WheelSettingsWV_SetAngularDamping(JPH_WheelSettingsWV* settings, float value); 2789 JPH_CAPI float JPH_WheelSettingsWV_GetMaxSteerAngle(const JPH_WheelSettingsWV* settings); 2790 JPH_CAPI void JPH_WheelSettingsWV_SetMaxSteerAngle(JPH_WheelSettingsWV* settings, float value); 2791 //JPH_CAPI JPH_LinearCurve* JPH_WheelSettingsWV_GetLongitudinalFriction(const JPH_WheelSettingsWV* settings); 2792 //JPH_CAPI void JPH_WheelSettingsWV_SetLongitudinalFriction(JPH_WheelSettingsWV* settings, const JPH_LinearCurve* value); 2793 //JPH_CAPI JPH_LinearCurve* JPH_WheelSettingsWV_GetLateralFriction(const JPH_WheelSettingsWV* settings); 2794 //JPH_CAPI void JPH_WheelSettingsWV_SetLateralFriction(JPH_WheelSettingsWV* settings, const JPH_LinearCurve* value); 2795 JPH_CAPI float JPH_WheelSettingsWV_GetMaxBrakeTorque(const JPH_WheelSettingsWV* settings); 2796 JPH_CAPI void JPH_WheelSettingsWV_SetMaxBrakeTorque(JPH_WheelSettingsWV* settings, float value); 2797 JPH_CAPI float JPH_WheelSettingsWV_GetMaxHandBrakeTorque(const JPH_WheelSettingsWV* settings); 2798 JPH_CAPI void JPH_WheelSettingsWV_SetMaxHandBrakeTorque(JPH_WheelSettingsWV* settings, float value); 2799 2800 JPH_CAPI JPH_WheelWV* JPH_WheelWV_Create(const JPH_WheelSettingsWV* settings); 2801 JPH_CAPI const JPH_WheelSettingsWV* JPH_WheelWV_GetSettings(const JPH_WheelWV* wheel); 2802 JPH_CAPI void JPH_WheelWV_ApplyTorque(JPH_WheelWV* wheel, float torque, float deltaTime); 2803 2804 JPH_CAPI JPH_WheeledVehicleControllerSettings* JPH_WheeledVehicleControllerSettings_Create(void); 2805 2806 JPH_CAPI void JPH_WheeledVehicleControllerSettings_GetEngine(const JPH_WheeledVehicleControllerSettings* settings, JPH_VehicleEngineSettings* result); 2807 JPH_CAPI void JPH_WheeledVehicleControllerSettings_SetEngine(JPH_WheeledVehicleControllerSettings* settings, const JPH_VehicleEngineSettings* value); 2808 JPH_CAPI const JPH_VehicleTransmissionSettings* JPH_WheeledVehicleControllerSettings_GetTransmission(const JPH_WheeledVehicleControllerSettings* settings); 2809 JPH_CAPI void JPH_WheeledVehicleControllerSettings_SetTransmission(JPH_WheeledVehicleControllerSettings* settings, const JPH_VehicleTransmissionSettings* value); 2810 2811 JPH_CAPI uint32_t JPH_WheeledVehicleControllerSettings_GetDifferentialsCount(const JPH_WheeledVehicleControllerSettings* settings); 2812 JPH_CAPI void JPH_WheeledVehicleControllerSettings_SetDifferentialsCount(JPH_WheeledVehicleControllerSettings* settings, uint32_t count); 2813 JPH_CAPI void JPH_WheeledVehicleControllerSettings_GetDifferential(const JPH_WheeledVehicleControllerSettings* settings, uint32_t index, JPH_VehicleDifferentialSettings* result); 2814 JPH_CAPI void JPH_WheeledVehicleControllerSettings_SetDifferential(JPH_WheeledVehicleControllerSettings* settings, uint32_t index, const JPH_VehicleDifferentialSettings* value); 2815 JPH_CAPI void JPH_WheeledVehicleControllerSettings_SetDifferentials(JPH_WheeledVehicleControllerSettings* settings, const JPH_VehicleDifferentialSettings* values, uint32_t count); 2816 2817 2818 JPH_CAPI float JPH_WheeledVehicleControllerSettings_GetDifferentialLimitedSlipRatio(const JPH_WheeledVehicleControllerSettings* settings); 2819 JPH_CAPI void JPH_WheeledVehicleControllerSettings_SetDifferentialLimitedSlipRatio(JPH_WheeledVehicleControllerSettings* settings, float value); 2820 2821 JPH_CAPI void JPH_WheeledVehicleController_SetDriverInput(JPH_WheeledVehicleController* controller, float forward, float right, float brake, float handBrake); 2822 JPH_CAPI void JPH_WheeledVehicleController_SetForwardInput(JPH_WheeledVehicleController* controller, float forward); 2823 JPH_CAPI float JPH_WheeledVehicleController_GetForwardInput(const JPH_WheeledVehicleController* controller); 2824 JPH_CAPI void JPH_WheeledVehicleController_SetRightInput(JPH_WheeledVehicleController* controller, float rightRatio); 2825 JPH_CAPI float JPH_WheeledVehicleController_GetRightInput(const JPH_WheeledVehicleController* controller); 2826 JPH_CAPI void JPH_WheeledVehicleController_SetBrakeInput(JPH_WheeledVehicleController* controller, float brakeInput); 2827 JPH_CAPI float JPH_WheeledVehicleController_GetBrakeInput(const JPH_WheeledVehicleController* controller); 2828 JPH_CAPI void JPH_WheeledVehicleController_SetHandBrakeInput(JPH_WheeledVehicleController* controller, float handBrakeInput); 2829 JPH_CAPI float JPH_WheeledVehicleController_GetHandBrakeInput(const JPH_WheeledVehicleController* controller); 2830 JPH_CAPI float JPH_WheeledVehicleController_GetWheelSpeedAtClutch(const JPH_WheeledVehicleController* controller); 2831 2832 /* WheelSettingsTV - WheelTV - TrackedVehicleController */ 2833 /* TODO: Add VehicleTrack and VehicleTrackSettings */ 2834 JPH_CAPI JPH_WheelSettingsTV* JPH_WheelSettingsTV_Create(void); 2835 JPH_CAPI float JPH_WheelSettingsTV_GetLongitudinalFriction(const JPH_WheelSettingsTV* settings); 2836 JPH_CAPI void JPH_WheelSettingsTV_SetLongitudinalFriction(JPH_WheelSettingsTV* settings, float value); 2837 JPH_CAPI float JPH_WheelSettingsTV_GetLateralFriction(const JPH_WheelSettingsTV* settings); 2838 JPH_CAPI void JPH_WheelSettingsTV_SetLateralFriction(JPH_WheelSettingsTV* settings, float value); 2839 2840 JPH_CAPI JPH_WheelTV* JPH_WheelTV_Create(const JPH_WheelSettingsTV* settings); 2841 JPH_CAPI const JPH_WheelSettingsTV* JPH_WheelTV_GetSettings(const JPH_WheelTV* wheel); 2842 2843 JPH_CAPI JPH_TrackedVehicleControllerSettings* JPH_TrackedVehicleControllerSettings_Create(void); 2844 2845 JPH_CAPI void JPH_TrackedVehicleControllerSettings_GetEngine(const JPH_TrackedVehicleControllerSettings* settings, JPH_VehicleEngineSettings* result); 2846 JPH_CAPI void JPH_TrackedVehicleControllerSettings_SetEngine(JPH_TrackedVehicleControllerSettings* settings, const JPH_VehicleEngineSettings* value); 2847 JPH_CAPI const JPH_VehicleTransmissionSettings* JPH_TrackedVehicleControllerSettings_GetTransmission(const JPH_TrackedVehicleControllerSettings* settings); 2848 JPH_CAPI void JPH_TrackedVehicleControllerSettings_SetTransmission(JPH_TrackedVehicleControllerSettings* settings, const JPH_VehicleTransmissionSettings* value); 2849 2850 JPH_CAPI void JPH_TrackedVehicleController_SetDriverInput(JPH_TrackedVehicleController* controller, float forward, float leftRatio, float rightRatio, float brake); 2851 JPH_CAPI float JPH_TrackedVehicleController_GetForwardInput(const JPH_TrackedVehicleController* controller); 2852 JPH_CAPI void JPH_TrackedVehicleController_SetForwardInput(JPH_TrackedVehicleController* controller, float value); 2853 JPH_CAPI float JPH_TrackedVehicleController_GetLeftRatio(const JPH_TrackedVehicleController* controller); 2854 JPH_CAPI void JPH_TrackedVehicleController_SetLeftRatio(JPH_TrackedVehicleController* controller, float value); 2855 JPH_CAPI float JPH_TrackedVehicleController_GetRightRatio(const JPH_TrackedVehicleController* controller); 2856 JPH_CAPI void JPH_TrackedVehicleController_SetRightRatio(JPH_TrackedVehicleController* controller, float value); 2857 JPH_CAPI float JPH_TrackedVehicleController_GetBrakeInput(const JPH_TrackedVehicleController* controller); 2858 JPH_CAPI void JPH_TrackedVehicleController_SetBrakeInput(JPH_TrackedVehicleController* controller, float value); 2859 2860 /* MotorcycleController */ 2861 JPH_CAPI JPH_MotorcycleControllerSettings* JPH_MotorcycleControllerSettings_Create(void); 2862 JPH_CAPI float JPH_MotorcycleControllerSettings_GetMaxLeanAngle(const JPH_MotorcycleControllerSettings* settings); 2863 JPH_CAPI void JPH_MotorcycleControllerSettings_SetMaxLeanAngle(JPH_MotorcycleControllerSettings* settings, float value); 2864 JPH_CAPI float JPH_MotorcycleControllerSettings_GetLeanSpringConstant(const JPH_MotorcycleControllerSettings* settings); 2865 JPH_CAPI void JPH_MotorcycleControllerSettings_SetLeanSpringConstant(JPH_MotorcycleControllerSettings* settings, float value); 2866 JPH_CAPI float JPH_MotorcycleControllerSettings_GetLeanSpringDamping(const JPH_MotorcycleControllerSettings* settings); 2867 JPH_CAPI void JPH_MotorcycleControllerSettings_SetLeanSpringDamping(JPH_MotorcycleControllerSettings* settings, float value); 2868 JPH_CAPI float JPH_MotorcycleControllerSettings_GetLeanSpringIntegrationCoefficient(const JPH_MotorcycleControllerSettings* settings); 2869 JPH_CAPI void JPH_MotorcycleControllerSettings_SetLeanSpringIntegrationCoefficient(JPH_MotorcycleControllerSettings* settings, float value); 2870 JPH_CAPI float JPH_MotorcycleControllerSettings_GetLeanSpringIntegrationCoefficientDecay(const JPH_MotorcycleControllerSettings* settings); 2871 JPH_CAPI void JPH_MotorcycleControllerSettings_SetLeanSpringIntegrationCoefficientDecay(JPH_MotorcycleControllerSettings* settings, float value); 2872 JPH_CAPI float JPH_MotorcycleControllerSettings_GetLeanSmoothingFactor(const JPH_MotorcycleControllerSettings* settings); 2873 JPH_CAPI void JPH_MotorcycleControllerSettings_SetLeanSmoothingFactor(JPH_MotorcycleControllerSettings* settings, float value); 2874 2875 JPH_CAPI float JPH_MotorcycleController_GetWheelBase(const JPH_MotorcycleController* controller); 2876 JPH_CAPI bool JPH_MotorcycleController_IsLeanControllerEnabled(const JPH_MotorcycleController* controller); 2877 JPH_CAPI void JPH_MotorcycleController_EnableLeanController(JPH_MotorcycleController* controller, bool value); 2878 JPH_CAPI bool JPH_MotorcycleController_IsLeanSteeringLimitEnabled(const JPH_MotorcycleController* controller); 2879 JPH_CAPI void JPH_MotorcycleController_EnableLeanSteeringLimit(JPH_MotorcycleController* controller, bool value); 2880 JPH_CAPI float JPH_MotorcycleController_GetLeanSpringConstant(const JPH_MotorcycleController* controller); 2881 JPH_CAPI void JPH_MotorcycleController_SetLeanSpringConstant(JPH_MotorcycleController* controller, float value); 2882 JPH_CAPI float JPH_MotorcycleController_GetLeanSpringDamping(const JPH_MotorcycleController* controller); 2883 JPH_CAPI void JPH_MotorcycleController_SetLeanSpringDamping(JPH_MotorcycleController* controller, float value); 2884 JPH_CAPI float JPH_MotorcycleController_GetLeanSpringIntegrationCoefficient(const JPH_MotorcycleController* controller); 2885 JPH_CAPI void JPH_MotorcycleController_SetLeanSpringIntegrationCoefficient(JPH_MotorcycleController* controller, float value); 2886 JPH_CAPI float JPH_MotorcycleController_GetLeanSpringIntegrationCoefficientDecay(const JPH_MotorcycleController* controller); 2887 JPH_CAPI void JPH_MotorcycleController_SetLeanSpringIntegrationCoefficientDecay(JPH_MotorcycleController* controller, float value); 2888 JPH_CAPI float JPH_MotorcycleController_GetLeanSmoothingFactor(const JPH_MotorcycleController* controller); 2889 JPH_CAPI void JPH_MotorcycleController_SetLeanSmoothingFactor(JPH_MotorcycleController* controller, float value); 2890 2891 #endif /* JOLT_C_H_ */