PxArticulationGPUAPIComputeType

Defined in include/PxDirectGPUAPI.h

class PxArticulationGPUAPIComputeType

This flag specifies the type of operation to perform when calling PxDirectGPUAPI::computeArticulationData.

Public Types

enum Enum

Values:

enumerator eUPDATE_KINEMATIC: Updates the link state for all the articulations specified in the index list. This operation can be performed by the user to propagate changes made to root transform/root velocities/joint positions/joint velocities to be reflected in the link transforms/velocities. Performing this operation will clear output values calculated by the simulation, specifically link accelerations, link incoming joint forces, and joint accelerations. Note that this is only necessary if the user wants to query link state, otherwise it will be performed automatically at the start of the next call to simulate(). The data input parameter will be ignored and can be set to NULL for this operation.

enumerator eDENSE_JACOBIANS: Computes the dense Jacobian for the articulation in world space, including the dofs of a potentially floating base. This is the batched, direct-GPU equivalent of PxArticulationReducedCoordinate::computeDenseJacobian. The output data buffer is laid out into sequential blocks per articulation, where each block has the size (6 + maxDofs) * (6 + (maxLinks - 1) * 6) * sizeof(float). maxLinks and maxDofs are the maximum link and dof counts across all the articulations in the scene, and can be queried by calling PxDirectGPUAPI::getArticulationGPUAPIMaxCounts(). The size of the jacobian can vary by articulation, and will be determined using these formulas: nCols = (fixedBase ? 0 : 6) + dofCount, nRows = (fixedBase ? 0 : 6) + (linkCount - 1) * 6. The matrix is indexed [nCols * row + column].

enumerator eGENERALIZED_MASS_MATRICES: Deprecated, use PxArticulationGPUAPIComputeType::eMASS_MATRICES instead. Computes the joint-space inertia matrices that maps joint accelerations to joint forces: forces = M * accelerations on the GPU. This is the batched, direct-GPU equivalent of PxArticulationReducedCoordinate::computeGeneralizedMassMatrix(). The output buffer is laid out into sequential blocks per articulation, where each block has the size maxDofs * maxDofs * sizeof(float). maxDofs is the maximum dof count across all the articulations in the scene, and can be queried by calling PxDirectGPUAPI::getArticulationGPUAPIMaxCounts(). The size of the matrix can vary by articulation, and will be dofCount * dofCount. The dof indices will be according to the low-level indexing, we refer to the documentation of PxArticulationCache for an explanation.

enumerator eGENERALIZED_GRAVITY_FORCES: Deprecated, use PxArticulationGPUAPIComputeType::eGRAVITY_COMPENSATION instead. Computes the joint dof forces required to counteract gravitational forces for the given articulation pose. This is the batched, direct-GPU equivalent of PxArticulationReducedCoordinate::computeGeneralizedGravityForce(). The output data buffer is laid out into sequential blocks per articulation, where each block has the size maxDofs * sizeof(float). maxDofs is the maximum dof count across all the articulations in the scene, and can be queried by calling PxDirectGPUAPI::getArticulationGPUAPIMaxCounts(). The data layout within each block follows the PxArticulationCache layout, for which we refer to the user guide. There will be 1 PxReal per articulation dof.

enumerator eCORIOLIS_AND_CENTRIFUGAL_FORCES: Deprecated, use PxArticulationGPUAPIComputeType::eCORIOLIS_AND_CENTRIFUGAL_COMPENSATION instead. Computes the joint dof forces required to counteract Coriolis and centrifugal forces for the given articulation pose. This is the batched, direct-GPU equivalent to PxArticulationReducedCoordinate::computeCoriolisAndCentrifugalForce(). The output data buffer is laid out into sequential blocks per articulation, where each block has the size maxDofs * sizeof(float). maxDofs is the maximum dof count across all the articulations in the scene, and can be queried by calling PxDirectGPUAPI::getArticulationGPUAPIMaxCounts(). The data layout within each block follows the PxArticulationCache layout, for which we refer to the user guide. There will be 1 PxReal per articulation dof.

enumerator eMASS_MATRICES: Computes the mass matrices that maps accelerations to forces: forces = M * accelerations on the GPU. This is the batched, direct-GPU equivalent of PxArticulationReducedCoordinate::computeMassMatrix(). The output buffer is laid out into sequential blocks per articulation, where each block has the size (maxDofs + 6) * (maxDofs + 6) * sizeof(float). maxDofs is the maximum dof count across all the articulations in the scene, and can be queried by calling PxDirectGPUAPI::getArticulationGPUAPIMaxCounts(), The size of the matrix can vary by articulation, and will be dofCount * dofCount for fixed-base articulations and (dofCount + 6) * (dofCount + 6) for floating-base articulations. We refer to the documentation of PxArticulationCache and PxArticulationReducedCoordinate::computeMassMatrix() for a more detailed explanation.

enumerator eCORIOLIS_AND_CENTRIFUGAL_COMPENSATION: Computes the joint dof forces (and root force) required to counteract Coriolis and centrifugal forces for the given articulation pose. This is the batched, direct-GPU equivalent to PxArticulationReducedCoordinate::computeCoriolisCompensation(). The output data buffer is laid out into sequential blocks per articulation, where each block has the size (maxDofs + 6) * sizeof(float). maxDofs is the maximum dof count across all the articulations in the scene, and can be queried by calling PxDirectGPUAPI::getArticulationGPUAPIMaxCounts(). The size of the output can vary by articulation, and will be dofCount for fixed-base articulations and (dofCount + 6) for floating-base articulations. We refer to the documentation of PxArticulationCache and PxArticulationReducedCoordinate::computeCoriolisCompensation() for a more detailed explanation.

enumerator eGRAVITY_COMPENSATION: Computes the forces required to counteract gravitational forces for the given articulation pose. This is the batched, direct-GPU equivalent of PxArticulationReducedCoordinate::computeGravityCompensation(). The output data buffer is laid out into sequential blocks per articulation, where each block has the size (maxDofs + 6) * sizeof(float). maxDofs is the maximum dof count across all the articulations in the scene, and can be queried by calling PxDirectGPUAPI::getArticulationGPUAPIMaxCounts(). The size of the output can vary by articulation, and will be dofCount for fixed-base articulations and (dofCount + 6) for floating-base articulations. We refer to the documentation of PxArticulationCache and PxArticulationReducedCoordinate::computeGravityCompensation() for a more detailed explanation.

enumerator eARTICULATION_COMS_WORLD_FRAME: Computes the articulation’s center of mass in the world frame for the given articulation pose. This is the batched, direct-GPU equivalent to PxArticulationReducedCoordinate::computeArticulationCOM(). The output data buffer is laid out into sequential blocks per articulation, where each block has the size sizeof(float) * 3.

enumerator eARTICULATION_COMS_ROOT_FRAME: Computes the articulation’s center of mass in the root frame for the given articulation pose. This is the batched, direct-GPU equivalent to PxArticulationReducedCoordinate::computeArticulationCOM(). The output data buffer is laid out into sequential blocks per articulation, where each block has the size sizeof(float) * 3.

enumerator eCENTROIDAL_MOMENTUM_MATRICES: Computes the centroidal momentum matrix and bias force for a floating-base articulation. This is the batched, direct-GPU equivalent to PxArticulationReducedCoordinate::computeCentroidalMomentumMatrix(). The data buffer is laid out into four main blocks. The two first blocks correspond to the input (mass matrix, Coriolis and Centrifugal compensation force), and the two last blocks correspond to the output (centroidal momentum matrix, bias force). Each block must be organized into sequential subblocks per articulation. The size of the subblock is (maxDofs + 6) * (maxDofs + 6) * sizeof(float) for the mass matrix, (maxDofs + 6) * sizeof(float) for the Coriolis and Centrifugal compensation force, 6 * (maxDofs + 6) * sizeof(float) for the centroidal momentum matrix, and 6 * sizeof(float) for the bias force. maxDofs is the maximum dof count across all the articulations in the scene, and can be queried by calling PxDirectGPUAPI::getArticulationGPUAPIMaxCounts(). The size of the actual data in each subblock can vary by articulation, and will depend on the value of dofCount. The dof indices will be according to the low-level indexing, we refer to the documentation of PxArticulationCache for an explanation.