218 lines
7.4 KiB
C++
218 lines
7.4 KiB
C++
// Redistribution and use in source and binary forms, with or without
|
|
// modification, are permitted provided that the following conditions
|
|
// are met:
|
|
// * Redistributions of source code must retain the above copyright
|
|
// notice, this list of conditions and the following disclaimer.
|
|
// * Redistributions in binary form must reproduce the above copyright
|
|
// notice, this list of conditions and the following disclaimer in the
|
|
// documentation and/or other materials provided with the distribution.
|
|
// * Neither the name of NVIDIA CORPORATION nor the names of its
|
|
// contributors may be used to endorse or promote products derived
|
|
// from this software without specific prior written permission.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ''AS IS'' AND ANY
|
|
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
|
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
|
|
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
|
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
|
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
|
|
// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
//
|
|
// Copyright (c) 2008-2025 NVIDIA Corporation. All rights reserved.
|
|
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
|
|
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
|
|
|
|
#ifndef PXG_SOLVER_CONSTRAINT_DESC_H
|
|
#define PXG_SOLVER_CONSTRAINT_DESC_H
|
|
|
|
#include "foundation/PxSimpleTypes.h"
|
|
#include "foundation/PxPreprocessor.h"
|
|
#include <vector_types.h>
|
|
#include "PxNodeIndex.h"
|
|
|
|
|
|
namespace physx
|
|
{
|
|
struct PxgSolverBody;
|
|
|
|
#if PX_VC
|
|
#pragma warning(push)
|
|
#pragma warning(disable : 4324)
|
|
#endif
|
|
struct PxgBlockConstraint1DVelocities
|
|
{
|
|
PX_ALIGN(256, float4 linear0XYZ_geometricErrorW[32]); //!< linear component of velocity jacobian in world space, geometric error of the constraint along this axi
|
|
PX_ALIGN(256, float4 angular0XYZ_velocityTargetW[32]); //!< angular component of velocity jacobian in world space, velocity target for the constraint along this axis
|
|
|
|
PX_ALIGN(256, float4 linear1XYZ_minImpulseW[32]); //!< linear component of velocity jacobian in world space, minimum impulse the solver may apply to enforce this constraint
|
|
PX_ALIGN(256, float4 angular1XYZ_maxImpulseW[32]); //!< angular component of velocity jacobian in world space, maximum impulse the solver may apply to enforce this constraint
|
|
};
|
|
|
|
struct PxgBlockConstraint1DParameters
|
|
{
|
|
|
|
union
|
|
{
|
|
struct SpringModifiers
|
|
{
|
|
PX_ALIGN(128, PxReal stiffness[32]); //!< spring parameter, for spring constraints
|
|
PX_ALIGN(128, PxReal damping[32]); //!< damping parameter, for spring constraints
|
|
} spring;
|
|
struct RestitutionModifiers
|
|
{
|
|
PX_ALIGN(128, PxReal restitution[32]); //!< restitution parameter for determining additional "bounce"
|
|
PX_ALIGN(128, PxReal velocityThreshold[32]); //!< minimum impact velocity for bounce
|
|
} bounce;
|
|
} mods;
|
|
|
|
PX_ALIGN(128, PxU32 flags[32]); //!< a set of Px1DConstraintFlags
|
|
PX_ALIGN(128, PxU32 solveHint[32]); //!< constraint optimization hint, should be an element of PxConstraintSolveHint
|
|
};
|
|
|
|
|
|
struct PxgConstraint1DVelocities
|
|
{
|
|
float4 linear0XYZ_geometricErrorW; //!< linear component of velocity jacobian in world space, geometric error of the constraint along this axi
|
|
float4 angular0XYZ_velocityTargetW; //!< angular component of velocity jacobian in world space, velocity target for the constraint along this axis
|
|
|
|
float4 linear1XYZ_minImpulseW; //!< linear component of velocity jacobian in world space, minimum impulse the solver may apply to enforce this constraint
|
|
float4 angular1XYZ_maxImpulseW; //!< angular component of velocity jacobian in world space, maximum impulse the solver may apply to enforce this constraint
|
|
};
|
|
|
|
struct PxgConstraint1DParameters
|
|
{
|
|
|
|
union
|
|
{
|
|
struct SpringModifiers
|
|
{
|
|
PxReal stiffness; //!< spring parameter, for spring constraints
|
|
PxReal damping; //!< damping parameter, for spring constraints
|
|
} spring;
|
|
struct RestitutionModifiers
|
|
{
|
|
PxReal restitution; //!< restitution parameter for determining additional "bounce"
|
|
PxReal velocityThreshold; //!< minimum impact velocity for bounce
|
|
} bounce;
|
|
} mods;
|
|
|
|
PxU16 flags; //!< a set of Px1DConstraintFlags
|
|
PxU16 solveHint; //!< constraint optimization hint, should be an element of PxConstraintSolveHint
|
|
|
|
PxU32 pad;
|
|
};
|
|
|
|
struct PxgSolverConstraintDesc
|
|
{
|
|
enum PxgConstraintType
|
|
{
|
|
eCONSTRAINT_1D,
|
|
eCONTACT,
|
|
eARTICULATION_CONSTRAINT_1D,
|
|
eARTICULATION_CONTACT,
|
|
};
|
|
PxU8* constraint; //8
|
|
PxU32 bodyAIndex;
|
|
PxU32 bodyBIndex;
|
|
PxU16 constraintType;
|
|
PxU16 patchIndex;
|
|
//PxU16 pad;
|
|
};
|
|
|
|
#if !PX_P64_FAMILY
|
|
PX_COMPILE_TIME_ASSERT(sizeof(PxgSolverConstraintDesc) == 16);
|
|
#endif
|
|
|
|
PX_ALIGN_PREFIX(16)
|
|
struct PxgConstraintInvMassScale
|
|
{
|
|
|
|
#if !PX_CUDA_COMPILER
|
|
PxReal linear0; //!< multiplier for inverse mass of body0
|
|
PxReal angular0; //!< multiplier for inverse MoI of body0
|
|
PxReal linear1; //!< multiplier for inverse mass of body1
|
|
PxReal angular1; //!< multiplier for inverse MoI of body1
|
|
#else
|
|
float4 lin0X_ang0Y_lin1Z_ang1W;
|
|
#endif
|
|
}PX_ALIGN_SUFFIX(16);
|
|
|
|
|
|
struct PxgBlockContactData;
|
|
struct PxgBlockContactPoint;
|
|
|
|
namespace Sc
|
|
{
|
|
class ShapeInteraction;
|
|
}
|
|
|
|
struct PxgConstraintBatchHeader
|
|
{
|
|
PxU16 mDescStride; //number between 1 to 32
|
|
PxU16 constraintType; //constraint type (joint or contact)
|
|
PxU32 mConstraintBatchIndex; //constraint batch index (the index for the specific joint/contact batch)
|
|
PxU32 mStartPartitionIndex; //start partition index (the start index for the set of partition edges representing this batch)
|
|
PxU32 mask; //Only used by the articulation internal constraint solver
|
|
};
|
|
|
|
|
|
struct PxgBlockConstraintBatch
|
|
{
|
|
PxU16 mDescStride; //number between 1 to 32
|
|
PxU16 constraintType;
|
|
PxU32 blockContactIndex;
|
|
PxU32 mConstraintBatchIndex;
|
|
PxU32 startConstraintIndex;
|
|
PxU32 startFrictionIndex;
|
|
PxU32 mStartPartitionIndex;
|
|
PxU32 mArticulationResponseIndex; //Only required for articulation constraints!
|
|
PxU32 mask;
|
|
|
|
PX_ALIGN(128, PxNodeIndex bodyANodeIndex[32]);
|
|
PX_ALIGN(128, PxNodeIndex bodyBNodeIndex[32]);
|
|
|
|
PX_ALIGN(128, PxU32 bodyAIndex[32]);
|
|
PX_ALIGN(128, PxU32 bodyBIndex[32]);
|
|
|
|
PX_ALIGN(128, PxU32 remappedBodyAIndex[32]);
|
|
PX_ALIGN(128, PxU32 remappedBodyBIndex[32]);
|
|
|
|
PX_ALIGN(128, PxU32 slabId[32]);
|
|
|
|
PX_ALIGN(128, Sc::ShapeInteraction* shapeInteraction[32]); // used for force-threshold reporting
|
|
};
|
|
|
|
struct PxgBlockWorkUnit
|
|
{
|
|
PX_ALIGN(128, PxU32 mWriteback[32]);
|
|
|
|
PX_ALIGN(128, float mRestDistance[32]);
|
|
|
|
PX_ALIGN(128, PxU32 mEdgeIndex[32]);
|
|
PX_ALIGN(128, PxU32 mFlags[32]);
|
|
PX_ALIGN(128, PxU32 mPatchIndex[32]);
|
|
PX_ALIGN(128, PxU32 mFrictionPatchIndex[32]);
|
|
PX_ALIGN(128, float2 mTorsionalFrictionData[32]);
|
|
};
|
|
|
|
#if PX_VC
|
|
#pragma warning(pop)
|
|
#endif
|
|
|
|
//This used in contact preprep(constraintContactBlockPrePrepLaunch) and joint prep code(setupSolverConstraintBlockGPU) in GPU
|
|
struct PxgSolverConstraintManagerConstants
|
|
{
|
|
PxU32 mEdgeIndex;
|
|
PxU32 mConstraintWriteBackIndex;
|
|
};
|
|
|
|
|
|
}
|
|
|
|
#endif
|
|
|