Revision control
++ // Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
++ // Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
++ // SPDX-FileCopyrightText: Copyright (c) 2008-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
++ // SPDX-License-Identifier: Apache-2.0
++
++ #ifndef PX_SOLVER_DEFS_H
++ #define PX_SOLVER_DEFS_H
++
++ #include "PxPhysXConfig.h"
++ #include "foundation/PxVec3.h"
++ #include "foundation/PxMat33.h"
++ #include "foundation/PxTransform.h"
++ #include "PxConstraintDesc.h"
++ #include "geomutils/PxContactPoint.h"
++
++ #if PX_VC
++ #pragma warning(push)
++ #pragma warning(disable : 4324) // structure was padded due to alignment
++ #endif
++
++ #if !PX_DOXYGEN
++ namespace physx
++ {
++ #endif
++
++ struct PxTGSSolverBodyVel;
++
++ /**
++ \brief Struct that the solver uses to store velocity updates for a body
++ */
++ struct PxSolverBody
++ {
++ PX_ALIGN(16, PxVec3) linearVelocity; //!< Delta linear velocity computed by the solver
++ PxU16 maxSolverNormalProgress; //!< Progress counter used by constraint batching and parallel island solver.
++ PxU16 maxSolverFrictionProgress; //!< Progress counter used by constraint batching and parallel island solver.
++
++ PxVec3 angularState; //!< Delta angular velocity state computed by the solver.
++
++ PxU32 solverProgress; //!< Progress counter used by constraint batching and parallel island solver
++
++ PxSolverBody() : linearVelocity(0.f), maxSolverNormalProgress(0), maxSolverFrictionProgress(0), angularState(0), solverProgress(0)
++ {
++ }
++ };
++ PX_COMPILE_TIME_ASSERT(sizeof(PxSolverBody) == 32);
++ PX_COMPILE_TIME_ASSERT((PX_OFFSET_OF(PxSolverBody, angularState) & 15) == 0);
++
++ /**
++ \brief Struct that the solver uses to store the state and other properties of a body
++ */
++ struct PxSolverBodyData
++ {
++ PX_ALIGN(16, PxVec3 linearVelocity); //!< 12 Pre-solver linear velocity
++ PxReal invMass; //!< 16 inverse mass
++ PxVec3 angularVelocity; //!< 28 Pre-solver angular velocity
++ PxReal reportThreshold; //!< 32 contact force threshold
++ PxMat33 sqrtInvInertia; //!< 68 inverse inertia in world space
++ PxReal penBiasClamp; //!< 72 the penetration bias clamp
++ PxU32 nodeIndex; //!< 76 the node idx of this solverBodyData. Used by solver to reference between solver bodies and island bodies. Not required by immediate mode
++ PxReal maxContactImpulse; //!< 80 the max contact impulse
++ PxTransform body2World; //!< 108 the body's transform
++ PxU32 pad; //!< 112 pad
++
++ PX_FORCE_INLINE PxReal projectVelocity(const PxVec3& lin, const PxVec3& ang) const
++ {
++ return linearVelocity.dot(lin) + angularVelocity.dot(ang);
++ }
++ };
++ PX_COMPILE_TIME_ASSERT(0 == (sizeof(PxSolverBodyData) & 15));
++ // PT: ensure that sqrtInvInertia is not the last member of PxSolverBodyData, i.e. it is safe to load 4 bytes after sqrtInvInertia
++ PX_COMPILE_TIME_ASSERT(PX_OFFSET_OF(PxSolverBodyData, sqrtInvInertia)+sizeof(PxSolverBodyData::sqrtInvInertia) + 4 <= sizeof(PxSolverBodyData));
++
++ //----------------------------------
++ /**
++ \brief A header that defines the size of a specific batch of constraints (of same type and without dependencies)
++ */
++ struct PxConstraintBatchHeader
++ {
++ PxU32 startIndex; //!< Start index for this batch
++ PxU16 stride; //!< Number of constraints in this batch (range: 1-4)
++ PxU16 constraintType; //!< The type of constraint this batch references
++ };
++
++ /**
++ \brief Constraint descriptor used inside the solver
++ */
++ PX_ALIGN_PREFIX(16)
++ struct PxSolverConstraintDesc
++ {
++ static const PxU16 RIGID_BODY = 0xffff;
++
++ enum ConstraintType
++ {
++ eCONTACT_CONSTRAINT, //!< Defines this pair is a contact constraint
++ eJOINT_CONSTRAINT //!< Defines this pair is a joint constraint
++ };
++
++ union
++ {
++ PxSolverBody* bodyA; //!< bodyA pointer
++ PxTGSSolverBodyVel* tgsBodyA; //!< bodyA pointer
++ void* articulationA; //!< Articulation pointer for body A
++ };
++
++ union
++ {
++ PxSolverBody* bodyB; //!< BodyB pointer
++ PxTGSSolverBodyVel* tgsBodyB; //!< BodyB pointer
++ void* articulationB; //!< Articulation pointer for body B
++ };
++ PxU32 bodyADataIndex; //!< Body A's index into the SolverBodyData array
++ PxU32 bodyBDataIndex; //!< Body B's index into the SolverBodyData array
++
++ PxU32 linkIndexA; //!< Link index defining which link in Articulation A this constraint affects. If not an articulation, must be PxSolverConstraintDesc::RIGID_BODY
++ PxU32 linkIndexB; //!< Link index defining which link in Articulation B this constraint affects. If not an articulation, must be PxSolverConstraintDesc::RIGID_BODY
++ PxU8* constraint; //!< Pointer to the constraint rows to be solved
++ void* writeBack; //!< Pointer to the writeback structure results for this given constraint are to be written to
++ void* writeBackFriction; //!< Pointer to writeback contact friction impulses. Points to a PxVec3* buffer
++
++ PxU16 progressA; //!< Internal progress counter
++ PxU16 progressB; //!< Internal progress counter
++
++ union
++ {
++ PxU16 constraintType; //!< type of constraint. Union member active until constraint prepping, afterwards memory used for constraint length
++ PxU16 constraintLengthOver16; //!< constraintLength/16, max constraint length is 1MB.
++ };
++ }PX_ALIGN_SUFFIX(16);
++ PX_COMPILE_TIME_ASSERT(sizeof(PxSolverConstraintDesc) % 16 == 0);
++
++ /**
++ \brief Data structure used for preparing constraints before solving them
++ */
++ struct PxSolverConstraintPrepDescBase
++ {
++ enum BodyState
++ {
++ eDYNAMIC_BODY = 1 << 0,
++ eSTATIC_BODY = 1 << 1,
++ eKINEMATIC_BODY = 1 << 2,
++ eARTICULATION = 1 << 3
++ };
++
++ PxConstraintInvMassScale invMassScales; //!< In: The local mass scaling for this pair.
++
++ PxSolverConstraintDesc* desc; //!< Output: The PxSolverConstraintDesc filled in by contact prep
++
++ const PxSolverBody* body0; //!< In: The first body. Stores velocity information. Unused unless contact involves articulations.
++ const PxSolverBody* body1; //!< In: The second body. Stores velocity information. Unused unless contact involves articulations.
++
++ const PxSolverBodyData* data0; //!< In: The first PxSolverBodyData. Stores mass and miscellaneous information for the first body.
++ const PxSolverBodyData* data1; //!< In: The second PxSolverBodyData. Stores mass and miscellaneous information for the second body
++
++ PxTransform bodyFrame0; //!< In: The world-space transform of the first body.
++ PxTransform bodyFrame1; //!< In: The world-space transform of the second body.
++
++ // PT: these two use 4 bytes each but we only need 4 bits (or even just 2 bits) for a type
++ BodyState bodyState0; //!< In: Defines what kind of actor the first body is
++ BodyState bodyState1; //!< In: Defines what kind of actor the second body is
++
++ // PT: the following pointers have been moved here from derived structures to fill padding bytes
++ union
++ {
++ // PT: moved from PxSolverConstraintPrepDesc
++ void* writeback; //!< Pointer to constraint writeback structure. Reports back joint breaking. If not required, set to NULL.
++
++ // PT: moved from PxSolverContactDesc
++ void* shapeInteraction; //!< Pointer to shape interaction. Used for force threshold reports in solver. Set to NULL if using immediate mode.
++ };
++ };
++ PX_COMPILE_TIME_ASSERT(sizeof(PxSolverConstraintPrepDescBase)<=128);
++ // PT: ensure that we can safely read 4 bytes after the bodyFrames
++ PX_COMPILE_TIME_ASSERT(PX_OFFSET_OF(PxSolverConstraintPrepDescBase, bodyFrame0)+sizeof(PxSolverConstraintPrepDescBase::bodyFrame0) + 4 <= sizeof(PxSolverConstraintPrepDescBase));
++ PX_COMPILE_TIME_ASSERT(PX_OFFSET_OF(PxSolverConstraintPrepDescBase, bodyFrame1)+sizeof(PxSolverConstraintPrepDescBase::bodyFrame1) + 4 <= sizeof(PxSolverConstraintPrepDescBase));
++
++ /**
++ \brief Data structure used for preparing constraints before solving them
++ */
++ struct PxSolverConstraintPrepDesc : public PxSolverConstraintPrepDescBase
++ {
++ PX_ALIGN(16, Px1DConstraint* rows); //!< The start of the constraint rows
++ PxU32 numRows; //!< The number of rows
++
++ PxReal linBreakForce, angBreakForce; //!< Break forces
++ PxReal minResponseThreshold; //!< The minimum response threshold
++ bool disablePreprocessing; //!< Disable joint pre-processing. Pre-processing can improve stability but under certain circumstances, e.g. when some invInertia rows are zero/almost zero, can cause instabilities.
++ bool improvedSlerp; //!< Use improved slerp model
++ bool driveLimitsAreForces; //!< Indicates whether drive limits are forces
++ bool extendedLimits; //!< Indicates whether we want to use extended limits
++ bool disableConstraint; //!< Disables constraint
++
++ PxVec3p body0WorldOffset; //!< Body0 world offset
++ };
++
++ /**
++ \brief Data structure used for preparing constraints before solving them
++ */
++ struct PxSolverContactDesc : public PxSolverConstraintPrepDescBase
++ {
++ PxU8* frictionPtr; //!< InOut: Friction patch correlation data. Set each frame by solver. Can be retained for improved behavior or discarded each frame.
++ const PxContactPoint* contacts; //!< The start of the contacts for this pair
++ PxU32 numContacts; //!< The total number of contacts this pair references.
++
++ PxU8 frictionCount; //!< The total number of friction patches in this pair
++ bool hasMaxImpulse; //!< Defines whether this pairs has maxImpulses clamping enabled
++ bool disableStrongFriction; //!< Defines whether this pair disables strong friction (sticky friction correlation)
++ bool hasForceThresholds; //!< Defines whether this pair requires force thresholds
++
++ PxReal restDistance; //!< A distance at which the solver should aim to hold the bodies separated. Default is 0
++ PxReal maxCCDSeparation; //!< A distance used to configure speculative CCD behavior. Default is PX_MAX_F32. Set internally in PhysX for bodies with eENABLE_SPECULATIVE_CCD on. Do not set directly!
++
++ PxReal* contactForces; //!< Out: A buffer for the solver to write applied contact forces to.
++
++ PxU32 startFrictionPatchIndex; //!< Start index of friction patch in the correlation buffer. Set by friction correlation
++ PxU32 numFrictionPatches; //!< Total number of friction patches in this pair. Set by friction correlation
++
++ PxU32 startContactPatchIndex; //!< The start index of this pair's contact patches in the correlation buffer. For internal use only
++ PxU16 numContactPatches; //!< Total number of contact patches.
++ PxU16 axisConstraintCount; //!< Axis constraint count. Defines how many constraint rows this pair has produced. Useful for statistical purposes.
++
++ PxReal offsetSlop; //!< Slop value used to snap contact line of action back in-line with the COM.
++ };
++
++ class PxConstraintAllocator
++ {
++ public:
++ /**
++ \brief Allocates constraint data. It is the application's responsibility to release this memory after PxSolveConstraints has completed.
++ \param[in] byteSize Allocation size in bytes
++ \return The allocated memory. This address must be 16-byte aligned.
++ */
++ virtual PxU8* reserveConstraintData(const PxU32 byteSize) = 0;
++
++ /**
++ \brief Allocates friction data. Friction data can be retained by the application for a given pair and provided as an input to PxSolverContactDesc to improve simulation stability.
++ It is the application's responsibility to release this memory. If this memory is released, the application should ensure it does not pass pointers to this memory to PxSolverContactDesc.
++ \param[in] byteSize Allocation size in bytes
++ \return The allocated memory. This address must be 4-byte aligned.
++ */
++ virtual PxU8* reserveFrictionData(const PxU32 byteSize) = 0;
++
++ virtual ~PxConstraintAllocator() {}
++ };
++
++ struct PxArticulationAxis
++ {
++ enum Enum
++ {
++ eTWIST = 0, //!< Rotational about eX
++ eSWING1 = 1, //!< Rotational about eY
++ eSWING2 = 2, //!< Rotational about eZ
++ eX = 3, //!< Linear in eX
++ eY = 4, //!< Linear in eY
++ eZ = 5, //!< Linear in eZ
++ eCOUNT = 6
++ };
++ };
++
++ PX_FLAGS_OPERATORS(PxArticulationAxis::Enum, PxU8)
++
++ struct PxArticulationMotion
++ {
++ enum Enum
++ {
++ eLOCKED = 0, //!< Locked axis, i.e. degree of freedom (DOF)
++ eLIMITED = 1, //!< Limited DOF - set limits of joint DOF together with this flag, see PxArticulationJointReducedCoordinate::setLimitParams
++ eFREE = 2 //!< Free DOF
++ };
++ };
++
++ typedef PxFlags<PxArticulationMotion::Enum, PxU8> PxArticulationMotions;
++ PX_FLAGS_OPERATORS(PxArticulationMotion::Enum, PxU8)
++
++ struct PxArticulationJointType
++ {
++ enum Enum
++ {
++ eFIX = 0, //!< All joint axes, i.e. degrees of freedom (DOFs) locked
++ ePRISMATIC = 1, //!< Single linear DOF, e.g. cart on a rail
++ eREVOLUTE = 2, //!< Single rotational DOF, e.g. an elbow joint or a rotational motor, position wrapped at 2pi radians
++ eREVOLUTE_UNWRAPPED = 3, //!< Single rotational DOF, e.g. an elbow joint or a rotational motor, position not wrapped
++ eSPHERICAL = 4, //!< Ball and socket joint with two or three DOFs
++ eUNDEFINED = 5
++ };
++ };
++
++ struct PxArticulationFlag
++ {
++ enum Enum
++ {
++ eFIX_BASE = (1 << 0), //!< Set articulation base to be fixed.
++ eDRIVE_LIMITS_ARE_FORCES = (1<<1), //!< Limits for drive effort are forces and torques rather than impulses, see PxArticulationDrive::maxForce.
++ eDISABLE_SELF_COLLISION = (1<<2) //!< Disable collisions between the articulation's links (note that parent/child collisions are disabled internally in either case).
++ };
++ };
++
++ typedef PxFlags<PxArticulationFlag::Enum, PxU8> PxArticulationFlags;
++ PX_FLAGS_OPERATORS(PxArticulationFlag::Enum, PxU8)
++
++ struct PxArticulationDriveType
++ {
++ enum Enum
++ {
++ eFORCE = 0, //!< The output of the implicit spring drive controller is a force/torque.
++ eACCELERATION = 1, //!< The output of the implicit spring drive controller is a joint acceleration (use this to get (spatial)-inertia-invariant behavior of the drive).
++ eNONE = 2
++ };
++ };
++
++ /**
++ \brief Data structure to set articulation joint limits.
++
++ - The lower limit should be strictly smaller than the higher limit. If the limits should be equal, use PxArticulationMotion::eLOCKED
++ and an appropriate offset in the parent/child joint frames.
++ - The limit units are linear units (equivalent to scene units) for a translational axis, or radians for a rotational axis.
++
++ \see PxArticulationJointReducedCoordinate::setLimitParams, PxArticulationReducedCoordinate
++ */
++ struct PxArticulationLimit
++ {
++ PxArticulationLimit(){}
++
++ PxArticulationLimit(const PxReal low_, const PxReal high_)
++ {
++ low = low_;
++ high = high_;
++ }
++
++ /**
++ \brief The lower limit on the joint axis position.
++
++ <b>Range:</b> [-PX_MAX_F32, high)<br>
++ <b>Default:</b> 0.0f<br>
++ */
++ PxReal low;
++
++ /**
++ \brief The higher limit on the joint axis position.
++
++ <b>Range:</b> (low, PX_MAX_F32]<br>
++ <b>Default:</b> 0.0f<br>
++ */
++ PxReal high;
++ };
++
++ /**
++ \brief Data structure to enforce static model of a DC motor.
++
++ Performance envelope is composed of 2 constraints:
++ 1. effort-velocity curve: |Effort| <= maxEffort - velDependentResistance * |jointVelocity|
++ 2. velocity-effort curve: |JointVelocity| <= maxActuatorVelocity - speedEffortGradient * |Effort|
++ where Effort refers to the sum of the articulation cache effort to the joint and the drive effort.
++ */
++ struct PxPerformanceEnvelope
++ {
++ // PX_SERIALIZATION
++ PxPerformanceEnvelope(const PxEMPTY&){}
++ // ~PX_SERIALIZATION
++
++ PxPerformanceEnvelope(
++ PxReal maxEffort_ = 0.0f,
++ PxReal maxActuatorVelocity_ = 0.0f,
++ PxReal velocityDependentResistance_ = 0.0f,
++ PxReal speedEffortGradient_ = 0.0f
++ ) : maxEffort(maxEffort_),
++ maxActuatorVelocity(maxActuatorVelocity_),
++ velocityDependentResistance(velocityDependentResistance_),
++ speedEffortGradient(speedEffortGradient_)
++ {}
++
++ /**
++ \brief Max effort the actuator can produce at zero velocity. For linear actuators, effort refers to force; for rotational actuators, effort refers to torque.
++
++ <b>Range:</b> [0, PX_MAX_F32]
++ <b>Default:</b> 0.0f
++ */
++ PxReal maxEffort;
++
++ /**
++ \brief The maximum velocity of the actuator at zero effort.
++
++ <b>Range:</b> [0, PX_MAX_F32]
++ <b>Default:</b> 0.0f
++ */
++ PxReal maxActuatorVelocity;
++
++ /**
++ \brief The rate at which available effort decreases as velocity increases.
++
++ This represents the slope of the effort-velocity curve.
++ <b>Range:</b> [0, PX_MAX_F32]
++ <b>Default:</b> 0.0f
++ */
++ PxReal velocityDependentResistance;
++
++ /**
++ \brief The rate at which maximum velocity decreases as effort increases.
++
++ This represents the inverse slope of the velocity-effort curve.
++ <b>Range:</b> [0, PX_MAX_F32]
++ <b>Default:</b> 0.0f
++ */
++ PxReal speedEffortGradient;
++ };
++
++ /**
++ \brief Data structure to store friction parameters.
++
++ \see PxArticulationJointReducedCoordinate::setFrictionParams, PxArticulationReducedCoordinate
++ */
++ struct PxJointFrictionParams
++ {
++ PxJointFrictionParams(){}
++
++ PxJointFrictionParams(const PxReal staticFrictionEffort_, const PxReal dynamicFrictionEffort_, const PxReal viscousFrictionCoefficient_)
++ : staticFrictionEffort(staticFrictionEffort_)
++ , dynamicFrictionEffort(dynamicFrictionEffort_)
++ , viscousFrictionCoefficient(viscousFrictionCoefficient_)
++ {
++ }
++
++ /**
++ \brief Coulomb static friction effort. For linear motion effort refers to force, for rotational - to torque.
++
++ <b>Range:</b> [0, PX_MAX_F32]<br>
++ <b>Default:</b> 0.0f<br>
++ */
++ PxReal staticFrictionEffort;
++
++ /**
++ \brief Coulomb dynamic friction effort. For linear motion effort refers to force, for rotational - to torque.
++
++ <b>Range:</b> [0, PX_MAX_F32]<br>
++ <b>Default:</b> 0.0f<br>
++ */
++ PxReal dynamicFrictionEffort;
++
++ /**
++ \brief Viscous friction coefficient. viscousFrictionForce(Torque) = -viscousFrictionCoefficient * speed.
++
++ <b>Range:</b> [0, PX_MAX_F32]<br>
++ <b>Default:</b> 0.0f<br>
++ */
++ PxReal viscousFrictionCoefficient;
++ };
++
++ /**
++ \brief Data structure for articulation joint drive configuration.
++
++ \see PxArticulationJointReducedCoordinate::setDriveParams, PxArticulationReducedCoordinate
++ */
++ struct PxArticulationDrive
++ {
++ // PX_SERIALIZATION
++ PxArticulationDrive(const PxEMPTY&) : envelope(PxEmpty) {}
++ //~PX_SERIALIZATION
++
++ PxArticulationDrive() {}
++
++ PxArticulationDrive(const PxReal stiffness_, const PxReal damping_, const PxReal maxForce_,
++ PxArticulationDriveType::Enum driveType_ = PxArticulationDriveType::eFORCE)
++ {
++ stiffness = stiffness_;
++ damping = damping_;
++ maxForce = maxForce_;
++ driveType = driveType_;
++ envelope = PxPerformanceEnvelope(0.0f, 0.0f, 0.0f, 0.0f);
++ }
++
++ PxArticulationDrive(const PxReal stiffness_, const PxReal damping_,
++ const PxPerformanceEnvelope envelope_,
++ PxArticulationDriveType::Enum driveType_ = PxArticulationDriveType::eFORCE)
++ {
++ stiffness = stiffness_;
++ damping = damping_;
++ driveType = driveType_;
++ envelope = envelope_;
++ maxForce = 0.0f;
++ }
++
++ /**
++ \brief The drive stiffness, i.e. the proportional gain of the implicit PD controller.
++
++ See manual for further information, and the drives' implicit spring-damper (i.e. PD control) implementation in particular.
++
++ <b>Units:</b> (distance = linear scene units)<br>
++ Rotational axis: torque/rad if driveType = PxArticulationDriveType::eFORCE; or (rad/s^2)/rad if driveType = PxArticulationDriveType::eACCELERATION<br>
++ Translational axis: force/distance if driveType = PxArticulationDriveType::eFORCE; or (distance/s^2)/distance if driveType = PxArticulationDriveType::eACCELERATION<br>
++ <b>Range:</b> [0, PX_MAX_F32]<br>
++ <b>Default:</b> 0.0f<br>
++ */
++ PxReal stiffness;
++
++ /**
++ \brief The drive damping, i.e. the derivative gain of the implicit PD controller.
++
++ See manual for further information, and the drives' implicit spring-damper (i.e. PD control) implementation in particular.
++
++ <b>Units:</b> (distance = linear scene units)<br>
++ Rotational axis: torque/(rad/s) if driveType = PxArticulationDriveType::eFORCE; or (rad/s^2)/(rad/s) if driveType = PxArticulationDriveType::eACCELERATION<br>
++ Translational axis: force/(distance/s) if driveType = PxArticulationDriveType::eFORCE; or (distance/s^2)/(distance/s) if driveType = PxArticulationDriveType::eACCELERATION<br>
++ <b>Range:</b> [0, PX_MAX_F32]<br>
++ <b>Default:</b> 0.0f<br>
++ */
++ PxReal damping;
++
++ /**
++ \deprecated Will be removed in a future version
++ \brief The drive force limit.
++
++ - The limit is enforced regardless of the drive type #PxArticulationDriveType.
++ - The limit corresponds to a force (linear axis) or torque (rotational axis) if PxArticulationFlag::eDRIVE_LIMITS_ARE_FORCES is set, and to an impulse (force|torque * dt) otherwise.
++
++ <b>Range:</b> [0, PX_MAX_F32]<br>
++ <b>Default:</b> 0.0f<br>
++
++ \see PxArticulationFlag::eDRIVE_LIMITS_ARE_FORCES
++ */
++ PxReal maxForce;
++
++ /**
++ \brief The performance envelope of a motor.
++
++ When an envelope with a non-zero maxEffort is explicitly set (via constructor or otherwise), the envelope takes precedence over maxForce.
++ In such cases, the joint force is clamped according to the performance envelope. If the default envelope (with zero maxEffort) is used,
++ clamping is instead based on the maxForce parameter and the PxArticulationFlag::eDRIVE_LIMITS_ARE_FORCES flag.
++
++ \see PxPerformanceEnvelope
++ */
++ PxPerformanceEnvelope envelope;
++
++ /**
++ \brief The drive type.
++
++ \see PxArticulationDriveType
++ */
++ PxArticulationDriveType::Enum driveType;
++ };
++
++ struct PxTGSSolverBodyVel
++ {
++ PX_ALIGN(16, PxVec3) linearVelocity; //12
++ PxU16 maxDynamicPartition; //14 Used to accumulate the max partition of dynamic interactions
++ PxU16 nbStaticInteractions; //16 Used to accumulate the number of static interactions
++ PxVec3 angularVelocity; //28
++ PxU32 partitionMask; //32 Used in partitioning as a bit-field
++ PxVec3 deltaAngDt; //44
++ PxReal maxAngVel; //48
++ PxVec3 deltaLinDt; //60
++ PxU16 lockFlags; //62
++ bool isKinematic; //63
++ PxU8 pad; //64
++
++ PX_FORCE_INLINE PxReal projectVelocity(const PxVec3& lin, const PxVec3& ang) const
++ {
++ return linearVelocity.dot(lin) + angularVelocity.dot(ang);
++ }
++ };
++
++ //Needed only by prep, integration and 1D constraints
++ //Solver body state at time = simulationTime + simStepDt*posIter/nbPosIters
++ struct PxTGSSolverBodyTxInertia
++ {
++ //Accumulated change to quaternion that has accumulated since solver started.
++ PxQuat deltaBody2WorldQ;
++ //Absolute body position at t
++ PxVec3 body2WorldP;
++ //RotMatrix * I0^(-1/2) * RotMatrixTranspose
++ PxMat33 sqrtInvInertia; //!< inverse inertia in world space
++ };
++ PX_COMPILE_TIME_ASSERT(0 == (sizeof(PxTGSSolverBodyTxInertia) & 15));
++
++ struct PxTGSSolverBodyData
++ {
++ PX_ALIGN(16, PxVec3) originalLinearVelocity; //!< Pre-solver linear velocity.
++ PxReal maxContactImpulse; //!< The max contact impulse.
++ PxVec3 originalAngularVelocity; //!< Pre-solver angular velocity
++ PxReal penBiasClamp; //!< The penetration bias clamp.
++
++ PxReal invMass; //!< Inverse mass.
++ PxU32 nodeIndex; //!< The node idx of this solverBodyData. Used by solver to reference between solver bodies and island bodies. Not required by immediate mode.
++ PxReal reportThreshold; //!< Contact force threshold.
++ PxU32 pad;
++
++ PxReal projectVelocity(const PxVec3& linear, const PxVec3& angular) const
++ {
++ return originalLinearVelocity.dot(linear) + originalAngularVelocity.dot(angular);
++ }
++ };
++
++ struct PxTGSSolverConstraintPrepDescBase
++ {
++ PxConstraintInvMassScale invMassScales; //!< In: The local mass scaling for this pair.
++
++ PxSolverConstraintDesc* desc; //!< Output: The PxSolverConstraintDesc filled in by contact prep
++
++ const PxTGSSolverBodyVel* body0; //!< In: The first body. Stores velocity information. Unused unless contact involves articulations.
++ const PxTGSSolverBodyVel* body1; //!< In: The second body. Stores velocity information. Unused unless contact involves articulations.
++
++ const PxTGSSolverBodyTxInertia* body0TxI; //!< In: The first PxTGSSolverBodyTxInertia. Stores the delta body to world transform and sqrtInvInertia for first body.
++ const PxTGSSolverBodyTxInertia* body1TxI; //!< In: The second PxTGSSolverBodyTxInertia. Stores the delta body to world transform and sqrtInvInertia for second body.
++
++ const PxTGSSolverBodyData* bodyData0; //!< In: The first PxTGSSolverBodyData. Stores mass and miscellaneous information for the first body.
++ const PxTGSSolverBodyData* bodyData1; //!< In: The second PxTGSSolverBodyData. Stores mass and miscellaneous information for the second body.
++
++ PxTransform bodyFrame0; //!< In: The world-space transform of the first body.
++ PxTransform bodyFrame1; //!< In: The world-space transform of the second body.
++
++ // PT: these two use 4 bytes each but we only need 4 bits (or even just 2 bits) for a type
++ PxSolverContactDesc::BodyState bodyState0; //!< In: Defines what kind of actor the first body is
++ PxSolverContactDesc::BodyState bodyState1; //!< In: Defines what kind of actor the second body is
++
++ // PT: the following pointers have been moved here from derived structures to fill padding bytes
++ union
++ {
++ // PT: moved from PxTGSSolverConstraintPrepDesc
++ void* writeback; //!< Pointer to constraint writeback structure. Reports back joint breaking. If not required, set to NULL.
++
++ // PT: moved from PxTGSSolverContactDesc
++ void* shapeInteraction; //!< Pointer to shape interaction. Used for force threshold reports in solver. Set to NULL if using immediate mode.
++ };
++ };
++
++ // PT: ensure that we can safely read 4 bytes after the bodyFrames
++ PX_COMPILE_TIME_ASSERT(PX_OFFSET_OF(PxTGSSolverConstraintPrepDescBase, bodyFrame0)+sizeof(PxTGSSolverConstraintPrepDescBase::bodyFrame0) + 4 <= sizeof(PxTGSSolverConstraintPrepDescBase));
++ PX_COMPILE_TIME_ASSERT(PX_OFFSET_OF(PxTGSSolverConstraintPrepDescBase, bodyFrame1)+sizeof(PxTGSSolverConstraintPrepDescBase::bodyFrame1) + 4 <= sizeof(PxTGSSolverConstraintPrepDescBase));
++
++ struct PxTGSSolverConstraintPrepDesc : public PxTGSSolverConstraintPrepDescBase
++ {
++ Px1DConstraint* rows; //!< The start of the constraint rows
++ PxU32 numRows; //!< The number of rows
++
++ PxReal linBreakForce, angBreakForce; //!< Break forces
++ PxReal minResponseThreshold; //!< The minimum response threshold
++ bool disablePreprocessing; //!< Disable joint pre-processing. Pre-processing can improve stability but under certain circumstances, e.g. when some invInertia rows are zero/almost zero, can cause instabilities.
++ bool improvedSlerp; //!< Use improved slerp model
++ bool driveLimitsAreForces; //!< Indicates whether drive limits are forces
++ bool extendedLimits; //!< Indicates whether extended limits are used
++ bool disableConstraint; //!< Disables constraint
++
++ PxVec3p body0WorldOffset; //!< Body0 world offset
++ PxVec3p cA2w; //!< Location of anchor point A in world space
++ PxVec3p cB2w; //!< Location of anchor point B in world space
++ };
++
++ struct PxTGSSolverContactDesc : public PxTGSSolverConstraintPrepDescBase
++ {
++ PxU8* frictionPtr; //!< InOut: Friction patch correlation data. Set each frame by solver. Can be retained for improved behavior or discarded each frame.
++ const PxContactPoint* contacts; //!< The start of the contacts for this pair
++ PxU32 numContacts; //!< The total number of contacts this pair references.
++
++ PxU8 frictionCount; //!< The total number of friction patches in this pair
++ bool hasMaxImpulse; //!< Defines whether this pairs has maxImpulses clamping enabled
++ bool disableStrongFriction; //!< Defines whether this pair disables strong friction (sticky friction correlation)
++ bool hasForceThresholds; //!< Defines whether this pair requires force thresholds
++
++ PxReal restDistance; //!< A distance at which the solver should aim to hold the bodies separated. Default is 0
++ PxReal maxCCDSeparation; //!< A distance used to configure speculative CCD behavior. Default is PX_MAX_F32. Set internally in PhysX for bodies with eENABLE_SPECULATIVE_CCD on. Do not set directly!
++
++ PxReal* contactForces; //!< Out: A buffer for the solver to write applied contact forces to.
++
++ PxU32 startFrictionPatchIndex; //!< Start index of friction patch in the correlation buffer. Set by friction correlation
++ PxU32 numFrictionPatches; //!< Total number of friction patches in this pair. Set by friction correlation
++
++ PxU32 startContactPatchIndex; //!< The start index of this pair's contact patches in the correlation buffer. For internal use only
++ PxU16 numContactPatches; //!< Total number of contact patches.
++ PxU16 axisConstraintCount; //!< Axis constraint count. Defines how many constraint rows this pair has produced. Useful for statistical purposes.
++
++ PxReal maxImpulse; //!< The maximum impulse the solver is allowed to introduce for this pair of bodies.
++
++ PxReal torsionalPatchRadius; //!< This defines the radius of the contact patch used to apply torsional friction.
++ PxReal minTorsionalPatchRadius; //!< This defines the minimum radius of the contact patch used to apply torsional friction.
++ PxReal offsetSlop; //!< Slop value used to snap contact line of action back in-line with the COM.
++ };
++
++ #if !PX_DOXYGEN
++ }
++ #endif
++
++ #if PX_VC
++ #pragma warning(pop)
++ #endif
++
++ #endif
++