file_path
stringlengths 21
202
| content
stringlengths 12
1.02M
| size
int64 12
1.02M
| lang
stringclasses 9
values | avg_line_length
float64 3.33
100
| max_line_length
int64 10
993
| alphanum_fraction
float64 0.27
0.93
|
|---|---|---|---|---|---|---|
NVIDIA-Omniverse/PhysX/physx/include/extensions/PxSimpleFactory.h | // 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-2023 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 PX_SIMPLE_FACTORY_H
#define PX_SIMPLE_FACTORY_H
/** \addtogroup extensions
@{
*/
#include "common/PxPhysXCommonConfig.h"
#include "foundation/PxTransform.h"
#include "foundation/PxPlane.h"
#if !PX_DOXYGEN
namespace physx
{
#endif
class PxPhysics;
class PxMaterial;
class PxRigidActor;
class PxRigidDynamic;
class PxRigidStatic;
class PxGeometry;
class PxShape;
/** \brief simple method to create a PxRigidDynamic actor with a single PxShape.
\param[in] sdk the PxPhysics object
\param[in] transform the global pose of the new object
\param[in] geometry the geometry of the new object's shape, which must be a sphere, capsule, box or convex
\param[in] material the material for the new object's shape
\param[in] density the density of the new object. Must be greater than zero.
\param[in] shapeOffset an optional offset for the new shape, defaults to identity
\return a new dynamic actor with the PxRigidBodyFlag, or NULL if it could
not be constructed
@see PxRigidDynamic PxShapeFlag
*/
PxRigidDynamic* PxCreateDynamic(PxPhysics& sdk,
const PxTransform& transform,
const PxGeometry& geometry,
PxMaterial& material,
PxReal density,
const PxTransform& shapeOffset = PxTransform(PxIdentity));
/** \brief simple method to create a PxRigidDynamic actor with a single PxShape.
\param[in] sdk the PxPhysics object
\param[in] transform the transform of the new object
\param[in] shape the shape of the new object
\param[in] density the density of the new object. Must be greater than zero.
\return a new dynamic actor with the PxRigidBodyFlag, or NULL if it could
not be constructed
@see PxRigidDynamic PxShapeFlag
*/
PxRigidDynamic* PxCreateDynamic(PxPhysics& sdk,
const PxTransform& transform,
PxShape& shape,
PxReal density);
/** \brief simple method to create a kinematic PxRigidDynamic actor with a single PxShape.
\param[in] sdk the PxPhysics object
\param[in] transform the global pose of the new object
\param[in] geometry the geometry of the new object's shape
\param[in] material the material for the new object's shape
\param[in] density the density of the new object. Must be greater than zero if the object is to participate in simulation.
\param[in] shapeOffset an optional offset for the new shape, defaults to identity
\note unlike PxCreateDynamic, the geometry is not restricted to box, capsule, sphere or convex. However,
kinematics of other geometry types may not participate in simulation collision and may be used only for
triggers or scene queries of moving objects under animation control. In this case the density parameter
will be ignored and the created shape will be set up as a scene query only shape (see #PxShapeFlag::eSCENE_QUERY_SHAPE)
\return a new dynamic actor with the PxRigidBodyFlag::eKINEMATIC set, or NULL if it could
not be constructed
@see PxRigidDynamic PxShapeFlag
*/
PxRigidDynamic* PxCreateKinematic(PxPhysics& sdk,
const PxTransform& transform,
const PxGeometry& geometry,
PxMaterial& material,
PxReal density,
const PxTransform& shapeOffset = PxTransform(PxIdentity));
/** \brief simple method to create a kinematic PxRigidDynamic actor with a single PxShape.
\param[in] sdk the PxPhysics object
\param[in] transform the global pose of the new object
\param[in] density the density of the new object. Must be greater than zero if the object is to participate in simulation.
\param[in] shape the shape of the new object
\note unlike PxCreateDynamic, the geometry is not restricted to box, capsule, sphere or convex. However,
kinematics of other geometry types may not participate in simulation collision and may be used only for
triggers or scene queries of moving objects under animation control. In this case the density parameter
will be ignored and the created shape will be set up as a scene query only shape (see #PxShapeFlag::eSCENE_QUERY_SHAPE)
\return a new dynamic actor with the PxRigidBodyFlag::eKINEMATIC set, or NULL if it could
not be constructed
@see PxRigidDynamic PxShapeFlag
*/
PxRigidDynamic* PxCreateKinematic(PxPhysics& sdk,
const PxTransform& transform,
PxShape& shape,
PxReal density);
/** \brief simple method to create a PxRigidStatic actor with a single PxShape.
\param[in] sdk the PxPhysics object
\param[in] transform the global pose of the new object
\param[in] geometry the geometry of the new object's shape
\param[in] material the material for the new object's shape
\param[in] shapeOffset an optional offset for the new shape, defaults to identity
\return a new static actor, or NULL if it could not be constructed
@see PxRigidStatic
*/
PxRigidStatic* PxCreateStatic(PxPhysics& sdk,
const PxTransform& transform,
const PxGeometry& geometry,
PxMaterial& material,
const PxTransform& shapeOffset = PxTransform(PxIdentity));
/** \brief simple method to create a PxRigidStatic actor with a single PxShape.
\param[in] sdk the PxPhysics object
\param[in] transform the global pose of the new object
\param[in] shape the new object's shape
\return a new static actor, or NULL if it could not be constructed
@see PxRigidStatic
*/
PxRigidStatic* PxCreateStatic(PxPhysics& sdk,
const PxTransform& transform,
PxShape& shape);
/**
\brief create a shape by copying attributes from another shape
The function clones a PxShape. The following properties are copied:
- geometry
- flags
- materials
- actor-local pose
- contact offset
- rest offset
- simulation filter data
- query filter data
- torsional patch radius
- minimum torsional patch radius
The following are not copied and retain their default values:
- name
- user data
\param[in] physicsSDK - the physics SDK used to allocate the shape
\param[in] shape the shape from which to take the attributes.
\param[in] isExclusive whether the new shape should be an exclusive or shared shape.
\return the newly-created rigid static
*/
PxShape* PxCloneShape(PxPhysics& physicsSDK,
const PxShape& shape,
bool isExclusive);
/**
\brief create a static body by copying attributes from another rigid actor
The function clones a PxRigidDynamic or PxRigidStatic as a PxRigidStatic. A uniform scale is applied. The following properties are copied:
- shapes
- actor flags
- owner client and client behavior bits
- dominance group
The following are not copied and retain their default values:
- name
- joints or observers
- aggregate or scene membership
- user data
\note Transforms are not copied with bit-exact accuracy.
\param[in] physicsSDK - the physics SDK used to allocate the rigid static
\param[in] actor the rigid actor from which to take the attributes.
\param[in] transform the transform of the new static.
\return the newly-created rigid static
*/
PxRigidStatic* PxCloneStatic(PxPhysics& physicsSDK,
const PxTransform& transform,
const PxRigidActor& actor);
/**
\brief create a dynamic body by copying attributes from an existing body
The following properties are copied:
- shapes
- actor flags, rigidDynamic flags and rigidDynamic lock flags
- mass, moment of inertia, and center of mass frame
- linear and angular velocity
- linear and angular damping
- maximum linear velocity
- maximum angular velocity
- position and velocity solver iterations
- maximum depenetration velocity
- sleep threshold
- contact report threshold
- dominance group
- owner client and client behavior bits
- name pointer
- kinematic target
The following are not copied and retain their default values:
- name
- joints or observers
- aggregate or scene membership
- sleep timer
- user data
\note Transforms are not copied with bit-exact accuracy.
\param[in] physicsSDK PxPhysics - the physics SDK used to allocate the rigid static
\param[in] body the rigid dynamic to clone.
\param[in] transform the transform of the new dynamic
\return the newly-created rigid static
*/
PxRigidDynamic* PxCloneDynamic(PxPhysics& physicsSDK,
const PxTransform& transform,
const PxRigidDynamic& body);
/** \brief create a plane actor. The plane equation is n.x + d = 0
\param[in] sdk the PxPhysics object
\param[in] plane a plane of the form n.x + d = 0
\param[in] material the material for the new object's shape
\return a new static actor, or NULL if it could not be constructed
@see PxRigidStatic
*/
PxRigidStatic* PxCreatePlane(PxPhysics& sdk,
const PxPlane& plane,
PxMaterial& material);
/**
\brief scale a rigid actor by a uniform scale
The geometry and relative positions of the actor are multiplied by the given scale value. If the actor is a rigid body or an
articulation link and the scaleMassProps value is true, the mass properties are scaled assuming the density is constant: the
center of mass is linearly scaled, the mass is multiplied by the cube of the scale, and the inertia tensor by the fifth power of the scale.
\param[in] actor a rigid actor
\param[in] scale the scale by which to multiply the actor. Must be >0.
\param[in] scaleMassProps whether to scale the mass properties
*/
void PxScaleRigidActor(PxRigidActor& actor, PxReal scale, bool scaleMassProps = true);
#if !PX_DOXYGEN
} // namespace physx
#endif
/** @} */
#endif
| 11,038 | C | 36.043624 | 140 | 0.758108 |
NVIDIA-Omniverse/PhysX/physx/include/extensions/PxRigidActorExt.h | // 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-2023 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 PX_RIGID_ACTOR_EXT_H
#define PX_RIGID_ACTOR_EXT_H
/** \addtogroup extensions
@{
*/
#include "PxPhysXConfig.h"
#include "PxPhysics.h"
#include "PxRigidActor.h"
#if !PX_DOXYGEN
namespace physx
{
#endif
class PxBVH;
/**
\brief utility functions for use with PxRigidActor and subclasses
@see PxRigidActor PxRigidStatic PxRigidBody PxRigidDynamic PxArticulationLink
*/
class PxRigidActorExt
{
public:
/**
\brief Creates a new shape with default properties and a list of materials and adds it to the list of shapes of this actor.
This is equivalent to the following
PxShape* shape(...) = PxGetPhysics().createShape(...); // reference count is 1
actor->attachShape(shape); // increments reference count
shape->release(); // releases user reference, leaving reference count at 1
As a consequence, detachShape() will result in the release of the last reference, and the shape will be deleted.
\note The default shape flags to be set are: eVISUALIZATION, eSIMULATION_SHAPE, eSCENE_QUERY_SHAPE (see #PxShapeFlag).
Triangle mesh, heightfield or plane geometry shapes configured as eSIMULATION_SHAPE are not supported for
non-kinematic PxRigidDynamic instances.
\note Creating compounds with a very large number of shapes may adversely affect performance and stability.
<b>Sleeping:</b> Does <b>NOT</b> wake the actor up automatically.
\param[in] actor the actor to which to attach the shape
\param[in] geometry the geometry of the shape
\param[in] materials a pointer to an array of material pointers
\param[in] materialCount the count of materials
\param[in] shapeFlags optional PxShapeFlags
\return The newly created shape.
@see PxShape PxShape::release(), PxPhysics::createShape(), PxRigidActor::attachShape()
*/
static PxShape* createExclusiveShape(PxRigidActor& actor, const PxGeometry& geometry, PxMaterial*const* materials, PxU16 materialCount,
PxShapeFlags shapeFlags = PxShapeFlag::eVISUALIZATION | PxShapeFlag::eSCENE_QUERY_SHAPE | PxShapeFlag::eSIMULATION_SHAPE)
{
PxShape* shape = PxGetPhysics().createShape(geometry, materials, materialCount, true, shapeFlags);
if(shape)
{
bool status = actor.attachShape(*shape); // attach can fail, if e.g. we try and attach a trimesh simulation shape to a dynamic actor
shape->release(); // if attach fails, we hold the only counted reference, and so this cleans up properly
if(!status)
shape = NULL;
}
return shape;
}
/**
\brief Creates a new shape with default properties and a single material adds it to the list of shapes of this actor.
This is equivalent to the following
PxShape* shape(...) = PxGetPhysics().createShape(...); // reference count is 1
actor->attachShape(shape); // increments reference count
shape->release(); // releases user reference, leaving reference count at 1
As a consequence, detachShape() will result in the release of the last reference, and the shape will be deleted.
\note The default shape flags to be set are: eVISUALIZATION, eSIMULATION_SHAPE, eSCENE_QUERY_SHAPE (see #PxShapeFlag).
Triangle mesh, heightfield or plane geometry shapes configured as eSIMULATION_SHAPE are not supported for
non-kinematic PxRigidDynamic instances.
\note Creating compounds with a very large number of shapes may adversely affect performance and stability.
<b>Sleeping:</b> Does <b>NOT</b> wake the actor up automatically.
\param[in] actor the actor to which to attach the shape
\param[in] geometry the geometry of the shape
\param[in] material the material for the shape
\param[in] shapeFlags optional PxShapeFlags
\return The newly created shape.
@see PxShape PxShape::release(), PxPhysics::createShape(), PxRigidActor::attachShape()
*/
static PX_FORCE_INLINE PxShape* createExclusiveShape(PxRigidActor& actor, const PxGeometry& geometry, const PxMaterial& material,
PxShapeFlags shapeFlags = PxShapeFlag::eVISUALIZATION | PxShapeFlag::eSCENE_QUERY_SHAPE | PxShapeFlag::eSIMULATION_SHAPE)
{
PxMaterial* materialPtr = const_cast<PxMaterial*>(&material);
return createExclusiveShape(actor, geometry, &materialPtr, 1, shapeFlags);
}
/**
\brief Gets a list of bounds based on shapes in rigid actor. This list can be used to cook/create
bounding volume hierarchy though PxCooking API.
\param[in] actor The actor from which the bounds list is retrieved.
\param[out] numBounds Number of bounds in returned list.
@see PxShape PxBVH PxCooking::createBVH PxCooking::cookBVH
*/
static PxBounds3* getRigidActorShapeLocalBoundsList(const PxRigidActor& actor, PxU32& numBounds);
/**
\brief Convenience function to create a PxBVH object from a PxRigidActor.
The computed PxBVH can then be used in PxScene::addActor() or PxAggregate::addActor().
After adding the actor & BVH to the scene/aggregate, release the PxBVH object by calling PxBVH::release().
\param[in] physics The physics object. The function will retrieve the insertion callback from it.
\param[in] actor The actor to compute a PxBVH for.
\return The PxBVH for this actor.
@see PxBVH PxScene::addActor PxAggregate::addActor
*/
static PxBVH* createBVHFromActor(PxPhysics& physics, const PxRigidActor& actor);
};
#if !PX_DOXYGEN
} // namespace physx
#endif
/** @} */
#endif
| 6,988 | C | 40.850299 | 143 | 0.75601 |
NVIDIA-Omniverse/PhysX/physx/include/extensions/PxSerialization.h | // 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-2023 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 PX_SERIALIZATION_H
#define PX_SERIALIZATION_H
/** \addtogroup extensions
@{
*/
#include "PxPhysXConfig.h"
#include "common/PxBase.h"
#include "cooking/PxCooking.h"
#include "foundation/PxIO.h"
#include "common/PxTolerancesScale.h"
#include "common/PxTypeInfo.h"
#include "common/PxStringTable.h"
/**
PX_BINARY_SERIAL_VERSION is used to version the PhysX binary data and meta data. The global unique identifier of the PhysX SDK needs to match
the one in the data and meta data, otherwise they are considered incompatible. A 32 character wide GUID can be generated with https://www.guidgenerator.com/ for example.
*/
#define PX_BINARY_SERIAL_VERSION "F57A6B4570DF49E38116AB1E0284A98B"
#if !PX_DOXYGEN
namespace physx
{
#endif
class PxBinaryConverter;
/**
\brief Utility functions for serialization
@see PxCollection, PxSerializationRegistry
*/
class PxSerialization
{
public:
/**
\brief Additional PxScene and PxPhysics options stored in XML serialized data.
\deprecated Xml serialization is deprecated. An alternative serialization system is provided through USD Physics.
The PxXmlMiscParameter parameter can be serialized and deserialized along with PxCollection instances (XML only).
This is for application use only and has no impact on how objects are serialized or deserialized.
@see PxSerialization::createCollectionFromXml, PxSerialization::serializeCollectionToXml
*/
struct PX_DEPRECATED PxXmlMiscParameter
{
/**
\brief Up vector for the scene reference coordinate system.
*/
PxVec3 upVector;
/**
\brief Tolerances scale to be used for the scene.
*/
PxTolerancesScale scale;
PxXmlMiscParameter() : upVector(0) {}
PxXmlMiscParameter(PxVec3& inUpVector, PxTolerancesScale inScale) : upVector(inUpVector), scale(inScale) {}
};
/**
\brief Returns whether the collection is serializable with the externalReferences collection.
Some definitions to explain whether a collection can be serialized or not:
For definitions of <b>requires</b> and <b>complete</b> see #PxSerialization::complete
A serializable object is <b>subordinate</b> if it cannot be serialized on its own
The following objects are subordinate:
- articulation links
- articulation joints
- joints
A collection C can be serialized with external references collection D iff
- C is complete relative to D (no dangling references)
- Every object in D required by an object in C has a valid ID (no unnamed references)
- Every subordinate object in C is required by another object in C (no orphans)
\param[in] collection Collection to be checked
\param[in] sr PxSerializationRegistry instance with information about registered classes.
\param[in] externalReferences the external References collection
\return Whether the collection is serializable
@see PxSerialization::complete, PxSerialization::serializeCollectionToBinary, PxSerialization::serializeCollectionToXml, PxSerializationRegistry
*/
static bool isSerializable(PxCollection& collection, PxSerializationRegistry& sr, const PxCollection* externalReferences = NULL);
/**
\brief Adds to a collection all objects such that it can be successfully serialized.
A collection C is complete relative to an other collection D if every object required by C is either in C or D.
This function adds objects to a collection, such that it becomes complete with respect to the exceptFor collection.
Completeness is needed for serialization. See #PxSerialization::serializeCollectionToBinary,
#PxSerialization::serializeCollectionToXml.
Sdk objects require other sdk object according to the following rules:
- joints require their actors and constraint
- rigid actors require their shapes
- shapes require their material(s) and mesh (triangle mesh, convex mesh or height field), if any
- articulations require their links and joints
- aggregates require their actors
If followJoints is specified another rule is added:
- actors require their joints
Specifying followJoints will make whole jointed actor chains being added to the collection. Following chains
is interrupted whenever a object in exceptFor is encountered.
\param[in,out] collection Collection which is completed
\param[in] sr PxSerializationRegistry instance with information about registered classes.
\param[in] exceptFor Optional exemption collection
\param[in] followJoints Specifies whether joints should be added for jointed actors
@see PxCollection, PxSerialization::serializeCollectionToBinary, PxSerialization::serializeCollectionToXml, PxSerializationRegistry
*/
static void complete(PxCollection& collection, PxSerializationRegistry& sr, const PxCollection* exceptFor = NULL, bool followJoints = false);
/**
\brief Creates PxSerialObjectId values for unnamed objects in a collection.
Creates PxSerialObjectId names for unnamed objects in a collection starting at a base value and incrementing,
skipping values that are already assigned to objects in the collection.
\param[in,out] collection Collection for which names are created
\param[in] base Start address for PxSerialObjectId names
@see PxCollection
*/
static void createSerialObjectIds(PxCollection& collection, const PxSerialObjectId base);
/**
\brief Creates a PxCollection from XML data.
\deprecated Xml serialization is deprecated. An alternative serialization system is provided through USD Physics.
\param inputData The input data containing the XML collection.
\param params Cooking parameters used for sdk object instantiation.
\param sr PxSerializationRegistry instance with information about registered classes.
\param externalRefs PxCollection used to resolve external references.
\param stringTable PxStringTable instance used for storing object names.
\param outArgs Optional parameters of physics and scene deserialized from XML. See #PxSerialization::PxXmlMiscParameter
\return a pointer to a PxCollection if successful or NULL if it failed.
@see PxCollection, PxSerializationRegistry, PxInputData, PxStringTable, PxCooking, PxSerialization::PxXmlMiscParameter
*/
PX_DEPRECATED static PxCollection* createCollectionFromXml(PxInputData& inputData, const PxCookingParams& params, PxSerializationRegistry& sr, const PxCollection* externalRefs = NULL, PxStringTable* stringTable = NULL, PxXmlMiscParameter* outArgs = NULL);
/**
\brief Deserializes a PxCollection from memory.
Creates a collection from memory. If the collection has external dependencies another collection
can be provided to resolve these.
The memory block provided has to be 128 bytes aligned and contain a contiguous serialized collection as written
by PxSerialization::serializeCollectionToBinary. The contained binary data needs to be compatible with the current binary format version
which is defined by "PX_PHYSICS_VERSION_MAJOR.PX_PHYSICS_VERSION_MINOR.PX_PHYSICS_VERSION_BUGFIX-PX_BINARY_SERIAL_VERSION".
For a list of compatible sdk releases refer to the documentation of PX_BINARY_SERIAL_VERSION.
\param[in] memBlock Pointer to memory block containing the serialized collection
\param[in] sr PxSerializationRegistry instance with information about registered classes.
\param[in] externalRefs Collection to resolve external dependencies
@see PxCollection, PxSerialization::complete, PxSerialization::serializeCollectionToBinary, PxSerializationRegistry, PX_BINARY_SERIAL_VERSION
*/
static PxCollection* createCollectionFromBinary(void* memBlock, PxSerializationRegistry& sr, const PxCollection* externalRefs = NULL);
/**
\brief Serializes a physics collection to an XML output stream.
\deprecated Xml serialization is deprecated. An alternative serialization system is provided through USD Physics.
The collection to be serialized needs to be complete @see PxSerialization.complete.
Optionally the XML may contain meshes in binary cooked format for fast loading. It does this when providing a valid non-null PxCooking pointer.
\note Serialization of objects in a scene that is simultaneously being simulated is not supported and leads to undefined behavior.
\param outputStream Stream to save collection to.
\param collection PxCollection instance which is serialized. The collection needs to be complete with respect to the externalRefs collection.
\param sr PxSerializationRegistry instance with information about registered classes.
\param params Optional pointer to cooking params. If provided, cooked mesh data is cached for fast loading.
\param externalRefs Collection containing external references.
\param inArgs Optional parameters of physics and scene serialized to XML along with the collection. See #PxSerialization::PxXmlMiscParameter
\return true if the collection is successfully serialized.
@see PxCollection, PxOutputStream, PxSerializationRegistry, PxCooking, PxSerialization::PxXmlMiscParameter
*/
PX_DEPRECATED static bool serializeCollectionToXml(PxOutputStream& outputStream, PxCollection& collection, PxSerializationRegistry& sr, const PxCookingParams* params = NULL, const PxCollection* externalRefs = NULL, PxXmlMiscParameter* inArgs = NULL);
/**
\brief Serializes a collection to a binary stream.
Serializes a collection to a stream. In order to resolve external dependencies the externalReferences collection has to be provided.
Optionally names of objects that where set for example with #PxActor::setName are serialized along with the objects.
The collection can be successfully serialized if isSerializable(collection) returns true. See #isSerializable.
The implementation of the output stream needs to fulfill the requirements on the memory block input taken by
PxSerialization::createCollectionFromBinary.
\note Serialization of objects in a scene that is simultaneously being simulated is not supported and leads to undefined behavior.
\param[out] outputStream into which the collection is serialized
\param[in] collection Collection to be serialized
\param[in] sr PxSerializationRegistry instance with information about registered classes.
\param[in] externalRefs Collection used to resolve external dependencies
\param[in] exportNames Specifies whether object names are serialized
\return Whether serialization was successful
@see PxCollection, PxOutputStream, PxSerialization::complete, PxSerialization::createCollectionFromBinary, PxSerializationRegistry
*/
static bool serializeCollectionToBinary(PxOutputStream& outputStream, PxCollection& collection, PxSerializationRegistry& sr, const PxCollection* externalRefs = NULL, bool exportNames = false );
/**
\brief Serializes a collection to a binary stream.
\deprecated Deterministic binary serialization is deprecated. PxSerialization::serializeCollectionToBinary might become deterministic in the future.
Convenience function that serializes a collection to a stream while rebasing memory addresses and handles
to achieve a deterministic output, independent of the PhysX runtime environment the objects have been created in.
The same functionality can be achieved by manually
- creating a binary data stream with PxSerialization::serializeCollectionToBinary
- producing the binary meta data of the current runtime platform with PxSerialization::dumpBinaryMetaData
- converting the binary data stream with the PxBinaryConverter, using the binary meta for both source and destination
@see PxSerialization::serializeCollectionToBinary, PxSerialization::dumpBinaryMetaData, PxBinaryConverter
*/
PX_DEPRECATED static bool serializeCollectionToBinaryDeterministic(PxOutputStream& outputStream, PxCollection& collection, PxSerializationRegistry& sr, const PxCollection* externalRefs = NULL, bool exportNames = false);
/**
\brief Dumps the binary meta-data to a stream.
\deprecated Binary conversion and binary meta data are deprecated.
A meta-data file contains information about the SDK's internal classes and about custom user types ready
for serialization. Such a file is needed to convert binary-serialized data from one platform to another (re-targeting).
The converter needs meta-data files for the source and target platforms to perform conversions.
Custom user types can be supported with PxSerializationRegistry::registerBinaryMetaDataCallback (see the guide for more information).
\param[out] outputStream Stream to write meta data to
\param[in] sr PxSerializationRegistry instance with information about registered classes used for conversion.
@see PxOutputStream, PxSerializationRegistry
*/
PX_DEPRECATED static void dumpBinaryMetaData(PxOutputStream& outputStream, PxSerializationRegistry& sr);
/**
\brief Creates binary converter for re-targeting binary-serialized data.
\deprecated Binary conversion and binary meta data are deprecated.
\return Binary converter instance.
*/
PX_DEPRECATED static PxBinaryConverter* createBinaryConverter();
/**
\brief Creates an application managed registry for serialization.
\param[in] physics Physics SDK to generate create serialization registry
\return PxSerializationRegistry instance.
@see PxSerializationRegistry
*/
static PxSerializationRegistry* createSerializationRegistry(PxPhysics& physics);
};
#if !PX_DOXYGEN
} // namespace physx
#endif
/** @} */
#endif
| 14,930 | C | 48.440397 | 256 | 0.804488 |
NVIDIA-Omniverse/PhysX/physx/include/extensions/PxParticleClothCooker.h | // 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-2023 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 PX_PARTICLE_CLOTH_COOKER_H
#define PX_PARTICLE_CLOTH_COOKER_H
/** \addtogroup extensions
@{
*/
#include "foundation/PxSimpleTypes.h"
#include "foundation/PxVec4.h"
#if !PX_DOXYGEN
namespace physx
{
#endif
namespace ExtGpu
{
/**
\brief Holds all the information for a particle cloth constraint used in the PxParticleClothCooker.
*/
struct PxParticleClothConstraint
{
enum
{
eTYPE_INVALID_CONSTRAINT = 0,
eTYPE_HORIZONTAL_CONSTRAINT = 1,
eTYPE_VERTICAL_CONSTRAINT = 2,
eTYPE_DIAGONAL_CONSTRAINT = 4,
eTYPE_BENDING_CONSTRAINT = 8,
eTYPE_DIAGONAL_BENDING_CONSTRAINT = 16,
eTYPE_ALL = eTYPE_HORIZONTAL_CONSTRAINT | eTYPE_VERTICAL_CONSTRAINT | eTYPE_DIAGONAL_CONSTRAINT | eTYPE_BENDING_CONSTRAINT | eTYPE_DIAGONAL_BENDING_CONSTRAINT
};
PxU32 particleIndexA; //!< The first particle index of this constraint.
PxU32 particleIndexB; //!< The second particle index of this constraint.
PxReal length; //!< The distance between particle A and B.
PxU32 constraintType; //!< The type of constraint, see the constraint type enum.
};
/*
\brief Generates PxParticleClothConstraint constraints that connect the individual particles of a particle cloth.
*/
class PxParticleClothCooker
{
public:
virtual void release() = 0;
/**
\brief Generate the constraint list and triangle index list.
\param[in] constraints A pointer to an array of PxParticleClothConstraint constraints. If NULL, the cooker will generate all the constraints. Otherwise, the user-provided constraints will be added.
\param[in] numConstraints The number of user-provided PxParticleClothConstraint s.
*/
virtual void cookConstraints(const PxParticleClothConstraint* constraints = NULL, const PxU32 numConstraints = 0) = 0;
virtual PxU32* getTriangleIndices() = 0; //!< \return A pointer to the triangle indices.
virtual PxU32 getTriangleIndicesCount() = 0; //!< \return The number of triangle indices.
virtual PxParticleClothConstraint* getConstraints() = 0; //!< \return A pointer to the PxParticleClothConstraint constraints.
virtual PxU32 getConstraintCount() = 0; //!< \return The number of constraints.
virtual void calculateMeshVolume() = 0; //!< Computes the volume of a closed mesh and the contraintScale. Expects vertices in local space - 'close' to origin.
virtual PxReal getMeshVolume() = 0; //!< \return The mesh volume calculated by PxParticleClothCooker::calculateMeshVolume.
protected:
virtual ~PxParticleClothCooker() {}
};
} // namespace ExtGpu
/**
\brief Creates a PxParticleClothCooker.
\param[in] vertexCount The number of vertices of the particle cloth.
\param[in] inVertices The vertex positions of the particle cloth.
\param[in] triangleIndexCount The number of triangles of the cloth mesh.
\param[in] inTriangleIndices The triangle indices of the cloth mesh
\param[in] constraintTypeFlags The types of constraints to generate. See PxParticleClothConstraint.
\param[in] verticalDirection The vertical direction of the cloth mesh. This is needed to generate the correct horizontal and vertical constraints to model shear stiffness.
\param[in] bendingConstraintMaxAngle The maximum angle (in radians) considered in the bending constraints.
\return A pointer to the new PxParticleClothCooker.
*/
ExtGpu::PxParticleClothCooker* PxCreateParticleClothCooker(PxU32 vertexCount, physx::PxVec4* inVertices, PxU32 triangleIndexCount, PxU32* inTriangleIndices,
PxU32 constraintTypeFlags = ExtGpu::PxParticleClothConstraint::eTYPE_ALL,
PxVec3 verticalDirection = PxVec3(0.0f, 1.0f, 0.0f), PxReal bendingConstraintMaxAngle = 20.0f*PxTwoPi/360.0f
);
#if !PX_DOXYGEN
} // namespace physx
#endif
/** @} */
#endif
| 5,357 | C | 43.280991 | 199 | 0.770581 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle2/PxVehicleComponentSequence.h | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#pragma once
/** \addtogroup vehicle2
@{
*/
#include "foundation/PxAssert.h"
#include "foundation/PxErrors.h"
#include "foundation/PxFoundation.h"
#include "PxVehicleComponent.h"
#if !PX_DOXYGEN
namespace physx
{
namespace vehicle2
{
#endif
struct PxVehicleComponentSequenceLimits
{
enum Enum
{
eMAX_NB_SUBGROUPS = 16,
eMAX_NB_COMPONENTS = 64,
eMAX_NB_SUBGROUPELEMENTS = eMAX_NB_SUBGROUPS + eMAX_NB_COMPONENTS
};
};
struct PxVehicleComponentSequence
{
enum
{
eINVALID_SUBSTEP_GROUP = 0xff
};
PxVehicleComponentSequence()
: mNbComponents(0), mNbSubgroups(1), mNbSubGroupElements(0), mActiveSubgroup(0)
{
}
/**
\brief Add a component to the sequence.
\param[in] component The component to add to the sequence.
\return True on success, else false (for example due to component count limit being reached).
*/
PX_FORCE_INLINE bool add(PxVehicleComponent* component);
/**
\brief Start a substepping group.
\note All components added using #add() will be added to the new substepping group until either the group
is marked as complete with a call to #endSubstepGroup() or a subsequent substepping group is started with
a call to #beginSubstepGroup().
\note Groups can be nested with stacked calls to #beginSubstepGroup().
\note Each group opened by #beginSubstepGroup() must be closed with a complementary #endSubstepGroup() prior to calling #update().
\param[in] nbSubSteps is the number of substeps for the group's sequence. This can be changed with a call to #setSubsteps().
\return Handle for the substepping group on success, else eINVALID_SUBSTEP_GROUP
@see setSubsteps()
@see endSubstepGroup()
*/
PX_FORCE_INLINE PxU8 beginSubstepGroup(const PxU8 nbSubSteps = 1);
/**
\brief End a substepping group
\note The group most recently opened with #beginSubstepGroup() will be closed by this call.
@see setSubsteps()
@see beginSubstepGroup()
*/
PX_FORCE_INLINE void endSubstepGroup()
{
mActiveSubgroup = mSubGroups[mActiveSubgroup].parentGroup;
}
/**
\brief Set the number of substeps to perform for a specific substepping group.
\param[in] subGroupHandle specifies the substepping group
\param[in] nbSteps is the number of times to invoke the sequence of components and groups in the specified substepping group.
@see beginSubstepGroup()
@see endSubstepGroup()
*/
void setSubsteps(const PxU8 subGroupHandle, const PxU8 nbSteps)
{
PX_ASSERT(subGroupHandle < mNbSubgroups);
mSubGroups[subGroupHandle].nbSteps = nbSteps;
}
/**
\brief Update each component in the sequence.
\note If the update method of a component in the sequence returns false, the update process gets aborted.
\param[in] dt is the timestep of the update. The provided value has to be positive.
\param[in] context specifies global quantities of the simulation such as gravitational acceleration.
*/
void update(const PxReal dt, const PxVehicleSimulationContext& context)
{
PX_ASSERT(0 == mActiveSubgroup);
if (dt > 0.0f)
{
updateSubGroup(dt, context, 0, 1);
}
else
{
PxGetFoundation().error(PxErrorCode::eINVALID_PARAMETER, PX_FL,
"PxVehicleComponentSequence::update: The timestep must be positive!");
}
}
private:
enum
{
eINVALID_COMPONENT = 0xff,
eINVALID_SUB_GROUP_ELEMENT = 0xff
};
//Elements have the form of a linked list to allow traversal over a list of elements.
//Each element is either a single component or a subgroup.
struct SubGroupElement
{
SubGroupElement()
: childGroup(eINVALID_SUBSTEP_GROUP),
component(eINVALID_COMPONENT),
nextElement(eINVALID_SUB_GROUP_ELEMENT)
{
}
PxU8 childGroup;
PxU8 component;
PxU8 nextElement;
};
//A group is a linked list of elements to be processed in sequence.
//Each group stores the first element in the sequence.
//Each element in the sequence stores the next element in the sequence
//to allow traversal over the list of elements in the group.
struct Group
{
Group()
: parentGroup(eINVALID_SUBSTEP_GROUP),
firstElement(eINVALID_SUB_GROUP_ELEMENT),
nbSteps(1)
{
}
PxU8 parentGroup;
PxU8 firstElement;
PxU8 nbSteps;
};
PxVehicleComponent* mComponents[PxVehicleComponentSequenceLimits::eMAX_NB_COMPONENTS];
PxU8 mNbComponents;
Group mSubGroups[PxVehicleComponentSequenceLimits::eMAX_NB_SUBGROUPS];
PxU8 mNbSubgroups;
SubGroupElement mSubGroupElements[PxVehicleComponentSequenceLimits::eMAX_NB_SUBGROUPELEMENTS];
PxU8 mNbSubGroupElements;
PxU8 mActiveSubgroup;
bool updateSubGroup(const PxReal dt, const PxVehicleSimulationContext& context, const PxU8 groupId, const PxU8 parentSepMultiplier)
{
const PxU8 nbSteps = mSubGroups[groupId].nbSteps;
const PxU8 stepMultiplier = parentSepMultiplier * nbSteps;
const PxReal timestepForGroup = dt / PxReal(stepMultiplier);
for (PxU8 k = 0; k < nbSteps; k++)
{
PxU8 nextElement = mSubGroups[groupId].firstElement;
while (eINVALID_SUB_GROUP_ELEMENT != nextElement)
{
const SubGroupElement& e = mSubGroupElements[nextElement];
PX_ASSERT(e.component != eINVALID_COMPONENT || e.childGroup != eINVALID_SUBSTEP_GROUP);
if (eINVALID_COMPONENT != e.component)
{
PxVehicleComponent* c = mComponents[e.component];
if (!c->update(timestepForGroup, context))
return false;
}
else
{
PX_ASSERT(eINVALID_SUBSTEP_GROUP != e.childGroup);
if (!updateSubGroup(dt, context, e.childGroup, stepMultiplier))
return false;
}
nextElement = e.nextElement;
}
}
return true;
}
PxU8 getLastKnownElementInGroup(const PxU8 groupId) const
{
PxU8 currElement = mSubGroups[groupId].firstElement;
PxU8 nextElement = mSubGroups[groupId].firstElement;
while (nextElement != eINVALID_SUB_GROUP_ELEMENT)
{
currElement = nextElement;
nextElement = mSubGroupElements[nextElement].nextElement;
}
return currElement;
}
};
bool PxVehicleComponentSequence::add(PxVehicleComponent* c)
{
if (PxVehicleComponentSequenceLimits::eMAX_NB_COMPONENTS == mNbComponents)
return false;
if (PxVehicleComponentSequenceLimits::eMAX_NB_SUBGROUPELEMENTS == mNbSubGroupElements)
return false;
//Create a new element and point it at the component.
SubGroupElement& nextElementInGroup = mSubGroupElements[mNbSubGroupElements];
nextElementInGroup.childGroup = eINVALID_SUBSTEP_GROUP;
nextElementInGroup.component = mNbComponents;
nextElementInGroup.nextElement = eINVALID_SUB_GROUP_ELEMENT;
if (eINVALID_SUB_GROUP_ELEMENT == mSubGroups[mActiveSubgroup].firstElement)
{
//The group is empty so add the first element to it.
//Point the group at the new element because this will
//be the first element in the group.
mSubGroups[mActiveSubgroup].firstElement = mNbSubGroupElements;
}
else
{
//We are extending the sequence of element of the group.
//Add the new element to the end of the group's sequence.
mSubGroupElements[getLastKnownElementInGroup(mActiveSubgroup)].nextElement = mNbSubGroupElements;
}
//Increment the number of elements.
mNbSubGroupElements++;
//Record the component and increment the number of components.
mComponents[mNbComponents] = c;
mNbComponents++;
return true;
}
PxU8 PxVehicleComponentSequence::beginSubstepGroup(const PxU8 nbSubSteps)
{
if (mNbSubgroups == PxVehicleComponentSequenceLimits::eMAX_NB_SUBGROUPS)
return eINVALID_SUBSTEP_GROUP;
if (mNbSubGroupElements == PxVehicleComponentSequenceLimits::eMAX_NB_SUBGROUPELEMENTS)
return eINVALID_SUBSTEP_GROUP;
//We have a parent and child group relationship.
const PxU8 parentGroup = mActiveSubgroup;
const PxU8 childGroup = mNbSubgroups;
//Set up the child group.
mSubGroups[childGroup].parentGroup = parentGroup;
mSubGroups[childGroup].firstElement = eINVALID_SUB_GROUP_ELEMENT;
mSubGroups[childGroup].nbSteps = nbSubSteps;
//Create a new element to add to the parent group and point it at the child group.
SubGroupElement& nextElementIInGroup = mSubGroupElements[mNbSubGroupElements];
nextElementIInGroup.childGroup = childGroup;
nextElementIInGroup.nextElement = eINVALID_SUB_GROUP_ELEMENT;
nextElementIInGroup.component = eINVALID_COMPONENT;
//Add the new element to the parent group.
if (eINVALID_SUB_GROUP_ELEMENT == mSubGroups[parentGroup].firstElement)
{
//The parent group is empty so add the first element to it.
//Point the parent group at the new element because this will
//be the first element in the group.
mSubGroups[parentGroup].firstElement = mNbSubGroupElements;
}
else
{
//We are extending the sequence of elements of the parent group.
//Add the new element to the end of the group's sequence.
mSubGroupElements[getLastKnownElementInGroup(parentGroup)].nextElement = mNbSubGroupElements;
}
//Push the active group.
//All subsequent operations will now address the child group and we push or pop the group.
mActiveSubgroup = childGroup;
//Increment the number of elements.
mNbSubGroupElements++;
//Increment the number of groups.
mNbSubgroups++;
//Return the group id.
return mActiveSubgroup;
}
#if !PX_DOXYGEN
} // namespace vehicle2
} // namespace physx
#endif
/** @} */
| 10,775 | C | 31.954128 | 132 | 0.757865 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle2/PxVehicleAPI.h | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#pragma once
/** \addtogroup vehicle2
@{
*/
#include "vehicle2/PxVehicleLimits.h"
#include "vehicle2/PxVehicleComponent.h"
#include "vehicle2/PxVehicleComponentSequence.h"
#include "vehicle2/PxVehicleParams.h"
#include "vehicle2/PxVehicleFunctions.h"
#include "vehicle2/PxVehicleMaths.h"
#include "vehicle2/braking/PxVehicleBrakingParams.h"
#include "vehicle2/braking/PxVehicleBrakingFunctions.h"
#include "vehicle2/commands/PxVehicleCommandParams.h"
#include "vehicle2/commands/PxVehicleCommandStates.h"
#include "vehicle2/commands/PxVehicleCommandHelpers.h"
#include "vehicle2/drivetrain/PxVehicleDrivetrainParams.h"
#include "vehicle2/drivetrain/PxVehicleDrivetrainStates.h"
#include "vehicle2/drivetrain/PxVehicleDrivetrainHelpers.h"
#include "vehicle2/drivetrain/PxVehicleDrivetrainFunctions.h"
#include "vehicle2/drivetrain/PxVehicleDrivetrainComponents.h"
#include "vehicle2/physxActor/PxVehiclePhysXActorStates.h"
#include "vehicle2/physxActor/PxVehiclePhysXActorHelpers.h"
#include "vehicle2/physxActor/PxVehiclePhysXActorFunctions.h"
#include "vehicle2/physxActor/PxVehiclePhysXActorComponents.h"
#include "vehicle2/physxConstraints/PxVehiclePhysXConstraintParams.h"
#include "vehicle2/physxConstraints/PxVehiclePhysXConstraintStates.h"
#include "vehicle2/physxConstraints/PxVehiclePhysXConstraintHelpers.h"
#include "vehicle2/physxConstraints/PxVehiclePhysXConstraintFunctions.h"
#include "vehicle2/physxConstraints/PxVehiclePhysXConstraintComponents.h"
#include "vehicle2/physxRoadGeometry/PxVehiclePhysXRoadGeometryState.h"
#include "vehicle2/physxRoadGeometry/PxVehiclePhysXRoadGeometryParams.h"
#include "vehicle2/physxRoadGeometry/PxVehiclePhysXRoadGeometryHelpers.h"
#include "vehicle2/physxRoadGeometry/PxVehiclePhysXRoadGeometryFunctions.h"
#include "vehicle2/physxRoadGeometry/PxVehiclePhysXRoadGeometryComponents.h"
#include "vehicle2/pvd/PxVehiclePvdHelpers.h"
#include "vehicle2/pvd/PxVehiclePvdFunctions.h"
#include "vehicle2/pvd/PxVehiclePvdComponents.h"
#include "vehicle2/rigidBody/PxVehicleRigidBodyParams.h"
#include "vehicle2/rigidBody/PxVehicleRigidBodyStates.h"
#include "vehicle2/rigidBody/PxVehicleRigidBodyFunctions.h"
#include "vehicle2/rigidBody/PxVehicleRigidBodyComponents.h"
#include "vehicle2/roadGeometry/PxVehicleRoadGeometryState.h"
#include "vehicle2/steering/PxVehicleSteeringParams.h"
#include "vehicle2/steering/PxVehicleSteeringFunctions.h"
#include "vehicle2/suspension/PxVehicleSuspensionParams.h"
#include "vehicle2/suspension/PxVehicleSuspensionStates.h"
#include "vehicle2/suspension/PxVehicleSuspensionHelpers.h"
#include "vehicle2/suspension/PxVehicleSuspensionFunctions.h"
#include "vehicle2/suspension/PxVehicleSuspensionComponents.h"
#include "vehicle2/tire/PxVehicleTireParams.h"
#include "vehicle2/tire/PxVehicleTireStates.h"
#include "vehicle2/tire/PxVehicleTireHelpers.h"
#include "vehicle2/tire/PxVehicleTireFunctions.h"
#include "vehicle2/tire/PxVehicleTireComponents.h"
#include "vehicle2/wheel/PxVehicleWheelParams.h"
#include "vehicle2/wheel/PxVehicleWheelStates.h"
#include "vehicle2/wheel/PxVehicleWheelHelpers.h"
#include "vehicle2/wheel/PxVehicleWheelFunctions.h"
#include "vehicle2/wheel/PxVehicleWheelComponents.h"
#if !PX_DOXYGEN
namespace physx
{
namespace vehicle2
{
#endif
/** \brief Initialize the PhysX Vehicle library.
This should be called before calling any functions or methods in extensions which may require allocation.
\note This function does not need to be called before creating a PxDefaultAllocator object.
\param foundation a PxFoundation object
@see PxCloseVehicleExtension PxFoundation
*/
PX_FORCE_INLINE bool PxInitVehicleExtension(physx::PxFoundation& foundation)
{
PX_UNUSED(foundation);
PX_CHECK_AND_RETURN_VAL(&PxGetFoundation() == &foundation, "Supplied foundation must match the one that will be used to perform allocations", false);
PxIncFoundationRefCount();
return true;
}
/** \brief Shut down the PhysX Vehicle library.
This function should be called to cleanly shut down the PhysX Vehicle library before application exit.
\note This function is required to be called to release foundation usage.
@see PxInitVehicleExtension
*/
PX_FORCE_INLINE void PxCloseVehicleExtension()
{
PxDecFoundationRefCount();
}
#if !PX_DOXYGEN
} // namespace vehicle2
} // namespace physx
#endif
/** @} */
| 6,044 | C | 39.844594 | 151 | 0.812376 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle2/PxVehicleFunctions.h | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#pragma once
/** \addtogroup vehicle2
@{
*/
#include "foundation/PxTransform.h"
#include "foundation/PxMat33.h"
#include "foundation/PxSimpleTypes.h"
#include "PxRigidBody.h"
#include "PxVehicleParams.h"
#include "roadGeometry/PxVehicleRoadGeometryState.h"
#include "rigidBody/PxVehicleRigidBodyStates.h"
#include "physxRoadGeometry/PxVehiclePhysXRoadGeometryState.h"
#include "physxActor/PxVehiclePhysXActorStates.h"
#if !PX_DOXYGEN
namespace physx
{
namespace vehicle2
{
#endif
PX_FORCE_INLINE PxVec3 PxVehicleTransformFrameToFrame
(const PxVehicleFrame& srcFrame, const PxVehicleFrame& trgFrame, const PxVec3& v)
{
PxVec3 result = v;
if ((srcFrame.lngAxis != trgFrame.lngAxis) || (srcFrame.latAxis != trgFrame.latAxis) || (srcFrame.vrtAxis != trgFrame.vrtAxis))
{
const PxMat33 a = srcFrame.getFrame();
const PxMat33 r = trgFrame.getFrame();
result = (r * a.getTranspose() * v);
}
return result;
}
PX_FORCE_INLINE PxVec3 PxVehicleTransformFrameToFrame
(const PxVehicleFrame& srcFrame, const PxVehicleFrame& trgFrame,
const PxVehicleScale& srcScale, const PxVehicleScale& trgScale,
const PxVec3& v)
{
PxVec3 result = PxVehicleTransformFrameToFrame(srcFrame, trgFrame, v);
if((srcScale.scale != trgScale.scale))
result *= (trgScale.scale / srcScale.scale);
return result;
}
PX_FORCE_INLINE PxTransform PxVehicleTransformFrameToFrame
(const PxVehicleFrame& srcFrame, const PxVehicleFrame& trgFrame,
const PxVehicleScale& srcScale, const PxVehicleScale& trgScale,
const PxTransform& v)
{
PxTransform result(PxVehicleTransformFrameToFrame(srcFrame, trgFrame, srcScale, trgScale, v.p), v.q);
if ((srcFrame.lngAxis != trgFrame.lngAxis) || (srcFrame.latAxis != trgFrame.latAxis) || (srcFrame.vrtAxis != trgFrame.vrtAxis))
{
PxF32 angle;
PxVec3 axis;
v.q.toRadiansAndUnitAxis(angle, axis);
result.q = PxQuat(angle, PxVehicleTransformFrameToFrame(srcFrame, trgFrame, axis));
}
return result;
}
PX_FORCE_INLINE PxVec3 PxVehicleComputeTranslation(const PxVehicleFrame& frame, const PxReal lng, const PxReal lat, const PxReal vrt)
{
const PxVec3 v = frame.getFrame()*PxVec3(lng, lat, vrt);
return v;
}
PX_FORCE_INLINE PxQuat PxVehicleComputeRotation(const PxVehicleFrame& frame, const PxReal roll, const PxReal pitch, const PxReal yaw)
{
const PxMat33 m = frame.getFrame();
const PxVec3& lngAxis = m.column0;
const PxVec3& latAxis = m.column1;
const PxVec3& vrtAxis = m.column2;
const PxQuat quatPitch(pitch, latAxis);
const PxQuat quatRoll(roll, lngAxis);
const PxQuat quatYaw(yaw, vrtAxis);
const PxQuat result = quatYaw * quatRoll * quatPitch;
return result;
}
PX_FORCE_INLINE PxF32 PxVehicleComputeSign(const PxReal f)
{
return physx::intrinsics::fsel(f, physx::intrinsics::fsel(-f, 0.0f, 1.0f), -1.0f);
}
/**
\brief Shift the origin of a vehicle by the specified vector.
Call this method to adjust the internal data structures of vehicles to reflect the shifted origin location
(the shift vector will get subtracted from all world space spatial data).
\param[in] axleDesc is a description of the wheels on the vehicle.
\param[in] shift is the translation vector used to shift the origin.
\param[in] rigidBodyState stores the current position of the vehicle
\param[in] roadGeometryStates stores the hit plane under each wheel.
\param[in] physxActor stores the PxRigidActor that is the vehicle's PhysX representation.
\param[in] physxQueryStates stores the hit point of the most recent execution of PxVehiclePhysXRoadGeometryQueryUpdate() for each wheel.
\note It is the user's responsibility to keep track of the summed total origin shift and adjust all input/output to/from the vehicle accordingly.
\note This call will not automatically shift the PhysX scene and its objects. PxScene::shiftOrigin() must be called seperately to keep the systems in sync.
\note If there is no associated PxRigidActor then set physxActor to NULL.
\note If there is an associated PxRigidActor and it is already in a PxScene then the complementary call to PxScene::shiftOrigin() will take care of
shifting the associated PxRigidActor. This being the case, set physxActor to NULL. physxActor should be a non-NULL pointer only when there is an
associated PxRigidActor and it is not part of a PxScene. This can occur if the associated PxRigidActor is updated using PhysX immediate mode.
\note If scene queries are independent of PhysX geometry then set queryStates to NULL.
*/
PX_FORCE_INLINE void PxVehicleShiftOrigin
(const PxVehicleAxleDescription& axleDesc, const PxVec3& shift,
PxVehicleRigidBodyState& rigidBodyState, PxVehicleRoadGeometryState* roadGeometryStates,
PxVehiclePhysXActor* physxActor = NULL, PxVehiclePhysXRoadGeometryQueryState* physxQueryStates = NULL)
{
//Adjust the vehicle's internal pose.
rigidBodyState.pose.p -= shift;
//Optionally adjust the PxRigidActor pose.
if (physxActor && !physxActor->rigidBody->getScene())
{
const PxTransform oldPose = physxActor->rigidBody->getGlobalPose();
const PxTransform newPose(oldPose.p - shift, oldPose.q);
physxActor->rigidBody->setGlobalPose(newPose);
}
for (PxU32 i = 0; i < axleDesc.nbWheels; i++)
{
const PxU32 wheelId = axleDesc.wheelIdsInAxleOrder[i];
//Optionally adjust the hit position.
if (physxQueryStates && physxQueryStates[wheelId].actor)
physxQueryStates[wheelId].hitPosition -= shift;
//Adjust the hit plane.
if (roadGeometryStates[wheelId].hitState)
{
const PxPlane plane = roadGeometryStates[wheelId].plane;
PxU32 largestNormalComponentAxis = 0;
PxReal largestNormalComponent = 0.0f;
const PxF32 normalComponents[3] = { plane.n.x, plane.n.y, plane.n.z };
for (PxU32 k = 0; k < 3; k++)
{
if (PxAbs(normalComponents[k]) > largestNormalComponent)
{
largestNormalComponent = PxAbs(normalComponents[k]);
largestNormalComponentAxis = k;
}
}
PxVec3 pointInPlane(PxZero);
switch (largestNormalComponentAxis)
{
case 0:
pointInPlane.x = -plane.d / plane.n.x;
break;
case 1:
pointInPlane.y = -plane.d / plane.n.y;
break;
case 2:
pointInPlane.z = -plane.d / plane.n.z;
break;
default:
break;
}
roadGeometryStates[wheelId].plane.d = -plane.n.dot(pointInPlane - shift);
}
}
}
#if !PX_DOXYGEN
} // namespace vehicle2
} // namespace physx
#endif
/** @} */
| 7,998 | C | 38.995 | 155 | 0.759565 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle2/PxVehicleMaths.h | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#pragma once
/** \addtogroup vehicle2
@{
*/
#include "foundation/PxSimpleTypes.h"
#include "foundation/PxMemory.h"
#include "PxVehicleLimits.h"
#if !PX_DOXYGEN
namespace physx
{
namespace vehicle2
{
#endif
class PxVehicleVectorN
{
public:
enum
{
eMAX_SIZE = PxVehicleLimits::eMAX_NB_WHEELS + 3
};
PxVehicleVectorN(const PxU32 size)
: mSize(size)
{
PX_ASSERT(mSize <= PxVehicleVectorN::eMAX_SIZE);
PxMemZero(mValues, sizeof(PxReal)*PxVehicleVectorN::eMAX_SIZE);
}
~PxVehicleVectorN()
{
}
PxVehicleVectorN(const PxVehicleVectorN& src)
{
for (PxU32 i = 0; i < src.mSize; i++)
{
mValues[i] = src.mValues[i];
}
mSize = src.mSize;
}
PX_FORCE_INLINE PxVehicleVectorN& operator=(const PxVehicleVectorN& src)
{
for (PxU32 i = 0; i < src.mSize; i++)
{
mValues[i] = src.mValues[i];
}
mSize = src.mSize;
return *this;
}
PX_FORCE_INLINE PxReal& operator[] (const PxU32 i)
{
PX_ASSERT(i < mSize);
return (mValues[i]);
}
PX_FORCE_INLINE const PxReal& operator[] (const PxU32 i) const
{
//PX_ASSERT(i < mSize);
return (mValues[i]);
}
PX_FORCE_INLINE PxU32 getSize() const { return mSize; }
private:
PxReal mValues[PxVehicleVectorN::eMAX_SIZE];
PxU32 mSize;
};
class PxVehicleMatrixNN
{
public:
PxVehicleMatrixNN()
: mSize(0)
{
}
PxVehicleMatrixNN(const PxU32 size)
: mSize(size)
{
PX_ASSERT(mSize <= PxVehicleVectorN::eMAX_SIZE);
PxMemZero(mValues, sizeof(PxReal)*PxVehicleVectorN::eMAX_SIZE*PxVehicleVectorN::eMAX_SIZE);
}
PxVehicleMatrixNN(const PxVehicleMatrixNN& src)
{
for (PxU32 i = 0; i < src.mSize; i++)
{
for (PxU32 j = 0; j < src.mSize; j++)
{
mValues[i][j] = src.mValues[i][j];
}
}
mSize = src.mSize;
}
~PxVehicleMatrixNN()
{
}
PX_FORCE_INLINE PxVehicleMatrixNN& operator=(const PxVehicleMatrixNN& src)
{
for (PxU32 i = 0; i < src.mSize; i++)
{
for (PxU32 j = 0; j < src.mSize; j++)
{
mValues[i][j] = src.mValues[i][j];
}
}
mSize = src.mSize;
return *this;
}
PX_FORCE_INLINE PxReal get(const PxU32 i, const PxU32 j) const
{
PX_ASSERT(i < mSize);
PX_ASSERT(j < mSize);
return mValues[i][j];
}
PX_FORCE_INLINE void set(const PxU32 i, const PxU32 j, const PxReal val)
{
PX_ASSERT(i < mSize);
PX_ASSERT(j < mSize);
mValues[i][j] = val;
}
PX_FORCE_INLINE PxU32 getSize() const { return mSize; }
PX_FORCE_INLINE void setSize(const PxU32 size)
{
PX_ASSERT(size <= PxVehicleVectorN::eMAX_SIZE);
mSize = size;
}
public:
PxReal mValues[PxVehicleVectorN::eMAX_SIZE][PxVehicleVectorN::eMAX_SIZE];
PxU32 mSize;
};
/*
LUPQ decomposition
Based upon "Outer Product LU with Complete Pivoting," from Matrix Computations (4th Edition), Golub and Van Loan
Solve A*x = b using:
MatrixNNLUSolver solver;
solver.decomposeLU(A);
solver.solve(b, x);
*/
class PxVehicleMatrixNNLUSolver
{
private:
PxVehicleMatrixNN mLU;
PxU32 mP[PxVehicleVectorN::eMAX_SIZE - 1]; // Row permutation
PxU32 mQ[PxVehicleVectorN::eMAX_SIZE - 1]; // Column permutation
PxReal mDetM;
public:
PxVehicleMatrixNNLUSolver() {}
~PxVehicleMatrixNNLUSolver() {}
PxReal getDet() const { return mDetM; }
void decomposeLU(const PxVehicleMatrixNN& A);
//Given a matrix A and a vector b find x that satisfies Ax = b, where the matrix A is the matrix that was passed to #decomposeLU.
//Returns true if the lu decomposition indicates that the matrix has an inverse and x was successfully computed.
//Returns false if the lu decomposition resulted in zero determinant ie the matrix has no inverse and no solution exists for x.
//Returns false if the size of either b or x doesn't match the size of the matrix passed to #decomposeLU.
//If false is returned then each relevant element of x is set to zero.
bool solve(const PxVehicleVectorN& b, PxVehicleVectorN& x) const;
};
class PxVehicleMatrixNGaussSeidelSolver
{
public:
void solve(const PxU32 maxIterations, const PxReal tolerance, const PxVehicleMatrixNN& A, const PxVehicleVectorN& b, PxVehicleVectorN& result) const;
};
class PxVehicleMatrix33Solver
{
public:
bool solve(const PxVehicleMatrixNN& A_, const PxVehicleVectorN& b_, PxVehicleVectorN& result) const;
};
#if !PX_DOXYGEN
} //namespace vehicle2
} //namespace physx
#endif
/** @} */
| 5,957 | C | 24.033613 | 150 | 0.715125 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle2/PxVehicleParams.h | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#pragma once
/** \addtogroup vehicle2
@{
*/
#include "foundation/PxFoundation.h"
#include "foundation/PxAssert.h"
#include "foundation/PxMemory.h"
#include "foundation/PxVec3.h"
#include "foundation/PxMat33.h"
#include "PxVehicleLimits.h"
class OmniPvdWriter;
#if !PX_DOXYGEN
namespace physx
{
class PxConvexMesh;
class PxScene;
namespace vehicle2
{
#endif
struct PxVehicleAxleDescription
{
PX_FORCE_INLINE void setToDefault()
{
PxMemZero(this, sizeof(PxVehicleAxleDescription));
}
/**
\brief Add an axle to the vehicle by specifying the number of wheels on the axle and an array of wheel ids specifying each wheel on the axle.
\param[in] nbWheelsOnAxle is the number of wheels on the axle to be added.
\param[in] wheelIdsOnAxle is an array of wheel ids specifying all the wheels on the axle to be added.
*/
void addAxle(const PxU32 nbWheelsOnAxle, const PxU32* const wheelIdsOnAxle)
{
PX_ASSERT((nbWheels + nbWheelsOnAxle) < PxVehicleLimits::eMAX_NB_WHEELS);
PX_ASSERT(nbAxles < PxVehicleLimits::eMAX_NB_AXLES);
nbWheelsPerAxle[nbAxles] = nbWheelsOnAxle;
axleToWheelIds[nbAxles] = nbWheels;
for (PxU32 i = 0; i < nbWheelsOnAxle; i++)
{
wheelIdsInAxleOrder[nbWheels + i] = wheelIdsOnAxle[i];
}
nbWheels += nbWheelsOnAxle;
nbAxles++;
}
/**
\brief Return the number of axles on the vehicle.
\return The number of axles.
@see getNbWheelsOnAxle()
*/
PX_FORCE_INLINE PxU32 getNbAxles() const
{
return nbAxles;
}
/**
\brief Return the number of wheels on the ith axle.
\param[in] i specifies the axle to be queried for its wheel count.
\return The number of wheels on the specified axle.
@see getWheelOnAxle()
*/
PX_FORCE_INLINE PxU32 getNbWheelsOnAxle(const PxU32 i) const
{
return nbWheelsPerAxle[i];
}
/**
\brief Return the wheel id of the jth wheel on the ith axle.
\param[in] j specifies that the wheel id to be returned is the jth wheel in the list of wheels on the specified axle.
\param[in] i specifies the axle to be queried.
\return The wheel id of the jth wheel on the ith axle.
@see getNbWheelsOnAxle()
*/
PX_FORCE_INLINE PxU32 getWheelOnAxle(const PxU32 j, const PxU32 i) const
{
return wheelIdsInAxleOrder[axleToWheelIds[i] + j];
}
/**
\brief Return the number of wheels on the vehicle.
\return The number of wheels.
*/
PX_FORCE_INLINE PxU32 getNbWheels() const
{
return nbWheels;
}
/**
\brief Return the axle of a specified wheel.
\param[in] wheelId is the wheel whose axle is to be queried.
\return The axle of the specified wheel.
*/
PX_FORCE_INLINE PxU32 getAxle(const PxU32 wheelId) const
{
for (PxU32 i = 0; i < getNbAxles(); i++)
{
for (PxU32 j = 0; j < getNbWheelsOnAxle(i); j++)
{
if (getWheelOnAxle(j, i) == wheelId)
return i;
}
}
return 0xffffffff;
}
PX_FORCE_INLINE bool isValid() const
{
PX_CHECK_AND_RETURN_VAL(nbAxles > 0, "PxVehicleAxleDescription.nbAxles must be greater than zero", false);
PX_CHECK_AND_RETURN_VAL(nbWheels > 0, "PxVehicleAxleDescription.nbWheels must be greater than zero", false);
return true;
}
PxU32 nbAxles; //!< The number of axles on the vehicle
PxU32 nbWheelsPerAxle[PxVehicleLimits::eMAX_NB_AXLES]; //!< The number of wheels on each axle.
PxU32 axleToWheelIds[PxVehicleLimits::eMAX_NB_AXLES]; //!< The list of wheel ids for the ith axle begins at wheelIdsInAxleOrder[axleToWheelIds[i]]
PxU32 wheelIdsInAxleOrder[PxVehicleLimits::eMAX_NB_WHEELS]; //!< The list of all wheel ids on the vehicle.
PxU32 nbWheels; //!< The number of wheels on the vehicle.
PX_COMPILE_TIME_ASSERT(PxVehicleLimits::eMAX_NB_AXLES == PxVehicleLimits::eMAX_NB_WHEELS);
// It should be possible to support cases where each wheel is controlled individually and thus
// having a wheel per axle for up to the max wheel count.
};
struct PxVehicleAxes
{
enum Enum
{
ePosX = 0, //!< The +x axis
eNegX, //!< The -x axis
ePosY, //!< The +y axis
eNegY, //!< The -y axis
ePosZ, //!< The +z axis
eNegZ, //!< The -z axis
eMAX_NB_AXES
};
};
struct PxVehicleFrame
{
PxVehicleAxes::Enum lngAxis; //!< The axis defining the longitudinal (forward) direction of the vehicle.
PxVehicleAxes::Enum latAxis; //!< The axis defining the lateral (side) direction of the vehicle.
PxVehicleAxes::Enum vrtAxis; //!< The axis defining the vertical (up) direction of the vehicle.
PX_FORCE_INLINE void setToDefault()
{
lngAxis = PxVehicleAxes::ePosX;
latAxis = PxVehicleAxes::ePosY;
vrtAxis = PxVehicleAxes::ePosZ;
}
PX_FORCE_INLINE PxMat33 getFrame() const
{
const PxVec3 basisDirs[6] = { PxVec3(1,0,0), PxVec3(-1,0,0), PxVec3(0,1,0), PxVec3(0,-1,0), PxVec3(0,0,1), PxVec3(0,0,-1) };
const PxMat33 mat33(basisDirs[lngAxis], basisDirs[latAxis], basisDirs[vrtAxis]);
return mat33;
}
PX_FORCE_INLINE PxVec3 getLngAxis() const
{
const PxVec3 basisDirs[6] = { PxVec3(1,0,0), PxVec3(-1,0,0), PxVec3(0,1,0), PxVec3(0,-1,0), PxVec3(0,0,1), PxVec3(0,0,-1) };
return basisDirs[lngAxis];
}
PX_FORCE_INLINE PxVec3 getLatAxis() const
{
const PxVec3 basisDirs[6] = { PxVec3(1,0,0), PxVec3(-1,0,0), PxVec3(0,1,0), PxVec3(0,-1,0), PxVec3(0,0,1), PxVec3(0,0,-1) };
return basisDirs[latAxis];
}
PX_FORCE_INLINE PxVec3 getVrtAxis() const
{
const PxVec3 basisDirs[6] = { PxVec3(1,0,0), PxVec3(-1,0,0), PxVec3(0,1,0), PxVec3(0,-1,0), PxVec3(0,0,1), PxVec3(0,0,-1) };
return basisDirs[vrtAxis];
}
PX_FORCE_INLINE bool isValid() const
{
PX_CHECK_AND_RETURN_VAL(lngAxis < PxVehicleAxes::eMAX_NB_AXES, "PxVehicleFrame.lngAxis is invalid", false);
PX_CHECK_AND_RETURN_VAL(latAxis < PxVehicleAxes::eMAX_NB_AXES, "PxVehicleFrame.latAxis is invalid", false);
PX_CHECK_AND_RETURN_VAL(vrtAxis < PxVehicleAxes::eMAX_NB_AXES, "PxVehicleFrame.vrtAxis is invalid", false);
const PxMat33 frame = getFrame();
const PxQuat quat(frame);
PX_CHECK_AND_RETURN_VAL(quat.isFinite() && quat.isUnit() && quat.isSane(), "PxVehicleFrame is not a legal frame", false);
return true;
}
};
struct PxVehicleScale
{
PxReal scale; //!< The length scale used for the vehicle. For example, if 1.0 is considered meters, then 100.0 would be for centimeters.
PX_FORCE_INLINE void setToDefault()
{
scale = 1.0f;
}
PX_FORCE_INLINE bool isValid() const
{
PX_CHECK_AND_RETURN_VAL(scale > 0.0f, "PxVehicleScale.scale must be greater than zero", false);
return true;
}
};
/**
\brief Helper struct to pass array type data to vehice components and functions.
The Vehicle SDK tries to give the user a certain freedom in how the parameters and
states are stored. This helper struct presents a way to either use array of structs
or array of pointers to structs to pass data into the provided vehicle components
and functions.
*/
template<typename T>
struct PxVehicleArrayData
{
enum DataFormat
{
eARRAY_OF_STRUCTS = 0, //!< The data is provided as an array of structs and stored in #arrayOfStructs.
eARRAY_OF_POINTERS //!< The data is provided as an array of pointers and stored in #arrayOfPointers.
};
/**
\brief Set the data as an array of structs.
\param[in] data The data as an array of structs.
*/
PX_FORCE_INLINE void setData(T* data)
{
arrayOfStructs = data;
dataFormat = eARRAY_OF_STRUCTS;
}
/**
\brief Set the data as an array of pointers.
\param[in] data The data as an array of pointers.
*/
PX_FORCE_INLINE void setData(T*const* data)
{
arrayOfPointers= data;
dataFormat = eARRAY_OF_POINTERS;
}
PX_FORCE_INLINE PxVehicleArrayData()
{
}
PX_FORCE_INLINE explicit PxVehicleArrayData(T* data)
{
setData(data);
}
PX_FORCE_INLINE explicit PxVehicleArrayData(T*const* data)
{
setData(data);
}
/**
\brief Get the data entry at a given index.
\param[in] index The index to retrieve the data entry for.
\return Reference to the requested data entry.
*/
PX_FORCE_INLINE T& getData(PxU32 index)
{
if (dataFormat == eARRAY_OF_STRUCTS)
return arrayOfStructs[index];
else
return *arrayOfPointers[index];
}
PX_FORCE_INLINE T& operator[](PxU32 index)
{
return getData(index);
}
/**
\brief Get the data entry at a given index.
\param[in] index The index to retrieve the data entry for.
\return Reference to the requested data entry.
*/
PX_FORCE_INLINE const T& getData(PxU32 index) const
{
if (dataFormat == eARRAY_OF_STRUCTS)
return arrayOfStructs[index];
else
return *arrayOfPointers[index];
}
PX_FORCE_INLINE const T& operator[](PxU32 index) const
{
return getData(index);
}
/**
\brief Set as empty.
*/
PX_FORCE_INLINE void setEmpty()
{
arrayOfStructs = NULL;
}
/**
\brief Check if declared as empty.
\return True if empty, else false.
*/
PX_FORCE_INLINE bool isEmpty() const
{
return (arrayOfStructs == NULL);
}
/**
\brief Get a reference to the array but read only.
\return Read only version of the data.
*/
PX_FORCE_INLINE const PxVehicleArrayData<const T>& getConst() const
{
return reinterpret_cast<const PxVehicleArrayData<const T>&>(*this);
}
union
{
T* arrayOfStructs; //!< The data stored as an array of structs.
T*const* arrayOfPointers; //!< The data stored as an array of pointers.
};
PxU8 dataFormat;
};
template<typename T>
struct PxVehicleSizedArrayData : public PxVehicleArrayData<T>
{
/**
\brief Set the data as an array of structs and set the number of data entries.
\param[in] data The data as an array of structs.
\param[in] count The number of entries in the data array.
*/
PX_FORCE_INLINE void setDataAndCount(T* data, const PxU32 count)
{
PxVehicleArrayData<T>::setData(data);
size = count;
}
/**
\brief Set the data as an array of pointers and set the number of data entries.
\param[in] data The data as an array of pointers.
\param[in] count The number of entries in the data array.
*/
PX_FORCE_INLINE void setDataAndCount(T*const* data, const PxU32 count)
{
PxVehicleArrayData<T>::setData(data);
size = count;
}
/**
\brief Set as empty.
*/
PX_FORCE_INLINE void setEmpty()
{
PxVehicleArrayData<T>::setEmpty();
size = 0;
}
/**
\brief Check if declared as empty.
\return True if empty, else false.
*/
PX_FORCE_INLINE bool isEmpty() const
{
return ((size == 0) || PxVehicleArrayData<T>::isEmpty());
}
PxU32 size;
};
/**
\brief Determine whether the PhysX actor associated with a vehicle is to be updated with a velocity change or an acceleration change.
A velocity change will be immediately reflected in linear and angular velocity queries against the vehicle. An acceleration change, on the other hand,
will leave the linear and angular velocities unchanged until the next PhysX scene update has applied the acceleration update to the actor's linear and
angular velocities.
@see PxVehiclePhysXActorEndComponent
@see PxVehicleWriteRigidBodyStateToPhysXActor
*/
struct PxVehiclePhysXActorUpdateMode
{
enum Enum
{
eAPPLY_VELOCITY = 0,
eAPPLY_ACCELERATION
};
};
/**
\brief Tire slip values are computed using ratios with potential for divide-by-zero errors. PxVehicleTireSlipParams
introduces a minimum value for the denominator of each of these ratios.
*/
struct PxVehicleTireSlipParams
{
/**
\brief The lateral slip angle is typically computed as a function of the ratio of lateral and longitudinal speeds
of the rigid body in the tire's frame. This leads to a divide-by-zero in the event that the longitudinal speed
approaches zero. The parameter minLatSlipDenominator sets a minimum denominator for the ratio of speeds used to
compute the lateral slip angle.
\note Larger timesteps typically require larger values of minLatSlipDenominator.
<b>Range:</b> (0, inf)<br>
<b>Unit:</b> velocity = length / time
*/
PxReal minLatSlipDenominator;
/**
\brief The longitudinal slip represents the difference between the longitudinal speed of the rigid body in the tire's
frame and the linear speed arising from the rotation of the wheel. This is typically normalized using the reciprocal
of the longitudinal speed of the rigid body in the tire's frame. This leads to a divide-by-zero in the event that the
longitudinal speed approaches zero. The parameter minPassiveLongSlipDenominator sets a minimum denominator for the normalized
longitudinal slip when the wheel experiences zero drive torque and zero brake torque and zero handbrake torque. The aim is
to bring the vehicle to rest without experiencing wheel rotational speeds that oscillate around zero.
\note The vehicle will come to rest more smoothly with larger values of minPassiveLongSlipDenominator, particularly
with large timesteps that often lead to oscillation in wheel rotation speeds when the wheel rotation speed approaches
zero.
\note It is recommended that minActiveLongSlipDenominator < minPassiveLongSlipDenominator.
<b>Range:</b> (0, inf)<br>
<b>Unit:</b> velocity = length / time
*/
PxReal minPassiveLongSlipDenominator;
/**
\brief The longitudinal slip represents the difference between the longitudinal speed of the rigid body in the tire's
frame and the linear speed arising from the rotation of the wheel. This is typically normalized using the reciprocal
of the longitudinal speed of the rigid body in the tire's frame. This leads to a divide-by-zero in the event that the
longitudinal speed approaches zero. The parameter minActiveLongSlipDenominator sets a minimum denominator for the normalized
longitudinal slip when the wheel experiences either a non-zero drive torque or a non-zero brake torque or a non-zero handbrake
torque.
\note Larger timesteps typically require larger values of minActiveLongSlipDenominator to avoid instabilities occurring when
the vehicle is aggressively throttled from rest.
\note It is recommended that minActiveLongSlipDenominator < minPassiveLongSlipDenominator.
<b>Range:</b> (0, inf)<br>
<b>Unit:</b> velocity = length / time
*/
PxReal minActiveLongSlipDenominator;
PX_FORCE_INLINE void setToDefault()
{
minLatSlipDenominator = 1.0f;
minActiveLongSlipDenominator = 0.1f;
minPassiveLongSlipDenominator = 4.0f;
}
PX_FORCE_INLINE PxVehicleTireSlipParams transformAndScale(
const PxVehicleFrame& srcFrame, const PxVehicleFrame& trgFrame, const PxVehicleScale& srcScale, const PxVehicleScale& trgScale) const
{
PX_UNUSED(srcFrame);
PX_UNUSED(trgFrame);
PxVehicleTireSlipParams p = *this;
const PxReal scaleRatio = trgScale.scale / srcScale.scale;
p.minLatSlipDenominator *= scaleRatio;
p.minPassiveLongSlipDenominator *= scaleRatio;
p.minActiveLongSlipDenominator *= scaleRatio;
return p;
}
PX_FORCE_INLINE bool isValid() const
{
PX_CHECK_AND_RETURN_VAL(minLatSlipDenominator > 0.0f, "PxVehicleTireSlipParams.minLatSlipDenominator must be greater than zero", false);
PX_CHECK_AND_RETURN_VAL(minPassiveLongSlipDenominator > 0.0f, "PxVehicleTireSlipParams.minPassiveLongSlipDenominator must be greater than zero", false);
PX_CHECK_AND_RETURN_VAL(minActiveLongSlipDenominator > 0.0f, "PxVehicleTireSlipParams.minActiveLongSlipDenominator must be greater than zero", false);
return true;
}
};
/**
\brief Tires have two important directions for the purposes of tire force computation: longitudinal and lateral.
*/
struct PxVehicleTireDirectionModes
{
enum Enum
{
eLONGITUDINAL = 0,
eLATERAL,
eMAX_NB_PLANAR_DIRECTIONS
};
};
/**
\brief The low speed regime often presents numerical difficulties for the tire model due to the potential for divide-by-zero errors.
This particularly affects scenarios where the vehicle is slowing down due to damping and drag. In scenarios where there is no
significant brake or drive torque, numerical error begins to dominate and it can be difficult to bring the vehicle to rest. A solution
to this problem is to recognise that the vehicle is close to rest and to replace the tire forces with velocity constraints that will
bring the vehicle to rest. This regime is known as the "sticky tire" regime. PxVehicleTireAxisStickyParams describes velocity and time
thresholds that categorise the "sticky tire" regime. It also describes the rate at which the velocity constraints approach zero speed.
*/
struct PxVehicleTireAxisStickyParams
{
/**
\brief A tire enters the "sticky tire" regime when it has been below a speed specified by #thresholdSpeed for a continuous time
specified by #thresholdTime.
<b>Range:</b> [0, inf)<br>
<b>Unit:</b> velocity = length / time
*/
PxReal thresholdSpeed;
/**
\brief A tire enters the "sticky tire" regime when it has been below a speed specified by #thresholdSpeed for a continuous time
specified by #thresholdTime.
<b>Range:</b> [0, inf)<br>
<b>Unit:</b> time
*/
PxReal thresholdTime;
/**
\brief The rate at which the velocity constraint approaches zero is controlled by the damping parameter.
\note Larger values of damping lead to faster approaches to zero. Since the damping behaves like a
stiffness with respect to the velocity, too large a value can lead to instabilities.
<b>Range:</b> [0, inf)<br>
<b>Unit:</b> 1 / time (acceleration instead of force based damping, thus not mass/time)
*/
PxReal damping;
PX_FORCE_INLINE PxVehicleTireAxisStickyParams transformAndScale(
const PxVehicleFrame& srcFrame, const PxVehicleFrame& trgFrame, const PxVehicleScale& srcScale, const PxVehicleScale& trgScale) const
{
PX_UNUSED(srcFrame);
PX_UNUSED(trgFrame);
PxVehicleTireAxisStickyParams p = *this;
const PxReal scaleRatio = trgScale.scale / srcScale.scale;
p.thresholdSpeed *= scaleRatio;
return p;
}
PX_FORCE_INLINE bool isValid() const
{
PX_CHECK_AND_RETURN_VAL(thresholdSpeed >= 0.0f, "PxVehicleTireAxisStickyParams.thresholdSpeed must be greater than or equal to zero", false);
PX_CHECK_AND_RETURN_VAL(thresholdTime >= 0.0f, "PxVehicleTireAxisStickyParams.thresholdTime must be greater than or equal to zero", false);
PX_CHECK_AND_RETURN_VAL(damping >= 0.0f, "PxVehicleTireAxisStickyParams.damping must be greater than or equal to zero", false);
return true;
}
};
/**
\brief For each tire, the forces of the tire model may be replaced by velocity constraints when the tire enters the "sticky tire"
regime. The "sticky tire" regime of the lateral and longitudinal directions of the tire are managed separately.
*/
struct PxVehicleTireStickyParams
{
/**
The "sticky tire" regime of the lateral and longitudinal directions of the tire are managed separately and are individually
parameterized.
*/
PxVehicleTireAxisStickyParams stickyParams[PxVehicleTireDirectionModes::eMAX_NB_PLANAR_DIRECTIONS];
PX_FORCE_INLINE void setToDefault()
{
stickyParams[PxVehicleTireDirectionModes::eLONGITUDINAL].thresholdSpeed = 0.2f;
stickyParams[PxVehicleTireDirectionModes::eLONGITUDINAL].thresholdTime = 1.0f;
stickyParams[PxVehicleTireDirectionModes::eLONGITUDINAL].damping = 1.0f;
stickyParams[PxVehicleTireDirectionModes::eLATERAL].thresholdSpeed = 0.2f;
stickyParams[PxVehicleTireDirectionModes::eLATERAL].thresholdTime = 1.0f;
stickyParams[PxVehicleTireDirectionModes::eLATERAL].damping = 0.1f;
}
PX_FORCE_INLINE PxVehicleTireStickyParams transformAndScale(
const PxVehicleFrame& srcFrame, const PxVehicleFrame& trgFrame, const PxVehicleScale& srcScale, const PxVehicleScale& trgScale) const
{
PxVehicleTireStickyParams p = *this;
p.stickyParams[PxVehicleTireDirectionModes::eLONGITUDINAL] =
stickyParams[PxVehicleTireDirectionModes::eLONGITUDINAL].transformAndScale(srcFrame, trgFrame, srcScale, trgScale);
p.stickyParams[PxVehicleTireDirectionModes::eLATERAL] =
stickyParams[PxVehicleTireDirectionModes::eLATERAL].transformAndScale(srcFrame, trgFrame, srcScale, trgScale);
return p;
}
PX_FORCE_INLINE bool isValid() const
{
if (!stickyParams[PxVehicleTireDirectionModes::eLONGITUDINAL].isValid())
return false;
if (!stickyParams[PxVehicleTireDirectionModes::eLATERAL].isValid())
return false;
return true;
}
};
struct PxVehicleSimulationContextType
{
enum Enum
{
eDEFAULT, //!< The simulation context inherits from PxVehicleSimulationContext
ePHYSX //!< The simulation context inherits from PxVehiclePhysXSimulationContext
};
};
/**
\brief Structure to support Omni PVD, the PhysX Visual Debugger.
*/
struct PxVehiclePvdContext
{
public:
PX_FORCE_INLINE void setToDefault()
{
attributeHandles = NULL;
writer = NULL;
}
/**
\brief The attribute handles used to reflect vehicle parameter and state data in omnipvd.
\note A null value will result in no values being reflected in omnipvd.
\note #attributeHandles and #writer both need to be non-NULL to reflect vehicle values in omnipvd.
@see PxVehiclePvdAttributesCreate
@see PxVehiclePvdAttributesRelease
@see PxVehiclePVDComponent
*/
const struct PxVehiclePvdAttributeHandles* attributeHandles;
/**
\brief An instance of OmniPvdWriter used to write vehicle prameter and state data to omnipvd.
\note A null value will result in no values being reflected in omnipvd.
\note #attributeHandles and #writer both need to be non-NULL to reflect vehicle values in omnipvd.
@see PxVehiclePvdAttributesCreate
@see PxVehiclePvdAttributesRelease
@see PxVehiclePVDComponent
*/
OmniPvdWriter* writer;
};
struct PxVehicleSimulationContext
{
PxVehicleSimulationContext()
: type(PxVehicleSimulationContextType::eDEFAULT)
{}
PxVec3 gravity;
PxVehicleFrame frame;
PxVehicleScale scale;
//Tire
PxVehicleTireSlipParams tireSlipParams;
PxVehicleTireStickyParams tireStickyParams;
/**
\brief Forward wheel speed below which the wheel rotation speed gets blended with the rolling speed.
The blended rotation speed is used to integrate the wheel rotation angle. At low forward wheel speed,
the wheel rotation speed can get unstable (depending on the tire model used) and, for example, oscillate.
\note If brake or throttle is applied, there will be no blending.
<b>Unit:</b> velocity = length / time
*/
PxReal thresholdForwardSpeedForWheelAngleIntegration;
/**
\brief Structure to support Omni PVD, the PhysX Visual Debugger.
*/
PxVehiclePvdContext pvdContext;
protected:
PxVehicleSimulationContextType::Enum type;
public:
PX_FORCE_INLINE PxVehicleSimulationContextType::Enum getType() const { return type; }
PX_FORCE_INLINE void setToDefault()
{
frame.setToDefault();
scale.setToDefault();
gravity = frame.getVrtAxis() * (-9.81f * scale.scale);
tireSlipParams.setToDefault();
tireStickyParams.setToDefault();
thresholdForwardSpeedForWheelAngleIntegration = 5.0f * scale.scale;
pvdContext.setToDefault();
}
PX_FORCE_INLINE PxVehicleSimulationContext transformAndScale(
const PxVehicleFrame& srcFrame, const PxVehicleFrame& trgFrame, const PxVehicleScale& srcScale, const PxVehicleScale& trgScale) const
{
PxVehicleSimulationContext c = *this;
const PxReal scaleRatio = trgScale.scale / srcScale.scale;
c.gravity = trgFrame.getFrame()*srcFrame.getFrame().getTranspose()*c.gravity;
c.gravity *= scaleRatio;
c.tireSlipParams = tireSlipParams.transformAndScale(srcFrame, trgFrame, srcScale, trgScale);
c.tireStickyParams = tireStickyParams.transformAndScale(srcFrame, trgFrame, srcScale, trgScale);
c.thresholdForwardSpeedForWheelAngleIntegration *= scaleRatio;
c.frame = trgFrame;
c.scale = trgScale;
return c;
}
};
struct PxVehiclePhysXSimulationContext : public PxVehicleSimulationContext
{
PxVehiclePhysXSimulationContext()
: PxVehicleSimulationContext()
{
type = PxVehicleSimulationContextType::ePHYSX;
}
//Road geometry queries to find the plane under the wheel.
const PxConvexMesh* physxUnitCylinderSweepMesh;
const PxScene* physxScene;
//PhysX actor update
PxVehiclePhysXActorUpdateMode::Enum physxActorUpdateMode;
/**
\brief Wake counter value to set on the physx actor if a reset is required.
Certain vehicle states should keep a physx actor of a vehicle awake. This
will be achieved by resetting the wake counter value if needed. The wake
counter value is the minimum simulation time that a physx actor will stay
awake.
<b>Unit:</b> time
@see physxActorWakeCounterThreshold PxVehiclePhysxActorKeepAwakeCheck
*/
PxReal physxActorWakeCounterResetValue;
/**
\brief Threshold below which to check whether the physx actor wake counter
should get reset.
<b>Unit:</b> time
@see physxActorWakeCounterResetValue PxVehiclePhysxActorKeepAwakeCheck
*/
PxReal physxActorWakeCounterThreshold;
PX_FORCE_INLINE void setToDefault()
{
PxVehicleSimulationContext::setToDefault();
physxUnitCylinderSweepMesh = NULL;
physxScene = NULL;
physxActorUpdateMode = PxVehiclePhysXActorUpdateMode::eAPPLY_VELOCITY;
physxActorWakeCounterResetValue = 20.0f * 0.02f; // 20 timesteps of size 0.02
physxActorWakeCounterThreshold = 0.5f * physxActorWakeCounterResetValue;
}
PX_FORCE_INLINE PxVehiclePhysXSimulationContext transformAndScale(
const PxVehicleFrame& srcFrame, const PxVehicleFrame& trgFrame, const PxVehicleScale& srcScale, const PxVehicleScale& trgScale) const
{
PxVehiclePhysXSimulationContext r = *this;
static_cast<PxVehicleSimulationContext&>(r) = PxVehicleSimulationContext::transformAndScale(srcFrame, trgFrame, srcScale, trgScale);
return r;
}
};
/**
* \brief Express a function as a sequence of points {(x, y)} that form a piecewise polynomial.
*/
template <class T, unsigned int NB_ELEMENTS>
class PxVehicleFixedSizeLookupTable
{
public:
PxVehicleFixedSizeLookupTable()
: nbDataPairs(0)
{
}
PxVehicleFixedSizeLookupTable(const PxVehicleFixedSizeLookupTable& src)
{
PxMemCopy(xVals, src.xVals, sizeof(PxReal)* src.nbDataPairs);
PxMemCopy(yVals, src.yVals, sizeof(T)*src.nbDataPairs);
nbDataPairs = src.nbDataPairs;
}
~PxVehicleFixedSizeLookupTable()
{
}
PxVehicleFixedSizeLookupTable& operator=(const PxVehicleFixedSizeLookupTable& src)
{
PxMemCopy(xVals, src.xVals, sizeof(PxReal)*src.nbDataPairs);
PxMemCopy(yVals, src.yVals, sizeof(T)*src.nbDataPairs);
nbDataPairs = src.nbDataPairs;
return *this;
}
/**
\brief Add one more point to create one more polynomial segment of a piecewise polynomial.
*/
PX_FORCE_INLINE bool addPair(const PxReal x, const T y)
{
PX_CHECK_AND_RETURN_VAL(nbDataPairs < NB_ELEMENTS, "PxVehicleFixedSizeLookupTable::addPair() exceeded fixed size capacity", false);
xVals[nbDataPairs] = x;
yVals[nbDataPairs] = y;
nbDataPairs++;
return true;
}
/**
\brief Identify the segment of the piecewise polynomial that includes x and compute the corresponding y value by linearly interpolating the gradient of the segment.
\param[in] x is the value on the x-axis of the piecewise polynomial.
\return Returns the y value that corresponds to the input x.
*/
PX_FORCE_INLINE T interpolate(const PxReal x) const
{
if (0 == nbDataPairs)
{
return T(0);
}
if (1 == nbDataPairs || x < xVals[0])
{
return yVals[0];
}
PxReal x0 = xVals[0];
T y0 = yVals[0];
for (PxU32 i = 1; i < nbDataPairs; i++)
{
const PxReal x1 = xVals[i];
const T y1 = yVals[i];
if ((x >= x0) && (x < x1))
{
return (y0 + (y1 - y0) * (x - x0) / (x1 - x0));
}
x0 = x1;
y0 = y1;
}
PX_ASSERT(x >= xVals[nbDataPairs - 1]);
return yVals[nbDataPairs - 1];
}
void clear()
{
PxMemSet(xVals, 0, NB_ELEMENTS * sizeof(PxReal));
PxMemSet(yVals, 0, NB_ELEMENTS * sizeof(T));
nbDataPairs = 0;
}
PxReal xVals[NB_ELEMENTS];
T yVals[NB_ELEMENTS];
PxU32 nbDataPairs;
PX_FORCE_INLINE bool isValid() const
{
for (PxU32 i = 1; i < nbDataPairs; i++)
{
PX_CHECK_AND_RETURN_VAL(xVals[i] > xVals[i - 1], "PxVehicleFixedSizeLookupTable:: xVals[i+1] must be greater than xVals[i]", false);
}
return true;
}
};
#if !PX_DOXYGEN
} // namespace vehicle2
} // namespace physx
#endif
/** @} */
| 29,370 | C | 31.099454 | 165 | 0.746612 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle2/PxVehicleComponent.h | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#pragma once
/** \addtogroup vehicle2
@{
*/
#include "foundation/PxSimpleTypes.h"
#if !PX_DOXYGEN
namespace physx
{
namespace vehicle2
{
#endif
struct PxVehicleSimulationContext;
class PxVehicleComponent
{
public:
virtual ~PxVehicleComponent() {}
/**
\brief Update function for a vehicle component.
\param[in] dt The timestep size to use for the update step.
\param[in] context Vehicle simulation context holding global data or data that usually applies to a
large group of vehicles.
\return True if subsequent components in a sequence should get updated, false if the sequence should
be aborted.
@see PxVehicleComponentSequence
*/
virtual bool update(const PxReal dt, const PxVehicleSimulationContext& context) = 0;
};
#if !PX_DOXYGEN
} // namespace vehicle2
} // namespace physx
#endif
/** @} */
| 2,546 | C | 34.873239 | 101 | 0.752553 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle2/physxActor/PxVehiclePhysXActorStates.h | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#pragma once
/** \addtogroup vehicle2
@{
*/
#include "foundation/PxPreprocessor.h"
#include "foundation/PxMemory.h"
#include "PxRigidBody.h"
#include "vehicle2/PxVehicleLimits.h"
#if !PX_DOXYGEN
namespace physx
{
class PxShape;
namespace vehicle2
{
#endif
/**
\brief A description of the PhysX actor and shapes that represent the vehicle in an associated PxScene.
*/
struct PxVehiclePhysXActor
{
/**
\brief The PhysX rigid body that represents the vehcle in the associated PhysX scene.
\note PxActorFlag::eDISABLE_GRAVITY must be set true on the PxRigidBody
*/
PxRigidBody* rigidBody;
/**
\brief An array of shapes with one shape pointer (or NULL) for each wheel.
*/
PxShape* wheelShapes[PxVehicleLimits::eMAX_NB_WHEELS];
PX_FORCE_INLINE void setToDefault()
{
PxMemZero(this, sizeof(PxVehiclePhysXActor));
}
};
#define PX_VEHICLE_UNSPECIFIED_STEER_STATE PX_MAX_F32
/**
\brief A description of the previous steer command applied to the vehicle.
*/
struct PxVehiclePhysXSteerState
{
/**
\brief The steer command that was most previously applied to the vehicle.
*/
PxReal previousSteerCommand;
PX_FORCE_INLINE void setToDefault()
{
previousSteerCommand = PX_VEHICLE_UNSPECIFIED_STEER_STATE;
}
};
#if !PX_DOXYGEN
} // namespace vehicle2
} // namespace physx
#endif
/** @} */
| 3,012 | C | 29.434343 | 103 | 0.753984 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle2/physxActor/PxVehiclePhysXActorHelpers.h | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#pragma once
/** \addtogroup vehicle2
@{
*/
#include "PxFiltering.h"
#include "PxShape.h"
#if !PX_DOXYGEN
namespace physx
{
class PxGeometry;
class PxMaterial;
struct PxCookingParams;
namespace vehicle2
{
#endif
struct PxVehicleRigidBodyParams;
struct PxVehicleAxleDescription;
struct PxVehicleWheelParams;
struct PxVehiclePhysXActor;
struct PxVehicleFrame;
struct PxVehicleSuspensionParams;
class PxVehiclePhysXRigidActorParams
{
PX_NOCOPY(PxVehiclePhysXRigidActorParams)
public:
PxVehiclePhysXRigidActorParams(const PxVehicleRigidBodyParams& _physxActorRigidBodyParams, const char* _physxActorName)
: rigidBodyParams(_physxActorRigidBodyParams),
physxActorName(_physxActorName)
{
}
const PxVehicleRigidBodyParams& rigidBodyParams;
const char* physxActorName;
};
class PxVehiclePhysXRigidActorShapeParams
{
PX_NOCOPY(PxVehiclePhysXRigidActorShapeParams)
public:
PxVehiclePhysXRigidActorShapeParams
(const PxGeometry& _geometry, const PxTransform& _localPose, const PxMaterial& _material,
const PxShapeFlags _flags, const PxFilterData& _simulationFilterData, const PxFilterData& _queryFilterData)
: geometry(_geometry),
localPose(_localPose),
material(_material),
flags(_flags),
simulationFilterData(_simulationFilterData),
queryFilterData(_queryFilterData)
{
}
const PxGeometry& geometry;
const PxTransform& localPose;
const PxMaterial& material;
PxShapeFlags flags;
PxFilterData simulationFilterData;
PxFilterData queryFilterData;
};
class PxVehiclePhysXWheelParams
{
PX_NOCOPY(PxVehiclePhysXWheelParams)
public:
PxVehiclePhysXWheelParams(const PxVehicleAxleDescription& _axleDescription, const PxVehicleWheelParams* _wheelParams)
: axleDescription(_axleDescription),
wheelParams(_wheelParams)
{
}
const PxVehicleAxleDescription& axleDescription;
const PxVehicleWheelParams* wheelParams;
};
class PxVehiclePhysXWheelShapeParams
{
PX_NOCOPY(PxVehiclePhysXWheelShapeParams)
public:
PxVehiclePhysXWheelShapeParams(const PxMaterial& _material, const PxShapeFlags _flags, const PxFilterData _simulationFilterData, const PxFilterData _queryFilterData)
: material(_material),
flags(_flags),
simulationFilterData(_simulationFilterData),
queryFilterData(_queryFilterData)
{
}
const PxMaterial& material;
PxShapeFlags flags;
PxFilterData simulationFilterData;
PxFilterData queryFilterData;
};
/**
\brief Create a PxRigidDynamic instance, instantiate it with desired properties and populate it with PxShape instances.
\param[in] vehicleFrame describes the frame of the vehicle.
\param[in] rigidActorParams describes the mass and moment of inertia of the rigid body.
\param[in] rigidActorCmassLocalPose specifies the mapping between actor and rigid body frame.
\param[in] rigidActorShapeParams describes the collision geometry associated with the rigid body.
\param[in] wheelParams describes the radius and half-width of the wheels.
\param[in] wheelShapeParams describes the PxMaterial and PxShapeFlags to apply to the wheel shapes.
\param[in] physics is a PxPhysics instance.
\param[in] params is a PxCookingParams instance
\param[in] vehiclePhysXActor is a record of the PxRigidDynamic and PxShape instances instantiated.
\note This is an alternative to PxVehiclePhysXArticulationLinkCreate.
\note PxVehiclePhysXActorCreate primarily serves as an illustration of the instantiation of the PhysX class instances
required to simulate a vehicle with a PxRigidDynamic.
@see PxVehiclePhysXActorDestroy
*/
void PxVehiclePhysXActorCreate
(const PxVehicleFrame& vehicleFrame,
const PxVehiclePhysXRigidActorParams& rigidActorParams, const PxTransform& rigidActorCmassLocalPose,
const PxVehiclePhysXRigidActorShapeParams& rigidActorShapeParams,
const PxVehiclePhysXWheelParams& wheelParams, const PxVehiclePhysXWheelShapeParams& wheelShapeParams,
PxPhysics& physics, const PxCookingParams& params,
PxVehiclePhysXActor& vehiclePhysXActor);
/**
\brief Configure an actor so that it is ready for vehicle simulation.
\param[in] rigidActorParams describes the mass and moment of inertia of the rigid body.
\param[in] rigidActorCmassLocalPose specifies the mapping between actor and rigid body frame.
\param[out] rigidBody is the body to be prepared for simulation.
*/
void PxVehiclePhysXActorConfigure
(const PxVehiclePhysXRigidActorParams& rigidActorParams, const PxTransform& rigidActorCmassLocalPose,
PxRigidBody& rigidBody);
/**
\brief Create a PxArticulationReducedCoordinate and a single PxArticulationLink,
instantiate the PxArticulationLink with desired properties and populate it with PxShape instances.
\param[in] vehicleFrame describes the frame of the vehicle.
\param[in] rigidActorParams describes the mass and moment of inertia of the rigid body.
\param[in] rigidActorCmassLocalPose specifies the mapping between actor and rigid body frame.
\param[in] rigidActorShapeParams describes the collision geometry associated with the rigid body.
\param[in] wheelParams describes the radius and half-width of the wheels.
\param[in] wheelShapeParams describes the PxMaterial and PxShapeFlags to apply to the wheel shapes.
\param[in] physics is a PxPhysics instance.
\param[in] params is a PxCookingParams instance
\param[in] vehiclePhysXActor is a record of the PxArticulationReducedCoordinate, PxArticulationLink and PxShape instances instantiated.
\note This is an alternative to PxVehiclePhysXActorCreate.
\note PxVehiclePhysXArticulationLinkCreate primarily serves as an illustration of the instantiation of the PhysX class instances
required to simulate a vehicle as part of an articulated ensemble.
@see PxVehiclePhysXActorDestroy
*/
void PxVehiclePhysXArticulationLinkCreate
(const PxVehicleFrame& vehicleFrame,
const PxVehiclePhysXRigidActorParams& rigidActorParams, const PxTransform& rigidActorCmassLocalPose,
const PxVehiclePhysXRigidActorShapeParams& rigidActorShapeParams,
const PxVehiclePhysXWheelParams& wheelParams, const PxVehiclePhysXWheelShapeParams& wheelShapeParams,
PxPhysics& physics, const PxCookingParams& params,
PxVehiclePhysXActor& vehiclePhysXActor);
/**
\brief Release the PxRigidDynamic, PxArticulationReducedCoordinate, PxArticulationLink and PxShape instances
instantiated by PxVehiclePhysXActorCreate or PxVehiclePhysXArticulationLinkCreate.
\param[in] vehiclePhysXActor is a description of the PhysX instances to be released.
*/
void PxVehiclePhysXActorDestroy(PxVehiclePhysXActor& vehiclePhysXActor);
#if !PX_DOXYGEN
} // namespace vehicle2
} // namespace physx
#endif
/** @} */
| 8,225 | C | 38.171428 | 166 | 0.814225 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle2/physxActor/PxVehiclePhysXActorFunctions.h | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#pragma once
/** \addtogroup vehicle2
@{
*/
#include "foundation/PxSimpleTypes.h"
#include "vehicle2/PxVehicleParams.h"
#if !PX_DOXYGEN
namespace physx
{
class PxRigidBody;
class PxShape;
namespace vehicle2
{
#endif
struct PxVehicleCommandState;
struct PxVehicleEngineDriveTransmissionCommandState;
struct PxVehicleEngineParams;
struct PxVehicleEngineState;
struct PxVehicleGearboxParams;
struct PxVehicleGearboxState;
struct PxVehicleRigidBodyState;
struct PxVehiclePhysXConstraints;
struct PxVehicleWheelLocalPose;
struct PxVehicleWheelParams;
struct PxVehicleWheelRigidBody1dState;
struct PxVehiclePhysXSteerState;
/**
\brief Wake up the physx actor if the actor is asleep and the commands signal an intent to
change the state of the vehicle.
\param[in] commands are the brake, throttle and steer values that will drive the vehicle.
\param[in] transmissionCommands are the target gear and clutch values that will control
the transmission. If the target gear is different from the current gearbox
target gear, then the physx actor will get woken up. Can be set to NULL if the
vehicle does not have a gearbox or if this is not a desired behavior. If
specified, then gearParams and gearState has to be specifed too.
\param[in] gearParams The gearbox parameters. Can be set to NULL if the vehicle does
not have a gearbox and transmissionCommands is NULL.
\param[in] gearState The state of the gearbox. Can be set to NULL if the vehicle does
not have a gearbox and transmissionCommands is NULL.
\param[in] physxActor is the PxRigidBody instance associated with the vehicle.
\param[in,out] physxSteerState and commands are compared to
determine if the steering state has changed since the last call to PxVehiclePhysxActorWakeup().
\note If the steering has changed, the actor will be woken up.
\note On exit from PxVehiclePhysxActorWakeup, physxSteerState.previousSteerCommand is assigned to the value
of commands.steer so that the steer state may be propagated to the subsequent call to PxVehiclePhysxActorWakeup().
\note If physxSteerState.previousSteerCommand has value PX_VEHICLE_UNSPECIFIED_STEER_STATE, the steering state
is treated as though it has not changed.
*/
void PxVehiclePhysxActorWakeup(
const PxVehicleCommandState& commands,
const PxVehicleEngineDriveTransmissionCommandState* transmissionCommands,
const PxVehicleGearboxParams* gearParams,
const PxVehicleGearboxState* gearState,
PxRigidBody& physxActor,
PxVehiclePhysXSteerState& physxSteerState);
/**
\brief Check if the physx actor is sleeping and clear certain vehicle states if it is.
\param[in] axleDescription identifies the wheels on each axle.
\param[in] physxActor is the PxRigidBody instance associated with the vehicle.
\param[in] engineParams The engine parameters. Can be set to NULL if the vehicle does
not have an engine. Must be specified, if engineState is specified.
\param[in,out] rigidBodyState is the state of the rigid body used by the Vehicle SDK.
\param[in,out] physxConstraints The state of the suspension limit and low speed tire constraints.
If the vehicle actor is sleeping and constraints are active, they will be
deactivated and marked as dirty.
\param[in,out] wheelRigidBody1dStates describes the angular speed of the wheels.
\param[out] engineState The engine state. Can be set to NULL if the vehicle does
not have an engine. If specified, then engineParams has to be specifed too.
The engine rotation speed will get set to the idle rotation speed if
the actor is sleeping.
\return True if the actor was sleeping, else false.
*/
bool PxVehiclePhysxActorSleepCheck
(const PxVehicleAxleDescription& axleDescription,
const PxRigidBody& physxActor,
const PxVehicleEngineParams* engineParams,
PxVehicleRigidBodyState& rigidBodyState,
PxVehiclePhysXConstraints& physxConstraints,
PxVehicleArrayData<PxVehicleWheelRigidBody1dState>& wheelRigidBody1dStates,
PxVehicleEngineState* engineState);
/**
\brief Check if the physx actor has to be kept awake.
Certain criteria should keep the vehicle physx actor awake, for example, if the
(mass normalized) rotational kinetic energy of the wheels is above a certain
threshold or if a gear change is pending or if throttle is applied.
This method will reset the wake counter of the physx actor to a specified value,
if any of the mentioned criteria are met.
\note The physx actor's sleep threshold will be used as threshold to test against
for the energy criteria.
\param[in] axleDescription identifies the wheels on each axle.
\param[in] wheelParams describes the radius, mass etc. of the wheels.
\param[in] wheelRigidBody1dStates describes the angular speed of the wheels.
\param[in] wakeCounterThreshold Once the wake counter of the physx actor falls
below this threshold, the method will start testing if the wake
counter needs to be reset.
\param[in] wakeCounterResetValue The value to set the physx actor wake counter
to, if any of the criteria to do so are met.
\param[in] gearState The gear state. Can be set to NULL if the vehicle does
not have gears or if the mentioned behavior is not desired.
\param[in] throttle The throttle command state (see #PxVehicleCommandState).
Can be set to NULL if the vehicle is not controlled through
PxVehicleCommandState or if the mentioned behavior is not desired.
\param[in] physxActor is the PxRigidBody instance associated with the vehicle.
*/
void PxVehiclePhysxActorKeepAwakeCheck
(const PxVehicleAxleDescription& axleDescription,
const PxVehicleArrayData<const PxVehicleWheelParams>& wheelParams,
const PxVehicleArrayData<const PxVehicleWheelRigidBody1dState>& wheelRigidBody1dStates,
const PxReal wakeCounterThreshold,
const PxReal wakeCounterResetValue,
const PxVehicleGearboxState* gearState,
const PxReal* throttle,
PxRigidBody& physxActor);
/**
\brief Read the rigid body state from a PhysX actor.
\param[in] physxActor is a reference to a PhysX actor.
\param[out] rigidBodyState is the state of the rigid body used by the Vehicle SDK.
*/
void PxVehicleReadRigidBodyStateFromPhysXActor
(const PxRigidBody& physxActor,
PxVehicleRigidBodyState& rigidBodyState);
/**
\brief Update the local pose of a PxShape that is associated with a wheel.
\param[in] wheelLocalPose describes the local pose of each wheel in the rigid body frame.
\param[in] wheelShapeLocalPose describes the local pose to apply to the PxShape instance in the wheel's frame.
\param[in] shape is the target PxShape.
*/
void PxVehicleWriteWheelLocalPoseToPhysXWheelShape
(const PxTransform& wheelLocalPose, const PxTransform& wheelShapeLocalPose, PxShape* shape);
/**
\brief Write the rigid body state to a PhysX actor.
\param[in] physxActorUpdateMode controls whether the PhysX actor is to be updated with
instantaneous velocity changes or with accumulated accelerations to be applied in
the next simulation step of the associated PxScene.
\param[in] rigidBodyState is the state of the rigid body.
\param[in] dt is the simulation time that has elapsed since the last call to
PxVehicleWriteRigidBodyStateToPhysXActor().
\param[out] physXActor is a reference to the PhysX actor.
*/
void PxVehicleWriteRigidBodyStateToPhysXActor
(const PxVehiclePhysXActorUpdateMode::Enum physxActorUpdateMode,
const PxVehicleRigidBodyState& rigidBodyState,
const PxReal dt,
PxRigidBody& physXActor);
#if !PX_DOXYGEN
} // namespace vehicle2
} // namespace physx
#endif
/** @} */
| 9,175 | C | 44.88 | 114 | 0.795095 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle2/physxActor/PxVehiclePhysXActorComponents.h | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#pragma once
/** \addtogroup vehicle2
@{
*/
#include "vehicle2/PxVehicleParams.h"
#include "vehicle2/PxVehicleComponent.h"
#include "vehicle2/wheel/PxVehicleWheelStates.h"
#include "PxVehiclePhysXActorFunctions.h"
#include "PxVehiclePhysXActorStates.h"
#include "common/PxProfileZone.h"
#if !PX_DOXYGEN
namespace physx
{
namespace vehicle2
{
#endif
/**
\brief Work items at the beginning of an update step for a PhysX actor based vehicle.
Includes:
- Waking the actor up if it is sleeping and a throttle or steer command is issued.
- Clearing certain states if the actor is sleeping.
- Reading the state from the PhysX actor and copy to the vehicle internal state.
@see PxVehiclePhysxActorWakeup PxVehiclePhysxActorSleepCheck PxVehicleReadRigidBodyStateFromPhysXActor
*/
class PxVehiclePhysXActorBeginComponent : public PxVehicleComponent
{
public:
PxVehiclePhysXActorBeginComponent() : PxVehicleComponent() {}
virtual ~PxVehiclePhysXActorBeginComponent() {}
/**
\brief Provide vehicle data items for this component.
\param[out] axleDescription identifies the wheels on each axle.
\param[out] commands are the brake, throttle and steer values that will drive the vehicle.
\param[out] transmissionCommands are the target gear and clutch values that will control
the transmission. Can be set to NULL if the vehicle does not have a gearbox. If
specified, then gearParams and gearState has to be specifed too.
\param[out] gearParams The gearbox parameters. Can be set to NULL if the vehicle does
not have a gearbox and transmissionCommands is NULL.
\param[out] gearState The state of the gearbox. Can be set to NULL if the vehicle does
not have a gearbox and transmissionCommands is NULL.
\param[out] engineParams The engine parameters. Can be set to NULL if the vehicle does
not have an engine. Must be specified, if engineState is specified.
\param[out] physxActor is the PxRigidBody instance associated with the vehicle.
\param[out] physxSteerState is the previous state of the steer and is used to determine if the
steering wheel has changed by comparing with PxVehicleCommandState::steer.
\param[out] physxConstraints The state of the suspension limit and low speed tire constraints.
If the vehicle actor is sleeping and constraints are active, they will be
deactivated and marked as dirty.
\param[out] rigidBodyState is the state of the rigid body used by the Vehicle SDK.
\param[out] wheelRigidBody1dStates describes the angular speed of each wheel.
\param[out] engineState The engine state. Can be set to NULL if the vehicle does
not have an engine. If specified, then engineParams has to be specifed too.
*/
virtual void getDataForPhysXActorBeginComponent(
const PxVehicleAxleDescription*& axleDescription,
const PxVehicleCommandState*& commands,
const PxVehicleEngineDriveTransmissionCommandState*& transmissionCommands,
const PxVehicleGearboxParams*& gearParams,
const PxVehicleGearboxState*& gearState,
const PxVehicleEngineParams*& engineParams,
PxVehiclePhysXActor*& physxActor,
PxVehiclePhysXSteerState*& physxSteerState,
PxVehiclePhysXConstraints*& physxConstraints,
PxVehicleRigidBodyState*& rigidBodyState,
PxVehicleArrayData<PxVehicleWheelRigidBody1dState>& wheelRigidBody1dStates,
PxVehicleEngineState*& engineState) = 0;
virtual bool update(const PxReal dt, const PxVehicleSimulationContext& context)
{
PX_UNUSED(dt);
PX_UNUSED(context);
PX_PROFILE_ZONE("PxVehiclePhysXActorBeginComponent::update", 0);
const PxVehicleAxleDescription* axleDescription;
const PxVehicleCommandState* commands;
const PxVehicleEngineDriveTransmissionCommandState* transmissionCommands;
const PxVehicleGearboxParams* gearParams;
const PxVehicleGearboxState* gearState;
const PxVehicleEngineParams* engineParams;
PxVehiclePhysXActor* physxActor;
PxVehiclePhysXSteerState* physxSteerState;
PxVehiclePhysXConstraints* physxConstraints;
PxVehicleRigidBodyState* rigidBodyState;
PxVehicleArrayData<PxVehicleWheelRigidBody1dState> wheelRigidBody1dStates;
PxVehicleEngineState* engineState;
getDataForPhysXActorBeginComponent(axleDescription, commands, transmissionCommands,
gearParams, gearState, engineParams,
physxActor, physxSteerState, physxConstraints,
rigidBodyState, wheelRigidBody1dStates, engineState);
if (physxActor->rigidBody->getScene()) // Considering case where actor is not in a scene and constraints get solved via immediate mode
{
PxVehiclePhysxActorWakeup(*commands, transmissionCommands, gearParams, gearState,
*physxActor->rigidBody, *physxSteerState);
if (PxVehiclePhysxActorSleepCheck(*axleDescription, *physxActor->rigidBody, engineParams,
*rigidBodyState, *physxConstraints, wheelRigidBody1dStates, engineState))
{
return false;
}
}
PxVehicleReadRigidBodyStateFromPhysXActor(*physxActor->rigidBody, *rigidBodyState);
return true;
}
};
/**
\brief Work items at the end of an update step for a PhysX actor based vehicle.
Includes:
- Writing vehicle internal state to the PhysX actor.
- Keeping the vehicle awake if certain criteria are met.
*/
class PxVehiclePhysXActorEndComponent : public PxVehicleComponent
{
public:
PxVehiclePhysXActorEndComponent() : PxVehicleComponent() {}
virtual ~PxVehiclePhysXActorEndComponent() {}
/**
\brief Provide vehicle data items for this component.
\param[out] axleDescription identifies the wheels on each axle.
\param[out] rigidBodyState is the state of the rigid body used by the Vehicle SDK.
\param[out] wheelParams describes the radius, mass etc. of the wheels.
\param[out] wheelShapeLocalPoses are the local poses in the wheel's frame to apply to the PxShape instances that represent the wheel
\param[out] wheelRigidBody1dStates describes the angular speed of the wheels.
\param[out] wheelLocalPoses describes the local poses of the wheels in the rigid body frame.
\param[out] gearState The gear state. Can be set to NULL if the vehicle does
not have gears.
\param[out] throttle The throttle command state (see #PxVehicleCommandState).
Can be set to NULL if the vehicle is not controlled through
PxVehicleCommandState.
\param[out] physxActor is the PxRigidBody instance associated with the vehicle.
*/
virtual void getDataForPhysXActorEndComponent(
const PxVehicleAxleDescription*& axleDescription,
const PxVehicleRigidBodyState*& rigidBodyState,
PxVehicleArrayData<const PxVehicleWheelParams>& wheelParams,
PxVehicleArrayData<const PxTransform>& wheelShapeLocalPoses,
PxVehicleArrayData<const PxVehicleWheelRigidBody1dState>& wheelRigidBody1dStates,
PxVehicleArrayData<const PxVehicleWheelLocalPose>& wheelLocalPoses,
const PxVehicleGearboxState*& gearState,
const PxReal*& throttle,
PxVehiclePhysXActor*& physxActor) = 0;
virtual bool update(const PxReal dt, const PxVehicleSimulationContext& context)
{
PX_UNUSED(dt);
PX_PROFILE_ZONE("PxVehiclePhysXActorEndComponent::update", 0);
const PxVehicleAxleDescription* axleDescription;
const PxVehicleRigidBodyState* rigidBodyState;
PxVehicleArrayData<const PxVehicleWheelParams> wheelParams;
PxVehicleArrayData<const PxTransform> wheelShapeLocalPoses;
PxVehicleArrayData<const PxVehicleWheelRigidBody1dState> wheelRigidBody1dStates;
PxVehicleArrayData<const PxVehicleWheelLocalPose> wheelLocalPoses;
const PxVehicleGearboxState* gearState;
const PxReal* throttle;
PxVehiclePhysXActor* physxActor;
getDataForPhysXActorEndComponent(axleDescription, rigidBodyState,
wheelParams, wheelShapeLocalPoses, wheelRigidBody1dStates, wheelLocalPoses, gearState, throttle,
physxActor);
for (PxU32 i = 0; i < axleDescription->nbWheels; i++)
{
const PxU32 wheelId = axleDescription->wheelIdsInAxleOrder[i];
PxVehicleWriteWheelLocalPoseToPhysXWheelShape(wheelLocalPoses[wheelId].localPose, wheelShapeLocalPoses[wheelId],
physxActor->wheelShapes[wheelId]);
}
if (context.getType() == PxVehicleSimulationContextType::ePHYSX)
{
const PxVehiclePhysXSimulationContext& physxContext = static_cast<const PxVehiclePhysXSimulationContext&>(context);
PxVehicleWriteRigidBodyStateToPhysXActor(physxContext.physxActorUpdateMode, *rigidBodyState, dt, *physxActor->rigidBody);
PxVehiclePhysxActorKeepAwakeCheck(*axleDescription, wheelParams, wheelRigidBody1dStates,
physxContext.physxActorWakeCounterThreshold, physxContext.physxActorWakeCounterResetValue, gearState, throttle,
*physxActor->rigidBody);
}
else
{
PX_ALWAYS_ASSERT();
}
return true;
}
};
#if !PX_DOXYGEN
} // namespace vehicle2
} // namespace physx
#endif
/** @} */
| 10,366 | C | 41.487705 | 137 | 0.791434 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle2/rigidBody/PxVehicleRigidBodyStates.h | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#pragma once
/** \addtogroup vehicle2
@{
*/
#include "foundation/PxTransform.h"
#include "foundation/PxVec3.h"
#include "vehicle2/PxVehicleParams.h"
#if !PX_DOXYGEN
namespace physx
{
namespace vehicle2
{
#endif
struct PxVehicleRigidBodyState
{
PxTransform pose; //!< the body's pose (in world space)
PxVec3 linearVelocity; //!< the body's linear velocity (in world space)
PxVec3 angularVelocity; //!< the body's angular velocity (in world space)
PxVec3 previousLinearVelocity; //!< the previous linear velocity of the body (in world space)
PxVec3 previousAngularVelocity; //!< the previous angular velocity of the body (in world space)
PxVec3 externalForce; //!< external force (in world space) affecting the rigid body (usually excluding gravitational force)
PxVec3 externalTorque; //!< external torque (in world space) affecting the rigid body
PX_FORCE_INLINE void setToDefault()
{
pose = PxTransform(PxIdentity);
linearVelocity = PxVec3(PxZero);
angularVelocity = PxVec3(PxZero);
externalForce = PxVec3(PxZero);
externalTorque = PxVec3(PxZero);
}
/**
\brief Compute the vertical speed of the rigid body transformed to the world frame.
\param[in] frame describes the axes of the vehicle
*/
PX_FORCE_INLINE PxReal getVerticalSpeed(const PxVehicleFrame& frame) const
{
return linearVelocity.dot(pose.q.rotate(frame.getVrtAxis()));
}
/**
\param[in] frame describes the axes of the vehicle
\brief Compute the lateral speed of the rigid body transformed to the world frame.
*/
PX_FORCE_INLINE PxReal getLateralSpeed(const PxVehicleFrame& frame) const
{
return linearVelocity.dot(pose.q.rotate(frame.getLatAxis()));
}
/**
\brief Compute the longitudinal speed of the rigid body transformed to the world frame.
\param[in] frame describes the axes of the vehicle
*/
PX_FORCE_INLINE PxReal getLongitudinalSpeed(const PxVehicleFrame& frame) const
{
return linearVelocity.dot(pose.q.rotate(frame.getLngAxis()));
}
};
#if !PX_DOXYGEN
} // namespace vehicle2
} // namespace physx
#endif
/** @} */
| 3,754 | C | 36.929293 | 126 | 0.75333 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle2/rigidBody/PxVehicleRigidBodyComponents.h | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#pragma once
/** \addtogroup vehicle2
@{
*/
#include "vehicle2/PxVehicleParams.h"
#include "vehicle2/PxVehicleComponent.h"
#include "PxVehicleRigidBodyFunctions.h"
#include "common/PxProfileZone.h"
#if !PX_DOXYGEN
namespace physx
{
namespace vehicle2
{
#endif
/**
\brief Forward integrate the momentum and pose of the vehicle's rigid body after applying forces and torques
from the suspension, tires and anti-roll bars.
*/
class PxVehicleRigidBodyComponent : public PxVehicleComponent
{
public:
PxVehicleRigidBodyComponent() : PxVehicleComponent() {}
virtual ~PxVehicleRigidBodyComponent() {}
/**
\brief Retrieve pointers to the parameter and state data required to update the dynamic state of a rigid body.
\param[out] axleDescription must be returned as a non-null pointer to a single PxVehicleAxleDescription instance that describes the wheels and axles
of the vehicle.
\param[out] rigidBodyParams must be returned as a non-null pointer to a single PxVehicleRigidBodyParams instance that describes the mass and moment of
inertia of the rigid body.
\param[out] suspensionForces must be returned as a non-null pointer to an array of suspension forces and torques in the world frame.
The suspension forces and torques will be applied to the rigid body to update *rigidBodyState*.
\param[out] tireForces must be returned as a non-null pointer to an array of tire forces and torques in the world frame.
The tire forces and torques will be applied to the rigid body to update *rigidBodyState*.
\param[out] antiRollTorque may be returned an optionally non-null pointer to a single PxVehicleAntiRollTorque instance that contains the accumulated anti-roll
torque to apply to the rigid body.
\param[out] rigidBodyState imust be returned as a non-null pointer to a single PxVehicleRigidBodyState instance that is to be forward integrated.
\note The suspensionForces array must contain an entry for each wheel listed as an active wheel in axleDescription.
\note The tireForces array must contain an entry for each wheel listed as an active wheel in axleDescription.
\note If antiRollTorque is returned as a null pointer then zero anti-roll torque will be applied to the rigid body.
*/
virtual void getDataForRigidBodyComponent(
const PxVehicleAxleDescription*& axleDescription,
const PxVehicleRigidBodyParams*& rigidBodyParams,
PxVehicleArrayData<const PxVehicleSuspensionForce>& suspensionForces,
PxVehicleArrayData<const PxVehicleTireForce>& tireForces,
const PxVehicleAntiRollTorque*& antiRollTorque,
PxVehicleRigidBodyState*& rigidBodyState) = 0;
virtual bool update(const PxReal dt, const PxVehicleSimulationContext& context)
{
PX_PROFILE_ZONE("PxVehicleRigidBodyComponent::update", 0);
const PxVehicleAxleDescription* axleDescription;
const PxVehicleRigidBodyParams* rigidBodyParams;
PxVehicleArrayData<const PxVehicleSuspensionForce> suspensionForces;
PxVehicleArrayData<const PxVehicleTireForce> tireForces;
const PxVehicleAntiRollTorque* antiRollTorque;
PxVehicleRigidBodyState* rigidBodyState;
getDataForRigidBodyComponent(axleDescription, rigidBodyParams,
suspensionForces, tireForces, antiRollTorque,
rigidBodyState);
PxVehicleRigidBodyUpdate(
*axleDescription, *rigidBodyParams,
suspensionForces, tireForces, antiRollTorque,
dt, context.gravity,
*rigidBodyState);
return true;
}
};
#if !PX_DOXYGEN
} // namespace vehicle2
} // namespace physx
#endif
/** @} */
| 5,162 | C | 43.895652 | 159 | 0.78826 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle2/rigidBody/PxVehicleRigidBodyFunctions.h | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#pragma once
/** \addtogroup vehicle2
@{
*/
#include "foundation/PxVec3.h"
#include "foundation/PxSimpleTypes.h"
#include "vehicle2/PxVehicleParams.h"
#if !PX_DOXYGEN
namespace physx
{
namespace vehicle2
{
#endif
struct PxVehicleRigidBodyParams;
struct PxVehicleSuspensionForce;
struct PxVehicleTireForce;
struct PxVehicleAntiRollTorque;
struct PxVehicleRigidBodyState;
/**
\brief Forward integrate rigid body state.
\param[in] axleDescription is a description of the axles of the vehicle and the wheels on each axle.
\param[in] rigidBodyParams is a description of rigid body mass and moment of inertia.
\param[in] suspensionForces is an array of suspension forces and torques in the world frame to be applied to the rigid body.
\param[in] tireForces is an array of tire forces and torques in the world frame to be applied to the rigid body.
\param[in] antiRollTorque is an optional pointer to a single PxVehicleAntiRollTorque instance that contains the accumulated anti-roll
torque to apply to the rigid body.
\param[in] dt is the timestep of the forward integration.
\param[in] gravity is gravitational acceleration.
\param[in,out] rigidBodyState is the rigid body state that is to be updated.
\note The suspensionForces array must contain an entry for each wheel listed as an active wheel in axleDescription.
\note The tireForces array must contain an entry for each wheel listed as an active wheel in axleDescription.
\note If antiRollTorque is a null pointer then zero anti-roll torque will be applied to the rigid body.
*/
void PxVehicleRigidBodyUpdate
(const PxVehicleAxleDescription& axleDescription, const PxVehicleRigidBodyParams& rigidBodyParams,
const PxVehicleArrayData<const PxVehicleSuspensionForce>& suspensionForces,
const PxVehicleArrayData<const PxVehicleTireForce>& tireForces,
const PxVehicleAntiRollTorque* antiRollTorque,
const PxReal dt, const PxVec3& gravity,
PxVehicleRigidBodyState& rigidBodyState);
#if !PX_DOXYGEN
} // namespace vehicle2
} // namespace physx
#endif
/** @} */
| 3,720 | C | 44.938271 | 133 | 0.787366 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle2/braking/PxVehicleBrakingFunctions.h | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#pragma once
/** \addtogroup vehicle2
@{
*/
#include "foundation/PxPreprocessor.h"
#include "foundation/PxMath.h"
#include "PxVehicleBrakingParams.h"
#include "../commands/PxVehicleCommandStates.h"
#include "../commands/PxVehicleCommandHelpers.h"
#include "../drivetrain/PxVehicleDrivetrainParams.h"
#if !PX_DOXYGEN
namespace physx
{
namespace vehicle2
{
#endif
/**
\brief Compute the brake torque response to an array of brake commands.
\param[in] brakeCommands is the array of input brake commands to be applied to the vehicle.
\param[in] nbBrakeCommands is the number of input brake commands to be applied to the vehicle.
\param[in] longitudinalSpeed is the longitudinal speed of the vehicle.
\param[in] wheelId specifies the wheel that is to have its brake response computed.
\param[in] brakeResponseParams specifies the per wheel brake torque response to each brake command as a nonlinear function of brake command and longitudinal speed.
\param[out] brakeResponseState is the brake torque response to the input brake command.
\note commands.brakes[i] and brakeResponseParams[i] are treated as pairs of brake command and brake command response.
*/
PX_FORCE_INLINE void PxVehicleBrakeCommandResponseUpdate
(const PxReal* brakeCommands, const PxU32 nbBrakeCommands, const PxReal longitudinalSpeed,
const PxU32 wheelId, const PxVehicleSizedArrayData<const PxVehicleBrakeCommandResponseParams>& brakeResponseParams,
PxReal& brakeResponseState)
{
PX_CHECK_AND_RETURN(nbBrakeCommands <= brakeResponseParams.size, "PxVehicleBrakeCommandLinearUpdate: nbBrakes must be less than or equal to brakeResponseParams.size");
PxReal sum = 0.0f;
for (PxU32 i = 0; i < nbBrakeCommands; i++)
{
sum += PxVehicleNonLinearResponseCompute(brakeCommands[i], longitudinalSpeed, wheelId, brakeResponseParams[i]);
}
brakeResponseState = sum;
}
#if !PX_DOXYGEN
} // namespace vehicle2
} // namespace physx
#endif
/** @} */
| 3,618 | C | 44.237499 | 168 | 0.778883 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle2/wheel/PxVehicleWheelFunctions.h | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#pragma once
/** \addtogroup vehicle2
@{
*/
#include "foundation/PxSimpleTypes.h"
#if !PX_DOXYGEN
namespace physx
{
namespace vehicle2
{
#endif
struct PxVehicleWheelParams;
struct PxVehicleWheelActuationState;
struct PxVehicleSuspensionState;
struct PxVehicleTireSpeedState;
struct PxVehicleScale;
struct PxVehicleWheelRigidBody1dState;
/**
\brief Forward integrate the rotation angle of a wheel
\note The rotation angle of the wheel plays no role in simulation but is important to compute the pose of the wheel for rendering.
\param[in] wheelParams describes the radius and half-width of the wheel
\param[in] actuationState describes whether the wheel has drive or brake torque applied to it.
\param[in] suspensionState describes whether the wheel touches the ground.
\param[in] tireSpeedState describes the components of rigid body velocity at the ground contact point along the tire's lateral and longitudinal directions.
\param[in] thresholdForwardSpeedForWheelAngleIntegration Forward wheel speed below which the wheel rotation speed gets blended with the rolling
speed (based on the forward wheel speed) which is then used to integrate the wheel rotation angle. At low forward wheel speed, the wheel
rotation speed can get unstable (depending on the tire model used) and, for example, oscillate. If brake or throttle is applied, there
will be no blending.
\param[in] dt is the simulation time that has lapsed since the last call to PxVehicleWheelRotationAngleUpdate
\param[in,out] wheelRigidBody1dState describes the current angular speed and angle of the wheel.
\note At low speeds and large timesteps, wheel rotation speed can become noisy due to singularities in the tire slip computations.
At low speeds, therefore, the wheel speed used for integrating the angle is a blend of current angular speed and rolling angular speed if the
wheel experiences neither brake nor drive torque and can be placed on the ground. The blended rotation speed gets stored in
PxVehicleWheelRigidBody1dState::correctedRotationSpeed.
*/
void PxVehicleWheelRotationAngleUpdate
(const PxVehicleWheelParams& wheelParams,
const PxVehicleWheelActuationState& actuationState, const PxVehicleSuspensionState& suspensionState, const PxVehicleTireSpeedState& tireSpeedState,
const PxReal thresholdForwardSpeedForWheelAngleIntegration, const PxReal dt,
PxVehicleWheelRigidBody1dState& wheelRigidBody1dState);
#if !PX_DOXYGEN
} // namespace vehicle2
} // namespace physx
#endif
/** @} */
| 4,201 | C | 50.243902 | 155 | 0.794335 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle2/wheel/PxVehicleWheelStates.h | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#pragma once
/** \addtogroup vehicle2
@{
*/
#include "foundation/PxSimpleTypes.h"
#include "foundation/PxTransform.h"
#include "foundation/PxMemory.h"
#if !PX_DOXYGEN
namespace physx
{
namespace vehicle2
{
#endif
/**
\brief It is useful to know if a brake or drive torque is to be applied to a wheel.
*/
struct PxVehicleWheelActuationState
{
bool isBrakeApplied; //!< True if a brake torque is applied, false if not.
bool isDriveApplied; //!< True if a drive torque is applied, false if not.
PX_FORCE_INLINE void setToDefault()
{
PxMemZero(this, sizeof(PxVehicleWheelActuationState));
}
};
struct PxVehicleWheelRigidBody1dState
{
/**
\brief The rotation speed of the wheel around the lateral axis.
<b>Unit:</b> radians / time
*/
PxReal rotationSpeed;
/**
\brief The corrected rotation speed of the wheel around the lateral axis in radians per second.
At low forward wheel speed, the wheel rotation speed can get unstable (depending on the tire
model used) and, for example, oscillate. To integrate the wheel rotation angle, a (potentially)
blended rotation speed is used which gets stored in #correctedRotationSpeed.
<b>Unit:</b> radians / time
@see PxVehicleSimulationContext::thresholdForwardSpeedForWheelAngleIntegration
*/
PxReal correctedRotationSpeed;
/**
\brief The accumulated angle of the wheel around the lateral axis in radians in range (-2*Pi,2*Pi)
*/
PxReal rotationAngle;
PX_FORCE_INLINE void setToDefault()
{
PxMemZero(this, sizeof(PxVehicleWheelRigidBody1dState));
}
};
struct PxVehicleWheelLocalPose
{
PxTransform localPose; //!< The pose of the wheel in the rigid body frame.
PX_FORCE_INLINE void setToDefault()
{
localPose = PxTransform(PxIdentity);
}
};
#if !PX_DOXYGEN
} // namespace vehicle2
} // namespace physx
#endif
/** @} */
| 3,511 | C | 31.220183 | 99 | 0.753062 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle2/wheel/PxVehicleWheelParams.h | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#pragma once
/** \addtogroup vehicle2
@{
*/
#include "foundation/PxFoundation.h"
#include "vehicle2/PxVehicleParams.h"
#if !PX_DOXYGEN
namespace physx
{
namespace vehicle2
{
#endif
struct PxVehicleWheelParams
{
/**
\brief Radius of unit that includes metal wheel plus rubber tire.
<b>Range:</b> (0, inf)<br>
<b>Unit:</b> length
*/
PxReal radius;
/**
\brief Half-width of unit that includes wheel plus tire.
<b>Range:</b> (0, inf)<br>
<b>Unit:</b> length
*/
PxReal halfWidth;
/**
\brief Mass of unit that includes wheel plus tire.
<b>Range:</b> (0, inf)<br>
<b>Unit:</b> mass
*/
PxReal mass;
/**
\brief Moment of inertia of unit that includes wheel plus tire about the rolling axis.
<b>Range:</b> (0, inf)<br>
<b>Unit:</b> mass * (length^2)
*/
PxReal moi;
/**
\brief Damping rate applied to wheel.
<b>Range:</b> [0, inf)<br>
<b>Unit:</b> torque * time = mass * (length^2) / time
*/
PxReal dampingRate;
PX_FORCE_INLINE PxVehicleWheelParams transformAndScale(
const PxVehicleFrame& srcFrame, const PxVehicleFrame& trgFrame, const PxVehicleScale& srcScale, const PxVehicleScale& trgScale) const
{
PX_UNUSED(srcFrame);
PX_UNUSED(trgFrame);
PxVehicleWheelParams r = *this;
const PxReal scale = trgScale.scale/srcScale.scale;
r.radius *= scale;
r.halfWidth *= scale;
r.moi *= (scale*scale);
r.dampingRate *= (scale*scale);
return r;
}
PX_FORCE_INLINE bool isValid() const
{
PX_CHECK_AND_RETURN_VAL(radius > 0.0f, "PxVehicleWheelParams.radius must be greater than zero", false);
PX_CHECK_AND_RETURN_VAL(halfWidth > 0.0f, "PxVehicleWheelParams.halfWidth must be greater than zero", false);
PX_CHECK_AND_RETURN_VAL(mass > 0.0f, "PxVehicleWheelParams.mass must be greater than zero", false);
PX_CHECK_AND_RETURN_VAL(moi > 0.0f, "PxVehicleWheelParams.moi must be greater than zero", false);
PX_CHECK_AND_RETURN_VAL(dampingRate >= 0.0f, "PxVehicleWheelParams.dampingRate must be greater than or equal to zero", false);
return true;
}
};
#if !PX_DOXYGEN
} // namespace vehicle2
} // namespace physx
#endif
/** @} */
| 3,789 | C | 30.583333 | 135 | 0.724202 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle2/wheel/PxVehicleWheelComponents.h | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#pragma once
/** \addtogroup vehicle2
@{
*/
#include "vehicle2/PxVehicleParams.h"
#include "vehicle2/PxVehicleComponent.h"
#include "vehicle2/commands/PxVehicleCommandHelpers.h"
#include "vehicle2/tire/PxVehicleTireStates.h"
#include "PxVehicleWheelFunctions.h"
#include "PxVehicleWheelHelpers.h"
#include "common/PxProfileZone.h"
#if !PX_DOXYGEN
namespace physx
{
namespace vehicle2
{
#endif
class PxVehicleWheelComponent : public PxVehicleComponent
{
public:
PxVehicleWheelComponent() : PxVehicleComponent() {}
virtual ~PxVehicleWheelComponent() {}
virtual void getDataForWheelComponent(
const PxVehicleAxleDescription*& axleDescription,
PxVehicleArrayData<const PxReal>& steerResponseStates,
PxVehicleArrayData<const PxVehicleWheelParams>& wheelParams,
PxVehicleArrayData<const PxVehicleSuspensionParams>& suspensionParams,
PxVehicleArrayData<const PxVehicleWheelActuationState>& actuationStates,
PxVehicleArrayData<const PxVehicleSuspensionState>& suspensionStates,
PxVehicleArrayData<const PxVehicleSuspensionComplianceState>& suspensionComplianceStates,
PxVehicleArrayData<const PxVehicleTireSpeedState>& tireSpeedStates,
PxVehicleArrayData<PxVehicleWheelRigidBody1dState>& wheelRigidBody1dStates,
PxVehicleArrayData<PxVehicleWheelLocalPose>& wheelLocalPoses) = 0;
virtual bool update(const PxReal dt, const PxVehicleSimulationContext& context)
{
PX_PROFILE_ZONE("PxVehicleWheelComponent::update", 0);
const PxVehicleAxleDescription* axleDescription;
PxVehicleArrayData<const PxReal> steerResponseStates;
PxVehicleArrayData<const PxVehicleWheelParams> wheelParams;
PxVehicleArrayData<const PxVehicleSuspensionParams> suspensionParams;
PxVehicleArrayData<const PxVehicleWheelActuationState> actuationStates;
PxVehicleArrayData<const PxVehicleSuspensionState> suspensionStates;
PxVehicleArrayData<const PxVehicleSuspensionComplianceState> suspensionComplianceStates;
PxVehicleArrayData<const PxVehicleTireSpeedState> tireSpeedStates;
PxVehicleArrayData<PxVehicleWheelRigidBody1dState> wheelRigidBody1dStates;
PxVehicleArrayData<PxVehicleWheelLocalPose> wheelLocalPoses;
getDataForWheelComponent(axleDescription, steerResponseStates,
wheelParams, suspensionParams, actuationStates, suspensionStates,
suspensionComplianceStates, tireSpeedStates, wheelRigidBody1dStates,
wheelLocalPoses);
for (PxU32 i = 0; i < axleDescription->nbWheels; i++)
{
const PxU32 wheelId = axleDescription->wheelIdsInAxleOrder[i];
PxVehicleWheelRotationAngleUpdate(
wheelParams[wheelId],
actuationStates[wheelId], suspensionStates[wheelId],
tireSpeedStates[wheelId],
context.thresholdForwardSpeedForWheelAngleIntegration, dt,
wheelRigidBody1dStates[wheelId]);
wheelLocalPoses[wheelId].localPose = PxVehicleComputeWheelLocalPose(context.frame,
suspensionParams[wheelId],
suspensionStates[wheelId],
suspensionComplianceStates[wheelId],
steerResponseStates[wheelId],
wheelRigidBody1dStates[wheelId]);
}
return true;
}
};
#if !PX_DOXYGEN
} // namespace vehicle2
} // namespace physx
#endif
/** @} */
| 4,819 | C | 38.83471 | 91 | 0.799751 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle2/wheel/PxVehicleWheelHelpers.h | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#pragma once
/** \addtogroup vehicle2
@{
*/
#include "vehicle2/PxVehicleFunctions.h"
#include "vehicle2/suspension/PxVehicleSuspensionParams.h"
#include "vehicle2/suspension/PxVehicleSuspensionStates.h"
#include "PxVehicleWheelParams.h"
#include "PxVehicleWheelStates.h"
#if !PX_DOXYGEN
namespace physx
{
namespace vehicle2
{
#endif
/**
\brief Compute the quaternion of a wheel in the rigid body frame.
\param[in] frame describes the longitudinal and lateral axes of the vehicle.
\param[in] suspensionParams describes the suspension and wheel frames.
\param[in] camberAngle is the camber angle in radian sinduced by suspension compliance.
\param[in] toeAngle is the toe angle in radians induced by suspension compliance.
\param[in] steerAngle is the steer angle in radians applied to the wheel.
\param[in] rotationAngle is the angle around the wheel's lateral axis.
\return The quaterion of the wheel in the rigid body frame.
@see PxVehicleComputeWheelOrientation
*/
PX_FORCE_INLINE PxQuat PxVehicleComputeWheelLocalOrientation
(const PxVehicleFrame& frame,
const PxVehicleSuspensionParams& suspensionParams,
const PxReal camberAngle, const PxReal toeAngle, const PxReal steerAngle,
const PxReal rotationAngle)
{
const PxQuat wheelLocalOrientation =
(suspensionParams.suspensionAttachment.q * PxVehicleComputeRotation(frame, camberAngle, 0.0f, steerAngle + toeAngle))*
(suspensionParams.wheelAttachment.q * PxVehicleComputeRotation(frame, 0.0f, rotationAngle, 0.0f));
return wheelLocalOrientation;
}
/**
\brief Compute the quaternion of a wheel in the world frame.
\param[in] frame describes the longitudinal and lateral axes of the vehicle.
\param[in] suspensionParams describes the suspension and wheel frames.
\param[in] camberAngle is the camber angle in radian induced by suspension compliance.
\param[in] toeAngle is the toe angle in radians induced by suspension compliance.
\param[in] steerAngle is the steer angle in radians applied to the wheel.
\param[in] rigidBodyOrientation is the quaterion of the rigid body in the world frame.
\param[in] rotationAngle is the angle around the wheel's lateral axis.
\return The quaterion of the wheel in the world frame.
@see PxVehicleComputeWheelLocalOrientation
*/
PX_FORCE_INLINE PxQuat PxVehicleComputeWheelOrientation
(const PxVehicleFrame& frame,
const PxVehicleSuspensionParams& suspensionParams,
const PxReal camberAngle, const PxReal toeAngle, const PxReal steerAngle,
const PxQuat& rigidBodyOrientation, const PxReal rotationAngle)
{
const PxQuat wheelOrientation = rigidBodyOrientation * PxVehicleComputeWheelLocalOrientation(frame, suspensionParams,
camberAngle, toeAngle, steerAngle, rotationAngle);
return wheelOrientation;
}
/**
\brief Compute the pose of the wheel in the rigid body frame.
\param[in] frame describes the longitudinal and lateral axes of the vehicle.
\param[in] suspensionParams describes the suspension and wheel frames.
\param[in] suspensionState is the compression state of the suspenson.
\param[in] camberAngle is the camber angle in radian induced by suspension compliance.
\param[in] toeAngle is the toe angle in radians induced by suspension compliance.
\param[in] steerAngle is the steer angle in radians applied to the wheel.
\param[in] rotationAngle is the angle around the wheel's lateral axis.
\return The pose of the wheel in the rigid body frame.
*/
PX_FORCE_INLINE PxTransform PxVehicleComputeWheelLocalPose
(const PxVehicleFrame& frame,
const PxVehicleSuspensionParams& suspensionParams,
const PxVehicleSuspensionState& suspensionState,
const PxReal camberAngle, const PxReal toeAngle, const PxReal steerAngle,
const PxReal rotationAngle)
{
//Full equation:
//PxTransform(suspAttachment.p + suspParams.suspensionTravelDir*suspDist, suspAttachment.q) *
//PxTransform(PxVec3(0), PxQuat(camber, 0, steer+toe)) *
//wheelAttachment *
//PxTransform(PxVec3(0), PxQuat(0, rotation, 0))
//Reduces to:
//PxTransform(suspAttachment.p + suspParams.suspensionTravelDir*suspDist, suspAttachment.q * PxQuat(camber, 0, steer+toe)) *
//PxTranfsorm(wheelAttachment.p, wheelAttachment.q * PxQuat(0, rotation, 0))
const PxF32 suspDist = (suspensionState.jounce != PX_VEHICLE_UNSPECIFIED_JOUNCE) ? (suspensionParams.suspensionTravelDist - suspensionState.jounce) : 0.0f;
const PxTransform wheelLocalPose =
PxTransform(
suspensionParams.suspensionAttachment.p + suspensionParams.suspensionTravelDir*suspDist,
suspensionParams.suspensionAttachment.q*PxVehicleComputeRotation(frame, camberAngle, 0.0f, steerAngle + toeAngle))*
PxTransform(
suspensionParams.wheelAttachment.p,
suspensionParams.wheelAttachment.q*PxVehicleComputeRotation(frame, 0.0f, rotationAngle, 0.0f));
return wheelLocalPose;
}
/**
\brief Compute the pose of the wheel in the rigid body frame.
\param[in] frame describes the longitudinal and lateral axes of the vehicle.
\param[in] suspensionParams describes the suspension and wheel frames.
\param[in] suspensionState is the compression state of the suspenson.
\param[in] suspensionComplianceState is the camber and toe angles induced by suspension compliance.
\param[in] steerAngle is the steer angle in radians applied to the wheel.
\param[in] wheelState is angle around the wheel's lateral axis.
\return The pose of the wheel in the rigid body frame.
*/
PX_FORCE_INLINE PxTransform PxVehicleComputeWheelLocalPose
(const PxVehicleFrame& frame,
const PxVehicleSuspensionParams& suspensionParams,
const PxVehicleSuspensionState& suspensionState, const PxVehicleSuspensionComplianceState& suspensionComplianceState,
const PxReal steerAngle,
const PxVehicleWheelRigidBody1dState& wheelState)
{
return PxVehicleComputeWheelLocalPose(frame, suspensionParams, suspensionState,
suspensionComplianceState.camber, suspensionComplianceState.toe, steerAngle,
wheelState.rotationAngle);
}
/**
\brief Compute the pose of the wheel in the world frame.
\param[in] frame describes the longitudinal and lateral axes of the vehicle.
\param[in] suspensionParams describes the suspension and wheel frames.
\param[in] suspensionState is the compression state of the suspenson.
\param[in] camberAngle is the camber angle in radian induced by suspension compliance.
\param[in] toeAngle is the toe angle in radians induced by suspension compliance.
\param[in] steerAngle is the steer angle in radians applied to the wheel.
\param[in] rigidBodyPose is the pose of the rigid body in the world frame.
\param[in] rotationAngle is the angle around the wheel's lateral axis.
\return The pose of the wheel in the world frame.
*/
PX_FORCE_INLINE PxTransform PxVehicleComputeWheelPose
(const PxVehicleFrame& frame,
const PxVehicleSuspensionParams& suspensionParams,
const PxVehicleSuspensionState& suspensionState,
const PxReal camberAngle, const PxReal toeAngle, const PxReal steerAngle,
const PxTransform& rigidBodyPose, const PxReal rotationAngle)
{
const PxTransform wheelPose = rigidBodyPose * PxVehicleComputeWheelLocalPose(frame, suspensionParams, suspensionState,
camberAngle, toeAngle, steerAngle, rotationAngle);
return wheelPose;
}
/**
\brief Compute the pose of the wheel in the world frame.
\param[in] frame describes the longitudinal and lateral axes of the vehicle.
\param[in] suspensionParams describes the suspension and wheel frames.
\param[in] suspensionState is the compression state of the suspenson.
\param[in] suspensionComplianceState is the camber and toe angles induced by suspension compliance.
\param[in] steerAngle is the steer angle in radians applied to the wheel.
\param[in] rigidBodyPose is the pose of the rigid body in the world frame.
\param[in] wheelState is angle around the wheel's lateral axis.
\return The pose of the wheel in the world frame.
*/
PX_FORCE_INLINE PxTransform PxVehicleComputeWheelPose
(const PxVehicleFrame& frame,
const PxVehicleSuspensionParams& suspensionParams,
const PxVehicleSuspensionState& suspensionState, const PxVehicleSuspensionComplianceState& suspensionComplianceState, const PxReal steerAngle,
const PxTransform& rigidBodyPose, const PxVehicleWheelRigidBody1dState& wheelState)
{
return PxVehicleComputeWheelPose(frame, suspensionParams, suspensionState,
suspensionComplianceState.camber, suspensionComplianceState.toe, steerAngle,
rigidBodyPose, wheelState.rotationAngle);
}
/**
\brief Check if the suspension could place the wheel on the ground or not.
\param[in] suspState The state of the suspension to check.
\return True if the wheel connects to the ground, else false.
@see PxVehicleSuspensionState
*/
PX_FORCE_INLINE bool PxVehicleIsWheelOnGround(const PxVehicleSuspensionState& suspState)
{
return (suspState.separation <= 0.0f);
}
#if !PX_DOXYGEN
} // namespace vehicle2
} // namespace physx
#endif
/** @} */
| 10,451 | C | 46.081081 | 156 | 0.80155 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle2/suspension/PxVehicleSuspensionHelpers.h | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#pragma once
/** \addtogroup vehicle2
@{
*/
#include "foundation/PxTransform.h"
#include "vehicle2/wheel/PxVehicleWheelParams.h"
#include "vehicle2/wheel/PxVehicleWheelHelpers.h"
#include "PxVehicleSuspensionParams.h"
#if !PX_DOXYGEN
namespace physx
{
namespace vehicle2
{
#endif
/**
\brief Compute suspension travel direction in the world frame.
\param[in] suspensionParams is a description of the suspension frame.
\param[in] rigidBodyPose is the current pose of the vehicle's rigid body.
\return The return value is the suspension travel direction in the world frame.
\note The suspension travel direction is used to perform queries against the road geometry.
*/
PX_FORCE_INLINE PxVec3 PxVehicleComputeSuspensionDirection(const PxVehicleSuspensionParams& suspensionParams, const PxTransform& rigidBodyPose)
{
const PxVec3 suspDir = rigidBodyPose.rotate(suspensionParams.suspensionTravelDir);
return suspDir;
}
/**
\brief Compute the start pose of a suspension query.
\param[in] frame is a description of the longitudinal, lateral and vertical axes.
\param[in] suspensionParams is a description of the suspension frame.
\param[in] steerAngle is the yaw angle of the wheel in radians.
\param[in] rigidBodyPose is the pose of the rigid body in the world frame.
*/
PX_FORCE_INLINE PxTransform PxVehicleComputeWheelPoseForSuspensionQuery(const PxVehicleFrame& frame, const PxVehicleSuspensionParams& suspensionParams,
const PxReal steerAngle, const PxTransform& rigidBodyPose)
{
//Compute the wheel pose with zero travel from attachment point, zero compliance,
//zero wheel pitch (ignore due to radial symmetry).
//Zero travel from attachment point (we want the wheel pose at the top of the suspension, i.e., at max compression)
PxVehicleSuspensionState suspState;
suspState.setToDefault();
//Compute the wheel pose.
const PxTransform wheelPose = PxVehicleComputeWheelPose(frame, suspensionParams, suspState, 0.0f, 0.0f, steerAngle, rigidBodyPose,
0.0f);
return wheelPose;
}
/**
\brief Compute the start point, direction and length of a suspension scene raycast.
\param[in] frame is a description of the longitudinal, lateral and vertical axes.
\param[in] wheelParams describes the radius and halfwidth of the wheel.
\param[in] suspensionParams describes the suspension frame and the maximum suspension travel.
\param[in] steerAngle is the yaw angle of the wheel in radians.
\param[in] rigidBodyPose is the pose of the rigid body in the world frame.
\param[out] start is the starting point of the raycast in the world frame.
\param[out] dir is the direction of the raycast in the world frame.
\param[out] dist is the length of the raycast.
\note start, dir and dist together describe a raycast that begins at the top of wheel at maximum compression
and ends at the bottom of wheel at maximum droop.
*/
PX_FORCE_INLINE void PxVehicleComputeSuspensionRaycast
(const PxVehicleFrame& frame, const PxVehicleWheelParams& wheelParams, const PxVehicleSuspensionParams& suspensionParams,
const PxF32 steerAngle, const PxTransform& rigidBodyPose,
PxVec3& start, PxVec3& dir, PxReal& dist)
{
const PxTransform wheelPose = PxVehicleComputeWheelPoseForSuspensionQuery(frame, suspensionParams, steerAngle, rigidBodyPose);
//Raycast from top of wheel at max compression to bottom of wheel at max droop.
dir = PxVehicleComputeSuspensionDirection(suspensionParams, rigidBodyPose);
start = wheelPose.p - dir * wheelParams.radius;
dist = suspensionParams.suspensionTravelDist + 2.0f*wheelParams.radius;
}
/**
\brief Compute the start pose, direction and length of a suspension scene sweep.
\param[in] frame is a description of the longitudinal, lateral and vertical axes.
\param[in] suspensionParams describes the suspension frame and the maximum suspension travel.
\param[in] steerAngle is the yaw angle of the wheel in radians.
\param[in] rigidBodyPose is the pose of the rigid body in the world frame.
\param[out] start is the start pose of the sweep in the world frame.
\param[out] dir is the direction of the sweep in the world frame.
\param[out] dist is the length of the sweep.
\note start, dir and dist together describe a sweep that begins with the wheel placed at maximum
compression and ends at the maximum droop pose.
*/
PX_FORCE_INLINE void PxVehicleComputeSuspensionSweep
(const PxVehicleFrame& frame, const PxVehicleSuspensionParams& suspensionParams,
const PxReal steerAngle, const PxTransform& rigidBodyPose,
PxTransform& start, PxVec3& dir, PxReal& dist)
{
start = PxVehicleComputeWheelPoseForSuspensionQuery(frame, suspensionParams, steerAngle, rigidBodyPose);
dir = PxVehicleComputeSuspensionDirection(suspensionParams, rigidBodyPose);
dist = suspensionParams.suspensionTravelDist;
}
/**
\brief Compute the sprung masses of the suspension springs given (i) the number of sprung masses,
(ii) coordinates of the sprung masses in the rigid body frame, (iii) the center of mass offset of the rigid body, (iv) the
total mass of the rigid body, and (v) the direction of gravity
\param[in] nbSprungMasses is the number of sprung masses of the vehicle. This value corresponds to the number of wheels on the vehicle.
\param[in] sprungMassCoordinates are the coordinates of the sprung masses in the rigid body frame. The array sprungMassCoordinates must be of
length nbSprungMasses or greater.
\param[in] totalMass is the total mass of all the sprung masses.
\param[in] gravityDirection describes the direction of gravitational acceleration.
\param[out] sprungMasses are the masses to set in the associated suspension data with PxVehicleSuspensionData::mSprungMass. The sprungMasses array must be of length
nbSprungMasses or greater. Each element in the sprungMasses array corresponds to the suspension located at the same array element in sprungMassCoordinates.
The center of mass of the masses in sprungMasses with the coordinates in sprungMassCoordinates satisfy the specified centerOfMass.
\return True if the sprung masses were successfully computed, false if the sprung masses were not successfully computed.
*/
bool PxVehicleComputeSprungMasses(const PxU32 nbSprungMasses, const PxVec3* sprungMassCoordinates, const PxReal totalMass, const PxVehicleAxes::Enum gravityDirection, PxReal* sprungMasses);
#if !PX_DOXYGEN
} // namespace vehicle2
} // namespace physx
#endif
/** @} */
| 8,021 | C | 50.754838 | 189 | 0.794539 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle2/suspension/PxVehicleSuspensionComponents.h | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#pragma once
/** \addtogroup vehicle2
@{
*/
#include "vehicle2/PxVehicleParams.h"
#include "vehicle2/PxVehicleComponent.h"
#include "vehicle2/commands/PxVehicleCommandStates.h"
#include "vehicle2/commands/PxVehicleCommandHelpers.h"
#include "vehicle2/rigidBody/PxVehicleRigidBodyParams.h"
#include "vehicle2/roadGeometry/PxVehicleRoadGeometryState.h"
#include "vehicle2/wheel/PxVehicleWheelParams.h"
#include "PxVehicleSuspensionParams.h"
#include "PxVehicleSuspensionStates.h"
#include "PxVehicleSuspensionFunctions.h"
#include "common/PxProfileZone.h"
#if !PX_DOXYGEN
namespace physx
{
namespace vehicle2
{
#endif
class PxVehicleSuspensionComponent : public PxVehicleComponent
{
public:
PxVehicleSuspensionComponent() : PxVehicleComponent() {}
virtual ~PxVehicleSuspensionComponent() {}
/**
\brief Retrieve pointers to the parameter and state data required to compute the suspension state and the forces/torques that arise from the suspension state.
\param[out] axleDescription must be returned as a non-null pointer to a single PxVehicleAxleDescription instance that describes the wheels and axles
of the vehicle.
\param[out] rigidBodyParams must be returned as a a non-null pointer to a single PxVehicleRigidBodyParams instance that describes the mass and moment
of inertia of the vehicle's rigid body.
\param[out] suspensionStateCalculationParams must be returned as a non-null pointer to a single PxVehicleSuspensionStateCalculationParams instance
that describes the jounce computation type etc.
\param[out] steerResponseStates must be returned as a non-null pointer to a single PxVehicleSteerCommandResponseStates instance that describes the steer
state of the wheels.
\param[out] rigidBodyState must be returned as a non-null pointer to a single PxVehicleRigidBodyState instance that describes the pose and momentum of
the vehicle's rigid body.
\param[out] wheelParams must be set to a non-null pointer to an array of PxVehicleWheelParams containing per-wheel parameters for each wheel
referenced by axleDescription.
\param[out] suspensionParams must be set to a non-null pointer to an array of PxVehicleSuspensionParams containing per-wheel parameters for each
wheel referenced by axleDescription.
\param[out] suspensionComplianceParams must be set to a non-null pointer to an array of PxVehicleSuspensionComplianceParams containing per-wheel
parameters for each wheel referenced by axleDescription.
\param[out] suspensionForceParams must be set to a non-null pointer to an array of PxVehicleSuspensionForceParams containing per-wheel parameters
for each wheel referenced by axleDescription.
\param[out] antiRollForceParams is optionally returned as a non-null pointer to an array of PxVehicleAntiRollForceParams with each element in the array
describing a unique anti-roll bar connecting a pair of wheels.
\param[out] wheelRoadGeomStates must be set to non-null pointer to an array of PxVehicleRoadGeometryState containing per-wheel road geometry for
each wheel referenced by axleDescription.
\param[out] suspensionStates must be set to a non-null pointer to an array of PxVehicleSuspensionState containing per-wheel suspension state for each
wheel referenced by axleDescription.
\param[out] suspensionComplianceStates must be set to a non-null pointer to an array of PxVehicleSuspensionComplianceState containing per-wheel suspension
compliance state for each wheel referenced by axleDescription.
\param[out] suspensionForces must be set to a non-null pointer to an array of PxVehicleSuspensionForce containing per-wheel suspension forces for each
wheel referenced by axleDescription.
\param[out] antiRollTorque is optionally returned as a non-null pointer to a single PxVehicleAntiRollTorque instance that will store the accumulated anti-roll
torque to be applied to the vheicle's rigid body.
\note antiRollForceParams and antiRollTorque should be returned either both non-NULL or both NULL.
*/
virtual void getDataForSuspensionComponent(
const PxVehicleAxleDescription*& axleDescription,
const PxVehicleRigidBodyParams*& rigidBodyParams,
const PxVehicleSuspensionStateCalculationParams*& suspensionStateCalculationParams,
PxVehicleArrayData<const PxReal>& steerResponseStates,
const PxVehicleRigidBodyState*& rigidBodyState,
PxVehicleArrayData<const PxVehicleWheelParams>& wheelParams,
PxVehicleArrayData<const PxVehicleSuspensionParams>& suspensionParams,
PxVehicleArrayData<const PxVehicleSuspensionComplianceParams>& suspensionComplianceParams,
PxVehicleArrayData<const PxVehicleSuspensionForceParams>& suspensionForceParams,
PxVehicleSizedArrayData<const PxVehicleAntiRollForceParams>& antiRollForceParams,
PxVehicleArrayData<const PxVehicleRoadGeometryState>& wheelRoadGeomStates,
PxVehicleArrayData<PxVehicleSuspensionState>& suspensionStates,
PxVehicleArrayData<PxVehicleSuspensionComplianceState>& suspensionComplianceStates,
PxVehicleArrayData<PxVehicleSuspensionForce>& suspensionForces,
PxVehicleAntiRollTorque*& antiRollTorque) = 0;
/**
\brief Update the suspension state and suspension compliance state and use those updated states to compute suspension and anti-roll forces/torques
to apply to the vehicle's rigid body.
\param[in] dt is the simulation time that has passed since the last call to PxVehicleSuspensionComponent::update()
\param[in] context describes a variety of global simulation constants such as frame and scale of the simulation and the gravitational acceleration
of the simulated environment.
\note The suspension and anti-roll forces/torques are computed in the world frame.
*/
virtual bool update(const PxReal dt, const PxVehicleSimulationContext& context)
{
PX_PROFILE_ZONE("PxVehicleSuspensionComponent::update", 0);
const PxVehicleAxleDescription* axleDescription;
const PxVehicleRigidBodyParams* rigidBodyParams;
const PxVehicleSuspensionStateCalculationParams* suspensionStateCalculationParams;
PxVehicleArrayData<const PxReal> steerResponseStates;
const PxVehicleRigidBodyState* rigidBodyState;
PxVehicleArrayData<const PxVehicleWheelParams> wheelParams;
PxVehicleArrayData<const PxVehicleSuspensionParams> suspensionParams;
PxVehicleArrayData<const PxVehicleSuspensionComplianceParams> suspensionComplianceParams;
PxVehicleArrayData<const PxVehicleSuspensionForceParams> suspensionForceParams;
PxVehicleSizedArrayData<const PxVehicleAntiRollForceParams> antiRollForceParams;
PxVehicleArrayData<const PxVehicleRoadGeometryState> wheelRoadGeomStates;
PxVehicleArrayData<PxVehicleSuspensionState> suspensionStates;
PxVehicleArrayData<PxVehicleSuspensionComplianceState> suspensionComplianceStates;
PxVehicleArrayData<PxVehicleSuspensionForce> suspensionForces;
PxVehicleAntiRollTorque* antiRollTorque;
getDataForSuspensionComponent(axleDescription, rigidBodyParams, suspensionStateCalculationParams,
steerResponseStates, rigidBodyState,
wheelParams, suspensionParams,
suspensionComplianceParams, suspensionForceParams, antiRollForceParams,
wheelRoadGeomStates, suspensionStates, suspensionComplianceStates,
suspensionForces, antiRollTorque);
for (PxU32 i = 0; i < axleDescription->nbWheels; i++)
{
const PxU32 wheelId = axleDescription->wheelIdsInAxleOrder[i];
//Update the suspension state (jounce, jounce speed)
PxVehicleSuspensionStateUpdate(
wheelParams[wheelId], suspensionParams[wheelId], *suspensionStateCalculationParams,
suspensionForceParams[wheelId].stiffness, suspensionForceParams[wheelId].damping,
steerResponseStates[wheelId], wheelRoadGeomStates[wheelId],
*rigidBodyState,
dt, context.frame, context.gravity,
suspensionStates[wheelId]);
//Update the compliance from the suspension state.
PxVehicleSuspensionComplianceUpdate(
suspensionParams[wheelId], suspensionComplianceParams[wheelId],
suspensionStates[wheelId],
suspensionComplianceStates[wheelId]);
//Compute the suspension force from the suspension and compliance states.
PxVehicleSuspensionForceUpdate(
suspensionParams[wheelId], suspensionForceParams[wheelId],
wheelRoadGeomStates[wheelId], suspensionStates[wheelId],
suspensionComplianceStates[wheelId], *rigidBodyState,
context.gravity, rigidBodyParams->mass,
suspensionForces[wheelId]);
}
if (antiRollForceParams.size>0 && antiRollTorque)
{
PxVehicleAntiRollForceUpdate(
suspensionParams, antiRollForceParams,
suspensionStates.getConst(), suspensionComplianceStates.getConst(), *rigidBodyState,
*antiRollTorque);
}
return true;
}
};
/**
* @deprecated
*/
class PX_DEPRECATED PxVehicleLegacySuspensionComponent : public PxVehicleComponent
{
public:
PxVehicleLegacySuspensionComponent() : PxVehicleComponent() {}
virtual ~PxVehicleLegacySuspensionComponent() {}
/**
\brief Retrieve pointers to the parameter and state data required to compute the suspension state and the forces/torques that arise from the suspension state.
\param[out] axleDescription must be returned as a non-null pointer to a single PxVehicleAxleDescription instance that describes the wheels and axles
of the vehicle.
\param[out] suspensionStateCalculationParams must be returned as a non-null pointer to a single PxVehicleSuspensionStateCalculationParams instance
that describes the jounce computation type etc.
\param[out] steerResponseStates must be returned as a non-null pointer to a single PxVehicleSteerCommandResponseStates instance that describes the steer
state of the wheels.
\param[out] rigidBodyState must be returned as a non-null pointer to a single PxVehicleRigidBodyState instance that describes the pose and momentum of
the vehicle's rigid body.
\param[out] wheelParams must be set to a non-null pointer to an array of PxVehicleWheelParams containing per-wheel parameters for each wheel
referenced by axleDescription.
\param[out] suspensionParams must be set to a non-null pointer to an array of PxVehicleSuspensionParams containing per-wheel parameters for each
wheel referenced by axleDescription.
\param[out] suspensionComplianceParams must be set to a non-null pointer to an array of PxVehicleSuspensionComplianceParams containing per-wheel
parameters for each wheel referenced by axleDescription.
\param[out] suspensionForceParams must be set to a non-null pointer to an array of PxVehicleSuspensionForceLegacyParams containing per-wheel parameters
for each wheel referenced by axleDescription.
\param[out] antiRollForceParams is optionally returned as a non-null pointer to an array of PxVehicleAntiRollForceParams with each element in the array
describing a unique anti-roll bar connecting a pair of wheels.
\param[out] wheelRoadGeomStates must be set to non-null pointer to an array of PxVehicleRoadGeometryState containing per-wheel road geometry for
each wheel referenced by axleDescription.
\param[out] suspensionStates must be set to a non-null pointer to an array of PxVehicleSuspensionState containing per-wheel suspension state for each
wheel referenced by axleDescription.
\param[out] suspensionComplianceStates must be set to a non-null pointer to an array of PxVehicleSuspensionComplianceState containing per-wheel suspension
compliance state for each wheel referenced by axleDescription.
\param[out] suspensionForces must be set to a non-null pointer to an array of PxVehicleSuspensionForce containing per-wheel suspension forces for each
wheel referenced by axleDescription.
\param[out] antiRollTorque is optionally returned as a non-null pointer to a single PxVehicleAntiRollTorque instance that will store the accumulated anti-roll
torque to be applied to the vheicle's rigid body.
\note antiRollForceParams and antiRollTorque should be returned either both non-NULL or both NULL.
*/
virtual void getDataForLegacySuspensionComponent(
const PxVehicleAxleDescription*& axleDescription,
const PxVehicleSuspensionStateCalculationParams*& suspensionStateCalculationParams,
PxVehicleArrayData<const PxReal>& steerResponseStates,
const PxVehicleRigidBodyState*& rigidBodyState,
PxVehicleArrayData<const PxVehicleWheelParams>& wheelParams,
PxVehicleArrayData<const PxVehicleSuspensionParams>& suspensionParams,
PxVehicleArrayData<const PxVehicleSuspensionComplianceParams>& suspensionComplianceParams,
PxVehicleArrayData<const PxVehicleSuspensionForceLegacyParams>& suspensionForceParams,
PxVehicleSizedArrayData<const PxVehicleAntiRollForceParams>& antiRollForceParams,
PxVehicleArrayData<const PxVehicleRoadGeometryState>& wheelRoadGeomStates,
PxVehicleArrayData<PxVehicleSuspensionState>& suspensionStates,
PxVehicleArrayData<PxVehicleSuspensionComplianceState>& suspensionComplianceStates,
PxVehicleArrayData<PxVehicleSuspensionForce>& suspensionForces,
PxVehicleAntiRollTorque*& antiRollTorque) = 0;
/**
\brief Update the suspension state and suspension compliance state and use those updated states to compute suspension and anti-roll forces/torques
to apply to the vehicle's rigid body.
\param[in] dt is the simulation time that has passed since the last call to PxVehicleSuspensionComponent::update()
\param[in] context describes a variety of global simulation constants such as frame and scale of the simulation and the gravitational acceleration
of the simulated environment.
\note The suspension and anti-roll forces are computed in the world frame.
\note PxVehicleLegacySuspensionComponent::update() implements legacy suspension behaviour.
*/
virtual bool update(const PxReal dt, const PxVehicleSimulationContext& context)
{
PX_PROFILE_ZONE("PxVehicleLegacySuspensionComponent::update", 0);
const PxVehicleAxleDescription* axleDescription;
const PxVehicleSuspensionStateCalculationParams* suspensionStateCalculationParams;
PxVehicleArrayData<const PxReal> steerResponseStates;
const PxVehicleRigidBodyState* rigidBodyState;
PxVehicleArrayData<const PxVehicleWheelParams> wheelParams;
PxVehicleArrayData<const PxVehicleSuspensionParams> suspensionParams;
PxVehicleArrayData<const PxVehicleSuspensionComplianceParams> suspensionComplianceParams;
PxVehicleArrayData<const PxVehicleSuspensionForceLegacyParams> suspensionForceParams;
PxVehicleSizedArrayData<const PxVehicleAntiRollForceParams> antiRollForceParams;
PxVehicleArrayData<const PxVehicleRoadGeometryState> wheelRoadGeomStates;
PxVehicleArrayData<PxVehicleSuspensionState> suspensionStates;
PxVehicleArrayData<PxVehicleSuspensionComplianceState> suspensionComplianceStates;
PxVehicleArrayData<PxVehicleSuspensionForce> suspensionForces;
PxVehicleAntiRollTorque* antiRollTorque;
getDataForLegacySuspensionComponent(axleDescription, suspensionStateCalculationParams,
steerResponseStates, rigidBodyState, wheelParams,
suspensionParams, suspensionComplianceParams,
suspensionForceParams, antiRollForceParams,
wheelRoadGeomStates, suspensionStates, suspensionComplianceStates,
suspensionForces, antiRollTorque);
for (PxU32 i = 0; i < axleDescription->nbWheels; i++)
{
const PxU32 wheelId = axleDescription->wheelIdsInAxleOrder[i];
//Update the suspension state (jounce, jounce speed)
PxVehicleSuspensionStateUpdate(
wheelParams[wheelId], suspensionParams[wheelId], *suspensionStateCalculationParams,
suspensionForceParams[wheelId].stiffness, suspensionForceParams[wheelId].damping,
steerResponseStates[wheelId], wheelRoadGeomStates[wheelId], *rigidBodyState,
dt, context.frame, context.gravity,
suspensionStates[wheelId]);
//Update the compliance from the suspension state.
PxVehicleSuspensionComplianceUpdate(
suspensionParams[wheelId], suspensionComplianceParams[wheelId],
suspensionStates[wheelId],
suspensionComplianceStates[wheelId]);
//Compute the suspension force from the suspension and compliance states.
PxVehicleSuspensionLegacyForceUpdate(
suspensionParams[wheelId], suspensionForceParams[wheelId],
wheelRoadGeomStates[wheelId], suspensionStates[wheelId],
suspensionComplianceStates[wheelId], *rigidBodyState,
context.gravity,
suspensionForces[wheelId]);
}
if (antiRollForceParams.size>0 && antiRollTorque)
{
PxVehicleAntiRollForceUpdate(
suspensionParams, antiRollForceParams,
suspensionStates.getConst(), suspensionComplianceStates.getConst(), *rigidBodyState,
*antiRollTorque);
}
return true;
}
};
#if !PX_DOXYGEN
} // namespace vehicle2
} // namespace physx
#endif
/** @} */
| 18,164 | C | 54.212766 | 160 | 0.821625 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle2/suspension/PxVehicleSuspensionStates.h | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#pragma once
/** \addtogroup vehicle2
@{
*/
#include "foundation/PxSimpleTypes.h"
#include "foundation/PxVec3.h"
#include "foundation/PxMemory.h"
#if !PX_DOXYGEN
namespace physx
{
namespace vehicle2
{
#endif
#define PX_VEHICLE_UNSPECIFIED_JOUNCE PX_MAX_F32
#define PX_VEHICLE_UNSPECIFIED_SEPARATION PX_MAX_F32
/**
*/
struct PxVehicleSuspensionState
{
/**
\brief jounce is the distance from maximum droop.
\note jounce is positive semi-definite
\note A value of 0.0 represents the suspension at maximum droop and zero suspension force.
\note A value of suspensionTravelDist represents the suspension at maximum compression.
\note jounce is clamped in range [0, suspensionTravelDist].
*/
PxReal jounce;
/**
\brief jounceSpeed is the rate of change of jounce.
*/
PxReal jounceSpeed;
/**
\brief separation holds extra information about the contact state of the wheel with the ground.
If the suspension travel range is enough to place the wheel on the ground, then separation will be 0.
If separation holds a negative value, then the wheel penetrates into the ground at maximum compression
as well as maximum droop. The suspension would need to go beyond maximum compression (ground normal
pointing in opposite direction of suspension) or beyond maximum droop (ground normal pointing in same
direction as suspension) to place the wheel on the ground. In that case the separation value defines
how much the wheel penetrates into the ground along the ground plane normal. This penetration may be
resolved by using a constraint that simulates the effect of a bump stop.
If separation holds a positive value, then the wheel does not penetrate the ground at maximum droop
but can not touch the ground because the suspension would need to expand beyond max droop to reach it
or because the suspension could not expand fast enough to reach the ground.
*/
PxReal separation;
PX_FORCE_INLINE void setToDefault(const PxReal _jounce = PX_VEHICLE_UNSPECIFIED_JOUNCE,
const PxReal _separation = PX_VEHICLE_UNSPECIFIED_SEPARATION)
{
jounce = _jounce;
jounceSpeed = 0;
separation = _separation;
}
};
/**
\brief The effect of suspension compliance on toe and camber angle and on the tire and suspension force application points.
*/
struct PxVehicleSuspensionComplianceState
{
/**
\brief The toe angle in radians that arises from suspension compliance.
\note toe is expressed in the suspension frame.
*/
PxReal toe;
/**
\brief The camber angle in radians that arises from suspension compliance.
\note camber is expressed in the suspension frame.
*/
PxReal camber;
/**
\brief The tire force application point that arises from suspension compliance.
\note tireForceAppPoint is expressed in the suspension frame.
*/
PxVec3 tireForceAppPoint;
/**
\brief The suspension force application point that arises from suspension compliance.
\note suspForceAppPoint is expressed in the suspension frame.
*/
PxVec3 suspForceAppPoint;
PX_FORCE_INLINE void setToDefault()
{
PxMemZero(this, sizeof(PxVehicleSuspensionComplianceState));
}
};
/**
\brief The force and torque for a single suspension to apply to the vehicle's rigid body.
*/
struct PxVehicleSuspensionForce
{
/**
\brief The force to apply to the rigid body.
\note force is expressed in the world frame.
<b>Unit:</b> mass * length / (time^2)
*/
PxVec3 force;
/**
\brief The torque to apply to the rigid body.
\note torque is expressed in the world frame.
<b>Unit:</b> mass * (length^2) / (time^2)
*/
PxVec3 torque;
/**
\brief The component of force that lies along the normal of the plane under the wheel.
\note normalForce may be used by the tire model as the tire load.
<b>Unit:</b> mass * length / (time^2)
*/
PxReal normalForce;
PX_FORCE_INLINE void setToDefault()
{
PxMemZero(this, sizeof(PxVehicleSuspensionForce));
}
};
/**
\brief The anti-roll torque of all anti-roll bars accumulates in a single torque to apply
to the vehicle's rigid body.
*/
struct PxVehicleAntiRollTorque
{
/**
\brief The accumulated torque to apply to the rigid body.
\note antiRollTorque is expressed in the world frame.
<b>Unit:</b> mass * (length^2) / (time^2)
*/
PxVec3 antiRollTorque;
PX_FORCE_INLINE void setToDefault()
{
PxMemZero(this, sizeof(PxVehicleAntiRollTorque));
}
};
#if !PX_DOXYGEN
} // namespace vehicle2
} // namespace physx
#endif
/** @} */
| 6,102 | C | 31.121052 | 123 | 0.753851 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle2/suspension/PxVehicleSuspensionParams.h | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#pragma once
/** \addtogroup vehicle2
@{
*/
#include "foundation/PxTransform.h"
#include "foundation/PxFoundation.h"
#include "common/PxCoreUtilityTypes.h"
#include "vehicle2/PxVehicleParams.h"
#include "vehicle2/PxVehicleFunctions.h"
#if !PX_DOXYGEN
namespace physx
{
namespace vehicle2
{
#endif
struct PxVehicleSuspensionParams
{
/**
\brief suspensionAttachment specifies the wheel pose at maximum compression.
\note suspensionAttachment is specified in the frame of the rigid body.
\note camber, steer and toe angles are all applied in the suspension frame.
*/
PxTransform suspensionAttachment;
/**
\brief suspensionTravelDir specifies the direction of suspension travel.
\note suspensionTravelDir is specified in the frame of the rigid body.
*/
PxVec3 suspensionTravelDir;
/**
\brief suspensionTravelDist is the maximum distance that the suspenson can elongate along #suspensionTravelDir
from the pose specified by #suspensionAttachment.
\note The position suspensionAttachment.p + #suspensionTravelDir*#suspensionTravelDist corresponds to the
the suspension at maximum droop in the rigid body frame.
*/
PxReal suspensionTravelDist;
/**
\brief wheelAttachment is the pose of the wheel in the suspension frame.
\note The rotation angle around the wheel's lateral axis is applied in the wheel attachment frame.
*/
PxTransform wheelAttachment;
PX_FORCE_INLINE PxVehicleSuspensionParams transformAndScale(
const PxVehicleFrame& srcFrame, const PxVehicleFrame& trgFrame, const PxVehicleScale& srcScale, const PxVehicleScale& trgScale) const
{
PxVehicleSuspensionParams r = *this;
r.suspensionAttachment= PxVehicleTransformFrameToFrame(srcFrame, trgFrame, srcScale, trgScale, suspensionAttachment);
r.suspensionTravelDir = PxVehicleTransformFrameToFrame(srcFrame, trgFrame, suspensionTravelDir);
r.suspensionTravelDist *= (trgScale.scale/srcScale.scale);
r.wheelAttachment = PxVehicleTransformFrameToFrame(srcFrame, trgFrame, srcScale, trgScale, wheelAttachment);
return r;
}
PX_FORCE_INLINE bool isValid() const
{
PX_CHECK_AND_RETURN_VAL(suspensionAttachment.isValid(), "PxVehicleSuspensionParams.suspensionAttachment must be a valid transform", false);
PX_CHECK_AND_RETURN_VAL(suspensionTravelDir.isFinite(), "PxVehicleSuspensionParams.suspensionTravelDir must be a valid vector", false);
PX_CHECK_AND_RETURN_VAL(suspensionTravelDir.isNormalized(), "PxVehicleSuspensionParams.suspensionTravelDir must be a unit vector", false);
PX_CHECK_AND_RETURN_VAL(suspensionTravelDist > 0.0f, "PxVehicleSuspensionParams.suspensionTravelDist must be greater than zero", false);
PX_CHECK_AND_RETURN_VAL(wheelAttachment.isValid(), "PxVehicleSuspensionParams.wheelAttachment must be a valid transform", false);
return true;
}
};
struct PxVehicleSuspensionJounceCalculationType
{
enum Enum
{
eRAYCAST, //!< The jounce is calculated using a raycast against the plane of the road geometry state
eSWEEP, //!< The jounce is calculated by sweeping a cylinder against the plane of the road geometry state
eMAX_NB
};
};
struct PxVehicleSuspensionStateCalculationParams
{
PxVehicleSuspensionJounceCalculationType::Enum suspensionJounceCalculationType;
/**
\brief Limit the suspension expansion dynamics.
If a hit with the ground is detected, the suspension jounce will be set such that the wheel
is placed on the ground. This can result in large changes to jounce within a single
simulation frame, if the ground surface has high frequency or if the simulation time step
is large. As a result, large damping forces can evolve and cause undesired behavior. If this
parameter is set to true, the suspension expansion speed will be limited to what can be
achieved given the time step, suspension stiffness etc. As a consequence, handling of the
vehicle will be affected as the wheel might loose contact with the ground more easily.
*/
bool limitSuspensionExpansionVelocity;
PX_FORCE_INLINE PxVehicleSuspensionStateCalculationParams transformAndScale(
const PxVehicleFrame& srcFrame, const PxVehicleFrame& trgFrame, const PxVehicleScale& srcScale, const PxVehicleScale& trgScale) const
{
PX_UNUSED(srcFrame);
PX_UNUSED(trgFrame);
PX_UNUSED(srcScale);
PX_UNUSED(trgScale);
return *this;
}
PX_FORCE_INLINE bool isValid() const
{
return true;
}
};
/**
\brief Compliance describes how toe and camber angle and force application points are affected by suspension compression.
\note Each compliance term is in the form of a graph with up to 3 points.
\note Each point in the graph has form (jounce/suspensionTravelDist, complianceValue).
\note The sequence of points must respresent monotonically increasing values of jounce.
\note The compliance value can be computed by linear interpolation.
\note If any graph has zero points in it, a value of 0.0 is used for the compliance value.
\note If any graph has 1 point in it, the compliance value of that point is used directly.
*/
struct PxVehicleSuspensionComplianceParams
{
/**
\brief A graph of toe angle against jounce/suspensionTravelDist with the toe angle expressed in radians.
\note The toe angle is applied in the suspension frame.
*/
PxVehicleFixedSizeLookupTable<PxReal, 3> wheelToeAngle;
/**
\brief A graph of camber angle against jounce/suspensionTravelDist with the camber angle expressed in radians.
\note The camber angle is applied in the suspension frame.
*/
PxVehicleFixedSizeLookupTable<PxReal, 3> wheelCamberAngle;
/**
\brief Suspension forces are applied at an offset from the suspension frame. suspForceAppPoint
specifies the (X, Y, Z) components of that offset as a function of jounce/suspensionTravelDist.
*/
PxVehicleFixedSizeLookupTable<PxVec3, 3> suspForceAppPoint;
/**
\brief Tire forces are applied at an offset from the suspension frame. tireForceAppPoint
specifies the (X, Y, Z) components of that offset as a function of jounce/suspensionTravelDist.
*/
PxVehicleFixedSizeLookupTable<PxVec3, 3> tireForceAppPoint;
PX_FORCE_INLINE PxVehicleSuspensionComplianceParams transformAndScale(
const PxVehicleFrame& srcFrame, const PxVehicleFrame& trgFrame, const PxVehicleScale& srcScale, const PxVehicleScale& trgScale) const
{
PX_UNUSED(srcFrame);
PX_UNUSED(trgFrame);
PxVehicleSuspensionComplianceParams r = *this;
const PxReal scale = trgScale.scale / srcScale.scale;
for (PxU32 i = 0; i < r.suspForceAppPoint.nbDataPairs; i++)
{
r.suspForceAppPoint.yVals[i] = PxVehicleTransformFrameToFrame(srcFrame, trgFrame, suspForceAppPoint.yVals[i]);
r.suspForceAppPoint.yVals[i] *= scale;
}
for (PxU32 i = 0; i < r.tireForceAppPoint.nbDataPairs; i++)
{
r.tireForceAppPoint.yVals[i] = PxVehicleTransformFrameToFrame(srcFrame, trgFrame, tireForceAppPoint.yVals[i]);
r.tireForceAppPoint.yVals[i] *= scale;
}
return r;
}
PX_FORCE_INLINE bool isValid() const
{
PX_CHECK_AND_RETURN_VAL(wheelToeAngle.isValid(), "PxVehicleSuspensionComplianceParams.wheelToeAngle is invalid", false);
PX_CHECK_AND_RETURN_VAL(wheelCamberAngle.isValid(), "PxVehicleSuspensionComplianceParams.wheelCamberAngle is invalid", false);
PX_CHECK_AND_RETURN_VAL(suspForceAppPoint.isValid(), "PxVehicleSuspensionComplianceParams.wheelToeAngle is invalid", false);
PX_CHECK_AND_RETURN_VAL(tireForceAppPoint.isValid(), "PxVehicleSuspensionComplianceParams.wheelCamberAngle is invalid", false);
for (PxU32 i = 0; i < wheelToeAngle.nbDataPairs; i++)
{
PX_CHECK_AND_RETURN_VAL(wheelToeAngle.xVals[i] >= 0.0f && wheelToeAngle.xVals[i] <= 1.0f, "PxVehicleSuspensionComplianceParams.wheelToeAngle must be an array of points (x,y) with x in range [0, 1]", false);
PX_CHECK_AND_RETURN_VAL(wheelToeAngle.yVals[i] >= -PxPi && wheelToeAngle.yVals[i] <= PxPi, "PxVehicleSuspensionComplianceParams.wheelToeAngle must be an array of points (x,y) with y in range [-Pi, Pi]", false);
}
for (PxU32 i = 0; i < wheelCamberAngle.nbDataPairs; i++)
{
PX_CHECK_AND_RETURN_VAL(wheelCamberAngle.xVals[i] >= 0.0f && wheelCamberAngle.xVals[i] <= 1.0f, "PxVehicleSuspensionComplianceParams.wheelCamberAngle must be an array of points (x,y) with x in range [0, 1]", false);
PX_CHECK_AND_RETURN_VAL(wheelCamberAngle.yVals[i] >= -PxPi && wheelCamberAngle.yVals[i] <= PxPi, "PxVehicleSuspensionComplianceParams.wheelCamberAngle must be an array of points (x,y) with y in range [-Pi, Pi]", false);
}
for (PxU32 i = 0; i < suspForceAppPoint.nbDataPairs; i++)
{
PX_CHECK_AND_RETURN_VAL(suspForceAppPoint.xVals[i] >= 0.0f && suspForceAppPoint.xVals[i] <= 1.0f, "PxVehicleSuspensionComplianceParams.suspForceAppPoint[0] must be an array of points (x,y) with x in range [0, 1]", false);
}
for (PxU32 i = 0; i < tireForceAppPoint.nbDataPairs; i++)
{
PX_CHECK_AND_RETURN_VAL(tireForceAppPoint.xVals[i] >= 0.0f && tireForceAppPoint.xVals[i] <= 1.0f, "PxVehicleSuspensionComplianceParams.tireForceAppPoint[0] must be an array of points (x,y) with x in range [0, 1]", false);
}
return true;
}
};
/**
\brief Suspension force is computed by converting suspenson state to suspension force under the assumption of a linear spring.
@see PxVehicleSuspensionForceUpdate
*/
struct PxVehicleSuspensionForceParams
{
/**
\brief Spring strength of suspension.
<b>Range:</b> (0, inf)<br>
<b>Unit:</b> mass / (time^2)
*/
PxReal stiffness;
/**
\brief Spring damper rate of suspension.
<b>Range:</b> [0, inf)<br>
<b>Unit:</b> mass / time
*/
PxReal damping;
/**
\brief Part of the vehicle mass that is supported by the suspension spring.
<b>Range:</b> (0, inf)<br>
<b>Unit:</b> mass
*/
PxReal sprungMass;
PX_FORCE_INLINE PxVehicleSuspensionForceParams transformAndScale(
const PxVehicleFrame& srcFrame, const PxVehicleFrame& trgFrame, const PxVehicleScale& srcScale, const PxVehicleScale& trgScale) const
{
PX_UNUSED(srcFrame);
PX_UNUSED(trgFrame);
PX_UNUSED(srcScale);
PX_UNUSED(trgScale);
return *this;
}
PX_FORCE_INLINE bool isValid() const
{
PX_CHECK_AND_RETURN_VAL(stiffness > 0.0f, "PxVehicleSuspensionForceParams.stiffness must be greater than zero", false);
PX_CHECK_AND_RETURN_VAL(damping >= 0.0f, "PxVehicleSuspensionForceParams.damping must be greater than or equal to zero", false);
PX_CHECK_AND_RETURN_VAL(sprungMass > 0.0f, "PxVehicleSuspensionForceParams.sprungMass must be greater than zero", false);
return true;
}
};
/**
\brief Suspension force is computed by converting suspenson state to suspension force under the assumption of a linear spring.
@see PxVehicleSuspensionLegacyForceUpdate
@deprecated
*/
struct PX_DEPRECATED PxVehicleSuspensionForceLegacyParams
{
/**
\brief Spring strength of suspension.
<b>Range:</b> (0, inf)<br>
<b>Unit:</b> mass / (time^2)
*/
PxReal stiffness;
/**
\brief Spring damper rate of suspension.
<b>Range:</b> [0, inf)<br>
<b>Unit:</b> mass / time
*/
PxReal damping;
/**
\brief The suspension compression that balances the gravitational force acting on the sprung mass.
<b>Range:</b> (0, inf)<br>
<b>Unit:</b> length
*/
PxReal restDistance;
/**
\brief The mass supported by the suspension spring.
<b>Range:</b> (0, inf)<br>
<b>Unit:</b> mass
*/
PxReal sprungMass;
PX_FORCE_INLINE PxVehicleSuspensionForceLegacyParams transformAndScale(
const PxVehicleFrame& srcFrame, const PxVehicleFrame& trgFrame, const PxVehicleScale& srcScale, const PxVehicleScale& trgScale) const
{
PX_UNUSED(srcFrame);
PX_UNUSED(trgFrame);
PxVehicleSuspensionForceLegacyParams r = *this;
r.restDistance *= (trgScale.scale / srcScale.scale);
return *this;
}
PX_FORCE_INLINE bool isValid() const
{
PX_CHECK_AND_RETURN_VAL(stiffness > 0.0f, "PxVehicleSuspensionForceLegacyParams.stiffness must be greater than zero", false);
PX_CHECK_AND_RETURN_VAL(damping >= 0.0f, "PxVehicleSuspensionForceLegacyParams.damping must be greater than or equal to zero", false);
PX_CHECK_AND_RETURN_VAL(restDistance > 0.0f, "PxVehicleSuspensionForceLegacyParams.restDistance must be greater than zero", false);
PX_CHECK_AND_RETURN_VAL(sprungMass > 0.0f, "PxVehicleSuspensionForceLegacyParams.sprungMass must be greater than zero", false);
return true;
}
};
/**
\brief The purpose of the anti-roll bar is to generate a torque to apply to the vehicle's rigid body that will reduce the jounce difference arising
between any pair of chosen wheels. If the chosen wheels share an axle, the anti-roll bar will attempt to reduce the roll angle of the vehicle's rigid body.
Alternatively, if the chosen wheels are the front and rear wheels along one side of the vehicle, the anti-roll bar will attempt to reduce the pitch angle of the
vehicle's rigid body.
*/
struct PxVehicleAntiRollForceParams
{
/*
\brief The anti-roll bar connects two wheels with indices wheel0 and wheel1
\note wheel0 and wheel1 may be chosen to have the effect of an anti-dive bar or to have the effect of an anti-roll bar.
*/
PxU32 wheel0;
/*
\brief The anti-roll bar connects two wheels with indices wheel0 and wheel1
\note wheel0 and wheel1 may be chosen to have the effect of an anti-dive bar or to have the effect of an anti-roll bar.
*/
PxU32 wheel1;
/*
\brief The linear stiffness of the anti-roll bar.
\note A positive stiffness will work to reduce the discrepancy in jounce between wheel0 and wheel1.
\note A negative stiffness will work to increase the discrepancy in jounce between wheel0 and wheel1.
<b>Unit:</b> mass / (time^2)
*/
PxReal stiffness;
PX_FORCE_INLINE PxVehicleAntiRollForceParams transformAndScale(
const PxVehicleFrame& srcFrame, const PxVehicleFrame& trgFrame, const PxVehicleScale& srcScale, const PxVehicleScale& trgScale) const
{
PX_UNUSED(srcFrame);
PX_UNUSED(trgFrame);
PX_UNUSED(srcScale);
PX_UNUSED(trgScale);
return *this;
}
PX_FORCE_INLINE bool isValid(const PxVehicleAxleDescription& axleDesc) const
{
if (!PxIsFinite(stiffness))
return false;
if (wheel0 == wheel1)
return false;
//Check that each wheel id is a valid wheel.
const PxU32 wheelIds[2] = { wheel0, wheel1 };
for (PxU32 k = 0; k < 2; k++)
{
const PxU32 wheelToFind = wheelIds[k];
bool foundWheelInAxleDescription = false;
for (PxU32 i = 0; i < axleDesc.nbWheels; i++)
{
const PxU32 wheel = axleDesc.wheelIdsInAxleOrder[i];
if (wheel == wheelToFind)
{
foundWheelInAxleDescription = true;
}
}
if (!foundWheelInAxleDescription)
return false;
}
return true;
}
};
#if !PX_DOXYGEN
} // namespace vehicle2
} // namespace physx
#endif
/** @} */
| 16,224 | C | 38.096385 | 224 | 0.759615 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle2/suspension/PxVehicleSuspensionFunctions.h | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#pragma once
/** \addtogroup vehicle2
@{
*/
#include "foundation/PxVec3.h"
#include "foundation/PxSimpleTypes.h"
#include "vehicle2/PxVehicleParams.h"
#if !PX_DOXYGEN
namespace physx
{
namespace vehicle2
{
#endif
struct PxVehicleWheelParams;
struct PxVehicleSuspensionParams;
struct PxVehicleSuspensionStateCalculationParams;
struct PxVehicleRoadGeometryState;
struct PxVehicleRigidBodyState;
struct PxVehicleSuspensionState;
struct PxVehicleSuspensionComplianceParams;
struct PxVehicleSuspensionComplianceState;
struct PxVehicleSuspensionForceParams;
struct PxVehicleSuspensionForce;
struct PxVehicleSuspensionForceLegacyParams;
struct PxVehicleAntiRollForceParams;
struct PxVehicleAntiRollTorque;
/**
\brief Compute the suspension compression and compression speed for a single suspension.
\param[in] wheelParams is a description of the radius and half-width of the wheel on the suspension.
\param[in] suspensionParams is a description of the suspension and wheel frames.
\param[in] suspensionStateCalcParams specifies whether to compute the suspension compression by either
raycasting or sweeping against the plane of the road geometry under the wheel.
\param[in] suspensionStiffness is the stiffness of the suspension
\param[in] suspensionDamping is the damping rate of the suspension.
or whether to apply a limit to the expansion speed so that the wheel may not reach the ground.
\param[in] steerAngle is the yaw angle (in radians) of the wheel.
\param[in] roadGeometryState describes the plane under the wheel.
\param[in] rigidBodyState describes the pose of the rigid body.
\param[in] dt is the simulation time that has lapsed since the last call to PxVehicleSuspensionStateUpdate
\param[in] frame describes the longitudinal, lateral and vertical axes of the vehicle.
\param[in] gravity is the gravitational acceleration that acts on the suspension sprung mass.
\param[in,out] suspState is the compression (jounce) and compression speed of the suspension.
*/
void PxVehicleSuspensionStateUpdate
(const PxVehicleWheelParams& wheelParams, const PxVehicleSuspensionParams& suspensionParams, const PxVehicleSuspensionStateCalculationParams& suspensionStateCalcParams,
const PxReal suspensionStiffness, const PxReal suspensionDamping,
const PxReal steerAngle, const PxVehicleRoadGeometryState& roadGeometryState, const PxVehicleRigidBodyState& rigidBodyState,
const PxReal dt, const PxVehicleFrame& frame, const PxVec3& gravity,
PxVehicleSuspensionState& suspState);
/**
\brief Compute the toe, camber and force application points that are affected by suspension compression.
\param[in] suspensionParams is a description of the suspension and wheel frames.
\param[in] complianceParams describes how toe, camber and force application points are affected by suspension compression.
\param[in] suspensionState describes the current suspension compression.
\param[in] complianceState is the computed toe, camber and force application points.
*/
void PxVehicleSuspensionComplianceUpdate
(const PxVehicleSuspensionParams& suspensionParams,
const PxVehicleSuspensionComplianceParams& complianceParams,
const PxVehicleSuspensionState& suspensionState,
PxVehicleSuspensionComplianceState& complianceState);
/**
\brief Compute the suspension force and torque arising from suspension compression and speed.
\param[in] suspensionParams is a description of the suspension and wheel frames.
\param[in] suspensionForceParams describes the conversion of suspension state to suspension force.
\param[in] roadGeometryState describes the plane under the wheel of the suspension.
\param[in] suspensionState is the current compression state of the suspension.
\param[in] complianceState is the current compliance state of the suspension.
\param[in] rigidBodyState describes the current pose of the rigid body.
\param[in] gravity is the gravitational acceleration.
\param[in] vehicleMass is the rigid body mass.
\param[out] suspensionForce is the force and torque to apply to the rigid body arising from the suspension state.
*/
void PxVehicleSuspensionForceUpdate
(const PxVehicleSuspensionParams& suspensionParams,
const PxVehicleSuspensionForceParams& suspensionForceParams,
const PxVehicleRoadGeometryState& roadGeometryState, const PxVehicleSuspensionState& suspensionState,
const PxVehicleSuspensionComplianceState& complianceState, const PxVehicleRigidBodyState& rigidBodyState,
const PxVec3& gravity, const PxReal vehicleMass,
PxVehicleSuspensionForce& suspensionForce);
/**
\brief Compute the suspension force and torque arising from suspension compression and speed.
\param[in] suspensionParams is a description of the suspension and wheel frames.
\param[in] suspensionForceParams describes the conversion of suspension state to suspension force.
\param[in] roadGeometryState describes the plane under the wheel of the suspension.
\param[in] suspensionState is the current compression state of the suspension.
\param[in] complianceState is the current compliance state of the suspension.
\param[in] rigidBodyState describes the current pose of the rigid body.
\param[in] gravity is the gravitational acceleration.
\param[out] suspensionForce is the force and torque to apply to the rigid body arising from the suspension state.
\note PxVehicleSuspensionLegacyForceUpdate implements the legacy force computation of PhysX 5.0 and earlier.
@deprecated
*/
PX_DEPRECATED void PxVehicleSuspensionLegacyForceUpdate
(const PxVehicleSuspensionParams& suspensionParams,
const PxVehicleSuspensionForceLegacyParams& suspensionForceParams,
const PxVehicleRoadGeometryState& roadGeometryState, const PxVehicleSuspensionState& suspensionState,
const PxVehicleSuspensionComplianceState& complianceState, const PxVehicleRigidBodyState& rigidBodyState,
const PxVec3& gravity,
PxVehicleSuspensionForce& suspensionForce);
/**
\brief Compute the accumulated anti-roll torque to apply to the vehicle's rigid body.
\param[in] suspensionParams The suspension parameters for each wheel.
\param[in] antiRollParams describes the wheel pairs connected by anti-roll bars and the strength of each anti-roll bar.
\param[in] suspensionStates The suspension states for each wheel.
\param[in] complianceStates The suspension compliance states for each wheel.
\param[in] rigidBodyState describes the pose and momentum of the vehicle's rigid body in the world frame.
\param[in] antiRollTorque is the accumulated anti-roll torque that is computed by iterating over all anti-roll bars
describes in *antiRollParams*.
\note suspensionParams must contain an entry for each wheel index referenced by *antiRollParams*.
\note suspensionStates must contain an entry for each wheel index referenced by *antiRollParams*.
\note complianceStates must contain an entry for each wheel index referenced by *antiRollParams*.
\note antiRollTorque is expressed in the world frame.
*/
void PxVehicleAntiRollForceUpdate
(const PxVehicleArrayData<const PxVehicleSuspensionParams>& suspensionParams,
const PxVehicleSizedArrayData<const PxVehicleAntiRollForceParams>& antiRollParams,
const PxVehicleArrayData<const PxVehicleSuspensionState>& suspensionStates,
const PxVehicleArrayData<const PxVehicleSuspensionComplianceState>& complianceStates,
const PxVehicleRigidBodyState& rigidBodyState,
PxVehicleAntiRollTorque& antiRollTorque);
#if !PX_DOXYGEN
} // namespace vehicle2
} // namespace physx
#endif
/** @} */
| 9,080 | C | 53.377245 | 168 | 0.822797 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle2/tire/PxVehicleTireParams.h | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#pragma once
/** \addtogroup vehicle2
@{
*/
#include "foundation/PxFoundation.h"
#include "vehicle2/PxVehicleParams.h"
#include "PxVehicleTireStates.h"
#if !PX_DOXYGEN
namespace physx
{
namespace vehicle2
{
#endif
struct PxVehicleTireForceParams
{
/**
\brief Tire lateral stiffness is a graph of tire load that has linear behavior near zero load and
flattens at large loads. latStiffX describes the minimum normalized load (load/restLoad) that gives a
flat lateral stiffness response to load.
\note A value of 0.0 indicates that the tire lateral stiffness is independent of load and will adopt
the value #latStiffY for all values of tire load.
*/
PxReal latStiffX;
/**
\brief Tire lateral stiffness is a graph of tire load that has linear behavior near zero load and
flattens at large loads. latStiffY describes the maximum possible value of lateral stiffness that occurs
when (load/restLoad) >= #latStiffX.
<b>Unit:</b> force per lateral slip = mass * length / (time^2)
*/
PxReal latStiffY;
/**
\brief Tire Longitudinal stiffness
\note Longitudinal force can be approximated as longStiff*longitudinalSlip.
<b>Unit:</b> force per longitudinal slip = mass * length / (time^2)
*/
PxReal longStiff;
/**
\brief Tire camber stiffness
\note Camber force can be approximated as camberStiff*camberAngle.
<b>Unit:</b> force per radian = mass * length / (time^2)
*/
PxReal camberStiff;
/**
\brief Graph of friction vs longitudinal slip with 3 points.
\note frictionVsSlip[0][0] is always zero.
\note frictionVsSlip[0][1] is the friction available at zero longitudinal slip.
\note frictionVsSlip[1][0] is the value of longitudinal slip with maximum friction.
\note frictionVsSlip[1][1] is the maximum friction.
\note frictionVsSlip[2][0] is the end point of the graph.
\note frictionVsSlip[2][1] is the value of friction for slips greater than frictionVsSlip[2][0].
\note The friction value is computed from the friction vs longitudinal slip graph using linear interpolation.
\note The friction value computed from the friction vs longitudinal slip graph is used to scale the friction
value of the road geometry.
\note frictionVsSlip[2][0] > frictionVsSlip[1][0] > frictionVsSlip[0][0]
\note frictionVsSlip[1][1] is typically greater than frictionVsSlip[0][1]
\note frictionVsSlip[2][1] is typically smaller than frictionVsSlip[1][1]
\note longitudinal slips > frictionVsSlip[2][0] use friction multiplier frictionVsSlip[2][1]
*/
PxReal frictionVsSlip[3][2]; //3 (x,y) points
/**
\brief The rest load is the load that develops on the tire when the vehicle is at rest on a flat plane.
\note The rest load is approximately the product of gravitational acceleration and (sprungMass + wheelMass).
<b>Unit:</b> force = mass * length / (time^2)
*/
PxReal restLoad;
/**
\brief Tire load variation can be strongly dependent on the time-step so it is a good idea to filter it
to give less jerky handling behavior.
\note Tire load filtering is implemented by linear interpolating a graph containing just two points.
The x-axis of the graph is normalized tire load, while the y-axis is the filtered normalized tire load that is
to be applied during the tire force calculation.
\note The normalized load is the force acting downwards on the tire divided by restLoad.
\note The minimum possible normalized load is zero.
\note There are two points on the graph: (minNormalisedLoad, minNormalisedFilteredLoad) and (maxNormalisedLoad, maxFilteredNormalisedLoad).
\note Normalized loads less than minNormalisedLoad have filtered normalized load = minNormalisedFilteredLoad.
\note Normalized loads greater than maxNormalisedLoad have filtered normalized load = maxFilteredNormalisedLoad.
\note Normalized loads in-between are linearly interpolated between minNormalisedFilteredLoad and maxFilteredNormalisedLoad.
\note The tire load applied as input to the tire force computation is the filtered normalized load multiplied by the rest load.
\note loadFilter[0][0] is minNormalisedLoad
\note loadFilter[0][1] is minFilteredNormalisedLoad
\note loadFilter[1][0] is maxNormalisedLoad
\note loadFilter[1][1] is maxFilteredNormalisedLoad
*/
PxReal loadFilter[2][2]; //2 (x,y) points
PX_FORCE_INLINE PxVehicleTireForceParams transformAndScale(
const PxVehicleFrame& srcFrame, const PxVehicleFrame& trgFrame, const PxVehicleScale& srcScale, const PxVehicleScale& trgScale) const
{
PX_UNUSED(srcFrame);
PX_UNUSED(trgFrame);
PxVehicleTireForceParams r = *this;
const PxReal scale = trgScale.scale / srcScale.scale;
r.latStiffY *= scale;
r.longStiff *= scale;
r.camberStiff *= scale;
r.restLoad *= scale;
return r;
}
PX_FORCE_INLINE bool isValid() const
{
PX_CHECK_AND_RETURN_VAL(latStiffX >= 0, "PxVehicleTireForceParams.latStiffX must be greater than or equal to zero", false);
PX_CHECK_AND_RETURN_VAL(latStiffY > 0, "PxVehicleTireForceParams.latStiffY must be greater than zero", false);
PX_CHECK_AND_RETURN_VAL(longStiff > 0, "PxVehicleTireForceParams.longStiff must be greater than zero", false);
PX_CHECK_AND_RETURN_VAL(camberStiff >= 0, "PxVehicleTireForceParams.camberStiff must be greater than or equal zero", false);
PX_CHECK_AND_RETURN_VAL(restLoad > 0, "PxVehicleTireForceParams.restLoad must be greater than zero", false);
PX_CHECK_AND_RETURN_VAL(loadFilter[1][0] >= loadFilter[0][0], "PxVehicleTireForceParams.loadFilter[1][0] must be greater than or equal to PxVehicleTireForceParams.loadFilter[0][0]", false);
PX_CHECK_AND_RETURN_VAL(loadFilter[1][1] > 0, "PxVehicleTireLoadFilterData.loadFilter[1][1] must be greater than zero", false);
PX_CHECK_AND_RETURN_VAL(0.0f == loadFilter[0][0], "PxVehicleTireLoadFilterData.loadFilter[0][0] must be equal to zero", false);
PX_CHECK_AND_RETURN_VAL(frictionVsSlip[0][0] >= 0.0f && frictionVsSlip[0][1] >= 0.0f, "Illegal values for frictionVsSlip[0]", false);
PX_CHECK_AND_RETURN_VAL(frictionVsSlip[1][0] >= 0.0f && frictionVsSlip[1][1] >= 0.0f, "Illegal values for frictionVsSlip[1]", false);
PX_CHECK_AND_RETURN_VAL(frictionVsSlip[2][0] >= 0.0f && frictionVsSlip[2][1] >= 0.0f, "Illegal values for frictionVsSlip[2]", false);
return true;
}
};
#if !PX_DOXYGEN
} // namespace vehicle2
} // namespace physx
#endif
/** @} */
| 7,983 | C | 46.808383 | 191 | 0.759614 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle2/tire/PxVehicleTireStates.h | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#pragma once
/** \addtogroup vehicle2
@{
*/
#include "foundation/PxVec3.h"
#include "foundation/PxMemory.h"
#include "vehicle2/PxVehicleParams.h"
#if !PX_DOXYGEN
namespace physx
{
namespace vehicle2
{
#endif
/**
\brief PxVehicleTireDirectionState stores the world frame lateral and longtidinal axes of the tire after
projecting the wheel pose in the world frame onto the road geometry plane (also in the world frame).
*/
struct PxVehicleTireDirectionState
{
PxVec3 directions[PxVehicleTireDirectionModes::eMAX_NB_PLANAR_DIRECTIONS];
PX_FORCE_INLINE void setToDefault()
{
PxMemZero(this, sizeof(PxVehicleTireDirectionState));
}
};
/**
\brief PxVehicleTireSpeedState stores the components of the instantaneous velocity of the rigid body at the tire contact point projected
along the lateral and longitudinal axes of the tire.
@see PxVehicleTireDirectionState
*/
struct PxVehicleTireSpeedState
{
PxReal speedStates[PxVehicleTireDirectionModes::eMAX_NB_PLANAR_DIRECTIONS];
PX_FORCE_INLINE void setToDefault()
{
PxMemZero(this, sizeof(PxVehicleTireSpeedState));
}
};
/**
\brief The lateral and longitudinal tire slips.
@see PxVehicleTireSpeedState
*/
struct PxVehicleTireSlipState
{
PxReal slips[PxVehicleTireDirectionModes::eMAX_NB_PLANAR_DIRECTIONS];
PX_FORCE_INLINE void setToDefault()
{
PxMemZero(this, sizeof(PxVehicleTireSlipState));
}
};
/**
\brief The load and friction experienced by a tire.
*/
struct PxVehicleTireGripState
{
/**
\brief The tire load
<b>Unit:</b> force = mass * length / (time^2)
*/
PxReal load;
/**
\brief The tire friction is the product of the road geometry friction and a friction response multiplier.
*/
PxReal friction;
PX_FORCE_INLINE void setToDefault()
{
PxMemZero(this, sizeof(PxVehicleTireGripState));
}
};
/**
\brief Camber angle of the tire relative to the ground plane.
*/
struct PxVehicleTireCamberAngleState
{
PxReal camberAngle;
PX_FORCE_INLINE void setToDefault()
{
PxMemZero(this, sizeof(PxVehicleTireCamberAngleState));
}
};
/**
\brief Prolonged low speeds in the lateral and longitudinal directions may be handled with "sticky" velocity constraints that activate after
a speed below a threshold has been recorded for a threshold time.
@see PxVehicleTireStickyParams
@see PxVehicleTireSpeedState
*/
struct PxVehicleTireStickyState
{
PxReal lowSpeedTime[PxVehicleTireDirectionModes::eMAX_NB_PLANAR_DIRECTIONS];
bool activeStatus[PxVehicleTireDirectionModes::eMAX_NB_PLANAR_DIRECTIONS];
PX_FORCE_INLINE void setToDefault()
{
PxMemZero(this, sizeof(PxVehicleTireStickyState));
}
};
/**
\brief The longitudinal/lateral forces/torques that develop on the tire.
*/
struct PxVehicleTireForce
{
/*
\brief The tire forces that develop along the tire's longitudinal and lateral directions. Specified in the world frame.
*/
PxVec3 forces[PxVehicleTireDirectionModes::eMAX_NB_PLANAR_DIRECTIONS];
/*
\brief The tire torques that develop around the tire's longitudinal and lateral directions. Specified in the world frame.
*/
PxVec3 torques[PxVehicleTireDirectionModes::eMAX_NB_PLANAR_DIRECTIONS];
/**
\brief The aligning moment may be propagated to a torque-driven steering controller.
*/
PxReal aligningMoment;
/**
\brief The torque to apply to the wheel's 1d rigid body.
*/
PxReal wheelTorque;
PX_FORCE_INLINE void setToDefault()
{
PxMemZero(this, sizeof(PxVehicleTireForce));
}
};
#if !PX_DOXYGEN
} // namespace vehicle2
} // namespace physx
#endif
/** @} */
| 5,186 | C | 27.5 | 140 | 0.76668 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle2/tire/PxVehicleTireComponents.h | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#pragma once
/** \addtogroup vehicle2
@{
*/
#include "vehicle2/PxVehicleParams.h"
#include "vehicle2/PxVehicleComponent.h"
#include "vehicle2/commands/PxVehicleCommandHelpers.h"
#include "vehicle2/roadGeometry/PxVehicleRoadGeometryState.h"
#include "vehicle2/suspension/PxVehicleSuspensionParams.h"
#include "vehicle2/suspension/PxVehicleSuspensionStates.h"
#include "vehicle2/wheel/PxVehicleWheelStates.h"
#include "vehicle2/wheel/PxVehicleWheelParams.h"
#include "vehicle2/wheel/PxVehicleWheelHelpers.h"
#include "PxVehicleTireFunctions.h"
#include "PxVehicleTireParams.h"
#include "common/PxProfileZone.h"
#if !PX_DOXYGEN
namespace physx
{
namespace vehicle2
{
#endif
class PxVehicleTireComponent : public PxVehicleComponent
{
public:
PxVehicleTireComponent() : PxVehicleComponent() {}
virtual ~PxVehicleTireComponent() {}
virtual void getDataForTireComponent(
const PxVehicleAxleDescription*& axleDescription,
PxVehicleArrayData<const PxReal>& steerResponseStates,
const PxVehicleRigidBodyState*& rigidBodyState,
PxVehicleArrayData<const PxVehicleWheelActuationState>& actuationStates,
PxVehicleArrayData<const PxVehicleWheelParams>& wheelParams,
PxVehicleArrayData<const PxVehicleSuspensionParams>& suspensionParams,
PxVehicleArrayData<const PxVehicleTireForceParams>& tireForceParams,
PxVehicleArrayData<const PxVehicleRoadGeometryState>& roadGeomStates,
PxVehicleArrayData<const PxVehicleSuspensionState>& suspensionStates,
PxVehicleArrayData<const PxVehicleSuspensionComplianceState>& suspensionComplianceStates,
PxVehicleArrayData<const PxVehicleSuspensionForce>& suspensionForces,
PxVehicleArrayData<const PxVehicleWheelRigidBody1dState>& wheelRigidBody1DStates,
PxVehicleArrayData<PxVehicleTireGripState>& tireGripStates,
PxVehicleArrayData<PxVehicleTireDirectionState>& tireDirectionStates,
PxVehicleArrayData<PxVehicleTireSpeedState>& tireSpeedStates,
PxVehicleArrayData<PxVehicleTireSlipState>& tireSlipStates,
PxVehicleArrayData<PxVehicleTireCamberAngleState>& tireCamberAngleStates,
PxVehicleArrayData<PxVehicleTireStickyState>& tireStickyStates,
PxVehicleArrayData<PxVehicleTireForce>& tireForces) = 0;
virtual bool update(const PxReal dt, const PxVehicleSimulationContext& context)
{
PX_PROFILE_ZONE("PxVehicleTireComponent::update", 0);
const PxVehicleAxleDescription* axleDescription;
PxVehicleArrayData<const PxReal> steerResponseStates;
const PxVehicleRigidBodyState* rigidBodyState;
PxVehicleArrayData<const PxVehicleWheelActuationState> actuationStates;
PxVehicleArrayData<const PxVehicleWheelParams> wheelParams;
PxVehicleArrayData<const PxVehicleSuspensionParams> suspensionParams;
PxVehicleArrayData<const PxVehicleTireForceParams> tireForceParams;
PxVehicleArrayData<const PxVehicleRoadGeometryState> roadGeomStates;
PxVehicleArrayData<const PxVehicleSuspensionState> suspensionStates;
PxVehicleArrayData<const PxVehicleSuspensionComplianceState> suspensionComplianceStates;
PxVehicleArrayData<const PxVehicleSuspensionForce> suspensionForces;
PxVehicleArrayData<const PxVehicleWheelRigidBody1dState> wheelRigidBody1DStates;
PxVehicleArrayData<PxVehicleTireGripState> tireGripStates;
PxVehicleArrayData<PxVehicleTireDirectionState> tireDirectionStates;
PxVehicleArrayData<PxVehicleTireSpeedState> tireSpeedStates;
PxVehicleArrayData<PxVehicleTireSlipState> tireSlipStates;
PxVehicleArrayData<PxVehicleTireCamberAngleState> tireCamberAngleStates;
PxVehicleArrayData<PxVehicleTireStickyState> tireStickyStates;
PxVehicleArrayData<PxVehicleTireForce> tireForces;
getDataForTireComponent(axleDescription, steerResponseStates,
rigidBodyState, actuationStates, wheelParams, suspensionParams, tireForceParams,
roadGeomStates, suspensionStates, suspensionComplianceStates, suspensionForces,
wheelRigidBody1DStates, tireGripStates, tireDirectionStates, tireSpeedStates,
tireSlipStates, tireCamberAngleStates, tireStickyStates, tireForces);
for (PxU32 i = 0; i < axleDescription->nbWheels; i++)
{
const PxU32 wheelId = axleDescription->wheelIdsInAxleOrder[i];
const bool isWheelOnGround = PxVehicleIsWheelOnGround(suspensionStates[wheelId]);
//Compute the tire slip directions
PxVehicleTireDirsUpdate(
suspensionParams[wheelId],
steerResponseStates[wheelId],
roadGeomStates[wheelId].plane.n, isWheelOnGround,
suspensionComplianceStates[wheelId],
*rigidBodyState,
context.frame,
tireDirectionStates[wheelId]);
//Compute the rigid body speeds along the tire slip directions.
PxVehicleTireSlipSpeedsUpdate(
wheelParams[wheelId], suspensionParams[wheelId],
steerResponseStates[wheelId], suspensionStates[wheelId], tireDirectionStates[wheelId],
*rigidBodyState, roadGeomStates[wheelId],
context.frame,
tireSpeedStates[wheelId]);
//Compute the tire slip angles.
PxVehicleTireSlipsUpdate(
wheelParams[wheelId], context.tireSlipParams,
actuationStates[wheelId], tireSpeedStates[wheelId],
wheelRigidBody1DStates[wheelId],
tireSlipStates[wheelId]);
//Update the camber angle
PxVehicleTireCamberAnglesUpdate(
suspensionParams[wheelId], steerResponseStates[wheelId],
roadGeomStates[wheelId].plane.n, isWheelOnGround,
suspensionComplianceStates[wheelId], *rigidBodyState,
context.frame,
tireCamberAngleStates[wheelId]);
//Compute the friction
PxVehicleTireGripUpdate(
tireForceParams[wheelId], roadGeomStates[wheelId].friction,
isWheelOnGround, suspensionForces[wheelId],
tireSlipStates[wheelId], tireGripStates[wheelId]);
//Update the tire sticky state
//
//Note: this should be skipped if tires do not use the sticky feature
PxVehicleTireStickyStateUpdate(
*axleDescription,
wheelParams[wheelId],
context.tireStickyParams,
actuationStates, tireGripStates[wheelId],
tireSpeedStates[wheelId], wheelRigidBody1DStates[wheelId],
dt,
tireStickyStates[wheelId]);
//If sticky tire is active set the slip angle to zero.
//
//Note: this should be skipped if tires do not use the sticky feature
PxVehicleTireSlipsAccountingForStickyStatesUpdate(
tireStickyStates[wheelId],
tireSlipStates[wheelId]);
//Compute the tire forces
PxVehicleTireForcesUpdate(
wheelParams[wheelId], suspensionParams[wheelId],
tireForceParams[wheelId],
suspensionComplianceStates[wheelId],
tireGripStates[wheelId], tireDirectionStates[wheelId],
tireSlipStates[wheelId], tireCamberAngleStates[wheelId],
*rigidBodyState,
tireForces[wheelId]);
}
return true;
}
};
/**
* @deprecated
*/
class PX_DEPRECATED PxVehicleLegacyTireComponent : public PxVehicleComponent
{
public:
PxVehicleLegacyTireComponent() : PxVehicleComponent() {}
virtual ~PxVehicleLegacyTireComponent() {}
virtual void getDataForLegacyTireComponent(
const PxVehicleAxleDescription*& axleDescription,
PxVehicleArrayData<const PxReal>& steerResponseStates,
const PxVehicleRigidBodyState*& rigidBodyState,
PxVehicleArrayData<const PxVehicleWheelActuationState>& actuationStates,
PxVehicleArrayData<const PxVehicleWheelParams>& wheelParams,
PxVehicleArrayData<const PxVehicleSuspensionParams>& suspensionParams,
PxVehicleArrayData<const PxVehicleTireForceParams>& tireForceParams,
PxVehicleArrayData<const PxVehicleRoadGeometryState>& roadGeomStates,
PxVehicleArrayData<const PxVehicleSuspensionState>& suspensionStates,
PxVehicleArrayData<const PxVehicleSuspensionComplianceState>& suspensionComplianceStates,
PxVehicleArrayData<const PxVehicleSuspensionForce>& suspensionForces,
PxVehicleArrayData<const PxVehicleWheelRigidBody1dState>& wheelRigidBody1DStates,
PxVehicleArrayData<PxVehicleTireGripState>& tireGripStates,
PxVehicleArrayData<PxVehicleTireDirectionState>& tireDirectionStates,
PxVehicleArrayData<PxVehicleTireSpeedState>& tireSpeedStates,
PxVehicleArrayData<PxVehicleTireSlipState>& tireSlipStates,
PxVehicleArrayData<PxVehicleTireCamberAngleState>& tireCamberAngleStates,
PxVehicleArrayData<PxVehicleTireStickyState>& tireStickyStates,
PxVehicleArrayData<PxVehicleTireForce>& tireForces) = 0;
virtual bool update(const PxReal dt, const PxVehicleSimulationContext& context)
{
PX_PROFILE_ZONE("PxVehicleLegacyTireComponent::update", 0);
const PxVehicleAxleDescription* axleDescription;
PxVehicleArrayData<const PxReal> steerResponseStates;
const PxVehicleRigidBodyState* rigidBodyState;
PxVehicleArrayData<const PxVehicleWheelActuationState> actuationStates;
PxVehicleArrayData<const PxVehicleWheelParams> wheelParams;
PxVehicleArrayData<const PxVehicleSuspensionParams> suspensionParams;
PxVehicleArrayData<const PxVehicleTireForceParams> tireForceParams;
PxVehicleArrayData<const PxVehicleRoadGeometryState> roadGeomStates;
PxVehicleArrayData<const PxVehicleSuspensionState> suspensionStates;
PxVehicleArrayData<const PxVehicleSuspensionComplianceState> suspensionComplianceStates;
PxVehicleArrayData<const PxVehicleSuspensionForce> suspensionForces;
PxVehicleArrayData<const PxVehicleWheelRigidBody1dState> wheelRigidBody1DStates;
PxVehicleArrayData<PxVehicleTireGripState> tireGripStates;
PxVehicleArrayData<PxVehicleTireDirectionState> tireDirectionStates;
PxVehicleArrayData<PxVehicleTireSpeedState> tireSpeedStates;
PxVehicleArrayData<PxVehicleTireSlipState> tireSlipStates;
PxVehicleArrayData<PxVehicleTireCamberAngleState> tireCamberAngleStates;
PxVehicleArrayData<PxVehicleTireStickyState> tireStickyStates;
PxVehicleArrayData<PxVehicleTireForce> tireForces;
getDataForLegacyTireComponent(axleDescription, steerResponseStates,
rigidBodyState, actuationStates,
wheelParams, suspensionParams, tireForceParams,
roadGeomStates, suspensionStates, suspensionComplianceStates,
suspensionForces, wheelRigidBody1DStates,
tireGripStates, tireDirectionStates, tireSpeedStates, tireSlipStates,
tireCamberAngleStates, tireStickyStates, tireForces);
for (PxU32 i = 0; i < axleDescription->nbWheels; i++)
{
const PxU32 wheelId = axleDescription->wheelIdsInAxleOrder[i];
const bool isWheelOnGround = roadGeomStates[wheelId].hitState;
// note: since this is the legacy component, PxVehicleIsWheelOnGround() is not used
// here
//Compute the tire slip directions
PxVehicleTireDirsLegacyUpdate(
suspensionParams[wheelId],
steerResponseStates[wheelId],
roadGeomStates[wheelId], *rigidBodyState,
context.frame,
tireDirectionStates[wheelId]);
//Compute the rigid body speeds along the tire slip directions.
PxVehicleTireSlipSpeedsUpdate(
wheelParams[wheelId], suspensionParams[wheelId],
steerResponseStates[wheelId], suspensionStates[wheelId], tireDirectionStates[wheelId],
*rigidBodyState, roadGeomStates[wheelId],
context.frame,
tireSpeedStates[wheelId]);
//Compute the tire slip angles.
PxVehicleTireSlipsLegacyUpdate(
wheelParams[wheelId], context.tireSlipParams,
actuationStates[wheelId], tireSpeedStates[wheelId],
wheelRigidBody1DStates[wheelId],
tireSlipStates[wheelId]);
//Update the camber angle
PxVehicleTireCamberAnglesUpdate(
suspensionParams[wheelId], steerResponseStates[wheelId],
roadGeomStates[wheelId].plane.n, isWheelOnGround,
suspensionComplianceStates[wheelId], *rigidBodyState,
context.frame,
tireCamberAngleStates[wheelId]);
//Compute the friction
PxVehicleTireGripUpdate(
tireForceParams[wheelId], roadGeomStates[wheelId].friction,
PxVehicleIsWheelOnGround(suspensionStates[wheelId]), suspensionForces[wheelId],
tireSlipStates[wheelId], tireGripStates[wheelId]);
// note: PxVehicleIsWheelOnGround() used here to reflect previous behavior since this is
// the legacy component after all
//Update the tire sticky state
//
//Note: this should be skipped if tires do not use the sticky feature
PxVehicleTireStickyStateUpdate(
*axleDescription,
wheelParams[wheelId],
context.tireStickyParams,
actuationStates, tireGripStates[wheelId],
tireSpeedStates[wheelId], wheelRigidBody1DStates[wheelId],
dt,
tireStickyStates[wheelId]);
//If sticky tire is active set the slip angle to zero.
//
//Note: this should be skipped if tires do not use the sticky feature
PxVehicleTireSlipsAccountingForStickyStatesUpdate(
tireStickyStates[wheelId],
tireSlipStates[wheelId]);
//Compute the tire forces
PxVehicleTireForcesUpdate(
wheelParams[wheelId], suspensionParams[wheelId],
tireForceParams[wheelId],
suspensionComplianceStates[wheelId],
tireGripStates[wheelId], tireDirectionStates[wheelId],
tireSlipStates[wheelId], tireCamberAngleStates[wheelId],
*rigidBodyState,
tireForces[wheelId]);
}
return true;
}
};
#if !PX_DOXYGEN
} // namespace vehicle2
} // namespace physx
#endif
/** @} */
| 14,559 | C | 41.080925 | 91 | 0.807542 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle2/tire/PxVehicleTireFunctions.h | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#pragma once
/** \addtogroup vehicle2
@{
*/
#include "foundation/PxSimpleTypes.h"
#include "vehicle2/PxVehicleParams.h"
#if !PX_DOXYGEN
namespace physx
{
namespace vehicle2
{
#endif
struct PxVehicleSuspensionParams;
struct PxVehicleRoadGeometryState;
struct PxVehicleRigidBodyState;
struct PxVehicleTireDirectionState;
struct PxVehicleSuspensionComplianceState;
struct PxVehicleWheelParams;
struct PxVehicleTireSpeedState;
struct PxVehicleWheelActuationState;
struct PxVehicleWheelRigidBody1dState;
struct PxVehicleTireSlipState;
struct PxVehicleSuspensionState;
struct PxVehicleTireCamberAngleState;
struct PxVehicleTireGripState;
struct PxVehicleTireForceParams;
struct PxVehicleSuspensionForce;
struct PxVehicleTireForce;
struct PxVehicleTireStickyState;
/**
\brief Compute the longitudinal and lateral tire directions in the ground plane.
\param[in] suspensionParams describes the frame of the suspension and wheel.
\param[in] steerAngle is the steer angle in radians to be applied to the wheel.
\param[in] roadGeometryState describes the plane of the road geometry under the wheel
\param[in] rigidBodyState describes the current pose of the vehicle's rigid body in the world frame.
\param[in] frame is a description of the vehicle's lateral and longitudinal axes.
\param[out] tireDirectionState is the computed tire longitudinal and lateral directions in the world frame.
\note PxVehicleTireDirsLegacyUpdate replicates the tire direction calculation of PhysX 5.0 and earlier.
@deprecated
*/
PX_DEPRECATED void PxVehicleTireDirsLegacyUpdate
(const PxVehicleSuspensionParams& suspensionParams,
const PxReal steerAngle, const PxVehicleRoadGeometryState& roadGeometryState, const PxVehicleRigidBodyState& rigidBodyState,
const PxVehicleFrame& frame,
PxVehicleTireDirectionState& tireDirectionState);
/**
\brief Compute the longitudinal and lateral tire directions in the ground plane.
\param[in] suspensionParams describes the frame of the suspension and wheel.
\param[in] steerAngle is the steer angle in radians to be applied to the wheel.
\param[in] groundNormal describes the plane normal of the road geometry under the wheel.
\param[in] isWheelOnGround defines whether the wheel touches the road geometry.
\param[in] complianceState is a description of the camber and toe angle that arise from suspension compliance.
\param[in] rigidBodyState describes the current pose of the vehicle's rigid body in the world frame.
\param[in] frame is a description of the vehicle's lateral and longitudinal axes.
\param[out] tireDirectionState is the computed tire longitudinal and lateral directions in the world frame.
\note The difference between PxVehicleTireDirsUpdate and PxVehicleTireDirsLegacyUpdate is that
PxVehicleTireDirsUpdate accounts for suspension compliance while PxVehicleTireDirsLegacyUpdate does not.
*/
void PxVehicleTireDirsUpdate
(const PxVehicleSuspensionParams& suspensionParams,
const PxReal steerAngle, const PxVec3& groundNormal, bool isWheelOnGround,
const PxVehicleSuspensionComplianceState& complianceState,
const PxVehicleRigidBodyState& rigidBodyState,
const PxVehicleFrame& frame,
PxVehicleTireDirectionState& tireDirectionState);
/**
\brief Project the rigid body velocity at the tire contact point along the tire longitudinal directions.
\param[in] wheelParams is a description of the wheel's radius and half-width.
\param[in] suspensionParams describes the frame of the suspension and wheel.
\param[in] steerAngle is the steer angle in radians to be applied to the wheel.
\param[in] suspensionStates is the current suspension compression state.
\param[in] tireDirectionState is the tire's longitudinal and lateral directions in the ground plane.
\param[in] rigidBodyState describes the current pose and velocity of the vehicle's rigid body in the world frame.
\param[in] roadGeometryState describes the current velocity of the road geometry under each wheel.
\param[in] frame is a description of the vehicle's lateral and longitudinal axes.
\param[out] tireSpeedState is the components of rigid body velocity at the tire contact point along the
tire's longitudinal and lateral axes.
@see PxVehicleTireDirsUpdate
@see PxVehicleTireDirsLegacyUpdate
*/
void PxVehicleTireSlipSpeedsUpdate
(const PxVehicleWheelParams& wheelParams, const PxVehicleSuspensionParams& suspensionParams,
const PxF32 steerAngle, const PxVehicleSuspensionState& suspensionStates, const PxVehicleTireDirectionState& tireDirectionState,
const PxVehicleRigidBodyState& rigidBodyState, const PxVehicleRoadGeometryState& roadGeometryState,
const PxVehicleFrame& frame,
PxVehicleTireSpeedState& tireSpeedState);
/**
\brief Compute a tire's longitudinal and lateral slip angles.
\param[in] wheelParams describes the radius of the wheel.
\param[in] tireSlipParams describes how to manage small longitudinal speeds by setting minimum values on the
denominator of the quotients used to calculate lateral and longitudinal slip.
\param[in] actuationState describes whether a wheel is to be driven by a drive torque or not.
\param[in] tireSpeedState is the component of rigid body velocity at the tire contact point projected along the
tire's longitudinal and lateral axes.
\param[in] wheelRigidBody1dState is the wheel rotation speed.
\param[out] tireSlipState is the computed tire longitudinal and lateral slips.
\note Longitudinal slip angle has the following theoretical form: (wheelRotationSpeed*wheelRadius - longitudinalSpeed)/|longitudinalSpeed|
\note Lateral slip angle has the following theoretical form: atan(lateralSpeed/|longitudinalSpeed|)
\note The calculation of both longitudinal and lateral slip angles avoid a zero denominator using minimum values for the denominator set in
tireSlipParams.
*/
void PxVehicleTireSlipsUpdate
(const PxVehicleWheelParams& wheelParams,
const PxVehicleTireSlipParams& tireSlipParams,
const PxVehicleWheelActuationState& actuationState, PxVehicleTireSpeedState& tireSpeedState, const PxVehicleWheelRigidBody1dState& wheelRigidBody1dState,
PxVehicleTireSlipState& tireSlipState);
/**
@deprecated
\brief Compute a tire's longitudinal and lateral slip angles.
\param[in] wheelParams describes the radius of the wheel.
\param[in] tireSlipParams describes how to manage small longitudinal speeds by setting minimum values on the
denominator of the quotients used to calculate lateral and longitudinal slip.
\param[in] actuationState describes whether a wheel is to be driven by a drive torque or not.
\param[in] tireSpeedState is the component of rigid body velocity at the tire contact point projected along the
tire's longitudinal and lateral axes.
\param[in] wheelRigidBody1dState is the wheel rotation speed.
\param[out] tireSlipState is the computed tire longitudinal and lateral slips.
\note Longitudinal slip angle has the following theoretical form: (wheelRotationSpeed*wheelRadius - longitudinalSpeed)/|longitudinalSpeed|
\note Lateral slip angle has the following theoretical form: atan(lateralSpeed/|longitudinalSpeed|)
\note The calculation of both longitudinal and lateral slip angles avoid a zero denominator using minimum values for the denominator set in
tireSlipParams.
*/
void PX_DEPRECATED PxVehicleTireSlipsLegacyUpdate
(const PxVehicleWheelParams& wheelParams,
const PxVehicleTireSlipParams& tireSlipParams,
const PxVehicleWheelActuationState& actuationState, PxVehicleTireSpeedState& tireSpeedState, const PxVehicleWheelRigidBody1dState& wheelRigidBody1dState,
PxVehicleTireSlipState& tireSlipState);
/**
\brief Compute the camber angle of the wheel
\param[in] suspensionParams describes the frame of the suspension and wheel.
\param[in] steerAngle is the steer angle in radians to be applied to the wheel.
\param[in] groundNormal describes the plane normal of the road geometry under the wheel.
\param[in] isWheelOnGround defines whether the wheel touches the road geometry.
\param[in] complianceState is a description of the camber and toe angle that arise from suspension compliance.
\param[in] rigidBodyState describes the current pose of the vehicle's rigid body in the world frame.
\param[in] frame is a description of the vehicle's lateral and longitudinal axes.
\param[out] tireCamberAngleState is the computed camber angle of the tire expressed in radians.
*/
void PxVehicleTireCamberAnglesUpdate
(const PxVehicleSuspensionParams& suspensionParams,
const PxReal steerAngle, const PxVec3& groundNormal, bool isWheelOnGround,
const PxVehicleSuspensionComplianceState& complianceState,
const PxVehicleRigidBodyState& rigidBodyState,
const PxVehicleFrame& frame,
PxVehicleTireCamberAngleState& tireCamberAngleState);
/**
\brief Compute the load and friction experienced by the tire.
\param[in] tireForceParams describes the tire's friction response to longitudinal lip angle and its load response.
\param[in] frictionCoefficient describes the friction coefficient for the tire and road geometry pair.
\param[in] isWheelOnGround defines whether the wheel touches the road geometry.
\param[in] suspensionForce is the force that the suspension exerts on the sprung mass of the suspension.
\param[in] tireSlipState is the tire longitudinal and lateral slip angles.
\param[out] tireGripState is the computed load and friction experienced by the tire.
\note If the suspension cannot place the wheel on the ground the tire load and friction will be 0.0.
*/
void PxVehicleTireGripUpdate
(const PxVehicleTireForceParams& tireForceParams,
PxReal frictionCoefficient, bool isWheelOnGround, const PxVehicleSuspensionForce& suspensionForce,
const PxVehicleTireSlipState& tireSlipState,
PxVehicleTireGripState& tireGripState);
/**
\brief When a tire has been at a very low speed for a threshold time without application of drive torque, a
secondary tire model is applied to bring the tire to rest using velocity constraints that asymptotically approach zero speed
along the tire's lateral and longitudinal directions. This secondary tire model is referred to as the sticky tire model and the
tire is considered to be in the sticky tire state when the speed and time conditions are satisfied. The purpose of
PxVehicleTireStickyStateUpdate is to compute the target speeds of the sticky state and to record whether sticky state is
active or not.
\param[in] axleDescription is the axles of the vehicle and the wheels on each axle.
\param[in] wheelParams describes the radius of the wheel
\param[in] tireStickyParams describe the threshold speeds and times for the lateral and longitudinal sticky states.
\param[in] actuationStates describes whether each wheel experiences a drive torque.
\param[in] tireGripState is the load and friction experienced by the tire.
\param[in] tireSpeedState is the component of rigid body velocity at the tire contact point projected along the
tire's longitudinal and lateral axes.
\param[in] wheelRigidBody1dState is the wheel rotation speed.
\param[in] dt is the simulation time that has lapsed since the last call to PxVehicleTireStickyStateUpdate
\param[out] tireStickyState is a description of the sticky state of the tire in the longitudinal and lateral directions.
\note The velocity constraints are maintained through integration with the PhysX scene using the function
PxVehiclePhysXConstraintStatesUpdate. Alternative implementations independent of PhysX are possible.
@see PxVehiclePhysXConstraintStatesUpdate
@see PxVehicleTireSlipsAccountingForStickyStatesUpdate
*/
void PxVehicleTireStickyStateUpdate
(const PxVehicleAxleDescription& axleDescription, const PxVehicleWheelParams& wheelParams,
const PxVehicleTireStickyParams& tireStickyParams,
const PxVehicleArrayData<const PxVehicleWheelActuationState>& actuationStates,
const PxVehicleTireGripState& tireGripState, const PxVehicleTireSpeedState& tireSpeedState, const PxVehicleWheelRigidBody1dState& wheelRigidBody1dState,
const PxReal dt,
PxVehicleTireStickyState& tireStickyState);
/**
\brief Set the tire longitudinal and lateral slip values to 0.0 in the event that the tire has entred tire sticky state. This is
necessary to avoid both tire models being simultaneously active and interfering with each other.
\param[in] tireStickyState is a description of the sticky state of the tire in the longitudinal and lateral directions.
\param[out] tireSlipState is the updated lateral and longudinal slip with either set to 0.0 in the event that the correspoinding
sticky state is active.
\note This function should not be invoked if there is no subsequent component to implement the sticky tire model.
*/
void PxVehicleTireSlipsAccountingForStickyStatesUpdate
(const PxVehicleTireStickyState& tireStickyState,
PxVehicleTireSlipState& tireSlipState);
/**
\brief Compute the longitudinal and lateral forces in the world frame that develop on the tire as a consequence of
the tire's slip angles, friction and load.
\param[in] wheelParams describes the radius and half-width of the wheel.
\param[in] suspensionParams describes the frame of the suspension and wheel.
\param[in] tireForceParams describes the conversion of slip angle, friction and load to a force along the longitudinal
and lateral directions of the tire.
\param[in] complianceState is a description of the camber and toe angle that arise from suspension compliance.
\param[out] tireGripState is the load and friction experienced by the tire.
\param[in] tireDirectionState is the tire's longitudinal and lateral directions in the ground plane.
\param[in] tireSlipState is the longitudinal and lateral slip angles.
\param[in] tireCamberAngleState is the camber angle of the tire expressed in radians.
\param[in] rigidBodyState describes the current pose of the vehicle's rigid body in the world frame.
\param[out] tireForce is the computed tire forces in the world frame.
*/
void PxVehicleTireForcesUpdate
(const PxVehicleWheelParams& wheelParams, const PxVehicleSuspensionParams& suspensionParams,
const PxVehicleTireForceParams& tireForceParams,
const PxVehicleSuspensionComplianceState& complianceState,
const PxVehicleTireGripState& tireGripState, const PxVehicleTireDirectionState& tireDirectionState,
const PxVehicleTireSlipState& tireSlipState, const PxVehicleTireCamberAngleState& tireCamberAngleState,
const PxVehicleRigidBodyState& rigidBodyState,
PxVehicleTireForce& tireForce);
#if !PX_DOXYGEN
} // namespace vehicle2
} // namespace physx
#endif
/** @} */
| 16,040 | C | 57.543795 | 154 | 0.824813 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle2/drivetrain/PxVehicleDrivetrainComponents.h | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#pragma once
/** \addtogroup vehicle2
@{
*/
#include "vehicle2/PxVehicleFunctions.h"
#include "vehicle2/PxVehicleParams.h"
#include "vehicle2/PxVehicleComponent.h"
#include "vehicle2/braking/PxVehicleBrakingFunctions.h"
#include "vehicle2/commands/PxVehicleCommandHelpers.h"
#include "vehicle2/rigidBody/PxVehicleRigidBodyStates.h"
#include "vehicle2/steering/PxVehicleSteeringFunctions.h"
#include "vehicle2/steering/PxVehicleSteeringParams.h"
#include "vehicle2/wheel/PxVehicleWheelStates.h"
#include "vehicle2/wheel/PxVehicleWheelParams.h"
#include "vehicle2/tire/PxVehicleTireStates.h"
#include "PxVehicleDrivetrainStates.h"
#include "PxVehicleDrivetrainFunctions.h"
#include "common/PxProfileZone.h"
#if !PX_DOXYGEN
namespace physx
{
namespace vehicle2
{
#endif
struct PxVehicleBrakeCommandResponseParams;
struct PxVehicleDirectDriveThrottleCommandResponseParams;
/**
\brief Forward the applicable set of control values for a direct drive vehicle to a command response state for each
applicable control value.
\note The applicable control values are brake, handbrake, throttle and steer.
@see PxVehicleDirectDriveActuationStateComponent
@see PxVehicleDirectDrivetrainComponent
@see PxVehicleBrakeCommandLinearUpdate
@see PxVehicleDirectDriveThrottleLinearCommandUpdate
@see PxVehicleSteerCommandLinearUpdate
@see PxVehicleAckermannSteerUpdate
*/
class PxVehicleDirectDriveCommandResponseComponent : public PxVehicleComponent
{
public:
PxVehicleDirectDriveCommandResponseComponent() : PxVehicleComponent() {}
virtual ~PxVehicleDirectDriveCommandResponseComponent() {}
/**
\brief Provide vehicle data items for this component.
\param[out] axleDescription identifies the wheels on each axle.
\param[out] brakeResponseParams An array of brake response parameters with a brake response for each brake command.
\param[out] throttleResponseParams The throttle response parameters.
\param[out] steerResponseParams The steer response parameters.
\param[out] ackermannParams The parameters defining Ackermann steering. NULL if no Ackermann steering is desired.
\param[out] commands The throttle, brake, steer etc. command states.
\param[out] transmissionCommands The transmission command state describing the current gear.
\param[out] rigidBodyState The state of the vehicle's rigid body.
\param[out] brakeResponseStates The resulting brake response states given the command input and brake response parameters.
\param[out] throttleResponseStates The resulting throttle response states given the command input and throttle response parameters.
\param[out] steerResponseStates The resulting steer response states given the command input, steer response and (optionally) Ackermann parameters.
*/
virtual void getDataForDirectDriveCommandResponseComponent(
const PxVehicleAxleDescription*& axleDescription,
PxVehicleSizedArrayData<const PxVehicleBrakeCommandResponseParams>& brakeResponseParams,
const PxVehicleDirectDriveThrottleCommandResponseParams*& throttleResponseParams,
const PxVehicleSteerCommandResponseParams*& steerResponseParams,
PxVehicleSizedArrayData<const PxVehicleAckermannParams>& ackermannParams,
const PxVehicleCommandState*& commands, const PxVehicleDirectDriveTransmissionCommandState*& transmissionCommands,
const PxVehicleRigidBodyState*& rigidBodyState,
PxVehicleArrayData<PxReal>& brakeResponseStates,
PxVehicleArrayData<PxReal>& throttleResponseStates,
PxVehicleArrayData<PxReal>& steerResponseStates) = 0;
/**
\brief Compute a per wheel response to the input brake/handbrake/throttle/steer commands
and determine if there is an intention to accelerate the vehicle.
*/
virtual bool update(const PxReal dt, const PxVehicleSimulationContext& context)
{
PX_UNUSED(dt);
PX_UNUSED(context);
PX_PROFILE_ZONE("PxVehicleDirectDriveCommandResponseComponent::update", 0);
const PxVehicleAxleDescription* axleDescription;
PxVehicleSizedArrayData<const PxVehicleBrakeCommandResponseParams> brakeResponseParams;
const PxVehicleDirectDriveThrottleCommandResponseParams* throttleResponseParams;
const PxVehicleSteerCommandResponseParams* steerResponseParams;
PxVehicleSizedArrayData<const PxVehicleAckermannParams> ackermannParams;
const PxVehicleCommandState* commands;
const PxVehicleDirectDriveTransmissionCommandState* transmissionCommands;
const PxVehicleRigidBodyState* rigidBodyState;
PxVehicleArrayData<PxReal> brakeResponseStates;
PxVehicleArrayData<PxReal> throttleResponseStates;
PxVehicleArrayData<PxReal> steerResponseStates;
getDataForDirectDriveCommandResponseComponent(axleDescription,
brakeResponseParams, throttleResponseParams, steerResponseParams, ackermannParams,
commands, transmissionCommands,
rigidBodyState,
brakeResponseStates, throttleResponseStates, steerResponseStates);
const PxReal longitudinalSpeed = rigidBodyState->getLongitudinalSpeed(context.frame);
for (PxU32 i = 0; i < axleDescription->nbWheels; i++)
{
const PxU32 wheelId = axleDescription->wheelIdsInAxleOrder[i];
PxVehicleBrakeCommandResponseUpdate(
commands->brakes, commands->nbBrakes, longitudinalSpeed,
wheelId, brakeResponseParams,
brakeResponseStates[wheelId]);
PxVehicleDirectDriveThrottleCommandResponseUpdate(
commands->throttle, *transmissionCommands, longitudinalSpeed,
wheelId, *throttleResponseParams,
throttleResponseStates[wheelId]);
PxVehicleSteerCommandResponseUpdate(
commands->steer, longitudinalSpeed,
wheelId, *steerResponseParams,
steerResponseStates[wheelId]);
}
if (ackermannParams.size > 0)
PxVehicleAckermannSteerUpdate(
commands->steer,
*steerResponseParams, ackermannParams,
steerResponseStates);
return true;
}
};
/**
\brief Determine the actuation state for each wheel of a direct drive vehicle.
\note The actuation state for each wheel contains a binary record of whether brake and drive torque are to be applied to the wheel.
@see PxVehicleDirectDriveCommandResponseComponent
@see PxVehicleDirectDrivetrainComponent
@see PxVehicleDirectDriveActuationStateUpdate
*/
class PxVehicleDirectDriveActuationStateComponent : public PxVehicleComponent
{
public:
PxVehicleDirectDriveActuationStateComponent() : PxVehicleComponent() {}
virtual ~PxVehicleDirectDriveActuationStateComponent() {}
/**
\brief Provide vehicle data items for this component.
\param[out] axleDescription identifies the wheels on each axle.
\param[out] brakeResponseStates The brake response states.
\param[out] throttleResponseStates The throttle response states.
\param[out] actuationStates The actuation states.
*/
virtual void getDataForDirectDriveActuationStateComponent(
const PxVehicleAxleDescription*& axleDescription,
PxVehicleArrayData<const PxReal>& brakeResponseStates,
PxVehicleArrayData<const PxReal>& throttleResponseStates,
PxVehicleArrayData<PxVehicleWheelActuationState>& actuationStates) = 0;
/**
\brief Compute the actuation state for each wheel given the brake, handbrake and throttle states.
\*/
virtual bool update(const PxReal dt, const PxVehicleSimulationContext& context)
{
PX_UNUSED(dt);
PX_UNUSED(context);
PX_PROFILE_ZONE("PxVehicleDirectDriveActuationStateComponent::update", 0);
const PxVehicleAxleDescription* axleDescription;
PxVehicleArrayData<const PxReal> brakeResponseStates;
PxVehicleArrayData<const PxReal> throttleResponseStates;
PxVehicleArrayData<PxVehicleWheelActuationState> actuationStates;
getDataForDirectDriveActuationStateComponent(
axleDescription,
brakeResponseStates, throttleResponseStates,
actuationStates);
for (PxU32 i = 0; i < axleDescription->nbWheels; i++)
{
const PxU32 wheelId = axleDescription->wheelIdsInAxleOrder[i];
PxVehicleDirectDriveActuationStateUpdate(
brakeResponseStates[wheelId], throttleResponseStates[wheelId],
actuationStates[wheelId]);
}
return true;
}
};
/**
\brief Forward integrate the angular speed of each wheel on a vehicle by integrating the
brake and drive torque applied to each wheel and the torque that develops on the tire as a response
to the longitudinal tire force.
@see PxVehicleDirectDriveUpdate
*/
class PxVehicleDirectDrivetrainComponent : public PxVehicleComponent
{
public:
PxVehicleDirectDrivetrainComponent() : PxVehicleComponent() {}
virtual ~PxVehicleDirectDrivetrainComponent() {}
virtual void getDataForDirectDrivetrainComponent(
const PxVehicleAxleDescription*& axleDescription,
PxVehicleArrayData<const PxReal>& brakeResponseStates,
PxVehicleArrayData<const PxReal>& throttleResponseStates,
PxVehicleArrayData<const PxVehicleWheelParams>& wheelParams,
PxVehicleArrayData<const PxVehicleWheelActuationState>& actuationStates,
PxVehicleArrayData<const PxVehicleTireForce>& tireForces,
PxVehicleArrayData<PxVehicleWheelRigidBody1dState>& wheelRigidBody1dStates) = 0;
virtual bool update(const PxReal dt, const PxVehicleSimulationContext& context)
{
PX_UNUSED(context);
PX_PROFILE_ZONE("PxVehicleDirectDrivetrainComponent::update", 0);
const PxVehicleAxleDescription* axleDescription;
PxVehicleArrayData<const PxReal> brakeResponseStates;
PxVehicleArrayData<const PxReal> throttleResponseStates;
PxVehicleArrayData<const PxVehicleWheelParams> wheelParams;
PxVehicleArrayData<const PxVehicleWheelActuationState> actuationStates;
PxVehicleArrayData<const PxVehicleTireForce> tireForces;
PxVehicleArrayData<PxVehicleWheelRigidBody1dState> wheelRigidBody1dStates;
getDataForDirectDrivetrainComponent(axleDescription,
brakeResponseStates, throttleResponseStates,
wheelParams, actuationStates, tireForces,
wheelRigidBody1dStates);
for (PxU32 i = 0; i < axleDescription->nbWheels; i++)
{
const PxU32 wheelId = axleDescription->wheelIdsInAxleOrder[i];
PxVehicleDirectDriveUpdate(
wheelParams[wheelId], actuationStates[wheelId],
brakeResponseStates[wheelId], throttleResponseStates[wheelId],
tireForces[wheelId],
dt,
wheelRigidBody1dStates[wheelId]);
}
return true;
}
};
/**
\brief Forward the applicable set of control values for a vehicle driven by an engine to a command response state for each
applicable control value.
If parameters for an autobox are provided, the autobox will determine if a gear change should begin in order to
maintain a desired engine revs.
@see PxVehicleBrakeCommandLinearUpdate
@see PxVehicleClutchCommandResponseLinearUpdate
@see PxVehicleEngineDriveThrottleCommandResponseUpdate
@see PxVehicleSteerCommandLinearUpdate
@see PxVehicleAckermannSteerUpdate
@see PxVehicleAutoBoxUpdate
@see PxVehicleGearCommandResponseUpdate
*/
class PxVehicleEngineDriveCommandResponseComponent : public PxVehicleComponent
{
public:
PxVehicleEngineDriveCommandResponseComponent() : PxVehicleComponent() {}
virtual ~PxVehicleEngineDriveCommandResponseComponent() {}
/**
\brief Provide vehicle data items for this component.
\param[out] axleDescription identifies the wheels on each axle.
\param[out] brakeResponseParams An array of brake response parameters with a brake response for each brake command.
\param[out] steerResponseParams The steer response parameters.
\param[out] ackermannParams The parameters defining Ackermann steering. NULL if no Ackermann steering is desired.
\param[out] gearboxParams The gearbox parameters.
\param[out] clutchResponseParams The clutch response parameters.
\param[out] engineParams The engine parameters. Only needed if an autobox is provided (see autoboxParams), else it can be set to NULL.
\param[out] engineState The engine state. Only needed if an autobox is provided (see autoboxParams), else it can be set to NULL.
\param[out] autoboxParams The autobox parameters. If not NULL, the autobox will determine the target gear. Requires the parameters
engineParams, engineState and autoboxState to be available. If no autobox is desired, NULL can be used in which case
the aforementioned additional parameters can be set to NULL too.
\param[out] rigidBodyState The state of the vehicle's rigid body.
\param[out] commands The throttle, brake, steer etc. command states.
\param[out] transmissionCommands The clutch, target gear etc. command states. If an autobox is provided (see autoboxParams)
and the target gear is set to PxVehicleEngineDriveTransmissionCommandState::eAUTOMATIC_GEAR, then the autobox will trigger
gear shifts.
\param[out] brakeResponseStates The resulting brake response states given the command input and brake response parameters.
\param[out] throttleResponseState The resulting throttle response to the input throttle command.
\param[out] steerResponseStates The resulting steer response states given the command input, steer response and (optionally) Ackermann parameters.
\param[out] gearboxResponseState The resulting gearbox response state given the command input and gearbox parameters.
\param[out] clutchResponseState The resulting clutch state given the command input and clutch response parameters.
\param[out] autoboxState The resulting autobox state given the autobox/engine/gear params and engine state. Only needed if an autobox is
provided (see autoboxParams), else it can be set to NULL.
*/
virtual void getDataForEngineDriveCommandResponseComponent(
const PxVehicleAxleDescription*& axleDescription,
PxVehicleSizedArrayData<const PxVehicleBrakeCommandResponseParams>& brakeResponseParams,
const PxVehicleSteerCommandResponseParams*& steerResponseParams,
PxVehicleSizedArrayData<const PxVehicleAckermannParams>& ackermannParams,
const PxVehicleGearboxParams*& gearboxParams,
const PxVehicleClutchCommandResponseParams*& clutchResponseParams,
const PxVehicleEngineParams*& engineParams,
const PxVehicleRigidBodyState*& rigidBodyState,
const PxVehicleEngineState*& engineState,
const PxVehicleAutoboxParams*& autoboxParams,
const PxVehicleCommandState*& commands,
const PxVehicleEngineDriveTransmissionCommandState*& transmissionCommands,
PxVehicleArrayData<PxReal>& brakeResponseStates,
PxVehicleEngineDriveThrottleCommandResponseState*& throttleResponseState,
PxVehicleArrayData<PxReal>& steerResponseStates,
PxVehicleGearboxState*& gearboxResponseState,
PxVehicleClutchCommandResponseState*& clutchResponseState,
PxVehicleAutoboxState*& autoboxState) = 0;
virtual bool update(const PxReal dt, const PxVehicleSimulationContext& context)
{
PX_UNUSED(dt);
PX_UNUSED(context);
PX_PROFILE_ZONE("PxVehicleEngineDriveCommandResponseComponent::update", 0);
const PxVehicleAxleDescription* axleDescription;
PxVehicleSizedArrayData<const PxVehicleBrakeCommandResponseParams> brakeResponseParams;
const PxVehicleSteerCommandResponseParams* steerResponseParams;
PxVehicleSizedArrayData<const PxVehicleAckermannParams> ackermannParams;
const PxVehicleGearboxParams* gearboxParams;
const PxVehicleClutchCommandResponseParams* clutchResponseParams;
const PxVehicleEngineParams* engineParams;
const PxVehicleRigidBodyState* rigidBodyState;
const PxVehicleEngineState* engineState;
const PxVehicleAutoboxParams* autoboxParams;
const PxVehicleCommandState* commands;
const PxVehicleEngineDriveTransmissionCommandState* transmissionCommands;
PxVehicleArrayData<PxReal> brakeResponseStates;
PxVehicleEngineDriveThrottleCommandResponseState* throttleResponseState;
PxVehicleArrayData<PxReal> steerResponseStates;
PxVehicleGearboxState* gearboxResponseState;
PxVehicleClutchCommandResponseState* clutchResponseState;
PxVehicleAutoboxState* autoboxState;
getDataForEngineDriveCommandResponseComponent(axleDescription,
brakeResponseParams, steerResponseParams, ackermannParams,
gearboxParams, clutchResponseParams, engineParams, rigidBodyState,
engineState, autoboxParams,
commands, transmissionCommands,
brakeResponseStates, throttleResponseState,
steerResponseStates,
gearboxResponseState, clutchResponseState, autoboxState);
//The autobox can modify commands like throttle and target gear. Since the user defined
//values should not be overwritten, a copy is used to compute the response.
PxVehicleCommandState commandsTmp = *commands;
PxVehicleEngineDriveTransmissionCommandState transmissionCommandsTmp = *transmissionCommands;
const PxReal longitudinalSpeed = rigidBodyState->getLongitudinalSpeed(context.frame);
//Let the autobox set the target gear, unless the user defined target gear requests
//a shift already
if (autoboxParams)
{
PX_ASSERT(engineParams);
PX_ASSERT(engineState);
PX_ASSERT(autoboxState);
PxVehicleAutoBoxUpdate(
*engineParams, *gearboxParams, *autoboxParams,
*engineState, *gearboxResponseState, dt,
transmissionCommandsTmp.targetGear, *autoboxState, commandsTmp.throttle);
}
else if (transmissionCommandsTmp.targetGear == PxVehicleEngineDriveTransmissionCommandState::eAUTOMATIC_GEAR)
{
//If there is no autobox but eAUTOMATIC_GEAR was specified, use the current target gear
transmissionCommandsTmp.targetGear = gearboxResponseState->targetGear;
}
//Distribute brake torque to the wheels across each axle.
for (PxU32 i = 0; i < axleDescription->nbWheels; i++)
{
const PxU32 wheelId = axleDescription->wheelIdsInAxleOrder[i];
PxVehicleBrakeCommandResponseUpdate(
commandsTmp.brakes, commandsTmp.nbBrakes, longitudinalSpeed,
wheelId, brakeResponseParams,
brakeResponseStates[i]);
}
//Update target gear as required.
PxVehicleGearCommandResponseUpdate(
transmissionCommandsTmp.targetGear,
*gearboxParams,
*gearboxResponseState);
//Compute the response to the clutch command.
PxVehicleClutchCommandResponseLinearUpdate(
transmissionCommandsTmp.clutch,
*clutchResponseParams,
*clutchResponseState);
//Compute the response to the throttle command.
PxVehicleEngineDriveThrottleCommandResponseLinearUpdate(
commandsTmp,
*throttleResponseState);
//Update the steer angles and Ackermann correction.
for (PxU32 i = 0; i < axleDescription->nbWheels; i++)
{
const PxU32 wheelId = axleDescription->wheelIdsInAxleOrder[i];
PxVehicleSteerCommandResponseUpdate(commandsTmp.steer, longitudinalSpeed, wheelId, *steerResponseParams, steerResponseStates[i]);
}
if (ackermannParams.size > 0)
PxVehicleAckermannSteerUpdate(commandsTmp.steer, *steerResponseParams, ackermannParams, steerResponseStates);
return true;
}
};
/**
\brief Compute the per wheel drive torque split of a multi-wheel drive differential.
@see PxVehicleDifferentialStateUpdate
*/
class PxVehicleMultiWheelDriveDifferentialStateComponent : public PxVehicleComponent
{
public:
PxVehicleMultiWheelDriveDifferentialStateComponent() : PxVehicleComponent() {}
virtual ~PxVehicleMultiWheelDriveDifferentialStateComponent() {}
virtual void getDataForMultiWheelDriveDifferentialStateComponent(
const PxVehicleAxleDescription*& axleDescription,
const PxVehicleMultiWheelDriveDifferentialParams*& differentialParams,
PxVehicleDifferentialState*& differentialState) = 0;
virtual bool update(const PxReal dt, const PxVehicleSimulationContext& context)
{
PX_UNUSED(dt);
PX_UNUSED(context);
PX_PROFILE_ZONE("PxVehicleMultiWheelDriveDifferentialStateComponent::update", 0);
const PxVehicleAxleDescription* axleDescription;
const PxVehicleMultiWheelDriveDifferentialParams* differentialParams;
PxVehicleDifferentialState* differentialState;
getDataForMultiWheelDriveDifferentialStateComponent(axleDescription,
differentialParams, differentialState);
PxVehicleDifferentialStateUpdate(
*axleDescription,
*differentialParams,
*differentialState);
return true;
}
};
/**
\brief Compute the per wheel drive torque split of a differential delivering torque to multiple wheels
with limited slip applied to specified wheel pairs.
@see PxVehicleDifferentialStateUpdate
*/
class PxVehicleFourWheelDriveDifferentialStateComponent : public PxVehicleComponent
{
public:
PxVehicleFourWheelDriveDifferentialStateComponent() : PxVehicleComponent() {}
virtual ~PxVehicleFourWheelDriveDifferentialStateComponent() {}
virtual void getDataForFourWheelDriveDifferentialStateComponent(
const PxVehicleAxleDescription*& axleDescription,
const PxVehicleFourWheelDriveDifferentialParams*& differentialParams,
PxVehicleArrayData<const PxVehicleWheelRigidBody1dState>& wheelRigidbody1dStates,
PxVehicleDifferentialState*& differentialState,
PxVehicleWheelConstraintGroupState*& wheelConstraintGroupState) = 0;
virtual bool update(const PxReal dt, const PxVehicleSimulationContext& context)
{
PX_UNUSED(dt);
PX_UNUSED(context);
PX_PROFILE_ZONE("PxVehicleFourWheelDriveDifferentialStateComponent::update", 0);
const PxVehicleAxleDescription* axleDescription;
const PxVehicleFourWheelDriveDifferentialParams* differentialParams;
PxVehicleArrayData<const PxVehicleWheelRigidBody1dState> wheelRigidbody1dStates;
PxVehicleDifferentialState* differentialState;
PxVehicleWheelConstraintGroupState* wheelConstraintGroupState;
getDataForFourWheelDriveDifferentialStateComponent(axleDescription, differentialParams,
wheelRigidbody1dStates,
differentialState, wheelConstraintGroupState);
PxVehicleDifferentialStateUpdate(
*axleDescription, *differentialParams,
wheelRigidbody1dStates, dt,
*differentialState, *wheelConstraintGroupState);
return true;
}
};
/**
\brief Compute the per wheel drive torque split of a tank drive differential.
@see PxVehicleDifferentialStateUpdate
*/
class PxVehicleTankDriveDifferentialStateComponent : public PxVehicleComponent
{
public:
PxVehicleTankDriveDifferentialStateComponent() : PxVehicleComponent() {}
virtual ~PxVehicleTankDriveDifferentialStateComponent() {}
/**
\brief Provide vehicle data items for this component.
\param[out] axleDescription identifies the wheels on each axle.
\param[out] transmissionCommands specifies the values of the thrust controllers that divert torque to the tank tracks.
\param[out] wheelParams is an array describing the radius of each wheel.
\param[out] differentialParams describes the operation of the tank differential by
specifying the default torque split between all wheels connected to the differential and by
specifying the wheels coupled to each tank track.
\param[out] differentialState stores the instantaneous torque split between all wheels arising from the difference between the thrust controllers.
\param[out] constraintGroupState stores the groups of wheels that are connected by sharing a tank track.
*/
virtual void getDataForTankDriveDifferentialStateComponent(
const PxVehicleAxleDescription*& axleDescription,
const PxVehicleTankDriveTransmissionCommandState*& transmissionCommands,
PxVehicleArrayData<const PxVehicleWheelParams>& wheelParams,
const PxVehicleTankDriveDifferentialParams*& differentialParams,
PxVehicleDifferentialState*& differentialState,
PxVehicleWheelConstraintGroupState*& constraintGroupState) = 0;
virtual bool update(const PxReal dt, const PxVehicleSimulationContext& context)
{
PX_UNUSED(dt);
PX_UNUSED(context);
PX_PROFILE_ZONE("PxVehicleTankDriveDifferentialStateComponent::update", 0);
const PxVehicleAxleDescription* axleDescription;
const PxVehicleTankDriveTransmissionCommandState* transmissionCommands;
PxVehicleArrayData<const PxVehicleWheelParams> wheelParams;
const PxVehicleTankDriveDifferentialParams* differentialParams;
PxVehicleDifferentialState* differentialState;
PxVehicleWheelConstraintGroupState* constraintGroupState;
getDataForTankDriveDifferentialStateComponent(
axleDescription,
transmissionCommands,
wheelParams,
differentialParams,
differentialState, constraintGroupState);
PxVehicleDifferentialStateUpdate(
*axleDescription,
wheelParams, *differentialParams,
transmissionCommands->thrusts[0], transmissionCommands->thrusts[1],
*differentialState, *constraintGroupState);
return true;
}
};
/**
@deprecated
\brief Compute the per wheel drive torque split of a four wheel drive differential.
@see PxVehicleDifferentialStateUpdate
*/
class PX_DEPRECATED PxVehicleLegacyFourWheelDriveDifferentialStateComponent : public PxVehicleComponent
{
public:
PxVehicleLegacyFourWheelDriveDifferentialStateComponent() : PxVehicleComponent() {}
virtual ~PxVehicleLegacyFourWheelDriveDifferentialStateComponent() {}
virtual void getDataForLegacyFourWheelDriveDifferentialStateComponent(
const PxVehicleAxleDescription*& axleDescription,
const PxVehicleFourWheelDriveDifferentialLegacyParams*& differentialParams,
PxVehicleArrayData<const PxVehicleWheelRigidBody1dState>& wheelRigidbody1dStates,
PxVehicleDifferentialState*& differentialState) = 0;
virtual bool update(const PxReal dt, const PxVehicleSimulationContext& context)
{
PX_UNUSED(dt);
PX_UNUSED(context);
PX_PROFILE_ZONE("PxVehicleLegacyFourWheelDriveDifferentialStateComponent::update", 0);
const PxVehicleAxleDescription* axleDescription;
const PxVehicleFourWheelDriveDifferentialLegacyParams* differentialParams;
PxVehicleArrayData<const PxVehicleWheelRigidBody1dState> wheelRigidbody1dStates;
PxVehicleDifferentialState* differentialState;
getDataForLegacyFourWheelDriveDifferentialStateComponent(axleDescription, differentialParams,
wheelRigidbody1dStates,
differentialState);
PxVehicleDifferentialStateUpdate(
*differentialParams, wheelRigidbody1dStates,
*differentialState);
return true;
}
};
/**
\brief Determine the actuation state for each wheel for a vehicle propelled by engine torque.
\note The actuation state for each wheel contains a binary record of whether brake and drive torque are to be applied to the wheel.
@see PxVehicleEngineDriveActuationStateUpdate
*/
class PxVehicleEngineDriveActuationStateComponent : public PxVehicleComponent
{
public:
PxVehicleEngineDriveActuationStateComponent() : PxVehicleComponent() {}
virtual ~PxVehicleEngineDriveActuationStateComponent() {}
virtual void getDataForEngineDriveActuationStateComponent(
const PxVehicleAxleDescription*& axleDescription,
const PxVehicleGearboxParams*& gearboxParams,
PxVehicleArrayData<const PxReal>& brakeResponseStates,
const PxVehicleEngineDriveThrottleCommandResponseState*& throttleResponseState,
const PxVehicleGearboxState*& gearboxState,
const PxVehicleDifferentialState*& differentialState,
const PxVehicleClutchCommandResponseState*& clutchResponseState,
PxVehicleArrayData<PxVehicleWheelActuationState>& actuationStates) = 0;
virtual bool update(const PxReal dt, const PxVehicleSimulationContext& context)
{
PX_UNUSED(dt);
PX_UNUSED(context);
PX_PROFILE_ZONE("PxVehicleEngineDriveActuationStateComponent::update", 0);
const PxVehicleAxleDescription* axleDescription;
const PxVehicleGearboxParams* gearboxParams;
PxVehicleArrayData<const PxReal> brakeResponseStates;
const PxVehicleEngineDriveThrottleCommandResponseState* throttleResponseState;
const PxVehicleGearboxState* gearboxState;
const PxVehicleDifferentialState* differentialState;
const PxVehicleClutchCommandResponseState* clutchResponseState;
PxVehicleArrayData<PxVehicleWheelActuationState> actuationStates;
getDataForEngineDriveActuationStateComponent(axleDescription, gearboxParams,
brakeResponseStates, throttleResponseState,
gearboxState, differentialState, clutchResponseState,
actuationStates);
PxVehicleEngineDriveActuationStateUpdate(
*axleDescription,
*gearboxParams,
brakeResponseStates,
*throttleResponseState,
*gearboxState, *differentialState, *clutchResponseState,
actuationStates);
return true;
}
};
/**
\brief Forward integrate the angular speed of each wheel and of the engine, accounting for the
state of the clutch, gearbox and differential.
@see PxVehicleGearboxUpdate
@see PxVehicleEngineDrivetrainUpdate
*/
class PxVehicleEngineDrivetrainComponent : public PxVehicleComponent
{
public:
PxVehicleEngineDrivetrainComponent() : PxVehicleComponent() {}
virtual ~PxVehicleEngineDrivetrainComponent() {}
/**
\brief Provide vehicle data items for this component.
\param[out] axleDescription identifies the wheels on each axle.
\param[out] wheelParams specifies the radius of each wheel.
\param[out] engineParams specifies the engine's torque curve, idle revs and max revs.
\param[out] clutchParams specifies the maximum strength of the clutch.
\param[out] gearboxParams specifies the gear ratio of each gear.
\param[out] brakeResponseStates stores the instantaneous brake brake torque to apply to each wheel.
\param[out] actuationStates stores whether a brake and/or drive torque are to be applied to each wheel.
\param[out] tireForces stores the lateral and longitudinal tire force that has developed on each tire.
\param[out] throttleResponseState stores the response of the throttle to the input throttle command.
\param[out] clutchResponseState stores the instantaneous clutch strength that arises from the input clutch command.
\param[out] differentialState stores the instantaneous torque split between the wheels.
\param[out] constraintGroupState stores the groups of wheels that are subject to constraints that require them to have the same angular or linear velocity.
\param[out] wheelRigidBody1dStates stores the per wheel angular speed to be computed by the component.
\param[out] engineState stores the engine rotation speed to be computed by the component.
\param[out] gearboxState stores the state of the gearbox to be computed by the component.
\param[out] clutchState stores the clutch slip to be computed by the component.
\note If constraintGroupState is set to NULL it is assumed that there are no requirements for any wheels to have the same angular or linear velocity.
*/
virtual void getDataForEngineDrivetrainComponent(
const PxVehicleAxleDescription*& axleDescription,
PxVehicleArrayData<const PxVehicleWheelParams>& wheelParams,
const PxVehicleEngineParams*& engineParams,
const PxVehicleClutchParams*& clutchParams,
const PxVehicleGearboxParams*& gearboxParams,
PxVehicleArrayData<const PxReal>& brakeResponseStates,
PxVehicleArrayData<const PxVehicleWheelActuationState>& actuationStates,
PxVehicleArrayData<const PxVehicleTireForce>& tireForces,
const PxVehicleEngineDriveThrottleCommandResponseState*& throttleResponseState,
const PxVehicleClutchCommandResponseState*& clutchResponseState,
const PxVehicleDifferentialState*& differentialState,
const PxVehicleWheelConstraintGroupState*& constraintGroupState,
PxVehicleArrayData<PxVehicleWheelRigidBody1dState>& wheelRigidBody1dStates,
PxVehicleEngineState*& engineState,
PxVehicleGearboxState*& gearboxState,
PxVehicleClutchSlipState*& clutchState) = 0;
virtual bool update(const PxReal dt, const PxVehicleSimulationContext& context)
{
PX_UNUSED(context);
PX_PROFILE_ZONE("PxVehicleEngineDrivetrainComponent::update", 0);
const PxVehicleAxleDescription* axleDescription;
PxVehicleArrayData<const PxVehicleWheelParams> wheelParams;
const PxVehicleEngineParams* engineParams;
const PxVehicleClutchParams* clutchParams;
const PxVehicleGearboxParams* gearboxParams;
PxVehicleArrayData<const PxReal> brakeResponseStates;
PxVehicleArrayData<const PxVehicleWheelActuationState> actuationStates;
PxVehicleArrayData<const PxVehicleTireForce> tireForces;
const PxVehicleEngineDriveThrottleCommandResponseState* throttleResponseState;
const PxVehicleClutchCommandResponseState* clutchResponseState;
const PxVehicleDifferentialState* differentialState;
const PxVehicleWheelConstraintGroupState* constraintGroupState;
PxVehicleArrayData<PxVehicleWheelRigidBody1dState> wheelRigidBody1dStates;
PxVehicleEngineState* engineState;
PxVehicleGearboxState* gearboxState;
PxVehicleClutchSlipState* clutchState;
getDataForEngineDrivetrainComponent(axleDescription, wheelParams,
engineParams, clutchParams, gearboxParams,
brakeResponseStates, actuationStates, tireForces,
throttleResponseState, clutchResponseState, differentialState, constraintGroupState,
wheelRigidBody1dStates, engineState, gearboxState, clutchState);
PxVehicleGearboxUpdate(*gearboxParams, dt, *gearboxState);
PxVehicleEngineDrivetrainUpdate(
*axleDescription,
wheelParams,
*engineParams, *clutchParams, *gearboxParams,
brakeResponseStates, actuationStates,
tireForces,
*gearboxState, *throttleResponseState, *clutchResponseState, *differentialState, constraintGroupState,
dt,
wheelRigidBody1dStates, *engineState, *clutchState);
return true;
}
};
#if !PX_DOXYGEN
} // namespace vehicle2
} // namespace physx
#endif
/** @} */
| 34,285 | C | 41.697385 | 156 | 0.822109 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle2/drivetrain/PxVehicleDrivetrainStates.h | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#pragma once
/** \addtogroup vehicle2
@{
*/
#include "vehicle2/commands/PxVehicleCommandStates.h"
#if !PX_DOXYGEN
namespace physx
{
namespace vehicle2
{
#endif
struct PxVehicleClutchCommandResponseState
{
PxReal normalisedCommandResponse;
PxReal commandResponse;
PX_FORCE_INLINE void setToDefault()
{
PxMemZero(this, sizeof(PxVehicleClutchCommandResponseState));
}
};
struct PxVehicleEngineDriveThrottleCommandResponseState
{
PxReal commandResponse;
PX_FORCE_INLINE void setToDefault()
{
PxMemZero(this, sizeof(PxVehicleEngineDriveThrottleCommandResponseState));
}
};
struct PxVehicleEngineState
{
/**
\brief The rotation speed of the engine (radians per second).
<b>Unit:</b> radians / time
*/
PxReal rotationSpeed;
PX_FORCE_INLINE void setToDefault()
{
PxMemZero(this, sizeof(PxVehicleEngineState));
}
};
#define PX_VEHICLE_NO_GEAR_SWITCH_PENDING -1.0f
#define PX_VEHICLE_GEAR_SWITCH_INITIATED -2.0f
struct PxVehicleGearboxState
{
/**
\brief Current gear
*/
PxU32 currentGear;
/**
\brief Target gear (different from current gear if a gear change is underway)
*/
PxU32 targetGear;
/**
\brief Reported time that has passed since gear change started.
The special value PX_VEHICLE_NO_GEAR_SWITCH_PENDING denotes that there is currently
no gear change underway.
If a gear switch was initiated, the special value PX_VEHICLE_GEAR_SWITCH_INITIATED
will be used temporarily but get translated to 0 in the gearbox update immediately.
This state might only get encountered, if the vehicle component update is split into
multiple sequences that do not run in one go.
<b>Unit:</b> time
*/
PxReal gearSwitchTime;
PX_FORCE_INLINE void setToDefault()
{
currentGear = 0;
targetGear = 0;
gearSwitchTime = PX_VEHICLE_NO_GEAR_SWITCH_PENDING;
}
};
#define PX_VEHICLE_UNSPECIFIED_TIME_SINCE_LAST_SHIFT PX_MAX_F32
struct PxVehicleAutoboxState
{
/**
\brief Time that has lapsed since the last autobox gear shift.
<b>Unit:</b> time
*/
PxReal timeSinceLastShift;
/**
\brief Describes whether a gear shift triggered by the autobox is still in flight.
*/
bool activeAutoboxGearShift;
PX_FORCE_INLINE void setToDefault()
{
timeSinceLastShift = PX_VEHICLE_UNSPECIFIED_TIME_SINCE_LAST_SHIFT;
activeAutoboxGearShift = false;
}
};
struct PxVehicleDifferentialState
{
/**
\brief A list of wheel indices that are connected to the differential.
*/
PxU32 connectedWheels[PxVehicleLimits::eMAX_NB_WHEELS];
/**
\brief The number of wheels that are connected to the differential.
*/
PxU32 nbConnectedWheels;
/**
\brief The fraction of available torque that is delivered to each wheel through the differential.
\note If a wheel is not connected to the differential then the fraction of available torque delivered to that wheel will be zero.
\note A negative torque ratio for a wheel indicates a negative gearing is to be applied to that wheel.
\note The sum of the absolute value of each fraction must equal 1.0.
*/
PxReal torqueRatiosAllWheels[PxVehicleLimits::eMAX_NB_WHEELS];
/**
\brief The contribution of each wheel to the average wheel rotation speed measured at the clutch.
\note If a wheel is not connected to the differential then the contribution to the average rotation speed measured at the clutch must be zero.
\note The sum of all contributions must equal 1.0.
*/
PxReal aveWheelSpeedContributionAllWheels[PxVehicleLimits::eMAX_NB_WHEELS];
PX_FORCE_INLINE void setToDefault()
{
PxMemZero(this, sizeof(PxVehicleDifferentialState));
}
};
/**
\brief Specify groups of wheels that are to be constrained to have pre-determined angular velocity relationship.
*/
struct PxVehicleWheelConstraintGroupState
{
PX_FORCE_INLINE void setToDefault()
{
PxMemZero(this, sizeof(PxVehicleWheelConstraintGroupState));
}
/**
\brief Add a wheel constraint group by specifying the number of wheels in the group, an array of wheel ids specifying each wheel in the group
and a desired rotational speed relationship.
\param[in] nbWheelsInGroupToAdd is the number of wheels in the group to be added.
\param[in] wheelIdsInGroupToAdd is an array of wheel ids specifying all the wheels in the group to be added.
\param[in] constraintMultipliers is an array of constraint multipliers describing the desired relationship of the wheel rotational speeds.
\note constraintMultipliers[j] specifies the target rotational speed of the jth wheel in the constraint group as a multiplier of the rotational
speed of the zeroth wheel in the group.
*/
void addConstraintGroup(const PxU32 nbWheelsInGroupToAdd, const PxU32* const wheelIdsInGroupToAdd, const PxF32* constraintMultipliers)
{
PX_ASSERT((nbWheelsInGroups + nbWheelsInGroupToAdd) < PxVehicleLimits::eMAX_NB_WHEELS);
PX_ASSERT(nbGroups < PxVehicleLimits::eMAX_NB_WHEELS);
nbWheelsPerGroup[nbGroups] = nbWheelsInGroupToAdd;
groupToWheelIds[nbGroups] = nbWheelsInGroups;
for (PxU32 i = 0; i < nbWheelsInGroupToAdd; i++)
{
wheelIdsInGroupOrder[nbWheelsInGroups + i] = wheelIdsInGroupToAdd[i];
wheelMultipliersInGroupOrder[nbWheelsInGroups + i] = constraintMultipliers[i];
}
nbWheelsInGroups += nbWheelsInGroupToAdd;
nbGroups++;
}
/**
\brief Return the number of wheel constraint groups in the vehicle.
\return The number of wheel constraint groups.
@see getNbWheelsInConstraintGroup()
*/
PX_FORCE_INLINE PxU32 getNbConstraintGroups() const
{
return nbGroups;
}
/**
\brief Return the number of wheels in the ith constraint group.
\param[in] i specifies the constraint group to be queried for its wheel count.
\return The number of wheels in the specified constraint group.
@see getWheelInConstraintGroup()
*/
PX_FORCE_INLINE PxU32 getNbWheelsInConstraintGroup(const PxU32 i) const
{
return nbWheelsPerGroup[i];
}
/**
\brief Return the wheel id of the jth wheel in the ith constraint group.
\param[in] j specifies that the wheel id to be returned is the jth wheel in the list of wheels on the specified constraint group.
\param[in] i specifies the constraint group to be queried.
\return The wheel id of the jth wheel in the ith constraint group.
@see getNbWheelsInConstraintGroup()
*/
PX_FORCE_INLINE PxU32 getWheelInConstraintGroup(const PxU32 j, const PxU32 i) const
{
return wheelIdsInGroupOrder[groupToWheelIds[i] + j];
}
/**
\brief Return the constraint multiplier of the jth wheel in the ith constraint group
\param[in] j specifies that the wheel id to be returned is the jth wheel in the list of wheels on the specified constraint group.
\param[in] i specifies the constraint group to be queried.
\return The constraint multiplier of the jth wheel in the ith constraint group.
*/
PX_FORCE_INLINE PxReal getMultiplierInConstraintGroup(const PxU32 j, const PxU32 i) const
{
return wheelMultipliersInGroupOrder[groupToWheelIds[i] + j];
}
PxU32 nbGroups; //!< The number of constraint groups in the vehicle
PxU32 nbWheelsPerGroup[PxVehicleLimits::eMAX_NB_AXLES]; //!< The number of wheels in each group
PxU32 groupToWheelIds[PxVehicleLimits::eMAX_NB_AXLES]; //!< The list of wheel ids for the ith group begins at wheelIdsInGroupOrder[groupToWheelIds[i]]
PxU32 wheelIdsInGroupOrder[PxVehicleLimits::eMAX_NB_WHEELS]; //!< The list of all wheel ids in constraint groups
PxF32 wheelMultipliersInGroupOrder[PxVehicleLimits::eMAX_NB_WHEELS];//!< The constraint multipliers for each constraint group.
PxU32 nbWheelsInGroups; //!< The number of wheels in a constraint group.
};
/**
\brief The clutch is modelled as two spinning plates with one connected to the wheels through the gearing and the other connected to the engine. The clutch slip is angular speed difference of the two plates.
*/
struct PxVehicleClutchSlipState
{
/**
\brief The slip at the clutch.
<b>Unit:</b> radians / time
*/
PxReal clutchSlip;
PX_FORCE_INLINE void setToDefault()
{
PxMemZero(this, sizeof(PxVehicleClutchSlipState));
}
};
#if !PX_DOXYGEN
} // namespace vehicle2
} // namespace physx
#endif
/** @} */
| 9,741 | C | 32.709342 | 207 | 0.764603 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle2/drivetrain/PxVehicleDrivetrainHelpers.h | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#pragma once
/** \addtogroup vehicle2
@{
*/
#include "vehicle2/drivetrain/PxVehicleDrivetrainParams.h"
#include "vehicle2/drivetrain/PxVehicleDrivetrainStates.h"
#if !PX_DOXYGEN
namespace physx
{
namespace vehicle2
{
#endif
struct PxVehicleWheelRigidBody1dState;
/**
\brief Compute the coupling strength of the clutch.
\param[in] clutchResponseState describes the response of the clutch to the input clutch command.
\param[in] gearboxParams holds the index of neutral gear.
\param[in] gearboxState describes the current gear.
\note If the gear is in neutral the clutch is fully disengaged and the clutch strength is 0.
\note A clutch response state of 0.0 denotes a fully engaged clutch with maximum strength.
\note A clutch response state of 1.0 denotes a fully disengaged clutch with a strength of 0.0.
*/
PX_FORCE_INLINE PxReal PxVehicleClutchStrengthCompute(const PxVehicleClutchCommandResponseState& clutchResponseState, const PxVehicleGearboxParams& gearboxParams, const PxVehicleGearboxState& gearboxState)
{
return (gearboxParams.neutralGear != gearboxState.currentGear) ? clutchResponseState.commandResponse : 0.0f;
}
/**
\brief Compute the damping rate of the engine.
\param[in] engineParams describes various damping rates of the engine in different operational states.
\param[in] gearboxParams holds the index of neutral gear.
\param[in] gearboxState describes the current gear.
\param[in] clutchResponseState is the response of the clutch to the clutch command.
\param[in] throttleResponseState is the response of the throttle to the throttle command.
\note Engines typically have different damping rates with clutch engaged and disengaged.
\note Engines typically have different damping rates at different throttle pedal values.
@see PxVehicleClutchStrengthCompute()
\note In neutral gear the clutch is considered to be fully disengaged.
*/
PX_FORCE_INLINE PxReal PxVehicleEngineDampingRateCompute
(const PxVehicleEngineParams& engineParams,
const PxVehicleGearboxParams& gearboxParams, const PxVehicleGearboxState& gearboxState,
const PxVehicleClutchCommandResponseState& clutchResponseState,
const PxVehicleEngineDriveThrottleCommandResponseState& throttleResponseState)
{
const PxReal K = (gearboxParams.neutralGear != gearboxState.currentGear) ? clutchResponseState.normalisedCommandResponse : 0.0f;
const PxReal zeroThrottleDamping = engineParams.dampingRateZeroThrottleClutchEngaged +
(1.0f - K)* (engineParams.dampingRateZeroThrottleClutchDisengaged - engineParams.dampingRateZeroThrottleClutchEngaged);
const PxReal appliedThrottle = throttleResponseState.commandResponse;
const PxReal fullThrottleDamping = engineParams.dampingRateFullThrottle;
const PxReal engineDamping = zeroThrottleDamping + (fullThrottleDamping - zeroThrottleDamping)*appliedThrottle;
return engineDamping;
}
/**
\brief Compute the gear ratio delivered by the gearbox in the current gear.
\param[in] gearboxParams describes the gear ratio of each gear and the final ratio.
\param[in] gearboxState describes the current gear.
\note The gear ratio is the product of the gear ratio of the current gear and the final gear ratio of the gearbox.
*/
PX_FORCE_INLINE PxReal PxVehicleGearRatioCompute
(const PxVehicleGearboxParams& gearboxParams, const PxVehicleGearboxState& gearboxState)
{
const PxReal gearRatio = gearboxParams.ratios[gearboxState.currentGear] * gearboxParams.finalRatio;
return gearRatio;
}
/**
\brief Compute the drive torque to deliver to the engine.
\param[in] engineParams describes the profile of maximum available torque across the full range of engine rotational speed.
\param[in] engineState describes the engine rotational speed.
\param[in] throttleCommandResponseState describes the engine's response to input throttle command.
*/
PX_FORCE_INLINE PxReal PxVehicleEngineDriveTorqueCompute
(const PxVehicleEngineParams& engineParams, const PxVehicleEngineState& engineState, const PxVehicleEngineDriveThrottleCommandResponseState& throttleCommandResponseState)
{
const PxReal appliedThrottle = throttleCommandResponseState.commandResponse;
const PxReal peakTorque = engineParams.peakTorque;
const PxVehicleFixedSizeLookupTable<PxReal, PxVehicleEngineParams::eMAX_NB_ENGINE_TORQUE_CURVE_ENTRIES>& torqueCurve = engineParams.torqueCurve;
const PxReal normalisedRotSpeed = engineState.rotationSpeed/engineParams.maxOmega;
const PxReal engineDriveTorque = appliedThrottle*peakTorque*torqueCurve.interpolate(normalisedRotSpeed);
return engineDriveTorque;
}
/**
@deprecated
\brief Compute the contribution that each wheel makes to the averaged wheel speed at the clutch plate connected to the wheels driven by
the differential.
\param[in] diffParams describes the wheels coupled to the differential and the operation of the torque split at the differential.
\param[in] nbWheels The number of wheels. Can be larger than the number of wheels connected to the differential.
\param[out] diffAveWheelSpeedContributions describes the contribution that each wheel makes to the averaged wheel speed at the clutch.
The buffer needs to be sized to be able to hold at least nbWheels entries.
\note Any wheel on an axle connected to the differential could have a non-zero value, depending on the way the differential couples to the wheels.
\note Any wheel on an axle not connected to the differential will have a zero contribution to the averaged wheel speed.
*/
void PX_DEPRECATED PxVehicleLegacyDifferentialWheelSpeedContributionsCompute
(const PxVehicleFourWheelDriveDifferentialLegacyParams& diffParams,
const PxU32 nbWheels, PxReal* diffAveWheelSpeedContributions);
/**
@deprecated
\brief Compute the fraction of available torque that is delivered to each wheel through the differential.
\param[in] diffParams describes the wheels coupled to the differential and the operation of the torque split at the differential.
\param[in] wheelOmegas describes the rotational speeds of the wheels. Is expected to have nbWheels entries.
\param[in] nbWheels The number of wheels. Can be larger than the number of wheels connected to the differential.
\param[out] diffTorqueRatios describes the fraction of available torque delivered to each wheel.
The buffer needs to be sized to be able to hold at least nbWheels entries.
\note Any wheel on an axle connected to the diff could receive a non-zero ratio, depending on the way the differential couples to the wheels.
\note Any wheel not on an axle connected to the diff will have a zero value.
\note The sum of all the ratios adds to 1.0.
\note Slipping wheels driven by the differential will typically receive less torque than non-slipping wheels in the event that the
differential has a limited slip configuration.
*/
void PX_DEPRECATED PxVehicleLegacyDifferentialTorqueRatiosCompute
(const PxVehicleFourWheelDriveDifferentialLegacyParams& diffParams,
const PxVehicleArrayData<const PxVehicleWheelRigidBody1dState>& wheelOmegas,
const PxU32 nbWheels, PxReal* diffTorqueRatios);
#if !PX_DOXYGEN
} // namespace vehicle2
} // namespace physx
#endif
/** @} */
| 8,765 | C | 53.447205 | 205 | 0.811067 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle2/drivetrain/PxVehicleDrivetrainFunctions.h | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#pragma once
/** \addtogroup vehicle2
@{
*/
#include "foundation/PxSimpleTypes.h"
#include "vehicle2/PxVehicleParams.h"
#if !PX_DOXYGEN
namespace physx
{
namespace vehicle2
{
#endif
struct PxVehicleCommandState;
struct PxVehicleDirectDriveTransmissionCommandState;
struct PxVehicleEngineDriveTransmissionCommandState;
struct PxVehicleDirectDriveThrottleCommandResponseParams;
struct PxVehicleWheelActuationState;
struct PxVehicleWheelParams;
struct PxVehicleTireForce;
struct PxVehicleWheelRigidBody1dState;
struct PxVehicleEngineParams;
struct PxVehicleGearboxParams;
struct PxVehicleAutoboxParams;
struct PxVehicleEngineState;
struct PxVehicleGearboxState;
struct PxVehicleAutoboxState;
struct PxVehicleClutchCommandResponseParams;
struct PxVehicleClutchCommandResponseState;
struct PxVehicleEngineDriveThrottleCommandResponseState;
struct PxVehicleDifferentialState;
struct PxVehicleMultiWheelDriveDifferentialParams;
struct PxVehicleFourWheelDriveDifferentialParams;
struct PxVehicleTankDriveDifferentialParams;
struct PxVehicleFourWheelDriveDifferentialLegacyParams;
struct PxVehicleClutchParams;
struct PxVehicleWheelConstraintGroupState;
struct PxVehicleClutchSlipState;
/**
\brief Compute the drive torque response to a throttle command.
\param[in] throttle is the throttle command.
\param[in] transmissionCommands is the gearing command to apply to the direct drive tranmission.
\param[in] longitudinalSpeed is the longitudinal speed of the vehicle's rigid body.
\param[in] wheelId specifies the wheel that is to have its throttle response computed.
\param[in] throttleResponseParams specifies the per wheel drive torque response to the throttle command as a nonlinear function of throttle command and longitudinal speed.
\param[out] throttleResponseState is the drive torque response to the input throttle command.
*/
void PxVehicleDirectDriveThrottleCommandResponseUpdate
(const PxReal throttle, const PxVehicleDirectDriveTransmissionCommandState& transmissionCommands, const PxReal longitudinalSpeed,
const PxU32 wheelId, const PxVehicleDirectDriveThrottleCommandResponseParams& throttleResponseParams,
PxReal& throttleResponseState);
/**
\brief Determine the actuation state of a wheel given the brake torque, handbrake torque and drive torque applied to it.
\param[in] brakeTorque is the brake torque to be applied to the wheel.
\param[in] driveTorque is the drive torque to be applied to the wheel.
\param[out] actuationState contains a binary record of whether brake or drive torque is applied to the wheel.
*/
void PxVehicleDirectDriveActuationStateUpdate
(const PxReal brakeTorque, const PxReal driveTorque,
PxVehicleWheelActuationState& actuationState);
/**
\brief Forward integrate the angular speed of a wheel given the brake and drive torque applied to it
\param[in] wheelParams specifies the moment of inertia of the wheel.
\param[in] actuationState is a binary record of whether brake and drive torque are to be applied to the wheel.
\param[in] brakeTorque is the brake torque to be applied to the wheel.
\param[in] driveTorque is the drive torque to be applied to the wheel.
\param[in] tireForce specifies the torque to apply to the wheel as a response to the longitudinal tire force.
\param[in] dt is the timestep of the forward integration.
\param[out] wheelRigidBody1dState describes the angular speed of the wheel.
*/
void PxVehicleDirectDriveUpdate
(const PxVehicleWheelParams& wheelParams,
const PxVehicleWheelActuationState& actuationState,
const PxReal brakeTorque, const PxReal driveTorque, const PxVehicleTireForce& tireForce,
const PxF32 dt,
PxVehicleWheelRigidBody1dState& wheelRigidBody1dState);
/**
\param[in] engineParams specifies the engine configuration.
\param[in] gearboxParams specifies the gear ratios and the time required to complete a gear change.
\param[in] autoboxParams specifies the conditions for switching gear.
\param[in] engineState contains the current angular speed of the engine.
\param[in] gearboxState describes the current and target gear.
\param[in] dt is the time that has lapsed since the last call to PxVehicleAutoBoxUpdate.
\param[in,out] targetGearCommand specifies the desired target gear for the gearbox. If set to
PxVehicleEngineDriveTransmissionCommandState::eAUTOMATIC_GEAR, the value will get overwritten
with a target gear chosen by the autobox.
\param[out] autoboxState specifies the time that has lapsed since the last automated gear change and contains a record of
any ongoing automated gear change.
\param[out] throttle A throttle command value in [0, 1] that will be set to 0 if a gear change is initiated or is ongoing.
\note The autobox will not begin a gear change if a gear change is already ongoing.
\note The autobox will not begin a gear change until a threshold time has lapsed since the last automated gear change.
\note A gear change is considered as ongoing for as long as PxVehicleGearboxState::currentGear is different from
PxVehicleGearboxState::targetGear.
\note The autobox will not shift down from 1st gear or up from reverse gear.
\note The autobox shifts in single gear increments or decrements.
\note The autobox instantiates a gear change by setting PxVehicleCommandState::targetGear to be different from
from PxVehicleGearboxState::currentGear
*/
void PxVehicleAutoBoxUpdate
(const PxVehicleEngineParams& engineParams, const PxVehicleGearboxParams& gearboxParams, const PxVehicleAutoboxParams& autoboxParams,
const PxVehicleEngineState& engineState, const PxVehicleGearboxState& gearboxState,
const PxReal dt,
PxU32& targetGearCommand, PxVehicleAutoboxState& autoboxState,
PxReal& throttle);
/**
\brief Propagate input gear commands to the gearbox state.
\param[in] targetGearCommand specifies the target gear for the gearbox.
\param[in] gearboxParams specifies the number of gears and the index of neutral gear.
\param[out] gearboxState contains a record of the current and target gear.
\note Any ongoing gear change must complete before starting another.
\note A gear change is considered as ongoing for as long as PxVehicleGearboxState::currentGear is different from
PxVehicleGearboxState::targetGear.
\note The gearbox remains in neutral for the duration of the gear change.
\note A gear change begins if PxVehicleCommandState::targetGear is different from PxVehicleGearboxState::currentGear.
*/
void PxVehicleGearCommandResponseUpdate
(const PxU32 targetGearCommand,
const PxVehicleGearboxParams& gearboxParams,
PxVehicleGearboxState& gearboxState);
/**
\brief Propagate the input clutch command to the clutch response state.
\param[in] clutchCommand specifies the state of the clutch pedal.
\param[in] clutchResponseParams specifies how the clutch responds to the input clutch command.
\param[out] clutchResponse specifies the response of the clutch to the input clutch command.
*/
void PxVehicleClutchCommandResponseLinearUpdate
(const PxReal clutchCommand,
const PxVehicleClutchCommandResponseParams& clutchResponseParams,
PxVehicleClutchCommandResponseState& clutchResponse);
/**
\brief Propagate the input throttle command to the throttle response state.
\param[in] commands specifies the state of the throttle pedal.
\param[out] throttleResponse specifies how the clutch responds to the input throttle command.
*/
void PxVehicleEngineDriveThrottleCommandResponseLinearUpdate
(const PxVehicleCommandState& commands,
PxVehicleEngineDriveThrottleCommandResponseState& throttleResponse);
/**
\brief Determine the actuation state of all wheels on a vehicle.
\param[in] axleDescription is a decription of the axles of the vehicle and the wheels on each axle.
\param[in] gearboxParams specifies the index of the neutral gear of the gearbox.
\param[in] brakeResponseStates specifies the response of each wheel to the input brake command.
\param[in] throttleResponseState specifies the response of the engine to the input throttle command.
\param[in] gearboxState specifies the current gear.
\param[in] diffState specifies the fraction of available drive torque to be delivered to each wheel.
\param[in] clutchResponseState specifies the response of the clutch to the input throttle command.
\param[out] actuationStates is an array of binary records determining whether brake and drive torque are to be applied to each wheel.
\note Drive torque is not applied to a wheel if
a) the gearbox is in neutral
b) the differential delivers no torque to the wheel
c) no throttle is applied to the engine
c) the clutch is fully disengaged.
*/
void PxVehicleEngineDriveActuationStateUpdate
(const PxVehicleAxleDescription& axleDescription,
const PxVehicleGearboxParams& gearboxParams,
const PxVehicleArrayData<const PxReal>& brakeResponseStates,
const PxVehicleEngineDriveThrottleCommandResponseState& throttleResponseState,
const PxVehicleGearboxState& gearboxState, const PxVehicleDifferentialState& diffState, const PxVehicleClutchCommandResponseState& clutchResponseState,
PxVehicleArrayData<PxVehicleWheelActuationState>& actuationStates);
/**
@deprecated
\brief Compute the fraction of available torque to be delivered to each wheel and gather a list of all
wheels connected to the differential.
\param[in] diffParams specifies the operation of a differential that can be connected to up to four wheels.
\param[in] wheelStates describes the angular speed of each wheel
\param[out] diffState contains the fraction of available drive torque to be delivered to each wheel.
\note If the handbrake is on then torque is only delivered to the wheels specified as the front wheels of the differential.
*/
void PX_DEPRECATED PxVehicleDifferentialStateUpdate
(const PxVehicleFourWheelDriveDifferentialLegacyParams& diffParams,
const PxVehicleArrayData<const PxVehicleWheelRigidBody1dState>& wheelStates,
PxVehicleDifferentialState& diffState);
/**
\brief Compute the fraction of available torque to be delivered to each wheel and gather a list of all
wheels connected to the differential. Additionally, add wheel constraints for wheel pairs whose
rotational speed ratio exceeds the corresponding differential bias.
\param[in] axleDescription is a decription of the axles of the vehicle and the wheels on each axle.
\param[in] diffParams describe the division of available drive torque and the biases of the limited
slip differential.
\param[in] wheelStates describes the rotational speeds of each wheel.
\param[in] dt is the simulation time that has passes since the last call to PxVehicleDifferentialStateUpdate()
\param[out] diffState contains the fraction of available drive torque to be delivered to each wheel.
\param[out] wheelConstraintGroupState describes the groups of wheels that have exceeded their corresponding
differential biases.
*/
void PxVehicleDifferentialStateUpdate
(const PxVehicleAxleDescription& axleDescription, const PxVehicleFourWheelDriveDifferentialParams& diffParams,
const PxVehicleArrayData<const PxVehicleWheelRigidBody1dState>& wheelStates,
const PxReal dt,
PxVehicleDifferentialState& diffState, PxVehicleWheelConstraintGroupState& wheelConstraintGroupState);
/**
\brief Compute the fraction of available torque to be delivered to each wheel and gather a list of all
wheels connected to the differential.
\param[in] axleDescription is a decription of the axles of the vehicle and the wheels on each axle.
\param[in] diffParams specifies the operation of a differential that can be connected to any combination of wheels.
\param[out] diffState contains the fraction of available drive torque to be delivered to each wheel connected to the differential.
*/
void PxVehicleDifferentialStateUpdate
(const PxVehicleAxleDescription& axleDescription, const PxVehicleMultiWheelDriveDifferentialParams& diffParams,
PxVehicleDifferentialState& diffState);
/**
\brief Compute the fraction of available torque to be delivered to each wheel and gather a list of all
wheels connected to the differential.
\param[in] axleDescription is a decription of the axles of the vehicle and the wheels on each axle.
\param[in] wheelParams is an array that describes the wheel radius of each wheel.
\param[in] diffParams specifies the operation of a tank differential.
\param[in] thrustCommand0 is the state of one of the two thrust controllers.
\param[in] thrustCommand1 is the state of one of the two thrust controllers.
\param[out] diffState contains the fraction of available drive torque to be delivered to each wheel connected to the differential.
\param[out] wheelConstraintGroupState describes the groups of wheels connected by sharing a tank track.
*/
void PxVehicleDifferentialStateUpdate
(const PxVehicleAxleDescription& axleDescription,
const PxVehicleArrayData<const PxVehicleWheelParams>& wheelParams, const PxVehicleTankDriveDifferentialParams& diffParams,
const PxReal thrustCommand0, PxReal thrustCommand1,
PxVehicleDifferentialState& diffState, PxVehicleWheelConstraintGroupState& wheelConstraintGroupState);
/**
\brief Update the current gear of the gearbox. If a gear change is ongoing then complete the gear change if a threshold
time has passed since the beginning of the gear change.
\param[in] gearboxParams describes the time required to complete a gear change.
\param[in] dt is the time that has lapsed since the last call to PxVehicleGearboxUpdate.
\param[out] gearboxState is the gearbox state to be updated.
\note A gear change is considered as ongoing for as long as PxVehicleGearboxState::currentGear is different from
PxVehicleGearboxState::targetGear.
*/
void PxVehicleGearboxUpdate
(const PxVehicleGearboxParams& gearboxParams,
const PxF32 dt,
PxVehicleGearboxState& gearboxState);
/**
\brief Forward integrate the angular speed of the vehicle's wheels and engine, given the state of clutch, differential and gearbox.
\param[in] axleDescription is a decription of the axles of the vehicle and the wheels on each axle.
\param[in] wheelParams specifies the moment of inertia of each wheel.
\param[in] engineParams specifies the torque curve of the engine and its moment of inertia.
\param[in] clutchParams specifies the maximum clutch strength that happens when the clutch is fully engaged.
\param[in] gearboxParams specifies the gearing ratios of the gearbox.
\param[in] brakeResponseStates describes the per wheel response to the input brake command.
\param[in] actuationStates is a binary record of whether brake or drive torque is applied to each wheel.
\param[in] tireForces describes the torque to apply to each wheel as a response to the longitudinal tire force.
\param[in] gearboxState describes the current gear.
\param[in] throttleResponse describes the engine response to the input throttle pedal.
\param[in] clutchResponse describes the clutch response to the input clutch pedal.
\param[in] diffState describes the fraction of available drive torque to be delivered to each wheel.
\param[in] constraintGroupState describes groups of wheels with rotational speed constrained to the same value.
\param[in] dt is the time that has lapsed since the last call to PxVehicleEngineDrivetrainUpdate
\param[out] wheelRigidbody1dStates describes the angular speed of each wheel.
\param[out] engineState describes the angular speed of the engine.
\param[out] clutchState describes the clutch slip.
\note If constraintGroupState is NULL then it is assumed that there are no wheels subject to rotational speed constraints.
*/
void PxVehicleEngineDrivetrainUpdate
(const PxVehicleAxleDescription& axleDescription,
const PxVehicleArrayData<const PxVehicleWheelParams>& wheelParams,
const PxVehicleEngineParams& engineParams, const PxVehicleClutchParams& clutchParams, const PxVehicleGearboxParams& gearboxParams,
const PxVehicleArrayData<const PxReal>& brakeResponseStates,
const PxVehicleArrayData<const PxVehicleWheelActuationState>& actuationStates,
const PxVehicleArrayData<const PxVehicleTireForce>& tireForces,
const PxVehicleGearboxState& gearboxState, const PxVehicleEngineDriveThrottleCommandResponseState& throttleResponse, const PxVehicleClutchCommandResponseState& clutchResponse,
const PxVehicleDifferentialState& diffState, const PxVehicleWheelConstraintGroupState* constraintGroupState,
const PxReal dt,
PxVehicleArrayData<PxVehicleWheelRigidBody1dState>& wheelRigidbody1dStates,
PxVehicleEngineState& engineState, PxVehicleClutchSlipState& clutchState);
#if !PX_DOXYGEN
} // namespace vehicle2
} // namespace physx
#endif
/** @} */
| 18,099 | C | 55.739812 | 177 | 0.823637 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle2/drivetrain/PxVehicleDrivetrainParams.h | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#pragma once
/** \addtogroup vehicle2
@{
*/
#include "foundation/PxFoundation.h"
#include "common/PxCoreUtilityTypes.h"
#include "vehicle2/PxVehicleParams.h"
#include "vehicle2/commands/PxVehicleCommandParams.h"
#if !PX_DOXYGEN
namespace physx
{
namespace vehicle2
{
#endif
/**
\brief Distribute a throttle response to the wheels of a direct drive vehicle.
\note The drive torque applied to each wheel on the ith axle is throttleCommand * maxResponse * wheelResponseMultipliers[i].
\note A typical use case is to set maxResponse to be the vehicle's maximum achievable drive torque
that occurs when the steer command is equal to 1.0. The array wheelResponseMultipliers[i] would then be used
to specify the maximum achievable drive torque per wheel as a fractional multiplier of the vehicle's maximum achievable steer angle.
*/
struct PxVehicleDirectDriveThrottleCommandResponseParams : public PxVehicleCommandResponseParams
{
PX_FORCE_INLINE PxVehicleDirectDriveThrottleCommandResponseParams transformAndScale(
const PxVehicleFrame& srcFrame, const PxVehicleFrame& trgFrame, const PxVehicleScale& srcScale, const PxVehicleScale& trgScale) const
{
PX_UNUSED(srcFrame);
PX_UNUSED(trgFrame);
PxVehicleDirectDriveThrottleCommandResponseParams r = *this;
const PxReal scale = trgScale.scale/srcScale.scale;
r.maxResponse *= (scale*scale); //Max response is a torque!
return r;
}
PX_FORCE_INLINE bool isValid(const PxVehicleAxleDescription& axleDesc) const
{
PX_CHECK_AND_RETURN_VAL(PxIsFinite(maxResponse), "PxVehicleDirectDriveThrottleCommandResponseParams.maxResponse must be a finite value", false);
for (PxU32 i = 0; i < axleDesc.nbWheels; i++)
{
PX_CHECK_AND_RETURN_VAL(PxIsFinite(wheelResponseMultipliers[axleDesc.wheelIdsInAxleOrder[i]]), "PxVehicleDirectDriveThrottleCommandResponseParams.wheelResponseMultipliers[i] must be a finite value", false);
}
return true;
}
};
/**
\brief Specifies the maximum clutch strength that occurs when the clutch pedal is fully disengaged and the clutch is fully engaged.
*/
struct PxVehicleClutchCommandResponseParams
{
/**
\brief Strength of clutch.
\note The clutch is the mechanism that couples the engine to the wheels.
A stronger clutch more strongly couples the engine to the wheels, while a
clutch of strength zero completely decouples the engine from the wheels.
Stronger clutches more quickly bring the wheels and engine into equilibrium, while weaker
clutches take longer, resulting in periods of clutch slip and delays in power transmission
from the engine to the wheels.
The torque generated by the clutch is proportional to the clutch strength and
the velocity difference between the engine's rotational speed and the rotational speed of the
driven wheels after accounting for the gear ratio.
The torque at the clutch is applied negatively to the engine and positively to the driven wheels.
<b>Range:</b> [0,inf)<br>
<b>Unit:</b> torque * time = mass * (length^2) / time
*/
PxReal maxResponse;
PX_FORCE_INLINE PxVehicleClutchCommandResponseParams transformAndScale(
const PxVehicleFrame& srcFrame, const PxVehicleFrame& trgFrame, const PxVehicleScale& srcScale, const PxVehicleScale& trgScale) const
{
PX_UNUSED(srcFrame);
PX_UNUSED(trgFrame);
const PxReal scale = trgScale.scale/srcScale.scale;
PxVehicleClutchCommandResponseParams r = *this;
r.maxResponse *= (scale*scale);
return r;
}
PX_FORCE_INLINE bool isValid() const
{
PX_CHECK_AND_RETURN_VAL(maxResponse >= 0.0f, "PxVehicleClutchCommandResponseParams.maxResponse must be greater than or equal to zero", false);
return true;
}
};
/**
\brief Choose between a potentially more expensive but more accurate solution to the clutch model or a potentially cheaper but less accurate solution.
@see PxVehicleClutchParams
*/
struct PxVehicleClutchAccuracyMode
{
enum Enum
{
eESTIMATE = 0,
eBEST_POSSIBLE
};
};
/**
\brief The clutch connects two plates together. One plate rotates with the speed of the engine. The second plate rotates with a weighted average of all
wheels connected to the differential after accounting for the gear ratio. The difference in rotation speeds generates a restoring torque applied to engine and wheels
that aims to reduce the difference in rotational speed. The restoring torque is proportional to the clutch strength and the clutch pedal position.
*/
struct PxVehicleClutchParams
{
public:
/**
\brief The engine and wheel rotation speeds that are coupled through the clutch can be updated by choosing
one of two modes: eESTIMATE and eBEST_POSSIBLE.
\note If eESTIMATE is chosen the vehicle sdk will update the wheel and engine rotation speeds
with estimated values to the implemented clutch model.
\note If eBEST_POSSIBLE is chosen the vehicle sdk will compute the best possible
solution (within floating point tolerance) to the implemented clutch model.
This is the recommended mode.
\note The clutch model remains the same if either eESTIMATE or eBEST_POSSIBLE is chosen but the accuracy and
computational cost of the solution to the model can be tuned as required.
*/
PxVehicleClutchAccuracyMode::Enum accuracyMode;
/**
\brief Tune the mathematical accuracy and computational cost of the computed estimate to the wheel and
engine rotation speeds if eESTIMATE is chosen.
\note As estimateIterations increases the computational cost of the clutch also increases and the solution
approaches the solution that would be computed if eBEST_POSSIBLE was chosen instead.
\note This has no effect if eBEST_POSSIBLE is chosen as the accuracy mode.
\note A value of zero is not allowed if eESTIMATE is chosen as the accuracy mode.
*/
PxU32 estimateIterations;
PX_FORCE_INLINE PxVehicleClutchParams transformAndScale(
const PxVehicleFrame& srcFrame, const PxVehicleFrame& trgFrame, const PxVehicleScale& srcScale, const PxVehicleScale& trgScale) const
{
PX_UNUSED(srcFrame);
PX_UNUSED(trgFrame);
PX_UNUSED(srcScale);
PX_UNUSED(trgScale);
return *this;
}
PX_FORCE_INLINE bool isValid() const
{
PX_CHECK_AND_RETURN_VAL((PxVehicleClutchAccuracyMode::eBEST_POSSIBLE == accuracyMode) || ((PxVehicleClutchAccuracyMode::eESTIMATE == accuracyMode) && (estimateIterations > 0)), "PxVehicleClutchParams.estimateIterations must be greater than zero if PxVehicleClutchAccuracyMode::eESTIMATE is selected", false);
return true;
}
};
struct PxVehicleEngineParams
{
/**
\brief Maximum supported number of points in the #torqueCurve graph.
*/
enum
{
eMAX_NB_ENGINE_TORQUE_CURVE_ENTRIES = 8
};
/**
\brief Graph of normalized torque (torque/#peakTorque) against normalized engine speed ( engineRotationSpeed / #maxOmega ).
\note The normalized engine speed is the x-axis of the graph, while the normalized torque is the y-axis of the graph.
*/
PxVehicleFixedSizeLookupTable<PxReal, eMAX_NB_ENGINE_TORQUE_CURVE_ENTRIES> torqueCurve;
/**
\brief Moment of inertia of the engine around the axis of rotation.
<b>Range:</b> (0, inf)<br>
<b>Unit:</b> mass * (length^2)
*/
PxReal moi;
/**
\brief Maximum torque available to apply to the engine when the accelerator pedal is at maximum.
\note The torque available is the value of the accelerator pedal (in range [0, 1]) multiplied by the normalized torque as computed from #torqueCurve multiplied by #peakTorque.
<b>Range:</b> [0, inf)<br>
<b>Unit:</b> mass * (length^2) / (time^2)
*/
PxReal peakTorque;
/**
\brief Minimum rotation speed of the engine.
<b>Range:</b> [0, inf)<br>
<b>Unit:</b> radians / time
*/
PxReal idleOmega;
/**
\brief Maximum rotation speed of the engine.
<b>Range:</b> [0, inf)<br>
<b>Unit:</b> radians / time
*/
PxReal maxOmega;
/**
\brief Damping rate of engine when full throttle is applied.
\note If the clutch is engaged (any gear except neutral) then the damping rate applied at run-time is an interpolation
between #dampingRateZeroThrottleClutchEngaged and #dampingRateFullThrottle:
#dampingRateZeroThrottleClutchEngaged + (#dampingRateFullThrottle-#dampingRateZeroThrottleClutchEngaged)*acceleratorPedal;
\note If the clutch is disengaged (in neutral gear) the damping rate applied at run-time is an interpolation
between #dampingRateZeroThrottleClutchDisengaged and #dampingRateFullThrottle:
#dampingRateZeroThrottleClutchDisengaged + (#dampingRateFullThrottle-#dampingRateZeroThrottleClutchDisengaged)*acceleratorPedal;
<b>Range:</b> [0, inf)<br>
<b>Unit:</b> torque * time = mass * (length^2) / time
*/
PxReal dampingRateFullThrottle;
/**
\brief Damping rate of engine when no throttle is applied and with engaged clutch.
\note If the clutch is engaged (any gear except neutral) then the damping rate applied at run-time is an interpolation
between #dampingRateZeroThrottleClutchEngaged and #dampingRateFullThrottle:
#dampingRateZeroThrottleClutchEngaged + (#dampingRateFullThrottle-#dampingRateZeroThrottleClutchEngaged)*acceleratorPedal;
\note If the clutch is disengaged (in neutral gear) the damping rate applied at run-time is an interpolation
between #dampingRateZeroThrottleClutchDisengaged and #dampingRateFullThrottle:
#dampingRateZeroThrottleClutchDisengaged + (#dampingRateFullThrottle-#dampingRateZeroThrottleClutchDisengaged)*acceleratorPedal;
<b>Range:</b> [0, inf)<br>
<b>Unit:</b> torque * time = mass * (length^2) / time
*/
PxReal dampingRateZeroThrottleClutchEngaged;
/**
\brief Damping rate of engine when no throttle is applied and with disengaged clutch.
\note If the clutch is engaged (any gear except neutral) then the damping rate applied at run-time is an interpolation
between #dampingRateZeroThrottleClutchEngaged and #dampingRateFullThrottle:
#dampingRateZeroThrottleClutchEngaged + (#dampingRateFullThrottle-#dampingRateZeroThrottleClutchEngaged)*acceleratorPedal;
\note If the clutch is disengaged (in neutral gear) the damping rate applied at run-time is an interpolation
between #dampingRateZeroThrottleClutchDisengaged and #dampingRateFullThrottle:
#dampingRateZeroThrottleClutchDisengaged + (#dampingRateFullThrottle-#dampingRateZeroThrottleClutchDisengaged)*acceleratorPedal;
<b>Range:</b> [0, inf)<br>
<b>Unit:</b> torque * time = mass * (length^2) / time
*/
PxReal dampingRateZeroThrottleClutchDisengaged;
PX_FORCE_INLINE PxVehicleEngineParams transformAndScale(
const PxVehicleFrame& srcFrame, const PxVehicleFrame& trgFrame, const PxVehicleScale& srcScale, const PxVehicleScale& trgScale) const
{
PX_UNUSED(srcFrame);
PX_UNUSED(trgFrame);
PxVehicleEngineParams r = *this;
const PxReal scale = trgScale.scale/srcScale.scale;
r.moi *= (scale*scale);
r.peakTorque *= (scale*scale);
r.dampingRateFullThrottle *= (scale*scale);
r.dampingRateZeroThrottleClutchDisengaged *= (scale*scale);
r.dampingRateZeroThrottleClutchEngaged *= (scale*scale);
return r;
}
PX_FORCE_INLINE bool isValid() const
{
PX_CHECK_AND_RETURN_VAL(moi > 0.0f, "PxVehicleEngineParams.moi must be greater than zero", false);
PX_CHECK_AND_RETURN_VAL(peakTorque >= 0.0f, "PxVehicleEngineParams.peakTorque must be greater than or equal to zero", false);
PX_CHECK_AND_RETURN_VAL(torqueCurve.isValid(), "PxVehicleEngineParams.torqueCurve is invalid", false);
PX_CHECK_AND_RETURN_VAL(maxOmega >= 0.0f, "PxVehicleEngineParams.maxOmega must be greater than or equal to zero", false);
PX_CHECK_AND_RETURN_VAL(idleOmega >= 0.0f, "PxVehicleEngineParams.idleOmega must be greater or equal to zero", false);
PX_CHECK_AND_RETURN_VAL(dampingRateFullThrottle >= 0.0f, "PxVehicleEngineParams.dampingRateFullThrottle must be greater than or equal to zero", false);
PX_CHECK_AND_RETURN_VAL(dampingRateZeroThrottleClutchEngaged >= 0.0f, "PxVehicleEngineParams.dampingRateZeroThrottleClutchEngaged must be greater than or equal to zero", false);
PX_CHECK_AND_RETURN_VAL(dampingRateZeroThrottleClutchDisengaged >= 0.0f, "PxVehicleEngineParams.dampingRateZeroThrottleClutchDisengaged must be greater than or equal to zero", false)
return true;
}
};
struct PxVehicleGearboxParams
{
public:
/**
\brief The gear that denotes neutral gear
*/
PxU32 neutralGear;
/**
\brief Maximum supported number of gears, including reverse and neutral.
*/
enum Enum
{
eMAX_NB_GEARS = 32
};
/**
\brief Gear ratios
The ratio for reverse gears must be negative, the ratio for the neutral gear
has to be 0 and the ratio for forward gears must be positive.
*/
PxReal ratios[eMAX_NB_GEARS];
/**
\brief Gear ratio applied is #ratios[currentGear]*#finalRatio
<b>Range:</b> (0, inf)<br>
*/
PxReal finalRatio;
/**
\brief Number of gears (including reverse and neutral).
<b>Range:</b> [1, eMAX_NB_GEARS]<br>
*/
PxU32 nbRatios;
/**
\brief Time it takes to switch gear.
<b>Range:</b> [0, inf)<br>
<b>Unit:</b> time
*/
PxReal switchTime;
PX_FORCE_INLINE PxVehicleGearboxParams transformAndScale(
const PxVehicleFrame& srcFrame, const PxVehicleFrame& trgFrame, const PxVehicleScale& srcScale, const PxVehicleScale& trgScale) const
{
PX_UNUSED(srcFrame);
PX_UNUSED(trgFrame);
PX_UNUSED(srcScale);
PX_UNUSED(trgScale);
return *this;
}
PX_FORCE_INLINE bool isValid() const
{
PX_CHECK_AND_RETURN_VAL(finalRatio > 0, "PxVehicleGearboxParams.finalRatio must be greater than zero", false);
PX_CHECK_AND_RETURN_VAL(nbRatios >= 1, "PxVehicleGearboxParams.nbRatios must be greater than zero", false);
PX_CHECK_AND_RETURN_VAL(nbRatios <= eMAX_NB_GEARS, "PxVehicleGearboxParams.nbRatios must be less than or equal to eMAX_NB_GEARS", false);
PX_CHECK_AND_RETURN_VAL(neutralGear < nbRatios, "PxVehicleGearboxParams.neutralGear must be less than PxVehicleGearboxParams.nbRatios", false);
PX_CHECK_AND_RETURN_VAL(switchTime >= 0.0f, "PxVehicleGearboxParams.switchTime must be greater than or equal to zero", false);
for(PxU32 i = 0; i < neutralGear; i++)
{
PX_CHECK_AND_RETURN_VAL(ratios[i] < 0.0f, "Reverse gear ratios must be less than zero", false);
}
{
PX_CHECK_AND_RETURN_VAL(ratios[neutralGear] == 0.0f, "Neutral gear ratio must be equal to zero", false);
}
for (PxU32 i = neutralGear + 1; i < nbRatios; i++)
{
PX_CHECK_AND_RETURN_VAL(ratios[i] > 0.0f, "Forward gear ratios must be greater than zero", false);
}
for (PxU32 i = neutralGear + 2; i < nbRatios; i++)
{
PX_CHECK_AND_RETURN_VAL(ratios[i] < ratios[i - 1], "Forward gear ratios must be a descending sequence of gear ratios", false);
}
return true;
}
};
struct PxVehicleAutoboxParams
{
public:
/**
\brief Value of ( engineRotationSpeed /maxEngineRevs ) that is high enough to increment gear.
\note When ( engineRotationSpeed / #PxVehicleEngineParams::maxOmega ) > upRatios[currentGear] the autobox will begin
a transition to currentGear+1 unless currentGear is the highest possible gear or neutral or reverse.
<b>Range:</b> [0, 1]<br>
*/
PxReal upRatios[PxVehicleGearboxParams::eMAX_NB_GEARS];
/**
\brief Value of engineRevs/maxEngineRevs that is low enough to decrement gear.
\note When ( engineRotationSpeed / #PxVehicleEngineParams::maxOmega) < downRatios[currentGear] the autobox will begin
a transition to currentGear-1 unless currentGear is first gear or neutral or reverse.
<b>Range:</b> [0, 1]<br>
*/
PxReal downRatios[PxVehicleGearboxParams::eMAX_NB_GEARS];
/**
\brief Set the latency time of the autobox.
\note Latency time is the minimum time that must pass between each gear change that is initiated by the autobox.
The auto-box will only attempt to initiate another gear change up or down if the simulation time that has passed since the most recent
automated gear change is greater than the specified latency.
<b>Range:</b> [0, inf)<br>
<b>Unit:</b> time
*/
PxReal latency;
PX_FORCE_INLINE PxVehicleAutoboxParams transformAndScale(
const PxVehicleFrame& srcFrame, const PxVehicleFrame& trgFrame, const PxVehicleScale& srcScale, const PxVehicleScale& trgScale) const
{
PX_UNUSED(srcFrame);
PX_UNUSED(trgFrame);
PX_UNUSED(srcScale);
PX_UNUSED(trgScale);
return *this;
}
PX_FORCE_INLINE bool isValid(const PxVehicleGearboxParams& gearboxParams) const
{
if (!gearboxParams.isValid())
return false;
for (PxU32 i = gearboxParams.neutralGear + 1; i < gearboxParams.nbRatios-1; i++)
{
PX_CHECK_AND_RETURN_VAL(upRatios[i] >= 0.0f, "PxVehicleAutoboxParams.upRatios must be greater than or equal to zero", false);
}
for (PxU32 i = gearboxParams.neutralGear + 2; i < gearboxParams.nbRatios; i++)
{
PX_CHECK_AND_RETURN_VAL(downRatios[i] >= 0.0f, "PxVehicleAutoboxParams.downRatios must be greater than or equal to zero", false);
}
PX_CHECK_AND_RETURN_VAL(latency >= 0.0f, "PxVehicleAutoboxParams.latency must be greater than or equal to zero", false);
return true;
}
};
/**
@deprecated
*/
struct PX_DEPRECATED PxVehicleFourWheelDriveDifferentialLegacyParams
{
public:
enum Enum
{
eDIFF_TYPE_LS_4WD, //limited slip differential for car with 4 driven wheels
eDIFF_TYPE_LS_FRONTWD, //limited slip differential for car with front-wheel drive
eDIFF_TYPE_LS_REARWD, //limited slip differential for car with rear-wheel drive
eMAX_NB_DIFF_TYPES
};
/**
\brief The two front wheels are specified by the array frontWheelIds.
\note The states eDIFF_TYPE_LS_4WD, eDIFF_TYPE_LS_FRONTWD require knowledge of the front wheels
to allow torque splits between front and rear axles as well as torque splits across the front axle.
\note frontWheelIds[0] should specify the wheel on the front axle that is negatively placed on the lateral axis.
\note frontWheelIds[1] should specify the wheel on the front axle that is positively placed on the lateral axis.
\note If #frontNegPosSplit > 0.5, more torque will be delivered to the wheel specified by frontWheelIds[0] than to the wheel
specified by frontWheelIds[1]. The converse is true if #frontNegPosSplit < 0.5.
*/
PxU32 frontWheelIds[2];
/**
\brief The two rear wheels are specified by the array rearWheelIds.
\note The states eDIFF_TYPE_LS_4WD, eDIFF_TYPE_LS_REARWD require knowledge of the rear wheels
to allow torque splits between front and rear axles as well as torque splits across the rear axle.
\note rearWheelIds[0] should specify the wheel on the rear axle that is negatively placed on the lateral axis.
\note rearWheelIds[1] should specify the wheel on the rear axle that is positively placed on the lateral axis.
\note If #rearNegPosSplit > 0.5, more torque will be delivered to the wheel specified by rearWheelIds[0] than to the wheel
specified by rearWheelIds[1]. The converse is true if #rearNegPosSplit < 0.5.
*/
PxU32 rearWheelIds[2];
/**
\brief Ratio of torque split between front and rear wheels (>0.5 means more front, <0.5 means more to rear).
\note Only applied to DIFF_TYPE_LS_4WD
<b>Range:</b> [0, 1]<br>
*/
PxReal frontRearSplit;
/**
\brief Ratio of torque split between front-negative and front-positive wheels (>0.5 means more to #frontWheelIds[0], <0.5 means more to #frontWheelIds[1]).
\note Only applied to DIFF_TYPE_LS_4WD and DIFF_TYPE_LS_FRONTWD
<b>Range:</b> [0, 1]<br>
*/
PxReal frontNegPosSplit;
/**
\brief Ratio of torque split between rear-negative wheel and rear-positive wheels (>0.5 means more to #rearWheelIds[0], <0.5 means more to #rearWheelIds[1]).
\note Only applied to DIFF_TYPE_LS_4WD and eDIFF_TYPE_LS_REARWD
<b>Range:</b> [0, 1]<br>
*/
PxReal rearNegPosSplit;
/**
\brief Maximum allowed ratio of average front wheel rotation speed and rear wheel rotation speeds.
The differential will divert more torque to the slower wheels when the bias is exceeded.
\note Only applied to DIFF_TYPE_LS_4WD
<b>Range:</b> [1, inf)<br>
*/
PxReal centerBias;
/**
\brief Maximum allowed ratio of front-left and front-right wheel rotation speeds.
The differential will divert more torque to the slower wheel when the bias is exceeded.
\note Only applied to DIFF_TYPE_LS_4WD and DIFF_TYPE_LS_FRONTWD
<b>Range:</b> [1, inf)<br>
*/
PxReal frontBias;
/**
\brief Maximum allowed ratio of rear-left and rear-right wheel rotation speeds.
The differential will divert more torque to the slower wheel when the bias is exceeded.
\note Only applied to DIFF_TYPE_LS_4WD and DIFF_TYPE_LS_REARWD
<b>Range:</b> [1, inf)<br>
*/
PxReal rearBias;
/**
\brief Type of differential.
<b>Range:</b> [DIFF_TYPE_LS_4WD, eDIFF_TYPE_LS_REARWD]<br>
*/
Enum type;
PX_FORCE_INLINE PxVehicleFourWheelDriveDifferentialLegacyParams transformAndScale(
const PxVehicleFrame& srcFrame, const PxVehicleFrame& trgFrame, const PxVehicleScale& srcScale, const PxVehicleScale& trgScale) const
{
PX_UNUSED(srcFrame);
PX_UNUSED(trgFrame);
PX_UNUSED(srcScale);
PX_UNUSED(trgScale);
return *this;
}
PX_FORCE_INLINE bool isValid(const PxVehicleAxleDescription& axleDesc) const
{
PX_UNUSED(axleDesc);
PX_CHECK_AND_RETURN_VAL((axleDesc.getAxle(frontWheelIds[0]) != 0xffffffff) && (axleDesc.getAxle(frontWheelIds[0])== axleDesc.getAxle(frontWheelIds[1])), "frontWheelIds[0] and frontWheelIds[1] must reference wheels on the same axle", false);
PX_CHECK_AND_RETURN_VAL((axleDesc.getAxle(rearWheelIds[0]) != 0xffffffff) && (axleDesc.getAxle(rearWheelIds[0]) == axleDesc.getAxle(rearWheelIds[1])), "rearWheelIds[0] and rearWheelIds[1] must reference wheels on the same axle", false);
PX_CHECK_AND_RETURN_VAL(frontRearSplit <= 1.0f && frontRearSplit >= 0.0f, "PxVehicleLegacyFourWheelDriveDifferentialParams.frontRearSplit must be in range [0,1]", false);
PX_CHECK_AND_RETURN_VAL(frontNegPosSplit <= 1.0f && frontNegPosSplit >= 0.0f, "PxVehicleLegacyFourWheelDriveDifferentialParams.frontNegPosSplit must be in range [0,1]", false);
PX_CHECK_AND_RETURN_VAL(rearNegPosSplit <= 1.0f && rearNegPosSplit >= 0.0f, "PxVehicleLegacyFourWheelDriveDifferentialParams.rearNegPosSplit must be in range [0,1]", false);
PX_CHECK_AND_RETURN_VAL(centerBias >= 1.0f, "PxVehicleLegacyFourWheelDriveDifferentialParams.centerBias must be greater than or equal to 1.0f", false);
PX_CHECK_AND_RETURN_VAL(frontBias >= 1.0f, "PxVehicleLegacyFourWheelDriveDifferentialParams.frontBias must be greater than or equal to 1.0f", false);
PX_CHECK_AND_RETURN_VAL(rearBias >= 1.0f, "PxVehicleLegacyFourWheelDriveDifferentialParams.rearBias must be greater than or equal to 1.0f", false);
PX_CHECK_AND_RETURN_VAL(type < PxVehicleFourWheelDriveDifferentialLegacyParams::eMAX_NB_DIFF_TYPES, "PxVehicleLegacyFourWheelDriveDifferentialParams.type has illegal value", false);
return true;
}
};
/**
\brief PxVehicleMultiWheelDriveDifferentialParams specifies the wheels that are to receive drive torque from the differential
and the division of torque between the wheels that are connected to the differential.
*/
struct PxVehicleMultiWheelDriveDifferentialParams
{
/**
\brief torqueRatios describes the fraction of torque delivered to each wheel through the differential.
\note Wheels not connected to the differential must receive zero torque.
\note Wheels connected to the differential may receive a non-zero torque.
\note The sum of the absolute of the ratios of all wheels must equal to 1.0.
\note A negative torque ratio simulates a wheel with negative gearing applied.
<b>Range:</b> [1, -1]<br>
*/
PxReal torqueRatios[PxVehicleLimits::eMAX_NB_WHEELS];
/**
\brief aveWheelSpeedRatios describes the contribution of each wheel to the average wheel speed measured at the clutch.
\note Wheels not connected to the differential do not contribute to the average wheel speed measured at the clutch.
\note Wheels connected to the differential may delivere a non-zero contribution to the average wheel speed measured at the clutch.
\note The sum of all ratios of all wheels must equal to 1.0.
<b>Range:</b> [0, 1]<br>
*/
PxReal aveWheelSpeedRatios[PxVehicleLimits::eMAX_NB_WHEELS];
PX_FORCE_INLINE void setToDefault()
{
PxMemZero(this, sizeof(PxVehicleMultiWheelDriveDifferentialParams));
}
PX_FORCE_INLINE PxVehicleMultiWheelDriveDifferentialParams transformAndScale(
const PxVehicleFrame& srcFrame, const PxVehicleFrame& trgFrame, const PxVehicleScale& srcScale, const PxVehicleScale& trgScale) const
{
PX_UNUSED(srcFrame);
PX_UNUSED(trgFrame);
PX_UNUSED(srcScale);
PX_UNUSED(trgScale);
return *this;
}
PX_FORCE_INLINE bool isValid(const PxVehicleAxleDescription& axleDesc) const
{
if (!axleDesc.isValid())
return false;
PxReal aveWheelSpeedSum = 0.0f;
PxReal torqueRatioSum = 0.0f;
for (PxU32 i = 0; i < axleDesc.nbWheels; i++)
{
const PxU32 wheelId = axleDesc.wheelIdsInAxleOrder[i];
PX_CHECK_AND_RETURN_VAL(PxAbs(torqueRatios[wheelId]) <= 1.0f, "PxVehicleMultiWheelDriveDifferentialParams.torqueRatios[i] must be in range [-1, 1] for all wheels connected to the differential", false);
PX_CHECK_AND_RETURN_VAL(aveWheelSpeedRatios[wheelId] >= 0.0f && aveWheelSpeedRatios[wheelId] <= 1.0f, "PxVehicleMultiWheelDriveDifferentialParams.aveWheelSpeedRatios[i] must be in range [0, 1] for all wheels connected to the differential", false);
aveWheelSpeedSum += aveWheelSpeedRatios[wheelId];
torqueRatioSum += PxAbs(torqueRatios[wheelId]);
}
PX_CHECK_AND_RETURN_VAL(aveWheelSpeedSum >= 0.99f && aveWheelSpeedSum <= 1.01f, "Sum of PxVehicleMultiWheelDriveDifferentialParams.aveWheelSpeedRatios[i] must be 1.0.", false);
PX_CHECK_AND_RETURN_VAL(torqueRatioSum >= 0.99f && torqueRatioSum <= 1.01f, "Sum of PxVehicleMultiWheelDriveDifferentialParams.torqueRatios[i] must be 1.0.", false);
PX_UNUSED(aveWheelSpeedSum);
PX_UNUSED(torqueRatioSum);
return true;
}
};
/**
\brief A special value that indicates instantaneous resolution of a slip that exceeds a differential bias.
*/
#define PX_VEHICLE_FOUR_WHEEL_DIFFERENTIAL_MAXIMUM_STRENGTH PX_MAX_F32
/**
\brief PxVehicleFourWheelDriveDifferentialParams specifies the wheels that are to receive drive torque from the differential
and the division of torque between the wheels that are connected to the differential. Additionally, it specifies the biases
and strength of a limited slip differential that operates on two wheels specified as front wheels and two wheels specified
as rear wheels.
*/
struct PxVehicleFourWheelDriveDifferentialParams : public PxVehicleMultiWheelDriveDifferentialParams
{
/**
\brief The ids of the two wheels considered by the differential to be the front pair.
\note When the ratio of the rotational speeds of the front wheels exceeds frontBias, drive torque is diverted so
that the ratio approaches the value specified by frontTarget. When the bias is not breached, the drive torque
is specified by the corresponding entries in PxVehicleMultiWheelDriveDifferentialParams::torqueRatios.
*/
PxU32 frontWheelIds[2];
/**
\brief The ids of the two wheels considered by the differential to be the rear pair.
\note When the ratio of the rotational speeds of the rear wheels exceeds rearBias, drive torque is diverted so
that the ratio approaches the value specified by rearTarget. When the bias is not breached, the drive torque
is specified by the corresponding entries in PxVehicleMultiWheelDriveDifferentialParams::torqueRatios.
*/
PxU32 rearWheelIds[2];
/**
\brief The parameter frontBias specifies the maximum angular speed ratio of the two front wheels specified by frontWheelIds[2].
\note If frontBias has value 0.0, the differential will not try to enforce any relationship between the rotational speeds of the two front wheels.
\note If frontBias has value 0.0, the torque split between the front wheels is specified by the array torqueRatios.
\note frontBias must have value 0.0 (deactivated limited slip) or be greater than 1.0 (activated limited slip) or be equal to 1.0 (locked axle).
\note If frontBias has value greater than or equal to 1.0 then the array frontWheelIds must be specified and the corresponding entries of
the isConnected[] array must be set true.
\note If frontBias has value greater than or equal to 1.0 then frontTarget must also be specified.
\note A locked axle may be achieved by setting frontBias and frontTarget to 1.0.
\note A limited slip differential may be achieved by setting frontBias > 1.0 and frontBias > frontTarget > 1.0.
*/
PxReal frontBias;
/**
\brief The parameter frontTarget specifies the target rotational speed ratio of the two front wheels in the event that the ratio exceeds frontBias and frontBias
is configured for an activated limited slip or locked axle.
\note frontTarget must be less than frontBias and greater than 1.0 to implement a limited slip differential.
\note Set frontTarget and frontBias to 1.0 to implement a locked axle.
*/
PxReal frontTarget;
/**
\brief The parameter rearBias specifies the maximum angular speed ratio of the two rear wheels specified by rearWheelIds[2].
\note If rearBias has value 0.0, the differential will not try to enforce any relationship between the rotational speeds of the two rear wheels.
\note If rearBias has value 0.0, the torque split between the rear wheels is specified by the array torqueRatios.
\note rearBias must have value 0.0 (deactivated limited slip) or be greater than 1.0 (activated limited slip) or be equal to 1.0 (locked axle).
\note If rearBias has value greater than or equal to 1.0 then the array rearWheelIds must be specified and the corresponding entries of
the isConnected[] array must be set true.
\note If rearBias has value greater than or equal to 1.0 then rearTarget must also be specified.
\note A locked axle may be achieved by setting rearBias and rearTarget to 1.0.
\note A limited slip differential may be achieved by setting rearBias > 1.0 and rearBias > rearTarget > 1.0
*/
PxReal rearBias;
/**
\brief The parameter rearTarget specifies the target rotational speed ratio of the two rear wheels in the event that the ratio exceeds rearBias and rearBias
is configured for an activated limited slip or locked axle.
\note rearTarget must be less than rearBias and greater than 1.0 to implement a limited slip differential.
\note Set rearTarget and rearBias to 1.0 to implement a locked axle.
*/
PxReal rearTarget;
/**
\brief The parameter centerBias specifies the maximum angular speed ratio of the sum of the two front wheels and the sum of the two rear wheels,
as specified by frontWheelIds[2] and rearWheelIds[2].
\note If centerBias has value 0.0, the differential will not try to enforce any relationship between the rotational speeds of the front and rear wheels.
\note If centerBias has value 0.0, the torque split between the front and rear rear wheels is specified by the array torqueRatios.
\note centerBias must have value 0.0 (deactivated limited slip) or be greater than 1.0 (activated limited slip) or be equal to 1.0 (locked).
\note If centerBias has value greater than or equal to 1.0 then the arrays frontWheelIds and rearWheelIds must be specified and the corresponding entries of
the isConnected[] array must be set true.
\note If centerBias has value greater than or equal to 1.0 then centerTarget must also be specified.
\note A locked front/rear differential may be achieved by setting centerBias and centerTarget to 1.0.
\note A limited slip differential may be achieved by setting centerBias > 1.0 and centerBias > centerTarget > 1.0
*/
PxReal centerBias;
/**
\brief The parameter centerTarget specifies the target rotational speed ratio of the sum of the two front wheels and the sum of the two rear wheels
in the event that the ratio exceeds centerBias and centerBias is configured for an activated limited slip.
\note centerTarget must be less than centerBias and greater than 1.0 to implement a limited slip differential.
\note Set centerTarget and centerBias to 1.0 to implement a locked differential.
*/
PxReal centerTarget;
/**
\brief The parameter rate specifies how quickly the ratio of rotational speeds approaches the target rotational speed ratio.
\note strength must be in range [0,PX_VEHICLE_FOUR_WHEEL_DIFF_MAXIMUM_STRENGTH].
\note The ratio of rotational speeds is decremented each update by rate*dt until the ratio is equal to the target ratio.
\note A value of 0 will result in a deactivated limited slip.
\note A value of PX_VEHICLE_FOUR_WHEEL_DIFF_MAXIMUM_STRENGTH will result in instantaneous correction of the rotational speed ratios.
*/
PxReal rate;
PX_FORCE_INLINE void setToDefault()
{
PxVehicleMultiWheelDriveDifferentialParams::setToDefault();
frontBias = 0.0f;
rearBias = 0.0f;
centerBias = 0.0f;
}
PX_FORCE_INLINE bool isValid(const PxVehicleAxleDescription& axleDesc) const
{
if (!PxVehicleMultiWheelDriveDifferentialParams::isValid(axleDesc))
return false;
PX_CHECK_AND_RETURN_VAL((0.0f == centerBias) ||
(centerBias > 1.0f &&
frontWheelIds[0] < axleDesc.nbWheels && frontWheelIds[1] < axleDesc.nbWheels &&
rearWheelIds[0] < axleDesc.nbWheels && rearWheelIds[1] < axleDesc.nbWheels),
"PxVehicleFourWheelDriveDifferentialParams:: centreBias is enabled but the frontWheelIds and rearWheelIds are not configured correctly.", false);
PX_CHECK_AND_RETURN_VAL((0.0f == centerBias) ||
(centerBias > 1.0f &&
frontWheelIds[0] != frontWheelIds[1] && frontWheelIds[0] != rearWheelIds[0] && frontWheelIds[0] != rearWheelIds[1] &&
frontWheelIds[1] != rearWheelIds[0] && frontWheelIds[1] != rearWheelIds[1] &&
rearWheelIds[0] != rearWheelIds[1]),
"PxVehicleFourWheelDriveDifferentialParams:: centreBias is enabled but the frontWheelIds and rearWheelIds are not configured correctly.", false);
PX_CHECK_AND_RETURN_VAL((0.0f == centerBias) ||
(centerBias > 1.0f &&
torqueRatios[frontWheelIds[0]] != 0.0f && torqueRatios[frontWheelIds[1]] != 0.0f && torqueRatios[rearWheelIds[0]] != 0.0f && torqueRatios[rearWheelIds[1]] != 0.0f),
"PxVehicleFourWheelDriveDifferentialParams:: centreBias is enabled but the front and rear wheels are not connected.", false);
PX_CHECK_AND_RETURN_VAL((0.0f == rearBias) ||
(rearBias > 1.0f && rearWheelIds[0] < axleDesc.nbWheels && rearWheelIds[1] < axleDesc.nbWheels),
"PxVehicleFourWheelDriveDifferentialParams:: rearBias is enabled but the rearWheelIds are not configured correctly.", false);
PX_CHECK_AND_RETURN_VAL((0.0f == rearBias) ||
(rearBias > 1.0f && rearWheelIds[0] != rearWheelIds[1]),
"PxVehicleFourWheelDriveDifferentialParams:: rearBias is enabled but the rearWheelIds are not configured correctly.", false);
PX_CHECK_AND_RETURN_VAL((0.0f == centerBias) ||
(rearBias > 1.0f && torqueRatios[rearWheelIds[0]] != 0.0f && torqueRatios[rearWheelIds[1]] != 0.0f),
"PxVehicleFourWheelDriveDifferentialParams:: rearBias is enabled but the rear wheels are not connected.", false);
PX_CHECK_AND_RETURN_VAL((0.0f == frontBias) ||
(frontBias > 1.0f && frontWheelIds[0] < axleDesc.nbWheels && frontWheelIds[1] < axleDesc.nbWheels),
"PxVehicleFourWheelDriveDifferentialParams:: frontBias is enabled but the frontWheelIds are not configured correctly.", false);
PX_CHECK_AND_RETURN_VAL((0.0f == frontBias) ||
(frontBias > 1.0f && frontWheelIds[0] != frontWheelIds[1]),
"PxVehicleFourWheelDriveDifferentialParams:: frontBias is enabled but the frontWheelIds are not configured correctly.", false);
PX_CHECK_AND_RETURN_VAL((0.0f == frontBias) ||
(frontBias > 1.0f && torqueRatios[frontWheelIds[0]] != 0.0f && frontWheelIds[frontWheelIds[1]]),
"PxVehicleFourWheelDriveDifferentialParams:: frontBias is enabled but the front wheels are not connected.", false);
PX_CHECK_AND_RETURN_VAL(((0.0f == frontBias) && (0.0f == rearBias) && (0.0f == centerBias)) || (rate >= 0.0f),
"PxVehicleFourWheelDriveDifferentialParams:: strength must be greater than or equal to zero", false);
PX_CHECK_AND_RETURN_VAL((0.0f == frontBias) || ((1.0f == frontTarget && 1.0f == rearTarget) || (frontTarget > 1.0f && frontTarget < frontBias)),
"PxVehicleFourWheelDriveDifferentialParams: frontBias is enabled but frontTarget not in range (1.0f, frontBias)", false);
PX_CHECK_AND_RETURN_VAL((0.0f == rearBias) || ((1.0f == rearTarget && 1.0f == rearBias) || (rearTarget > 1.0f && rearTarget < rearBias)),
"PxVehicleFourWheelDriveDifferentialParams: rearBias is enabled but rearTarget not in range (1.0f, rearBias)", false);
PX_CHECK_AND_RETURN_VAL((0.0f == centerBias) || ((1.0f == centerTarget && 1.0f == centerBias) || (centerTarget > 1.0f && centerTarget < centerBias)),
"PxVehicleFourWheelDriveDifferentialParams: centerBias is enabled but centerTarget not in range (1.0f, centerBias)", false);
return true;
}
PX_FORCE_INLINE PxVehicleFourWheelDriveDifferentialParams transformAndScale(
const PxVehicleFrame& srcFrame, const PxVehicleFrame& trgFrame, const PxVehicleScale& srcScale, const PxVehicleScale& trgScale) const
{
PX_UNUSED(srcFrame);
PX_UNUSED(trgFrame);
PX_UNUSED(srcScale);
PX_UNUSED(trgScale);
PxVehicleFourWheelDriveDifferentialParams r = *this;
static_cast<PxVehicleMultiWheelDriveDifferentialParams&>(r) = PxVehicleMultiWheelDriveDifferentialParams::transformAndScale(srcFrame, trgFrame, srcScale, trgScale);
return r;
}
};
/**
\brief A description of a tank differential.
\note The wheels on a tank may be connected to the differential or not connected to the differential.
\note The wheels on a tank track may be connected to a tank track or not connected to a tank track.
\note Wheels connected to the differential but not to a tank track receive the torque split specified by the
corresponding elements of PxVehicleMultiWheelDriveDifferentialParams::torqueRatios[].
\note Wheels connected to a tank track but not to the differential receive no torque from the engine.
\note Wheels connected to a tank track and to the differential receive the torque split specified by the
corresponding elements of PxVehicleMultiWheelDriveDifferentialParams::torqueRatios[] multiplied by the corresponding
thrust controller value. If the thrust controller has a negative value, the wheels will receive a torque that is negative
with respect to the gearing ratio.
\note The wheels in each tank track have a constraint applied to them to enforce the rule that they all have the same longitudinal speed
at the contact point between the wheel and the tank track.
*/
struct PxVehicleTankDriveDifferentialParams : public PxVehicleMultiWheelDriveDifferentialParams
{
PX_FORCE_INLINE void setToDefault()
{
PxVehicleMultiWheelDriveDifferentialParams::setToDefault();
nbTracks = 0;
}
/**
\brief Add a tank track by specifying the number of wheels along the track and an array of wheel ids specifying each wheel in the tank track.
\param[in] nbWheelsInTrackToAdd is the number of wheels in the track to be added.
\param[in] wheelIdsInTrackToAdd is an array of wheel ids specifying all the wheels in the track to be added.
\param[in] thrustControllerIndex specifies the index of the thrust controller that will be used to control the tank track.
*/
void addTankTrack(const PxU32 nbWheelsInTrackToAdd, const PxU32* const wheelIdsInTrackToAdd, const PxU32 thrustControllerIndex)
{
PxU32 trackToWheelIdsOffset = nbTracks ? trackToWheelIds[nbTracks - 1] + nbWheelsPerTrack[nbTracks - 1] : 0;
PX_ASSERT((trackToWheelIdsOffset + nbWheelsInTrackToAdd) <= PxVehicleLimits::eMAX_NB_WHEELS);
PX_ASSERT(nbTracks < PxVehicleLimits::eMAX_NB_WHEELS);
PX_ASSERT(thrustControllerIndex < 2);
nbWheelsPerTrack[nbTracks] = nbWheelsInTrackToAdd;
thrustIdPerTrack[nbTracks] = thrustControllerIndex;
trackToWheelIds[nbTracks] = trackToWheelIdsOffset;
for (PxU32 i = 0; i < nbWheelsInTrackToAdd; i++)
{
wheelIdsInTrackOrder[trackToWheelIdsOffset + i] = wheelIdsInTrackToAdd[i];
}
nbTracks++;
}
/**
\brief Return the number of tracks.
\return The number of tracks.
@see getNbWheelsInTrack()
*/
PX_FORCE_INLINE PxU32 getNbTracks() const
{
return nbTracks;
}
/**
\brief Return the number of wheels in the ith track.
\param[in] i specifies the track to be queried for its wheel count.
\return The number of wheels in the specified track.
@see getWheelInTrack()
*/
PX_FORCE_INLINE PxU32 getNbWheelsInTrack(const PxU32 i) const
{
return nbWheelsPerTrack[i];
}
/**
\brief Return the array of all wheels in the ith track.
\param[in] i specifies the track to be queried for its wheels.
\return The array of wheels in the specified track.
*/
PX_FORCE_INLINE const PxU32* getWheelsInTrack(const PxU32 i) const
{
return (wheelIdsInTrackOrder + trackToWheelIds[i]);
}
/**
\brief Return the wheel id of the jth wheel in the ith track.
\param[in] j specifies that the wheel id to be returned is the jth wheel in the list of wheels on the specified track.
\param[in] i specifies the track to be queried.
\return The wheel id of the jth wheel in the ith track.
@see getNbWheelsInTrack()
*/
PX_FORCE_INLINE PxU32 getWheelInTrack(const PxU32 j, const PxU32 i) const
{
return wheelIdsInTrackOrder[trackToWheelIds[i] + j];
}
/**
\brief Return the index of the thrust controller that will control a specified track.
\param[in] i specifies the track to be queried for its thrust controller index
\return The index of the thrust controller that will control the ith track.
*/
PX_FORCE_INLINE PxU32 getThrustControllerIndex(const PxU32 i) const
{
return thrustIdPerTrack[i];
}
PX_FORCE_INLINE PxVehicleTankDriveDifferentialParams transformAndScale(
const PxVehicleFrame& srcFrame, const PxVehicleFrame& trgFrame, const PxVehicleScale& srcScale, const PxVehicleScale& trgScale) const
{
PX_UNUSED(srcFrame);
PX_UNUSED(trgFrame);
PX_UNUSED(srcScale);
PX_UNUSED(trgScale);
PxVehicleTankDriveDifferentialParams r = *this;
static_cast<PxVehicleMultiWheelDriveDifferentialParams&>(r) = PxVehicleMultiWheelDriveDifferentialParams::transformAndScale(srcFrame, trgFrame, srcScale, trgScale);
return r;
}
PX_FORCE_INLINE bool isValid(const PxVehicleAxleDescription& axleDesc) const
{
if (!PxVehicleMultiWheelDriveDifferentialParams::isValid(axleDesc))
return false;
PX_CHECK_AND_RETURN_VAL(nbTracks <= PxVehicleLimits::eMAX_NB_WHEELS, "PxVehicleTankDriveDifferentialParams.nbTracks must not exceed PxVehicleLimits::eMAX_NB_WHEELS", false);
const PxU32 nbWheelsInTracksSize = nbTracks ? trackToWheelIds[nbTracks - 1] + nbWheelsPerTrack[nbTracks - 1] : 0;
PX_UNUSED(nbWheelsInTracksSize);
PX_CHECK_AND_RETURN_VAL(nbWheelsInTracksSize <= PxVehicleLimits::eMAX_NB_WHEELS, "PxVehicleTankDriveDifferentialParams.nbWheelsInTracks must not exceed PxVehicleLimits::eMAX_NB_WHEELS", false);
for (PxU32 i = 0; i < nbTracks; i++)
{
PX_CHECK_AND_RETURN_VAL(thrustIdPerTrack[i] < 2, "PxVehicleTankDriveDifferentialParams.thrustId must be less than 2", false);
}
for (PxU32 i = 0; i < axleDesc.nbWheels; i++)
{
const PxU32 wheelId = axleDesc.wheelIdsInAxleOrder[i];
PxU32 count = 0;
for (PxU32 j = 0; j < nbTracks; j++)
{
const PxU32 nbWheels = getNbWheelsInTrack(j);
const PxU32* wheelIds = getWheelsInTrack(j);
for (PxU32 k = 0; k < nbWheels; k++)
{
if (wheelIds[k] == wheelId)
count++;
}
}
PX_CHECK_AND_RETURN_VAL(count <= 1, "PxVehicleTankDriveDifferentialParams - a wheel cannot be in more than one tank track", false);
}
return true;
}
PxU32 nbTracks; //!< The number of tracks
PxU32 thrustIdPerTrack[PxVehicleLimits::eMAX_NB_WHEELS]; //!< The id of the thrust that will control the track. Must have value 0 or 1.
PxU32 nbWheelsPerTrack[PxVehicleLimits::eMAX_NB_WHEELS]; //!< The number of wheels in each track
PxU32 trackToWheelIds[PxVehicleLimits::eMAX_NB_WHEELS]; //!< The list of wheel ids for the ith tank track begins at wheelIdsInTrackOrder[trackToWheelIds[i]]
PxU32 wheelIdsInTrackOrder[PxVehicleLimits::eMAX_NB_WHEELS];//!< The list of all wheel ids in all tracks
};
#if !PX_DOXYGEN
} // namespace vehicle2
} // namespace physx
#endif
/** @} */
| 45,498 | C | 44.59018 | 310 | 0.763814 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle2/pvd/PxVehiclePvdFunctions.h | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#pragma once
/** \addtogroup vehicle2
@{
*/
#include "vehicle2/PxVehicleParams.h"
#include "vehicle2/braking/PxVehicleBrakingParams.h"
#include "vehicle2/commands/PxVehicleCommandStates.h"
#include "vehicle2/drivetrain/PxVehicleDrivetrainParams.h"
#include "vehicle2/drivetrain/PxVehicleDrivetrainStates.h"
#include "vehicle2/physxActor/PxVehiclePhysXActorStates.h"
#include "vehicle2/physxConstraints/PxVehiclePhysXConstraintParams.h"
#include "vehicle2/physxConstraints/PxVehiclePhysXConstraintStates.h"
#include "vehicle2/physxRoadGeometry/PxVehiclePhysXRoadGeometryParams.h"
#include "vehicle2/physxRoadGeometry/PxVehiclePhysXRoadGeometryState.h"
#include "vehicle2/roadGeometry/PxVehicleRoadGeometryState.h"
#include "vehicle2/steering/PxVehicleSteeringParams.h"
#include "vehicle2/suspension/PxVehicleSuspensionParams.h"
#include "vehicle2/suspension/PxVehicleSuspensionStates.h"
#include "vehicle2/tire/PxVehicleTireParams.h"
#include "vehicle2/tire/PxVehicleTireStates.h"
#include "vehicle2/wheel/PxVehicleWheelParams.h"
#include "vehicle2/wheel/PxVehicleWheelStates.h"
class OmniPvdWriter;
namespace physx
{
class PxAllocatorCallback;
namespace vehicle2
{
struct PxVehiclePvdAttributeHandles;
struct PxVehiclePvdObjectHandles;
} // namespace vehicle2
} // namespace physx
#if !PX_DOXYGEN
namespace physx
{
namespace vehicle2
{
#endif
/**
\brief Create object instances in omnipvd that will be used to reflect the parameters and state of the rigid body of a vehicle instance.
Handles to the created object instances will be stored in a PxVehiclePvdObjectHandles instance.
\param[in] rbodyParams describes the parameters of the vehicle's rigid body.
\param[in] rbodyState describes the state of the vehicle's rigid body.
\param[in] attributeHandles contains a general description of vehicle parameters and states that will be reflected in omnipvd.
\param[in] objectHandles contains unique handles for the parameters and states of each vehicle instance.
\param[in] omniWriter is an OmniPvdWriter instance used to communicate state and parameter data to omnipvd.
\note If rbodyParams is NULL, omnipvd will not reflect rigid body parameters.
\note If rbodyState is NULL, omnipvd will not reflect rigid body state.
\note PxVehiclePvdRigidBodyRegister should be called once for each vehicle instance.
@see PxVehiclePvdAttributesCreate
@see PxVehiclePvdObjectCreate
@see PxVehiclePvdRigidBodyWrite
*/
void PxVehiclePvdRigidBodyRegister
(const PxVehicleRigidBodyParams* rbodyParams, const PxVehicleRigidBodyState* rbodyState,
const PxVehiclePvdAttributeHandles& attributeHandles,
PxVehiclePvdObjectHandles& objectHandles, OmniPvdWriter& omniWriter);
/**
\brief Write the parameters and state of the rigid body of a vehicle instance to omnipvd.
\param[in] rbodyParams describes the parameters of the vehicle's rigid body.
\param[in] rbodyState describes the state of the vehicle's rigid body.
\param[in] attributeHandles contains a general description of vehicle parameters and states that will be reflected in omnipvd.
\param[in] objectHandles contains unique handles for the parameters and states of each vehicle instance.
\param[in] omniWriter is an OmniPvdWriter instance used to communicate state and parameter data to omnipvd.
\note If rbodyParams is NULL but a non-NULL value was used in PxVehiclePvdRigidBodyRegister(), the rigid body parameters will not be updated in omnipvd.
\note If rbodyState is NULL but a non-NULL value was used in PxVehiclePvdRigidBodyRegister(), the rigid body state will not be updated in omnipvd.
\note omniWriter must be the same instance used in PxVehiclePvdRigidBodyRegister().
@see PxVehiclePvdAttributesCreate
@see PxVehiclePvdObjectCreate
@see PxVehiclePvdRigidBodyRegister
*/
void PxVehiclePvdRigidBodyWrite
(const PxVehicleRigidBodyParams* rbodyParams, const PxVehicleRigidBodyState* rbodyState,
const PxVehiclePvdAttributeHandles& attributeHandles,
const PxVehiclePvdObjectHandles& objectHandles, OmniPvdWriter& omniWriter);
/**
\brief Register object instances in omnipvd that will be used to reflect the suspension state calculation parameters of a vehicle instance.
\param[in] suspStateCalcParams describes parameters used to calculate suspension state.
\param[in] attributeHandles contains a general description of vehicle parameters and states that will be reflected in omnipvd.
\param[in] objectHandles contains unique handles for the parameters and states of each vehicle instance.
\param[in] omniWriter is an OmniPvdWriter instance used to communicate state and parameter data to omnipvd.
\note If suspStateCalcParams is NULL, omnipvd will not reflect the suspension state calculation parameters.
@see PxVehiclePvdAttributesCreate
@see PxVehiclePvdObjectCreate
@see PxVehiclePvdSuspensionStateCalculationParamsWrite
*/
void PxVehiclePvdSuspensionStateCalculationParamsRegister
(const PxVehicleSuspensionStateCalculationParams* suspStateCalcParams,
const PxVehiclePvdAttributeHandles& attributeHandles,
PxVehiclePvdObjectHandles& objectHandles, OmniPvdWriter& omniWriter);
/**
\brief Write the parameters and state of the rigid body of a vehicle instance to omnipvd.
\param[in] suspStateCalcParams describes parameters used to calculate suspension state.
\param[in] attributeHandles contains a general description of vehicle parameters and states that will be reflected in omnipvd.
\param[in] objectHandles contains unique handles for the parameters and states of each vehicle instance.
\param[in] omniWriter is an OmniPvdWriter instance used to communicate state and parameter data to omnipvd.
\note If suspStateCalcParams is NULL but a non-NULL value was used in void PxVehiclePvdSuspensionStateCalculationParamsRegister(),
the suspension state calculation parameters will not be updated in omnipvd.
\note omniWriter must be the same instance used in PxVehiclePvdSuspensionStateCalculationParamsRegister().
@see PxVehiclePvdAttributesCreate
@see PxVehiclePvdObjectCreate
@see PxVehiclePvdSuspensionStateCalculationParamsRegister
*/
void PxVehiclePvdSuspensionStateCalculationParamsWrite
(const PxVehicleSuspensionStateCalculationParams* suspStateCalcParams,
const PxVehiclePvdAttributeHandles& attributeHandles,
const PxVehiclePvdObjectHandles& objectHandles, OmniPvdWriter& omniWriter);
/**
\brief Register object instances in omnipvd that will be used to reflect the brake and steer command response parameters of a vehicle instance.
\param[in] brakeResponseParams is an array of brake command response parameters.
\param[in] steerResponseParams describes the steer command response parameters.
\param[in] ackermannParams defines the Ackermann steer correction.
\param[in] brakeResponseStates is an array of brake responses torqyes,
\param[in] steerResponseStates is an array of steer response angles.
\param[in] attributeHandles contains a general description of vehicle parameters and states that will be reflected in omnipvd.
\param[in] objectHandles contains unique handles for the parameters and states of each vehicle instance.
\param[in] omniWriter is an OmniPvdWriter instance used to communicate state and parameter data to omnipvd.
\note If brakeResponseParams is empty, omnipvd will not reflect any brake command response parameters.
\note If steerResponseParams is NULL, omnipvd will not reflect the steer command response parameters.
\note If ackermannParams is NULL, omnipvd will not reflect any Ackermann steer correction parameters.
\note If brakeResponseStates is empty, omnipvd will not reflect any brake command response state.
\note If steerResponseStates is empty, omnipvd will not reflect any steer command response state.
@see PxVehiclePvdAttributesCreate
@see PxVehiclePvdObjectCreate
@see PxVehiclePvdCommandResponseWrite
*/
void PxVehiclePvdCommandResponseRegister
(const PxVehicleSizedArrayData<const PxVehicleBrakeCommandResponseParams>& brakeResponseParams,
const PxVehicleSteerCommandResponseParams* steerResponseParams,
const PxVehicleAckermannParams* ackermannParams,
const PxVehicleArrayData<PxReal>& brakeResponseStates,
const PxVehicleArrayData<PxReal>& steerResponseStates,
const PxVehiclePvdAttributeHandles& attributeHandles,
PxVehiclePvdObjectHandles& objectHandles, OmniPvdWriter& omniWriter);
/**
\brief Write brake and steer command response parameters to omnipvd.
\param[in] axleDesc is a description of the wheels and axles of a vehicle.
\param[in] brakeResponseParams is an array of brake command response parameters.
\param[in] steerResponseParams describes the steer command response parameters.
\param[in] ackermannParams defines the Ackermann steer correction.
\param[in] brakeResponseStates is an array of brake response torques.
\param[in] steerResponseStates is an array of steer response angles.
\param[in] attributeHandles contains a general description of vehicle parameters and states that will be reflected in omnipvd.
\param[in] objectHandles contains unique handles for the parameters and states of each vehicle instance.
\param[in] omniWriter is an OmniPvdWriter instance used to communicate state and parameter data to omnipvd.
\note If brakeResponseParams is empty but a non-empty array was used in PxVehiclePvdCommandResponseRegister(),
the brake command response parameters will not be updated in omnipvd.
\note If steerResponseParams is non-NULL but a NULL value was used in PxVehiclePvdCommandResponseRegister(),
the steer command parameters will not be updated in omnipvd.
\note If ackermannParams is non-NULL but a NULL value was used in PxVehiclePvdCommandResponseRegister(),
the Ackermann steer correction parameters will not be updated in omnipvd.
\note If brakeResponseStates is empty but a non-empty array was used in PxVehiclePvdCommandResponseRegister(),
the brake response states will not be updated in omnipvd.
\note If steerResponseStates is empty but a non-empty array was used in PxVehiclePvdCommandResponseRegister(),
the steer response states will not be updated in omnipvd.
\note omniWriter must be the same instance used in PxVehiclePvdCommandResponseRegister().
@see PxVehiclePvdAttributesCreate
@see PxVehiclePvdObjectCreate
@see PxVehiclePvdCommandResponseRegister
*/
void PxVehiclePvdCommandResponseWrite
(const PxVehicleAxleDescription& axleDesc,
const PxVehicleSizedArrayData<const PxVehicleBrakeCommandResponseParams>& brakeResponseParams,
const PxVehicleSteerCommandResponseParams* steerResponseParams,
const PxVehicleAckermannParams* ackermannParams,
const PxVehicleArrayData<PxReal>& brakeResponseStates,
const PxVehicleArrayData<PxReal>& steerResponseStates,
const PxVehiclePvdAttributeHandles& attributeHandles,
const PxVehiclePvdObjectHandles& objectHandles, OmniPvdWriter& omniWriter);
/**
\brief Register object instances in omnipvd that will be used to reflect wheel attachment data such as tires, suspensions and wheels.
\param[in] axleDesc is a description of the wheels and axles of a vehicle.
\param[in] wheelParams is an array of wheel parameters.
\param[in] wheelActuationStates is an array of wheel actuation states.
\param[in] wheelRigidBody1dStates is an array of wheel rigid body states.
\param[in] wheelLocalPoses is an array of wheel local poses.
\param[in] roadGeometryStates is an array of road geometry states.
\param[in] suspParams is an array of suspension parameters.
\param[in] suspCompParams is an array of suspension compliance parameters.
\param[in] suspForceParams is an array of suspension force parameters.
\param[in] suspStates is an array of suspension states.
\param[in] suspCompStates is an array of suspension compliance states.
\param[in] suspForces is an array of suspension forces.
\param[in] tireForceParams is an array of tire force parameters.
\param[in] tireDirectionStates is an array of tire direction states.
\param[in] tireSpeedStates is an array of tire speed states.
\param[in] tireSlipStates is an array of tire slip states.
\param[in] tireStickyStates is an array of tire sticky states.
\param[in] tireGripStates is an array of tire grip states.
\param[in] tireCamberStates is an array of tire camber states.
\param[in] tireForces is an array of tire forces.
\param[in] attributeHandles contains a general description of vehicle parameters and states that will be reflected in omnipvd.
\param[in] objectHandles contains unique handles for the parameters and states of each vehicle instance.
\param[in] omniWriter is an OmniPvdWriter instance used to communicate state and parameter data to omnipvd.
\note If any array is empty, the corresponding data will not be reflected in omnipvd.
\note Each array must either be empty or contain an entry for each wheel present in axleDesc.
@see PxVehiclePvdAttributesCreate
@see PxVehiclePvdObjectCreate
@see PxVehiclePvdWheelAttachmentsWrite
*/
void PxVehiclePvdWheelAttachmentsRegister
(const PxVehicleAxleDescription& axleDesc,
const PxVehicleArrayData<const PxVehicleWheelParams>& wheelParams,
const PxVehicleArrayData<const PxVehicleWheelActuationState>& wheelActuationStates,
const PxVehicleArrayData<const PxVehicleWheelRigidBody1dState>& wheelRigidBody1dStates,
const PxVehicleArrayData<const PxVehicleWheelLocalPose>& wheelLocalPoses,
const PxVehicleArrayData<const PxVehicleRoadGeometryState>& roadGeometryStates,
const PxVehicleArrayData<const PxVehicleSuspensionParams>& suspParams,
const PxVehicleArrayData<const PxVehicleSuspensionComplianceParams>& suspCompParams,
const PxVehicleArrayData<const PxVehicleSuspensionForceParams>& suspForceParams,
const PxVehicleArrayData<const PxVehicleSuspensionState>& suspStates,
const PxVehicleArrayData<const PxVehicleSuspensionComplianceState>& suspCompStates,
const PxVehicleArrayData<const PxVehicleSuspensionForce>& suspForces,
const PxVehicleArrayData<const PxVehicleTireForceParams>& tireForceParams,
const PxVehicleArrayData<const PxVehicleTireDirectionState>& tireDirectionStates,
const PxVehicleArrayData<const PxVehicleTireSpeedState>& tireSpeedStates,
const PxVehicleArrayData<const PxVehicleTireSlipState>& tireSlipStates,
const PxVehicleArrayData<const PxVehicleTireStickyState>& tireStickyStates,
const PxVehicleArrayData<const PxVehicleTireGripState>& tireGripStates,
const PxVehicleArrayData<const PxVehicleTireCamberAngleState>& tireCamberStates,
const PxVehicleArrayData<const PxVehicleTireForce>& tireForces,
const PxVehiclePvdAttributeHandles& attributeHandles,
PxVehiclePvdObjectHandles& objectHandles, OmniPvdWriter& omniWriter);
/**
\brief Write wheel attachment data such as tire, suspension and wheel data to omnipvd.
\param[in] axleDesc is a description of the wheels and axles of a vehicle.
\param[in] wheelParams is an array of wheel parameters.
\param[in] wheelActuationStates is an array of wheel actuation states.
\param[in] wheelRigidBody1dStates is an array of wheel rigid body states.
\param[in] wheelLocalPoses is an array of wheel local poses.
\param[in] roadGeometryStates is an array of road geometry states.
\param[in] suspParams is an array of suspension parameters.
\param[in] suspCompParams is an array of suspension compliance parameters.
\param[in] suspForceParams is an array of suspension force parameters.
\param[in] suspStates is an array of suspension states.
\param[in] suspCompStates is an array of suspension compliance states.
\param[in] suspForces is an array of suspension forces.
\param[in] tireForceParams is an array of tire force parameters.
\param[in] tireDirectionStates is an array of tire direction states.
\param[in] tireSpeedStates is an array of tire speed states.
\param[in] tireSlipStates is an array of tire slip states.
\param[in] tireStickyStates is an array of tire sticky states.
\param[in] tireGripStates is an array of tire grip states.
\param[in] tireCamberStates is an array of tire camber states.
\param[in] tireForces is an array of tire forces.
\param[in] attributeHandles contains a general description of vehicle parameters and states that will be reflected in omnipvd.
\param[in] objectHandles contains unique handles for the parameters and states of each vehicle instance.
\param[in] omniWriter is an OmniPvdWriter instance used to communicate state and parameter data to omnipvd.
\note If any array is empty but the corresponding argument in PxVehiclePvdWheelAttachmentsRegister was not empty, the corresponding data will not be updated in omnipvd.
\note Each array must either be empty or contain an entry for each wheel present in axleDesc.
@see PxVehiclePvdAttributesCreate
@see PxVehiclePvdObjectCreate
@see PxVehiclePvdWheelAttachmentsRegister
*/
void PxVehiclePvdWheelAttachmentsWrite
(const PxVehicleAxleDescription& axleDesc,
const PxVehicleArrayData<const PxVehicleWheelParams>& wheelParams,
const PxVehicleArrayData<const PxVehicleWheelActuationState>& wheelActuationStates,
const PxVehicleArrayData<const PxVehicleWheelRigidBody1dState>& wheelRigidBody1dStates,
const PxVehicleArrayData<const PxVehicleWheelLocalPose>& wheelLocalPoses,
const PxVehicleArrayData<const PxVehicleRoadGeometryState>& roadGeometryStates,
const PxVehicleArrayData<const PxVehicleSuspensionParams>& suspParams,
const PxVehicleArrayData<const PxVehicleSuspensionComplianceParams>& suspCompParams,
const PxVehicleArrayData<const PxVehicleSuspensionForceParams>& suspForceParams,
const PxVehicleArrayData<const PxVehicleSuspensionState>& suspStates,
const PxVehicleArrayData<const PxVehicleSuspensionComplianceState>& suspCompStates,
const PxVehicleArrayData<const PxVehicleSuspensionForce>& suspForces,
const PxVehicleArrayData<const PxVehicleTireForceParams>& tireForceParams,
const PxVehicleArrayData<const PxVehicleTireDirectionState>& tireDirectionStates,
const PxVehicleArrayData<const PxVehicleTireSpeedState>& tireSpeedStates,
const PxVehicleArrayData<const PxVehicleTireSlipState>& tireSlipStates,
const PxVehicleArrayData<const PxVehicleTireStickyState>& tireStickyStates,
const PxVehicleArrayData<const PxVehicleTireGripState>& tireGripStates,
const PxVehicleArrayData<const PxVehicleTireCamberAngleState>& tireCamberStates,
const PxVehicleArrayData<const PxVehicleTireForce>& tireForces,
const PxVehiclePvdAttributeHandles& attributeHandles,
const PxVehiclePvdObjectHandles& objectHandles, OmniPvdWriter& omniWriter);
/**
\brief Register object instances in omnipvd that will be used to reflect the antiroll bars of a vehicle instance.
\param[in] antiRollForceParams is an array of antiroll parameters.
\param[in] antiRollTorque describes the instantaneous accumulated torque from all antiroll bas.
\param[in] attributeHandles contains a general description of vehicle parameters and states that will be reflected in omnipvd.
\param[in] objectHandles contains unique handles for the parameters and states of each vehicle instance.
\param[in] omniWriter is an OmniPvdWriter instance used to communicate state and parameter data to omnipvd.
\note If antiRollForceParams is empty, the corresponding data will not be reflected in omnipvd.
\note If antiRollTorque is NULL, the corresponding data will not be reflected in omnipvd.
@see PxVehiclePvdAttributesCreate
@see PxVehiclePvdObjectCreate
@see PxVehiclePvdAntiRollsWrite
*/
void PxVehiclePvdAntiRollsRegister
(const PxVehicleSizedArrayData<const PxVehicleAntiRollForceParams>& antiRollForceParams, const PxVehicleAntiRollTorque* antiRollTorque,
const PxVehiclePvdAttributeHandles& attributeHandles,
PxVehiclePvdObjectHandles& objectHandles, OmniPvdWriter& omniWriter);
/**
\brief Write antiroll data to omnipvd.
\param[in] antiRollForceParams is an array of antiroll parameters.
\param[in] antiRollTorque describes the instantaneous accumulated torque from all antiroll bas.
\param[in] attributeHandles contains a general description of vehicle parameters and states that will be reflected in omnipvd.
\param[in] objectHandles contains unique handles for the parameters and states of each vehicle instance.
\param[in] omniWriter is an OmniPvdWriter instance used to communicate state and parameter data to omnipvd.
\note If antiRollForceParams is empty but the corresponding argument was not empty, the corresponding data will not be updated in omnipvd.
\note If antiRollTorque is NULL but the corresponding argument was not NULL, the corresponding data will not be updated in omnipvd.
@see PxVehiclePvdAttributesCreate
@see PxVehiclePvdObjectCreate
@see PxVehiclePvdAntiRollsRegister
*/
void PxVehiclePvdAntiRollsWrite
(const PxVehicleSizedArrayData<const PxVehicleAntiRollForceParams>& antiRollForceParams, const PxVehicleAntiRollTorque* antiRollTorque,
const PxVehiclePvdAttributeHandles& attributeHandles,
const PxVehiclePvdObjectHandles& objectHandles, OmniPvdWriter& omniWriter);
/**
\brief Register object instances in omnipvd that will be used to reflect the direct drivetrain of a vehicle instance.
\param[in] commandState describes the control values applied to the vehicle.
\param[in] transmissionCommandState describes the state of the direct drive transmission.
\param[in] directDriveThrottleResponseParams describes the vehicle's torque response to a throttle command.
\param[in] directDriveThrottleResponseState is the instantaneous torque response of each wheel to a throttle command.
\param[in] attributeHandles contains a general description of vehicle parameters and states that will be reflected in omnipvd.
\param[in] objectHandles contains unique handles for the parameters and states of each vehicle instance.
\param[in] omniWriter is an OmniPvdWriter instance used to communicate state and parameter data to omnipvd.
\note If commandState is NULL, the corresponding data will not be reflected in omnipvd.
\note If transmissionCommandState is NULL, the corresponding data will not be reflected in omnipvd.
\note If directDriveThrottleResponseParams is NULL, the corresponding data will not be reflected in omnipvd.
\note If directDriveThrottleResponseState is empty, the corresponding data will not be reflected in omnipvd.
@see PxVehiclePvdAttributesCreate
@see PxVehiclePvdObjectCreate
@see PxVehiclePvdDirectDrivetrainWrite
*/
void PxVehiclePvdDirectDrivetrainRegister
(const PxVehicleCommandState* commandState, const PxVehicleDirectDriveTransmissionCommandState* transmissionCommandState,
const PxVehicleDirectDriveThrottleCommandResponseParams* directDriveThrottleResponseParams,
const PxVehicleArrayData<PxReal>& directDriveThrottleResponseState,
const PxVehiclePvdAttributeHandles& attributeHandles,
PxVehiclePvdObjectHandles& objectHandles, OmniPvdWriter& omniWriter);
/**
\brief Write direct drivetrain data to omnipvd.
\param[in] axleDesc is a description of the wheels and axles of a vehicle.
\param[in] commandState describes the control values applied to the vehicle.
\param[in] transmissionCommandState describes the state of the direct drive transmission.
\param[in] directDriveThrottleResponseParams describes the vehicle's torque response to a throttle command.
\param[in] directDriveThrottleResponseState is the instantaneous torque response of each wheel to a throttle command.
\param[in] attributeHandles contains a general description of vehicle parameters and states that will be reflected in omnipvd.
\param[in] objectHandles contains unique handles for the parameters and states of each vehicle instance.
\param[in] omniWriter is an OmniPvdWriter instance used to communicate state and parameter data to omnipvd.
\note If commandState is NULL but the corresponding entry in PxVehiclePvdDirectDrivetrainRegister() was not NULL, the corresponding data will not be updated in omnipvd.
\note If transmissionCommandState is NULL but the corresponding entry in PxVehiclePvdDirectDrivetrainRegister() was not NULL, the corresponding data will not be updated in omnipvd.
\note If directDriveThrottleResponseParams is NULL but the corresponding entry in PxVehiclePvdDirectDrivetrainRegister() was not NULL, the corresponding data will not be updated in omnipvd.
\note If directDriveThrottleResponseState is empty but the corresponding entry in PxVehiclePvdDirectDrivetrainRegister() was not empty, the corresponding data will not be updated in omnipvd.
@see PxVehiclePvdAttributesCreate
@see PxVehiclePvdObjectCreate
@see PxVehiclePvdDirectDrivetrainRegister
*/
void PxVehiclePvdDirectDrivetrainWrite
(const PxVehicleAxleDescription& axleDesc,
const PxVehicleCommandState* commandState, const PxVehicleDirectDriveTransmissionCommandState* transmissionCommandState,
const PxVehicleDirectDriveThrottleCommandResponseParams* directDriveThrottleResponseParams,
const PxVehicleArrayData<PxReal>& directDriveThrottleResponseState,
const PxVehiclePvdAttributeHandles& attributeHandles,
const PxVehiclePvdObjectHandles& objectHandles, OmniPvdWriter& omniWriter);
/**
\brief Register object instances in omnipvd that will be used to reflect the engine drivetrain of a vehicle instance.
\param[in] commandState describes the control values applied to the vehicle.
\param[in] engineDriveTransmissionCommandState describes the state of the engine drive transmission.
\param[in] tankDriveTransmissionCommandState describes the state of the tank drive transmission.
\param[in] clutchResponseParams describes the vehicle's response to a clutch command.
\param[in] clutchParams describes the vehicle's clutch.
\param[in] engineParams describes the engine.
\param[in] gearboxParams describes the gearbox.
\param[in] autoboxParams describes the automatic gearbox.
\param[in] multiWheelDiffParams describes a multiwheel differential without limited slip compensation.
\param[in] fourWheelDiffPrams describes a differential that delivers torque to four drive wheels with limited slip compensation.
\param[in] tankDiffParams describes the operation of the tank differential.
\param[in] clutchResponseState is the instantaneous reponse of the clutch to a clutch command.
\param[in] throttleResponseState is the instantaneous response to a throttle command.
\param[in] engineState is the instantaneous state of the engine.
\param[in] gearboxState is the instantaneous state of the gearbox.
\param[in] autoboxState is the instantaneous state of the automatic gearbox.
\param[in] diffState is the instantaneous state of the differential.
\param[in] clutchSlipState is the instantaneous slip recorded at the clutch.
\param[in] attributeHandles contains a general description of vehicle parameters and states that will be reflected in omnipvd.
\param[in] objectHandles contains unique handles for the parameters and states of each vehicle instance.
\param[in] omniWriter is an OmniPvdWriter instance used to communicate state and parameter data to omnipvd.
\note If any pointer is NULL, the corresponding data will not be reflected in omnipvd.
\note At most one of engineDriveTransmissionCommandState and tankDriveTransmissionCommandState is expected to be non-NULL.
\note At most one of multiWheelDiffParams, fourWheelDiffParams and tankDiffParams is expected to be non-NULL.
@see PxVehiclePvdAttributesCreate
@see PxVehiclePvdObjectCreate
@see PxVehiclePvdEngineDrivetrainWrite
*/
void PxVehiclePvdEngineDrivetrainRegister
(const PxVehicleCommandState* commandState,
const PxVehicleEngineDriveTransmissionCommandState* engineDriveTransmissionCommandState,
const PxVehicleTankDriveTransmissionCommandState* tankDriveTransmissionCommandState,
const PxVehicleClutchCommandResponseParams* clutchResponseParams,
const PxVehicleClutchParams* clutchParams,
const PxVehicleEngineParams* engineParams,
const PxVehicleGearboxParams* gearboxParams,
const PxVehicleAutoboxParams* autoboxParams,
const PxVehicleMultiWheelDriveDifferentialParams* multiWheelDiffParams,
const PxVehicleFourWheelDriveDifferentialParams* fourWheelDiffPrams,
const PxVehicleTankDriveDifferentialParams* tankDiffParams,
const PxVehicleClutchCommandResponseState* clutchResponseState,
const PxVehicleEngineDriveThrottleCommandResponseState* throttleResponseState,
const PxVehicleEngineState* engineState,
const PxVehicleGearboxState* gearboxState,
const PxVehicleAutoboxState* autoboxState,
const PxVehicleDifferentialState* diffState,
const PxVehicleClutchSlipState* clutchSlipState,
const PxVehiclePvdAttributeHandles& attributeHandles,
PxVehiclePvdObjectHandles& objectHandles, OmniPvdWriter& omniWriter);
/**
\brief Write engine drivetrain data of a vehicle instance to omnipvd.
\param[in] commandState describes the control values applied to the vehicle.
\param[in] engineDriveTransmissionCommandState describes the state of the engine drive transmission.
\param[in] tankDriveTransmissionCommandState describes the state of the tank drive transmission.
\param[in] clutchResponseParams describes the vehicle's response to a clutch command.
\param[in] clutchParams describes the vehicle's clutch.
\param[in] engineParams describes the engine.
\param[in] gearboxParams describes the gearbox.
\param[in] autoboxParams describes the automatic gearbox.
\param[in] multiWheelDiffParams describes a multiwheel differential without limited slip compensation.
\param[in] fourWheelDiffParams describes a differential that delivers torque to four drive wheels with limited slip compensation.
\param[in] tankDiffParams describes the operation of the tank differential.
\param[in] clutchResponseState is the instantaneous reponse of the clutch to a clutch command.
\param[in] throttleResponseState is the instantaneous response to a throttle command.
\param[in] engineState is the instantaneous state of the engine.
\param[in] gearboxState is the instantaneous state of the gearbox.
\param[in] autoboxState is the instantaneous state of the automatic gearbox.
\param[in] diffState is the instantaneous state of the differential.
\param[in] clutchSlipState is the instantaneous slip recorded at the clutch.
\param[in] attributeHandles contains a general description of vehicle parameters and states that will be reflected in omnipvd.
\param[in] objectHandles contains unique handles for the parameters and states of each vehicle instance.
\param[in] omniWriter is an OmniPvdWriter instance used to communicate state and parameter data to omnipvd.
\note If any pointer is NULL and the corresponding argument in PxVehiclePvdEngineDrivetrainRegister() was not NULL, the corresponding data will not be reflected in omnipvd.
\note At most one of engineDriveTransmissionCommandState and tankDriveTransmissionCommandState is expected to be non-NULL.
\note At most one of multiWheelDiffParams, fourWheelDiffParams and tankDiffParams is expected to be non-NULL.
@see PxVehiclePvdAttributesCreate
@see PxVehiclePvdObjectCreate
@see PxVehiclePvdEngineDrivetrainRegister
*/
void PxVehiclePvdEngineDrivetrainWrite
(const PxVehicleCommandState* commandState,
const PxVehicleEngineDriveTransmissionCommandState* engineDriveTransmissionCommandState,
const PxVehicleTankDriveTransmissionCommandState* tankDriveTransmissionCommandState,
const PxVehicleClutchCommandResponseParams* clutchResponseParams,
const PxVehicleClutchParams* clutchParams,
const PxVehicleEngineParams* engineParams,
const PxVehicleGearboxParams* gearboxParams,
const PxVehicleAutoboxParams* autoboxParams,
const PxVehicleMultiWheelDriveDifferentialParams* multiWheelDiffParams,
const PxVehicleFourWheelDriveDifferentialParams* fourWheelDiffParams,
const PxVehicleTankDriveDifferentialParams* tankDiffParams,
const PxVehicleClutchCommandResponseState* clutchResponseState,
const PxVehicleEngineDriveThrottleCommandResponseState* throttleResponseState,
const PxVehicleEngineState* engineState,
const PxVehicleGearboxState* gearboxState,
const PxVehicleAutoboxState* autoboxState,
const PxVehicleDifferentialState* diffState,
const PxVehicleClutchSlipState* clutchSlipState,
const PxVehiclePvdAttributeHandles& attributeHandles,
const PxVehiclePvdObjectHandles& objectHandles, OmniPvdWriter& omniWriter);
/**
\brief Register per wheel attachment data that involves the vehicle's integration with a PhysX scene.
\param[in] axleDesc is a description of the wheels and axles of a vehicle.
\param[in] physxSuspLimitConstraintParams describes the method used by PhysX to enforce suspension travel limits.
\param[in] physxMaterialFrictionParams describes the friction response of each wheel to a set of PxMaterial instances.
\param[in] physxActor describes the PxRigidActor and PxShape instances that are used to represent the vehicle's rigid body and wheel shapes in PhysX.
\param[in] physxRoadGeometryQueryParams describes the physx scene query method used to place each wheel on the ground.
\param[in] physxRoadGeomState is an array of per wheel physx scene query results.
\param[in] physxConstraintStates is an array of constraints states used by PhysX to enforce sticky tire and suspension travel limit constraints.
\param[in] attributeHandles contains a general description of vehicle parameters and states that will be reflected in omnipvd.
\param[in] objectHandles contains unique handles for the parameters and states of each vehicle instance.
\param[in] omniWriter is an OmniPvdWriter instance used to communicate state and parameter data to omnipvd.
\note If any array is empty, the corresponding data will not be reflected in omnipvd.
\note If physxActor is NULL, the corresponding data will not be reflected in omnipvd.
\note If physxRoadGeometryQueryParams is NULL, the corresponding data will not be reflected in omnipvd.
\note Each array must either be empty or contain an entry for each wheel present in axleDesc.
@see PxVehiclePvdAttributesCreate
@see PxVehiclePvdObjectCreate
@see PxVehiclePvdPhysXWheelAttachmentWrite
*/
void PxVehiclePvdPhysXWheelAttachmentRegister
(const PxVehicleAxleDescription& axleDesc,
const PxVehicleArrayData<const PxVehiclePhysXSuspensionLimitConstraintParams>& physxSuspLimitConstraintParams,
const PxVehicleArrayData<const PxVehiclePhysXMaterialFrictionParams>& physxMaterialFrictionParams,
const PxVehiclePhysXActor* physxActor, const PxVehiclePhysXRoadGeometryQueryParams* physxRoadGeometryQueryParams,
const PxVehicleArrayData<const PxVehiclePhysXRoadGeometryQueryState>& physxRoadGeomState,
const PxVehicleArrayData<const PxVehiclePhysXConstraintState>& physxConstraintStates,
const PxVehiclePvdAttributeHandles& attributeHandles,
PxVehiclePvdObjectHandles& objectHandles, OmniPvdWriter& omniWriter);
/**
\brief Write to omnipvd the per wheel attachment data that involves the vehicle's integration with a PhysX scene.
\param[in] axleDesc is a description of the wheels and axles of a vehicle.
\param[in] physxSuspLimitConstraintParams describes the method used by PhysX to enforce suspension travel limits.
\param[in] physxMaterialFrictionParams describes the friction response of each wheel to a set of PxMaterial instances.
\param[in] physxActor describes the PxShape instances that are used to represent the vehicle's wheel shapes in PhysX.
\param[in] physxRoadGeometryQueryParams describes the physx scene query method used to place each wheel on the ground.
\param[in] physxRoadGeomState is an array of per wheel physx scene query results.
\param[in] physxConstraintStates is an array of constraints states used by PhysX to enforce sticky tire and suspension travel limit constraints.
\param[in] attributeHandles contains a general description of vehicle parameters and states that will be reflected in omnipvd.
\param[in] objectHandles contains unique handles for the parameters and states of each vehicle instance.
\param[in] omniWriter is an OmniPvdWriter instance used to communicate state and parameter data to omnipvd.
\note If any array is empty but the corresponding array in PxVehiclePvdPhysXWheelAttachmentRegister() was not empty, the corresponding data will not be updated in omnipvd.
\note If physxActor is NULL but the corresponding argument in PxVehiclePvdPhysXWheelAttachmentRegister was not NULL, the corresponding data will not be reflected in omnipvd.
\note If physxRoadGeometryQueryParams is NULL but the corresponding argument in PxVehiclePvdPhysXWheelAttachmentRegister was not NULL, the corresponding data will not be reflected in omnipvd.
\note Each array must either be empty or contain an entry for each wheel present in axleDesc.
@see PxVehiclePvdAttributesCreate
@see PxVehiclePvdObjectCreate
@see PxVehiclePvdPhysXWheelAttachmentWrite
*/
void PxVehiclePvdPhysXWheelAttachmentWrite
(const PxVehicleAxleDescription& axleDesc,
const PxVehicleArrayData<const PxVehiclePhysXSuspensionLimitConstraintParams>& physxSuspLimitConstraintParams,
const PxVehicleArrayData<const PxVehiclePhysXMaterialFrictionParams>& physxMaterialFrictionParams,
const PxVehiclePhysXActor* physxActor, const PxVehiclePhysXRoadGeometryQueryParams* physxRoadGeometryQueryParams,
const PxVehicleArrayData<const PxVehiclePhysXRoadGeometryQueryState>& physxRoadGeomState,
const PxVehicleArrayData<const PxVehiclePhysXConstraintState>& physxConstraintStates,
const PxVehiclePvdAttributeHandles& attributeHandles,
const PxVehiclePvdObjectHandles& objectHandles, OmniPvdWriter& omniWriter);
/**
\brief Register the PxRigidActor instance that represents the vehicle's rigid body in a PhysX scene.
\param[in] physxActor describes the PxRigidActor instance that is used to represent the vehicle's rigid body in PhysX.
\param[in] attributeHandles contains a general description of vehicle parameters and states that will be reflected in omnipvd.
\param[in] objectHandles contains unique handles for the parameters and states of each vehicle instance.
\param[in] omniWriter is an OmniPvdWriter instance used to communicate state and parameter data to omnipvd.
\note If physxActor is NULL, the corresponding data will not be reflected in omnipvd.
@see PxVehiclePvdAttributesCreate
@see PxVehiclePvdObjectCreate
@see PxVehiclePvdPhysXRigidActorWrite
*/
void PxVehiclePvdPhysXRigidActorRegister
(const PxVehiclePhysXActor* physxActor,
const PxVehiclePvdAttributeHandles& attributeHandles,
PxVehiclePvdObjectHandles& objectHandles, OmniPvdWriter& omniWriter);
/**
\brief Write the PxRigidActor instance to omnipvd.
\param[in] physxActor describes the PxRigidActor instance that is used to represent the vehicle's rigid body in PhysX.
\param[in] attributeHandles contains a general description of vehicle parameters and states that will be reflected in omnipvd.
\param[in] objectHandles contains unique handles for the parameters and states of each vehicle instance.
\param[in] omniWriter is an OmniPvdWriter instance used to communicate state and parameter data to omnipvd.
\note If physxActor is NULL and the corresponding argument in PxVehiclePvdPhysXRigidActorRegister was not NULL, the corresponding data will not be updated in omnipvd.
@see PxVehiclePvdAttributesCreate
@see PxVehiclePvdObjectCreate
@see PxVehiclePvdPhysXRigidActorRegister
*/
void PxVehiclePvdPhysXRigidActorWrite
(const PxVehiclePhysXActor* physxActor,
const PxVehiclePvdAttributeHandles& attributeHandles,
const PxVehiclePvdObjectHandles& objectHandles, OmniPvdWriter& omniWriter);
/**
\brief Register the PhysX related steer state class.
\param[in] physxSteerState describes the PxVehiclePhysXSteerState instance that holds steer related state information.
\param[in] attributeHandles contains a general description of vehicle parameters and states that will be reflected in omnipvd.
\param[in] objectHandles contains unique handles for the parameters and states of each vehicle instance.
\param[in] omniWriter is an OmniPvdWriter instance used to communicate state and parameter data to omnipvd.
\note If physxSteerState is NULL, the corresponding data will not be reflected in omnipvd.
@see PxVehiclePvdAttributesCreate
@see PxVehiclePvdObjectCreate
@see PxVehiclePvdPhysXSteerStateWrite
*/
void PxVehiclePvdPhysXSteerStateRegister
(const PxVehiclePhysXSteerState* physxSteerState,
const PxVehiclePvdAttributeHandles& attributeHandles,
PxVehiclePvdObjectHandles& objectHandles, OmniPvdWriter& omniWriter);
/**
\brief Write the PxVehiclePhysXSteerState instance to omnipvd.
\param[in] physxSteerState describes the PxVehiclePhysXSteerState instance that holds steer related state information.
\param[in] attributeHandles contains a general description of vehicle parameters and states that will be reflected in omnipvd.
\param[in] objectHandles contains unique handles for the parameters and states of each vehicle instance.
\param[in] omniWriter is an OmniPvdWriter instance used to communicate state and parameter data to omnipvd.
\note If physxSteerState is NULL and the corresponding argument in PxVehiclePvdPhysXSteerStateRegister was not NULL, the corresponding data will not be updated in omnipvd.
@see PxVehiclePvdAttributesCreate
@see PxVehiclePvdObjectCreate
@see PxVehiclePvdPhysXSteerStateRegister
*/
void PxVehiclePvdPhysXSteerStateWrite
(const PxVehiclePhysXSteerState* physxSteerState,
const PxVehiclePvdAttributeHandles& attributeHandles,
const PxVehiclePvdObjectHandles& objectHandles, OmniPvdWriter& omniWriter);
#if !PX_DOXYGEN
} // namespace vehicle2
} // namespace physx
#endif
/** @} */
| 42,550 | C | 65.589984 | 192 | 0.842374 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle2/pvd/PxVehiclePvdHelpers.h | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#pragma once
/** \addtogroup vehicle2
@{
*/
#include "foundation/PxSimpleTypes.h"
class OmniPvdWriter;
namespace physx
{
class PxAllocatorCallback;
namespace vehicle2
{
struct PxVehiclePvdAttributeHandles;
struct PxVehiclePvdObjectHandles;
}
}
#if !PX_DOXYGEN
namespace physx
{
namespace vehicle2
{
#endif
/**
\brief Create the attribute handles necessary to reflect vehicles in omnipvd.
\param[in] allocator is used to allocate the memory used to store the attribute handles.
\param[in] omniWriter is used to register the attribute handles with omnipvd.
@see PxVehicleSimulationContext
@see PxVehiclePVDComponent
@see PxVehiclePvdAttributesRelease
*/
PxVehiclePvdAttributeHandles* PxVehiclePvdAttributesCreate
(PxAllocatorCallback& allocator, OmniPvdWriter& omniWriter);
/**
\brief Destory the attribute handles created by PxVehiclePvdAttributesCreate().
\param[in] allocator must be the instance used by PxVehiclePvdObjectCreate().
\param[in] attributeHandles is the PxVehiclePvdAttributeHandles created by PxVehiclePvdAttributesCreate().
@see PxVehiclePvdAttributesCreate
*/
void PxVehiclePvdAttributesRelease
(PxAllocatorCallback& allocator, PxVehiclePvdAttributeHandles& attributeHandles);
/**
\brief Create omnipvd objects that will be used to reflect an individual veicle in omnipvd.
\param[in] nbWheels must be greater than or equal to the number of wheels on the vehicle.
\param[in] nbAntirolls must be greater than or equal to the number of antiroll bars on the vehicle.
\param[in] maxNbPhysxMaterialFrictions must be greater than or equal to the number of PxPhysXMaterialFriction instances associated with any wheel of the vehicle.
\param[in] contextHandle is typically used to associated vehicles with a particular scene or group.
\param[in] allocator is used to allocate the memory used to store handles to the created omnipvd objects.
\note PxVehiclePvdObjectCreate() must be called after PxVehiclePvdAttributesCreate().
@see PxVehicleAxleDescription
@see PxVehicleAntiRollForceParams
@see PxVehiclePhysXMaterialFrictionParams
@see PxVehiclePVDComponent
@see PxVehiclePvdAttributesCreate
*/
PxVehiclePvdObjectHandles* PxVehiclePvdObjectCreate
(const PxU32 nbWheels, const PxU32 nbAntirolls, const PxU32 maxNbPhysxMaterialFrictions,
const PxU64 contextHandle, PxAllocatorCallback& allocator);
/**
\brief Destroy the PxVehiclePvdObjectHandles instance created by PxVehiclePvdObjectCreate().
\param[in] omniWriter is used to register the attribute handles with omnipvd.
\param[in] allocator must be the instance used by PxVehiclePvdObjectCreate().
\param[in] objectHandles is the PxVehiclePvdObjectHandles that was created by PxVehiclePvdObjectCreate().
*/
void PxVehiclePvdObjectRelease
(OmniPvdWriter& omniWriter, PxAllocatorCallback& allocator, PxVehiclePvdObjectHandles& objectHandles);
#if !PX_DOXYGEN
} // namespace vehicle2
} // namespace physx
#endif
/** @} */
| 4,592 | C | 41.527777 | 161 | 0.802918 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle2/pvd/PxVehiclePvdComponents.h | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#pragma once
/** \addtogroup vehicle2
@{
*/
#include "vehicle2/PxVehicleComponent.h"
#include "vehicle2/PxVehicleParams.h"
#include "PxVehiclePvdFunctions.h"
#if !PX_DOXYGEN
namespace physx
{
namespace vehicle2
{
#endif
#define VEHICLE_FLOAT_ARRAY_DATA(b) PxVehicleArrayData<PxReal> b; b.setEmpty();
#define VEHICLE_ARRAY_DATA(a, b) PxVehicleArrayData<const a> b; b.setEmpty();
#define VEHICLE_SIZED_ARRAY_DATA(a, b) PxVehicleSizedArrayData<const a> b; b.setEmpty();
class PxVehiclePVDComponent : public PxVehicleComponent
{
public:
PxVehiclePVDComponent() : PxVehicleComponent() , firstTime(true) {}
virtual ~PxVehiclePVDComponent() {}
virtual void getDataForPVDComponent(
const PxVehicleAxleDescription*& axleDescription,
const PxVehicleRigidBodyParams*& rbodyParams, const PxVehicleRigidBodyState*& rbodyState,
const PxVehicleSuspensionStateCalculationParams*& suspStateCalcParams,
PxVehicleSizedArrayData<const PxVehicleBrakeCommandResponseParams>& brakeResponseParams,
const PxVehicleSteerCommandResponseParams*& steerResponseParams,
const PxVehicleAckermannParams*& ackermannParams,
PxVehicleArrayData<PxReal>& brakeResponseStates,
PxVehicleArrayData<PxReal>& steerResponseStates,
PxVehicleArrayData<const PxVehicleWheelParams>& wheelParams,
PxVehicleArrayData<const PxVehicleWheelActuationState>& wheelActuationStates,
PxVehicleArrayData<const PxVehicleWheelRigidBody1dState>& wheelRigidBody1dStates,
PxVehicleArrayData<const PxVehicleWheelLocalPose>& wheelLocalPoses,
PxVehicleArrayData<const PxVehicleRoadGeometryState>& roadGeomStates,
PxVehicleArrayData<const PxVehicleSuspensionParams>& suspParams,
PxVehicleArrayData<const PxVehicleSuspensionComplianceParams>& suspCompParams,
PxVehicleArrayData<const PxVehicleSuspensionForceParams>& suspForceParams,
PxVehicleArrayData<const PxVehicleSuspensionState>& suspStates,
PxVehicleArrayData<const PxVehicleSuspensionComplianceState>& suspCompStates,
PxVehicleArrayData<const PxVehicleSuspensionForce>& suspForces,
PxVehicleArrayData<const PxVehicleTireForceParams>& tireForceParams,
PxVehicleArrayData<const PxVehicleTireDirectionState>& tireDirectionStates,
PxVehicleArrayData<const PxVehicleTireSpeedState>& tireSpeedStates,
PxVehicleArrayData<const PxVehicleTireSlipState>& tireSlipStates,
PxVehicleArrayData<const PxVehicleTireStickyState>& tireStickyStates,
PxVehicleArrayData<const PxVehicleTireGripState>& tireGripStates,
PxVehicleArrayData<const PxVehicleTireCamberAngleState>& tireCamberStates,
PxVehicleArrayData<const PxVehicleTireForce>& tireForces,
PxVehicleSizedArrayData<const PxVehicleAntiRollForceParams>& antiRollForceParams,
const PxVehicleAntiRollTorque*& antiRollTorque,
const PxVehicleCommandState*& commandState,
const PxVehicleDirectDriveThrottleCommandResponseParams*& directDriveThrottleResponseParams,
const PxVehicleDirectDriveTransmissionCommandState*& directDriveTransmissionState,
PxVehicleArrayData<PxReal>& directDrivethrottleResponseState,
const PxVehicleClutchCommandResponseParams*& clutchResponseParams,
const PxVehicleClutchParams*& clutchParams,
const PxVehicleEngineParams*& engineParams,
const PxVehicleGearboxParams*& gearboxParams,
const PxVehicleAutoboxParams*& autoboxParams,
const PxVehicleMultiWheelDriveDifferentialParams*& multiWheelDiffParams,
const PxVehicleFourWheelDriveDifferentialParams*& fourWheelDiffParams,
const PxVehicleTankDriveDifferentialParams*& tankDiffParams,
const PxVehicleEngineDriveTransmissionCommandState*& engineDriveTransmissionState,
const PxVehicleTankDriveTransmissionCommandState*& tankDriveTransmissionState,
const PxVehicleClutchCommandResponseState*& clutchResponseState,
const PxVehicleEngineDriveThrottleCommandResponseState*& engineDriveThrottleResponseState,
const PxVehicleEngineState*& engineState,
const PxVehicleGearboxState*& gearboxState,
const PxVehicleAutoboxState*& autoboxState,
const PxVehicleDifferentialState*& diffState,
const PxVehicleClutchSlipState*& clutchSlipState,
PxVehicleArrayData<const PxVehiclePhysXSuspensionLimitConstraintParams>& physxConstraintParams,
PxVehicleArrayData<const PxVehiclePhysXMaterialFrictionParams>& physxMaterialFrictionParams,
const PxVehiclePhysXActor*& physxActor,
const PxVehiclePhysXRoadGeometryQueryParams*& physxRoadGeomQryParams,
PxVehicleArrayData<const PxVehiclePhysXRoadGeometryQueryState>& physxRoadGeomStates,
PxVehicleArrayData<const PxVehiclePhysXConstraintState>& physxConstraintStates,
const PxVehiclePhysXSteerState*& physxSteerState,
PxVehiclePvdObjectHandles*& objectHandles) = 0;
virtual bool update(const PxReal dt, const PxVehicleSimulationContext& context)
{
PX_UNUSED(dt);
PX_UNUSED(context);
OmniPvdWriter* pvdWriter = context.pvdContext.writer;
if(!context.pvdContext.attributeHandles || !pvdWriter)
return true;
const PxVehicleAxleDescription* axleDesc = NULL;
const PxVehicleRigidBodyParams* rbodyParams = NULL;
const PxVehicleRigidBodyState* rbodyState = NULL;
const PxVehicleSuspensionStateCalculationParams* suspStateCalcParams = NULL;
VEHICLE_SIZED_ARRAY_DATA(PxVehicleBrakeCommandResponseParams, brakeResponseParams);
const PxVehicleSteerCommandResponseParams* steerResponseParams = NULL;
const PxVehicleAckermannParams* ackermannParams = NULL;
VEHICLE_FLOAT_ARRAY_DATA(brakeResponseStates);
VEHICLE_FLOAT_ARRAY_DATA(steerResponseStates);
VEHICLE_ARRAY_DATA(PxVehicleWheelParams, wheelParams);
VEHICLE_ARRAY_DATA(PxVehicleWheelActuationState, wheelActuationStates);
VEHICLE_ARRAY_DATA(PxVehicleWheelRigidBody1dState, wheelRigidBody1dStates);
VEHICLE_ARRAY_DATA(PxVehicleWheelLocalPose, wheelLocalPoses);
VEHICLE_ARRAY_DATA(PxVehicleRoadGeometryState, roadGeomStates);
VEHICLE_ARRAY_DATA(PxVehicleSuspensionParams, suspParams);
VEHICLE_ARRAY_DATA(PxVehicleSuspensionComplianceParams, suspComplianceParams);
VEHICLE_ARRAY_DATA(PxVehicleSuspensionForceParams, suspForceParams);
VEHICLE_ARRAY_DATA(PxVehicleSuspensionState, suspStates);
VEHICLE_ARRAY_DATA(PxVehicleSuspensionComplianceState, suspComplianceStates);
VEHICLE_ARRAY_DATA(PxVehicleSuspensionForce, suspForces);
VEHICLE_ARRAY_DATA(PxVehicleTireForceParams, tireForceParams);
VEHICLE_ARRAY_DATA(PxVehicleTireDirectionState, tireDirectionStates);
VEHICLE_ARRAY_DATA(PxVehicleTireSpeedState, tireSpeedStates);
VEHICLE_ARRAY_DATA(PxVehicleTireSlipState, tireSlipStates);
VEHICLE_ARRAY_DATA(PxVehicleTireStickyState, tireStickyStates);
VEHICLE_ARRAY_DATA(PxVehicleTireGripState, tireGripStates);
VEHICLE_ARRAY_DATA(PxVehicleTireCamberAngleState, tireCamberStates);
VEHICLE_ARRAY_DATA(PxVehicleTireForce, tireForces);
VEHICLE_SIZED_ARRAY_DATA(PxVehicleAntiRollForceParams, antiRollParams);
const PxVehicleAntiRollTorque* antiRollTorque = NULL;
const PxVehicleCommandState* commandState = NULL;
const PxVehicleDirectDriveThrottleCommandResponseParams* directDriveThrottleResponseParams = NULL;
const PxVehicleDirectDriveTransmissionCommandState* directDriveTransmissionState = NULL;
VEHICLE_FLOAT_ARRAY_DATA(directDrivethrottleResponseState);
const PxVehicleClutchCommandResponseParams* clutchResponseParams = NULL;
const PxVehicleClutchParams* clutchParams = NULL;
const PxVehicleEngineParams* engineParams = NULL;
const PxVehicleGearboxParams* gearboxParams = NULL;
const PxVehicleAutoboxParams* autoboxParams = NULL;
const PxVehicleMultiWheelDriveDifferentialParams* multiWheelDiffParams = NULL;
const PxVehicleFourWheelDriveDifferentialParams* fourWheelDiffParams = NULL;
const PxVehicleTankDriveDifferentialParams* tankDiffParams = NULL;
const PxVehicleEngineDriveTransmissionCommandState* engineDriveTransmissionCommandState = NULL;
const PxVehicleTankDriveTransmissionCommandState* tankDriveTransmissionCommandState = NULL;
const PxVehicleClutchCommandResponseState* clutchResponseState = NULL;
const PxVehicleEngineDriveThrottleCommandResponseState* throttleResponseState = NULL;
const PxVehicleEngineState* engineState = NULL;
const PxVehicleGearboxState* gearboxState = NULL;
const PxVehicleAutoboxState* autoboxState = NULL;
const PxVehicleDifferentialState* diffState = NULL;
const PxVehicleClutchSlipState* clutchSlipState = NULL;
VEHICLE_ARRAY_DATA(PxVehiclePhysXSuspensionLimitConstraintParams, physxConstraintParams);
VEHICLE_ARRAY_DATA(PxVehiclePhysXMaterialFrictionParams, physxMaterialFrictionParams);
const PxVehiclePhysXActor* physxActor = NULL;
const PxVehiclePhysXRoadGeometryQueryParams* physxRoadGeomQryParams = NULL;
VEHICLE_ARRAY_DATA(PxVehiclePhysXRoadGeometryQueryState, physxRoadGeomStates);
VEHICLE_ARRAY_DATA(PxVehiclePhysXConstraintState, physxConstraintStates);
const PxVehiclePhysXSteerState* physxSteerState = NULL;
PxVehiclePvdObjectHandles* omniPvdObjectHandles = NULL;
getDataForPVDComponent(
axleDesc,
rbodyParams, rbodyState,
suspStateCalcParams,
brakeResponseParams, steerResponseParams, ackermannParams,
brakeResponseStates, steerResponseStates,
wheelParams,
wheelActuationStates, wheelRigidBody1dStates, wheelLocalPoses,
roadGeomStates,
suspParams, suspComplianceParams, suspForceParams,
suspStates, suspComplianceStates,
suspForces,
tireForceParams,
tireDirectionStates, tireSpeedStates, tireSlipStates, tireStickyStates, tireGripStates, tireCamberStates,
tireForces,
antiRollParams, antiRollTorque,
commandState,
directDriveThrottleResponseParams, directDriveTransmissionState, directDrivethrottleResponseState,
clutchResponseParams, clutchParams, engineParams, gearboxParams, autoboxParams,
multiWheelDiffParams, fourWheelDiffParams, tankDiffParams,
engineDriveTransmissionCommandState, tankDriveTransmissionCommandState,
clutchResponseState, throttleResponseState, engineState, gearboxState, autoboxState, diffState, clutchSlipState,
physxConstraintParams, physxMaterialFrictionParams,
physxActor, physxRoadGeomQryParams, physxRoadGeomStates, physxConstraintStates, physxSteerState,
omniPvdObjectHandles);
if(!omniPvdObjectHandles)
return true;
if(firstTime)
{
PxVehiclePvdRigidBodyRegister(
rbodyParams, rbodyState,
*context.pvdContext.attributeHandles, *omniPvdObjectHandles, *pvdWriter);
PxVehiclePvdSuspensionStateCalculationParamsRegister(
suspStateCalcParams,
*context.pvdContext.attributeHandles, *omniPvdObjectHandles, *pvdWriter);
PxVehiclePvdCommandResponseRegister(
brakeResponseParams, steerResponseParams, ackermannParams,
brakeResponseStates, steerResponseStates,
*context.pvdContext.attributeHandles, *omniPvdObjectHandles, *pvdWriter);
PxVehiclePvdWheelAttachmentsRegister(
*axleDesc,
wheelParams, wheelActuationStates, wheelRigidBody1dStates, wheelLocalPoses,
roadGeomStates,
suspParams, suspComplianceParams, suspForceParams, suspStates, suspComplianceStates,
suspForces,
tireForceParams,
tireDirectionStates, tireSpeedStates, tireSlipStates, tireStickyStates, tireGripStates, tireCamberStates,
tireForces,
*context.pvdContext.attributeHandles, *omniPvdObjectHandles, *pvdWriter);
PxVehiclePvdAntiRollsRegister(
antiRollParams, antiRollTorque,
*context.pvdContext.attributeHandles, *omniPvdObjectHandles, *pvdWriter);
if (engineParams)
{
PxVehiclePvdEngineDrivetrainRegister(
commandState, engineDriveTransmissionCommandState, tankDriveTransmissionCommandState,
clutchResponseParams, clutchParams, engineParams, gearboxParams, autoboxParams,
multiWheelDiffParams, fourWheelDiffParams, tankDiffParams,
clutchResponseState, throttleResponseState, engineState, gearboxState, autoboxState, diffState, clutchSlipState,
*context.pvdContext.attributeHandles, *omniPvdObjectHandles, *pvdWriter);
}
else
{
PxVehiclePvdDirectDrivetrainRegister(
commandState, directDriveTransmissionState,
directDriveThrottleResponseParams,
directDrivethrottleResponseState,
*context.pvdContext.attributeHandles, *omniPvdObjectHandles, *pvdWriter);
}
PxVehiclePvdPhysXWheelAttachmentRegister(
*axleDesc,
physxConstraintParams, physxMaterialFrictionParams,
physxActor, physxRoadGeomQryParams, physxRoadGeomStates, physxConstraintStates,
*context.pvdContext.attributeHandles, *omniPvdObjectHandles, *pvdWriter);
PxVehiclePvdPhysXRigidActorRegister(
physxActor,
*context.pvdContext.attributeHandles, *omniPvdObjectHandles, *pvdWriter);
PxVehiclePvdPhysXSteerStateRegister(
physxSteerState,
*context.pvdContext.attributeHandles, *omniPvdObjectHandles, *pvdWriter);
firstTime = false;
}
PxVehiclePvdRigidBodyWrite(
rbodyParams, rbodyState,
*context.pvdContext.attributeHandles, *omniPvdObjectHandles, *pvdWriter);
PxVehiclePvdSuspensionStateCalculationParamsWrite(
suspStateCalcParams,
*context.pvdContext.attributeHandles, *omniPvdObjectHandles, *pvdWriter);
PxVehiclePvdCommandResponseWrite(
*axleDesc, brakeResponseParams, steerResponseParams, ackermannParams,
brakeResponseStates, steerResponseStates,
*context.pvdContext.attributeHandles, *omniPvdObjectHandles, *pvdWriter);
PxVehiclePvdWheelAttachmentsWrite(
*axleDesc,
wheelParams, wheelActuationStates, wheelRigidBody1dStates, wheelLocalPoses,
roadGeomStates,
suspParams, suspComplianceParams, suspForceParams, suspStates, suspComplianceStates,
suspForces,
tireForceParams,
tireDirectionStates, tireSpeedStates, tireSlipStates, tireStickyStates, tireGripStates, tireCamberStates,
tireForces,
*context.pvdContext.attributeHandles, *omniPvdObjectHandles, *pvdWriter);
PxVehiclePvdAntiRollsWrite(
antiRollParams, antiRollTorque,
*context.pvdContext.attributeHandles, *omniPvdObjectHandles, *pvdWriter);
if (engineParams)
{
PxVehiclePvdEngineDrivetrainWrite(
commandState, engineDriveTransmissionCommandState, tankDriveTransmissionCommandState,
clutchResponseParams, clutchParams, engineParams, gearboxParams, autoboxParams,
multiWheelDiffParams, fourWheelDiffParams, tankDiffParams,
clutchResponseState, throttleResponseState, engineState, gearboxState, autoboxState, diffState, clutchSlipState,
*context.pvdContext.attributeHandles, *omniPvdObjectHandles, *pvdWriter);
}
else
{
PxVehiclePvdDirectDrivetrainWrite(
*axleDesc,
commandState, directDriveTransmissionState,
directDriveThrottleResponseParams,
directDrivethrottleResponseState,
*context.pvdContext.attributeHandles, *omniPvdObjectHandles, *pvdWriter);
}
PxVehiclePvdPhysXWheelAttachmentWrite(
*axleDesc,
physxConstraintParams, physxMaterialFrictionParams,
physxActor, physxRoadGeomQryParams, physxRoadGeomStates, physxConstraintStates,
*context.pvdContext.attributeHandles, *omniPvdObjectHandles, *pvdWriter);
PxVehiclePvdPhysXRigidActorWrite(
physxActor,
*context.pvdContext.attributeHandles, *omniPvdObjectHandles, *pvdWriter);
PxVehiclePvdPhysXSteerStateWrite(
physxSteerState,
*context.pvdContext.attributeHandles, *omniPvdObjectHandles, *pvdWriter);
return true;
}
private:
bool firstTime;
};
#if !PX_DOXYGEN
} // namespace vehicle2
} // namespace physx
#endif
/** @} */
| 16,980 | C | 46.699438 | 117 | 0.824912 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle2/steering/PxVehicleSteeringFunctions.h | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#pragma once
/** \addtogroup vehicle2
@{
*/
#include "foundation/PxPreprocessor.h"
#include "foundation/PxSimpleTypes.h"
#include "vehicle2/PxVehicleParams.h"
#include "PxVehicleSteeringParams.h"
#if !PX_DOXYGEN
namespace physx
{
namespace vehicle2
{
#endif
struct PxVehicleCommandState;
/**
\brief Compute the yaw angle response to a steer command.
\param[in] steer is the input steer command value.
\param[in] longitudinalSpeed is the longitudinal speed of the vehicle.
\param[in] wheelId specifies the wheel to have its steer response computed.
\param[in] steerResponseParmas specifies the per wheel yaw angle response to the steer command as a nonlinear function of steer command and longitudinal speed.
\param[out] steerResponseState is the yaw angle response to the input steer command.
*/
void PxVehicleSteerCommandResponseUpdate
(const PxReal steer, const PxReal longitudinalSpeed,
const PxU32 wheelId, const PxVehicleSteerCommandResponseParams& steerResponseParmas,
PxReal& steerResponseState);
/**
\brief Account for Ackermann correction by modifying the per wheel steer response multipliers to engineer an asymmetric steer response across axles.
\param[in] steer is the input steer command value.
\param[in] steerResponseParmas describes the maximum response and a response multiplier per axle.
\param[in] ackermannParams is an array that describes the wheels affected by Ackerman steer correction.
\param[in,out] steerResponseStates contains the corrected per wheel steer response multipliers that take account of Ackermann steer correction.
*/
void PxVehicleAckermannSteerUpdate
(const PxReal steer, const PxVehicleSteerCommandResponseParams& steerResponseParmas,
const PxVehicleSizedArrayData<const PxVehicleAckermannParams>& ackermannParams,
PxVehicleArrayData<PxReal>& steerResponseStates);
#if !PX_DOXYGEN
} // namespace vehicle2
} // namespace physx
#endif
/** @} */
| 3,599 | C | 43.444444 | 159 | 0.789664 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle2/steering/PxVehicleSteeringParams.h | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#pragma once
/** \addtogroup vehicle2
@{
*/
#include "foundation/PxFoundation.h"
#include "vehicle2/PxVehicleParams.h"
#include "vehicle2/commands/PxVehicleCommandParams.h"
#if !PX_DOXYGEN
namespace physx
{
namespace vehicle2
{
#endif
struct PxVehicleFrame;
struct PxVehicleScale;
/**
\brief Distribute a steer response to the wheels of a vehicle.
\note The steer angle applied to each wheel on the ith wheel is steerCommand * maxResponse * wheelResponseMultipliers[i].
\note A typical use case is to set maxResponse to be the vehicle's maximum achievable steer angle
that occurs when the steer command is equal to 1.0. The array wheelResponseMultipliers[i] would then be used
to specify the maximum achievable steer angle per wheel as a fractional multiplier of the vehicle's maximum achievable steer angle.
*/
struct PxVehicleSteerCommandResponseParams : public PxVehicleCommandResponseParams
{
PX_FORCE_INLINE PxVehicleSteerCommandResponseParams transformAndScale(
const PxVehicleFrame& srcFrame, const PxVehicleFrame& trgFrame, const PxVehicleScale& srcScale, const PxVehicleScale& trgScale) const
{
PX_UNUSED(srcFrame);
PX_UNUSED(trgFrame);
PX_UNUSED(srcScale);
PX_UNUSED(trgScale);
return *this;
}
PX_FORCE_INLINE bool isValid(const PxVehicleAxleDescription& axleDesc) const
{
if (!axleDesc.isValid())
return false;
for (PxU32 i = 0; i < axleDesc.nbWheels; i++)
{
PX_CHECK_AND_RETURN_VAL(PxAbs(maxResponse*wheelResponseMultipliers[axleDesc.wheelIdsInAxleOrder[i]]) <= PxPi,
"PxVehicleSteerCommandResponseParams.maxResponse*PxVehicleSteerCommandResponseParams.wheelResponseMultipliers[i] must be in range [-Pi, Pi]", false);
}
return true;
}
};
/**
\brief A description of a single axle that is to be affected by Ackermann steer correction.
*/
struct PxVehicleAckermannParams
{
PxU32 wheelIds[2]; //!< wheelIds[0] is the id of the wheel that is negative along the lateral axis, wheelIds[1] is the wheel id that is positive along the lateral axis.
PxReal wheelBase; //!< wheelBase is the longitudinal distance between the axle that is affected by Ackermann correction and a reference axle.
PxReal trackWidth; //!< trackWidth is the width of the axle specified by #wheelIds
PxReal strength; //!< is the strength of the correction with 0 denoting no correction and 1 denoting perfect correction.
PX_FORCE_INLINE bool isValid(const PxVehicleAxleDescription& axleDesc) const
{
PX_CHECK_AND_RETURN_VAL(0.0f == strength || wheelIds[0] < axleDesc.getNbWheels(), "PxVehicleAckermannParams.wheelIds[0] must be valid wheel", false);
PX_CHECK_AND_RETURN_VAL(0.0f == strength || wheelIds[1] < axleDesc.getNbWheels(), "PxVehicleAckermannParams.wheelIds[1] must be a valid wheel", false);
PX_CHECK_AND_RETURN_VAL(0.0f == strength || wheelIds[0] != wheelIds[1], "PxVehicleAckermannParams.wheelIds[0] and PxVehicleAckermannParams.wheelIds[1] must reference two different wheels", false);
PX_CHECK_AND_RETURN_VAL(0.0f == strength || wheelBase > 0.0f, "PxVehicleAckermannParams.wheelBase must be greater than zero", false);
PX_CHECK_AND_RETURN_VAL(0.0f == strength || trackWidth > 0.0f, "PxVehicleAckermannParams.trackWidth must be greater than zero", false);
PX_CHECK_AND_RETURN_VAL(strength >= 0.0f && strength <= 1.0f, "PxVehicleAckermannParams.strength must be in range [0,1]", false);
PX_UNUSED(axleDesc);
return true;
}
PX_FORCE_INLINE PxVehicleAckermannParams transformAndScale(
const PxVehicleFrame& srcFrame, const PxVehicleFrame& trgFrame, const PxVehicleScale& srcScale, const PxVehicleScale& trgScale) const
{
PX_UNUSED(srcFrame);
PX_UNUSED(trgFrame);
PxVehicleAckermannParams r = *this;
const PxReal scale = trgScale.scale / srcScale.scale;
r.wheelBase *= scale;
r.trackWidth *= scale;
return r;
}
};
#if !PX_DOXYGEN
} // namespace vehicle2
} // namespace physx
#endif
/** @} */
| 5,575 | C | 44.333333 | 198 | 0.763408 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle2/commands/PxVehicleCommandStates.h | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#pragma once
/** \addtogroup vehicle2
@{
*/
#include "foundation/PxPreprocessor.h"
#include "foundation/PxSimpleTypes.h"
#include "foundation/PxMemory.h"
#include "vehicle2/PxVehicleLimits.h"
#if !PX_DOXYGEN
namespace physx
{
namespace vehicle2
{
#endif
/**
\brief A description of the state of commands that are applied to the vehicle
\note brakes[0] and brakes[1] may be used to distinguish brake and handbrake controls.
*/
struct PxVehicleCommandState
{
PxReal brakes[2]; //!< The instantaneous state of the brake controllers in range [0,1] with 1 denoting fully pressed and 0 fully depressed.
PxU32 nbBrakes; //|< The number of brake commands.
PxReal throttle; //!< The instantaneous state of the throttle controller in range [0,1] with 1 denoting fully pressed and 0 fully depressed.
PxReal steer; //!< The instantaneous state of the steer controller in range [-1,1].
PX_FORCE_INLINE void setToDefault()
{
PxMemZero(this, sizeof(PxVehicleCommandState));
}
};
/**
\brief A description of the state of transmission-related commands that are applied to a vehicle with direct drive.
*/
struct PxVehicleDirectDriveTransmissionCommandState
{
/**
\brief Direct drive vehicles only have reverse, neutral or forward gear.
*/
enum Enum
{
eREVERSE = 0,
eNEUTRAL,
eFORWARD
};
Enum gear; //!< The desired gear of the input gear controller.
PX_FORCE_INLINE void setToDefault()
{
PxMemZero(this, sizeof(PxVehicleDirectDriveTransmissionCommandState));
}
};
/**
\brief A description of the state of transmission-related commands that are applied to a vehicle with engine drive.
*/
struct PxVehicleEngineDriveTransmissionCommandState
{
enum Enum
{
/**
\brief Special gear value to denote the automatic shift mode (often referred to as DRIVE).
When using automatic transmission, setting this value as target gear will enable automatic
gear shifts between first and highest gear. If the current gear is a reverse gear or
the neutral gear, then this value will trigger a shift to first gear. If this value is
used even though there is no automatic transmission available, the gear state will remain
unchanged.
*/
eAUTOMATIC_GEAR = 0xff
};
PxReal clutch; //!< The instantaneous state of the clutch controller in range [0,1] with 1 denoting fully pressed and 0 fully depressed.
PxU32 targetGear; //!< The desired gear of the input gear controller.
PX_FORCE_INLINE void setToDefault()
{
PxMemZero(this, sizeof(PxVehicleEngineDriveTransmissionCommandState));
}
};
/**
\brief A description of the state of transmission-related commands that are applied to a vehicle with tank drive.
*/
struct PxVehicleTankDriveTransmissionCommandState : public PxVehicleEngineDriveTransmissionCommandState
{
/**
\brief The wheels of each tank track are either all connected to thrusts[0] or all connected to thrusts[1].
\note The thrust commands are used to divert torque from the engine to the wheels of the tank tracks controlled by each thrust.
\note thrusts[0] and thrusts[1] are in range [-1,1] with the sign dictating whether the thrust will be applied positively or negatively with respect to the gearing ratio.
*/
PxReal thrusts[2];
PX_FORCE_INLINE void setToDefault()
{
PxMemZero(this, sizeof(PxVehicleTankDriveTransmissionCommandState));
}
};
#if !PX_DOXYGEN
} // namespace vehicle2
} // namespace physx
#endif
/** @} */
| 5,088 | C | 35.092198 | 171 | 0.760024 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle2/commands/PxVehicleCommandHelpers.h | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#pragma once
/** \addtogroup vehicle2
@{
*/
#include "vehicle2/PxVehicleParams.h"
#include "PxVehicleCommandParams.h"
#include "PxVehicleCommandStates.h"
#if !PX_DOXYGEN
namespace physx
{
namespace vehicle2
{
#endif
/**
\brief Compute the linear response to a command.
\param[in] command is a normalised command value.
\param[in] wheelId specifies the wheel that is to respond to the command.
\param[in] responseParams specifies the wheel responses for all wheels on a vehicle.
\return The linear response of the specified wheel to the command.
*/
PX_FORCE_INLINE PxReal PxVehicleLinearResponseCompute
(const PxReal command, const PxU32 wheelId, const PxVehicleCommandResponseParams& responseParams)
{
return command*responseParams.maxResponse*responseParams.wheelResponseMultipliers[wheelId];
}
/**
\brief Compute the non-linear response to a command.
\param[in] command is a normalised command value.
\param[in] longitudinalSpeed is the longitudional speed of the vehicle.
\param[in] wheelId specifies the wheel that is to respond to the command.
\param[in] responseParams specifies the wheel responses for all wheels on a vehicle.
\note responseParams is used to compute an interpolated normalized response to the combination of command and longitudinalSpeed.
The interpolated normalized response is then used in place of the command as input to PxVehicleComputeLinearResponse().
*/
PxReal PxVehicleNonLinearResponseCompute
(const PxReal command, const PxReal longitudinalSpeed, const PxU32 wheelId, const PxVehicleCommandResponseParams& responseParams);
#if !PX_DOXYGEN
} // namespace vehicle2
} // namespace physx
#endif
/** @} */
| 3,347 | C | 42.480519 | 130 | 0.782193 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle2/commands/PxVehicleCommandParams.h | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#pragma once
/** \addtogroup vehicle2
@{
*/
#include "foundation/PxFoundation.h"
#include "vehicle2/PxVehicleLimits.h"
#include "vehicle2/PxVehicleParams.h"
#if !PX_DOXYGEN
namespace physx
{
namespace vehicle2
{
#endif
/**
\brief Each command value may be associated with a table specifying a normalized response as a function of longitudinal speed.
Multiple instances of PxVehicleCommandValueResponseTable allow a normalized response to be authored as a multi-variate
piecewise polynomial with normalized command response expressed as a nonlinear function of command value and speed.
*/
struct PxVehicleCommandValueResponseTable
{
enum Enum
{
eMAX_NB_SPEED_RESPONSES = 64
};
/**
\brief The command value associated with the table of speed responses.
*/
PxReal commandValue;
/**
\brief A lookup table specifying the normalised response to the specified command value as a function of longitudinal speed.
\note Each entry in the speedResponses table must be of the form (speed, normalizedResponse).
\note The longitudinal speeds in the table must form a strictly increasing series.
\note The normalized responses must be in range [0, 1].
*/
PxVehicleFixedSizeLookupTable<PxReal, eMAX_NB_SPEED_RESPONSES> speedResponses;
};
/**
\note Brake, drive and steer response typically reduce at increased longitudinal speed. Moreover, response to a brake, throttle or steer command is typically
nonlinear and may be subject to dead zones where response is constant with either zero or non-zero response. PxVehicleCommandNonLinearResponseParams allows
command responses to be authored as multi-variate piecewise polynomials with normalized command response a function of command value and longitudinal speed.
*/
class PxVehicleCommandNonLinearResponseParams
{
public:
enum Enum
{
eMAX_NB_COMMAND_VALUES = 8
};
PxVehicleCommandNonLinearResponseParams()
: nbSpeedResponses(0),
nbCommandValues(0)
{
}
void clear()
{
nbCommandValues = 0;
nbSpeedResponses = 0;
}
/**
\brief Add a table of normalised response vs speed and associated it with a specified command value.
\note commandValueSpeedResponses must be authored as a series of strictly increasing speeds with form {speed, normalizedResponse}
\note The responses added must form a series of strictly increasing command values.
*/
bool addResponse(const PxVehicleCommandValueResponseTable& commandValueSpeedResponses)
{
const PxReal commandValue = commandValueSpeedResponses.commandValue;
const PxReal* speeds = commandValueSpeedResponses.speedResponses.xVals;
const PxReal* responses = commandValueSpeedResponses.speedResponses.yVals;
const PxU16 nb = PxU16(commandValueSpeedResponses.speedResponses.nbDataPairs);
PX_CHECK_AND_RETURN_VAL(commandValue >= 0.0f && commandValue <= 1.0f, "PxVehicleCommandAndResponseTable::commandValue must be in range [0, 1]", false);
PX_CHECK_AND_RETURN_VAL(nbCommandValues < eMAX_NB_COMMAND_VALUES, "PxVehicleNonLinearCommandResponse::addResponse - exceeded maximum number of command responses", false);
PX_CHECK_AND_RETURN_VAL(((nbSpeedResponses + nb) <= PxVehicleCommandValueResponseTable::eMAX_NB_SPEED_RESPONSES), "PxVehicleNonLinearCommandResponse::addResponse - exceeded maximum number of command responses", false);
PX_CHECK_AND_RETURN_VAL((0 == nbCommandValues) || (commandValue > commandValues[nbCommandValues - 1]), "PxVehicleNonLinearCommandResponse::addResponse - command must be part of a strictly increasing series", false);
PX_CHECK_AND_RETURN_VAL(nb > 0, "PxVehicleNonLinearCommandResponse::addResponse - each command response must have at least 1 point", false);
#if PX_CHECKED
for (PxU32 i = 1; i < nb; i++)
{
PX_CHECK_AND_RETURN_VAL(speeds[i] > speeds[i - 1], "PxVehicleNonLinearCommandResponse::addResponse - speeds array must be a strictly increasing series", false);
PX_CHECK_AND_RETURN_VAL(responses[i] >= 0.0f && responses[i] <= 1.0f , "PxVehicleNonLinearCommandResponse::addResponse - response must be in range [0, 1]", false);
}
#endif
commandValues[nbCommandValues] = commandValue;
nbSpeedResponsesPerCommandValue[nbCommandValues] = nb;
speedResponsesPerCommandValue[nbCommandValues] = nbSpeedResponses;
PxMemCopy(speedResponses + 2 * nbSpeedResponses, speeds, sizeof(PxReal)*nb);
PxMemCopy(speedResponses + 2 * nbSpeedResponses + nb, responses, sizeof(PxReal)*nb);
nbCommandValues++;
nbSpeedResponses += nb;
return true;
}
public:
/**
\brief A ragged array of speeds and normalized responses.
*/
PxReal speedResponses[PxVehicleCommandValueResponseTable::eMAX_NB_SPEED_RESPONSES * 2];
/**
\brief The number of speeds and normalized responses.
*/
PxU16 nbSpeedResponses;
/**
\brief The table of speed responses for the ith command value begins at speedResponses[2*speedResponsesPerCommandValue[i]]
*/
PxU16 speedResponsesPerCommandValue[eMAX_NB_COMMAND_VALUES];
/**
\brief The ith command value has N speed responses with N = nbSpeedRenponsesPerCommandValue[i].
*/
PxU16 nbSpeedResponsesPerCommandValue[eMAX_NB_COMMAND_VALUES];
/**
\brief The command values.
*/
PxReal commandValues[eMAX_NB_COMMAND_VALUES];
/**
\brief The number of command values.
*/
PxU16 nbCommandValues;
};
/**
\brief A description of the per wheel response to an input command.
*/
struct PxVehicleCommandResponseParams
{
/**
\brief A nonlinear response to command value expressed as a lookup table of normalized response as a function of command value and longitudinal speed.
\note The effect of the default state of nonlinearResponse is a linear response to command value that is independent of longitudinal speed.
*/
PxVehicleCommandNonLinearResponseParams nonlinearResponse;
/**
\brief A description of the per wheel response multiplier to an input command.
*/
PxReal wheelResponseMultipliers[PxVehicleLimits::eMAX_NB_WHEELS];
/**
\brief The maximum response that occurs when the wheel response multiplier has value 1.0 and nonlinearResponse is in the default state of linear response.
*/
PxF32 maxResponse;
};
#if !PX_DOXYGEN
} // namespace vehicle2
} // namespace physx
#endif
/** @} */
| 7,828 | C | 37.566502 | 220 | 0.773633 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle2/physxConstraints/PxVehiclePhysXConstraintParams.h | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#pragma once
/** \addtogroup vehicle2
@{
*/
#include "foundation/PxFoundation.h"
#if !PX_DOXYGEN
namespace physx
{
namespace vehicle2
{
#endif
struct PxVehicleFrame;
struct PxVehicleScale;
/**
\brief A description of the PhysX models employed to resolve suspension limit constraints.
@see PxVehiclePhysXConstraintState
*/
struct PxVehiclePhysXSuspensionLimitConstraintParams
{
/**
\brief restitution is used by the restitution model used to generate a target velocity when resolving suspension limit
constraints.
\note A value of 0.0 means that the restitution model is not employed.
\note Restitution has no effect if directionForSuspensionLimitConstraint has value Enum::eNONE.
@see Px1DConstraintFlag::eRESTITUTION
@see Px1DConstraint::RestitutionModifiers::restitution
*/
PxReal restitution;
/**
\brief Set the direction to apply a constraint impulse when the suspension cannot place the wheel on the ground
and simultaneously respect the limits of suspension travel. The choices are to push along the ground normal to resolve the
geometric error or to push along the suspension direction. The former choice can be thought of as mimicing a force applied
by the tire's contact with the ground, while the latter can be thought of as mimicing a force arising from a suspension limit spring.
When the ground normal and the suspension direction are approximately aligned, both do an equivalent job of maintaining the wheel above
the ground. When the vehicle is on its side, eSUSPENSION does a better job of keeping the wheels above
the ground but comes at the cost of an unnaturally strong torque that can lead to unwanted self-righting behaviour.
eROAD_GEOMETRY_NORMAL is a good choice to avoid self-righting behaviour and still do a reasonable job at maintaining
the wheel above the ground in the event that the vehicle is tending towards a roll onto its side.
eNONE should be chosen if it is desired that no extra impulse is applied when the suspension alone cannot keep the wheels above
the ground plane.
*/
enum DirectionSpecifier
{
eSUSPENSION,
eROAD_GEOMETRY_NORMAL,
eNONE
};
DirectionSpecifier directionForSuspensionLimitConstraint;
PX_FORCE_INLINE PxVehiclePhysXSuspensionLimitConstraintParams transformAndScale(
const PxVehicleFrame& srcFrame, const PxVehicleFrame& trgFrame, const PxVehicleScale& srcScale, const PxVehicleScale& trgScale) const
{
PX_UNUSED(srcFrame);
PX_UNUSED(trgFrame);
PX_UNUSED(srcScale);
PX_UNUSED(trgScale);
return *this;
}
PX_FORCE_INLINE bool isValid() const
{
PX_CHECK_AND_RETURN_VAL(
PxVehiclePhysXSuspensionLimitConstraintParams::eSUSPENSION == directionForSuspensionLimitConstraint ||
PxVehiclePhysXSuspensionLimitConstraintParams::eROAD_GEOMETRY_NORMAL == directionForSuspensionLimitConstraint ||
PxVehiclePhysXSuspensionLimitConstraintParams::eNONE == directionForSuspensionLimitConstraint, "PxVehiclePhysXSuspensionLimitConstraintParams.directionForSuspensionLimitConstraint must have legal value", false);
PX_CHECK_AND_RETURN_VAL(restitution >= 0.0f && restitution <= 1.0f, "PxVehiclePhysXSuspensionLimitConstraintParams.restitution must be in range [0, 1]", false);
return true;
}
};
#if !PX_DOXYGEN
} // namespace vehicle2
} // namespace physx
#endif
/** @} */
| 4,988 | C | 43.945946 | 214 | 0.787089 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle2/physxConstraints/PxVehiclePhysXConstraintStates.h | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#pragma once
/** \addtogroup vehicle2
@{
*/
#include "foundation/PxAssert.h"
#include "foundation/PxTransform.h"
#include "extensions/PxConstraintExt.h"
#include "vehicle2/PxVehicleLimits.h"
#include "vehicle2/tire/PxVehicleTireStates.h"
#include "PxConstraint.h"
#include "PxConstraintDesc.h"
#if !PX_DOXYGEN
namespace physx
{
class PxConstraint;
namespace vehicle2
{
#endif
/**
\brief A description of the number of PxConstraintConnector instances per vehicle required to maintain suspension limit
and sticky tire instances.
*/
struct PxVehiclePhysXConstraintLimits
{
enum Enum
{
eNB_DOFS_PER_PXCONSTRAINT = 12,
eNB_DOFS_PER_WHEEL = 3,
eNB_WHEELS_PER_PXCONSTRAINT = eNB_DOFS_PER_PXCONSTRAINT / eNB_DOFS_PER_WHEEL,
eNB_CONSTRAINTS_PER_VEHICLE = (PxVehicleLimits::eMAX_NB_WHEELS + (eNB_WHEELS_PER_PXCONSTRAINT - 1)) / (eNB_WHEELS_PER_PXCONSTRAINT)
};
};
/**
\brief PxVehiclePhysXConstraintState is a data structure used to write
constraint data to the internal state of the associated PxScene.
@see Px1dConstraint
*/
struct PxVehiclePhysXConstraintState
{
/**
\brief a boolean describing whether to trigger a low speed constraint along the tire longitudinal and lateral directions.
*/
bool tireActiveStatus[PxVehicleTireDirectionModes::eMAX_NB_PLANAR_DIRECTIONS];
/**
\brief linear component of velocity jacobian in world space for the tire's longitudinal and lateral directions.
*/
PxVec3 tireLinears[PxVehicleTireDirectionModes::eMAX_NB_PLANAR_DIRECTIONS];
/**
\brief angular component of velocity jacobian in world space for the tire's longitudinal and lateral directions.
*/
PxVec3 tireAngulars[PxVehicleTireDirectionModes::eMAX_NB_PLANAR_DIRECTIONS];
/**
\brief damping coefficient applied to the tire's longitudinal and lateral velocities.
The constraint sets a target velocity of 0 and the damping coefficient will impact the size of the
impulse applied to reach the target. Since damping acts as a stiffness with respect to the velocity,
too large a value can cause instabilities.
*/
PxReal tireDamping[PxVehicleTireDirectionModes::eMAX_NB_PLANAR_DIRECTIONS];
/**
\brief a boolean describing whether to trigger a suspension limit constraint.
*/
bool suspActiveStatus;
/**
\brief linear component of velocity jacobian in the world frame.
*/
PxVec3 suspLinear;
/**
\brief angular component of velocity jacobian in the world frame.
*/
PxVec3 suspAngular;
/**
\brief the excess suspension compression to be resolved by the constraint that cannot be resolved due to the travel limit
of the suspension spring.
\note The expected error value is the excess suspension compression projected onto the ground plane normal and should have
a negative sign.
*/
PxReal suspGeometricError;
/**
\brief restitution value of the restitution model used to generate a target velocity that will resolve the geometric error.
\note A value of 0.0 means that the restitution model is not employed.
@see Px1DConstraintFlag::eRESTITUTION
@see Px1DConstraint::RestitutionModifiers::restitution
*/
PxReal restitution;
PX_FORCE_INLINE void setToDefault()
{
PxMemZero(this, sizeof(PxVehiclePhysXConstraintState));
}
};
//TAG:solverprepshader
PX_FORCE_INLINE PxU32 vehicleConstraintSolverPrep
(Px1DConstraint* constraints,
PxVec3p& body0WorldOffset,
PxU32 maxConstraints,
PxConstraintInvMassScale&,
const void* constantBlock,
const PxTransform& bodyAToWorld,
const PxTransform& bodyBToWorld,
bool,
PxVec3p& cA2w, PxVec3p& cB2w)
{
PX_UNUSED(maxConstraints);
PX_UNUSED(body0WorldOffset);
PX_UNUSED(bodyBToWorld);
PX_ASSERT(bodyAToWorld.isValid()); PX_ASSERT(bodyBToWorld.isValid());
const PxVehiclePhysXConstraintState* data = static_cast<const PxVehiclePhysXConstraintState*>(constantBlock);
PxU32 numActive = 0;
//KS - the TGS solver will use raXn to try to add to the angular part of the linear constraints.
//We overcome this by setting the ra and rb offsets to be 0.
cA2w = bodyAToWorld.p;
cB2w = bodyBToWorld.p;
// note: this is only needed for PxSolverType::eTGS and even then it should not have an effect as
// long as a constraint raises Px1DConstraintFlag::eANGULAR_CONSTRAINT
//Susp limit constraints.
for (PxU32 i = 0; i < PxVehiclePhysXConstraintLimits::eNB_WHEELS_PER_PXCONSTRAINT; i++)
{
if (data[i].suspActiveStatus)
{
// Going beyond max suspension compression should be treated similar to rigid body contacts.
// Thus setting up constraints that try to emulate such contacts.
//
// linear l = contact normal = n
// angular a = suspension force application offset x contact normal = cross(r, n)
//
// velocity at contact:
// vl: part from linear vehicle velocity v
// vl = dot(n, v) = dot(l, v)
//
// va: part from angular vehicle velocity w
// va = dot(n, cross(w, r)) = dot(w, cross(r, n)) = dot(w, a)
//
// ve: part from excess suspension compression
// ve = (geomError / dt) (note: geomError is expected to be negative here)
//
// velocity target vt = vl + va + ve
// => should become 0 by applying positive impulse along l. If vt is positive,
// nothing will happen as a negative impulse would have to be applied (but
// min impulse is set to 0). If vt is negative, a positive impulse will get
// applied to push vt towards 0.
//
Px1DConstraint& p = constraints[numActive];
p.linear0 = data[i].suspLinear;
p.angular0 = data[i].suspAngular;
p.geometricError = data[i].suspGeometricError;
p.linear1 = PxVec3(0);
p.angular1 = PxVec3(0);
p.minImpulse = 0;
p.maxImpulse = FLT_MAX;
p.velocityTarget = 0;
p.solveHint = PxConstraintSolveHint::eINEQUALITY;
// note: this is only needed for PxSolverType::eTGS to not have the angular part
// be modified based on the linear part during substeps. Basically, it will
// disable the constraint re-projection etc. to emulate PxSolverType::ePGS.
p.flags |= Px1DConstraintFlag::eANGULAR_CONSTRAINT;
if (data[i].restitution > 0.0f)
{
p.flags |= Px1DConstraintFlag::eRESTITUTION;
p.mods.bounce.restitution = data[i].restitution;
p.mods.bounce.velocityThreshold = -FLT_MAX;
}
numActive++;
}
}
//Sticky tire friction constraints.
for (PxU32 i = 0; i < PxVehiclePhysXConstraintLimits::eNB_WHEELS_PER_PXCONSTRAINT; i++)
{
if (data[i].tireActiveStatus[PxVehicleTireDirectionModes::eLONGITUDINAL])
{
Px1DConstraint& p = constraints[numActive];
p.linear0 = data[i].tireLinears[PxVehicleTireDirectionModes::eLONGITUDINAL];
p.angular0 = data[i].tireAngulars[PxVehicleTireDirectionModes::eLONGITUDINAL];
p.geometricError = 0.0f;
p.linear1 = PxVec3(0);
p.angular1 = PxVec3(0);
p.minImpulse = -FLT_MAX;
p.maxImpulse = FLT_MAX;
p.velocityTarget = 0.0f;
p.mods.spring.damping = data[i].tireDamping[PxVehicleTireDirectionModes::eLONGITUDINAL];
// note: no stiffness specified as this will have no effect with geometricError=0
p.flags = Px1DConstraintFlag::eSPRING | Px1DConstraintFlag::eACCELERATION_SPRING;
p.flags |= Px1DConstraintFlag::eANGULAR_CONSTRAINT; // see explanation of same flag usage further above
numActive++;
}
}
//Sticky tire friction constraints.
for (PxU32 i = 0; i < PxVehiclePhysXConstraintLimits::eNB_WHEELS_PER_PXCONSTRAINT; i++)
{
if (data[i].tireActiveStatus[PxVehicleTireDirectionModes::eLATERAL])
{
Px1DConstraint& p = constraints[numActive];
p.linear0 = data[i].tireLinears[PxVehicleTireDirectionModes::eLATERAL];
p.angular0 = data[i].tireAngulars[PxVehicleTireDirectionModes::eLATERAL];
p.geometricError = 0.0f;
p.linear1 = PxVec3(0);
p.angular1 = PxVec3(0);
p.minImpulse = -FLT_MAX;
p.maxImpulse = FLT_MAX;
p.velocityTarget = 0.0f;
p.mods.spring.damping = data[i].tireDamping[PxVehicleTireDirectionModes::eLATERAL];
// note: no stiffness specified as this will have no effect with geometricError=0
p.flags = Px1DConstraintFlag::eSPRING | Px1DConstraintFlag::eACCELERATION_SPRING;
p.flags |= Px1DConstraintFlag::eANGULAR_CONSTRAINT; // see explanation of same flag usage further above
numActive++;
}
}
return numActive;
}
PX_FORCE_INLINE void visualiseVehicleConstraint
(PxConstraintVisualizer &viz,
const void* constantBlock,
const PxTransform& body0Transform,
const PxTransform& body1Transform,
PxU32 flags)
{
PX_UNUSED(&viz);
PX_UNUSED(constantBlock);
PX_UNUSED(body0Transform);
PX_UNUSED(body1Transform);
PX_UNUSED(flags);
PX_ASSERT(body0Transform.isValid());
PX_ASSERT(body1Transform.isValid());
}
class PxVehicleConstraintConnector : public PxConstraintConnector
{
public:
PxVehicleConstraintConnector() : mVehicleConstraintState(NULL) {}
PxVehicleConstraintConnector(PxVehiclePhysXConstraintState* vehicleConstraintState) : mVehicleConstraintState(vehicleConstraintState) {}
~PxVehicleConstraintConnector() {}
void setConstraintState(PxVehiclePhysXConstraintState* constraintState) { mVehicleConstraintState = constraintState; }
virtual void* prepareData() { return mVehicleConstraintState; }
virtual const void* getConstantBlock() const { return mVehicleConstraintState; }
virtual PxConstraintSolverPrep getPrep() const { return vehicleConstraintSolverPrep; }
//Is this necessary if physx no longer supports double-buffering?
virtual void onConstraintRelease() { }
//Can be empty functions.
virtual bool updatePvdProperties(physx::pvdsdk::PvdDataStream& pvdConnection, const PxConstraint* c, PxPvdUpdateType::Enum updateType) const
{
PX_UNUSED(pvdConnection);
PX_UNUSED(c);
PX_UNUSED(updateType);
return true;
}
virtual void updateOmniPvdProperties() const { }
virtual void onComShift(PxU32 actor) { PX_UNUSED(actor); }
virtual void onOriginShift(const PxVec3& shift) { PX_UNUSED(shift); }
virtual void* getExternalReference(PxU32& typeID) { typeID = PxConstraintExtIDs::eVEHICLE_JOINT; return this; }
virtual PxBase* getSerializable() { return NULL; }
private:
PxVehiclePhysXConstraintState* mVehicleConstraintState;
};
/**
\brief A mapping between constraint state data and the associated PxConstraint instances.
*/
struct PxVehiclePhysXConstraints
{
/**
\brief PxVehiclePhysXConstraintComponent writes to the constraintStates array and a
callback invoked by PxScene::simulate() reads a portion from it for a block of wheels
and writes that portion to an associated PxConstraint instance.
*/
PxVehiclePhysXConstraintState constraintStates[PxVehicleLimits::eMAX_NB_WHEELS];
/**
\brief PxVehiclePhysXConstraintComponent writes to the constraintStates array and a
callback invoked by PxScene::simulate() reads a portion from it for a block of wheels
and writes that portion to an associated PxConstraint instance.
*/
PxConstraint* constraints[PxVehiclePhysXConstraintLimits::eNB_CONSTRAINTS_PER_VEHICLE];
/**
\brief A constraint connector is necessary to connect each PxConstraint to a portion of the constraintStates array.
*/
PxVehicleConstraintConnector* constraintConnectors[PxVehiclePhysXConstraintLimits::eNB_CONSTRAINTS_PER_VEHICLE];
PX_FORCE_INLINE void setToDefault()
{
for (PxU32 i = 0; i < PxVehicleLimits::eMAX_NB_WHEELS; i++)
{
constraintStates[i].setToDefault();
}
for(PxU32 i = 0; i < PxVehiclePhysXConstraintLimits::eNB_CONSTRAINTS_PER_VEHICLE; i++)
{
constraints[i] = NULL;
constraintConnectors[i] = NULL;
}
}
};
#if !PX_DOXYGEN
} // namespace vehicle2
} // namespace physx
#endif
/** @} */
| 13,146 | C | 35.723464 | 141 | 0.754298 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle2/physxConstraints/PxVehiclePhysXConstraintHelpers.h | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#pragma once
#include "foundation/PxPreprocessor.h"
/** \addtogroup vehicle2
@{
*/
#if !PX_DOXYGEN
namespace physx
{
class PxPhysics;
class PxRigidBody;
namespace vehicle2
{
#endif
struct PxVehicleAxleDescription;
struct PxVehiclePhysXConstraints;
/**
\brief Instantiate the PhysX custom constraints.
Custom constraints will resolve excess suspension compression and velocity constraints that serve as
a replacement low speed tire model.
\param[in] axleDescription describes the axles of the vehicle and the wheels on each axle.
\param[in] physics is a PxPhysics instance.
\param[in] physxActor is the vehicle's PhysX representation as a PxRigidBody
\param[in] vehicleConstraints is a wrapper class that holds pointers to PhysX objects required to implement the custom constraint.
*/
void PxVehicleConstraintsCreate
(const PxVehicleAxleDescription& axleDescription,
PxPhysics& physics, PxRigidBody& physxActor,
PxVehiclePhysXConstraints& vehicleConstraints);
/**
\brief To ensure the constraints are processed by the PhysX scene they are marked as dirty prior to each simulate step.
\param[in] vehicleConstraints is a wrapper class that holds pointers to PhysX objects required to implement the custom constraint.
@see PxVehicleConstraintsCreate
*/
void PxVehicleConstraintsDirtyStateUpdate
(PxVehiclePhysXConstraints& vehicleConstraints);
/**
\brief Destroy the PhysX custom constraints.
\param[in,out] vehicleConstraints describes the PhysX custom constraints to be released.
@see PxVehicleConstraintsCreate
*/
void PxVehicleConstraintsDestroy
(PxVehiclePhysXConstraints& vehicleConstraints);
#if !PX_DOXYGEN
} // namespace vehicle2
} // namespace physx
#endif
/** @} */
| 3,392 | C | 35.483871 | 130 | 0.786851 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle2/physxConstraints/PxVehiclePhysXConstraintComponents.h | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#pragma once
/** \addtogroup vehicle2
@{
*/
#include "vehicle2/PxVehicleParams.h"
#include "vehicle2/PxVehicleComponent.h"
#include "vehicle2/roadGeometry/PxVehicleRoadGeometryState.h"
#include "vehicle2/suspension/PxVehicleSuspensionParams.h"
#include "vehicle2/suspension/PxVehicleSuspensionStates.h"
#include "PxVehiclePhysXConstraintFunctions.h"
#include "PxVehiclePhysXConstraintHelpers.h"
#include "PxVehiclePhysXConstraintStates.h"
#include "PxVehiclePhysXConstraintParams.h"
#include "common/PxProfileZone.h"
#if !PX_DOXYGEN
namespace physx
{
namespace vehicle2
{
#endif
class PxVehiclePhysXConstraintComponent : public PxVehicleComponent
{
public:
PxVehiclePhysXConstraintComponent() : PxVehicleComponent() {}
virtual ~PxVehiclePhysXConstraintComponent() {}
virtual void getDataForPhysXConstraintComponent(
const PxVehicleAxleDescription*& axleDescription,
const PxVehicleRigidBodyState*& rigidBodyState,
PxVehicleArrayData<const PxVehicleSuspensionParams>& suspensionParams,
PxVehicleArrayData<const PxVehiclePhysXSuspensionLimitConstraintParams>& suspensionLimitParams,
PxVehicleArrayData<const PxVehicleSuspensionState>& suspensionStates,
PxVehicleArrayData<const PxVehicleSuspensionComplianceState>& suspensionComplianceStates,
PxVehicleArrayData<const PxVehicleRoadGeometryState>& wheelRoadGeomStates,
PxVehicleArrayData<const PxVehicleTireDirectionState>& tireDirectionStates,
PxVehicleArrayData<const PxVehicleTireStickyState>& tireStickyStates,
PxVehiclePhysXConstraints*& constraints) = 0;
virtual bool update(const PxReal dt, const PxVehicleSimulationContext& context)
{
PX_UNUSED(dt);
PX_UNUSED(context);
PX_PROFILE_ZONE("PxVehiclePhysXConstraintComponent::update", 0);
const PxVehicleAxleDescription* axleDescription;
const PxVehicleRigidBodyState* rigidBodyState;
PxVehicleArrayData<const PxVehicleSuspensionParams> suspensionParams;
PxVehicleArrayData<const PxVehiclePhysXSuspensionLimitConstraintParams> suspensionLimitParams;
PxVehicleArrayData<const PxVehicleSuspensionState> suspensionStates;
PxVehicleArrayData<const PxVehicleSuspensionComplianceState> suspensionComplianceStates;
PxVehicleArrayData<const PxVehicleRoadGeometryState> wheelRoadGeomStates;
PxVehicleArrayData<const PxVehicleTireDirectionState> tireDirectionStates;
PxVehicleArrayData<const PxVehicleTireStickyState> tireStickyStates;
PxVehiclePhysXConstraints* constraints;
getDataForPhysXConstraintComponent(axleDescription, rigidBodyState,
suspensionParams, suspensionLimitParams, suspensionStates, suspensionComplianceStates,
wheelRoadGeomStates, tireDirectionStates, tireStickyStates,
constraints);
PxVehicleConstraintsDirtyStateUpdate(*constraints);
for (PxU32 i = 0; i < axleDescription->nbWheels; i++)
{
const PxU32 wheelId = axleDescription->wheelIdsInAxleOrder[i];
PxVehiclePhysXConstraintStatesUpdate(
suspensionParams[wheelId], suspensionLimitParams[wheelId],
suspensionStates[wheelId], suspensionComplianceStates[wheelId],
wheelRoadGeomStates[wheelId].plane.n,
context.tireStickyParams.stickyParams[PxVehicleTireDirectionModes::eLONGITUDINAL].damping,
context.tireStickyParams.stickyParams[PxVehicleTireDirectionModes::eLATERAL].damping,
tireDirectionStates[wheelId], tireStickyStates[wheelId],
*rigidBodyState,
constraints->constraintStates[wheelId]);
}
return true;
}
};
#if !PX_DOXYGEN
} // namespace vehicle2
} // namespace physx
#endif
/** @} */
| 5,188 | C | 40.846774 | 97 | 0.809946 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle2/physxConstraints/PxVehiclePhysXConstraintFunctions.h | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#pragma once
/** \addtogroup vehicle2
@{
*/
#include "foundation/PxVec3.h"
#if !PX_DOXYGEN
namespace physx
{
namespace vehicle2
{
#endif
struct PxVehicleSuspensionParams;
struct PxVehiclePhysXSuspensionLimitConstraintParams;
struct PxVehicleSuspensionState;
struct PxVehicleSuspensionComplianceState;
struct PxVehicleTireDirectionState;
struct PxVehicleTireStickyState;
struct PxVehicleRigidBodyState;
struct PxVehiclePhysXConstraintState;
/**
\brief Read constraint data from the vehicle's internal state for a single wheel and write it to a
structure that will be read by the associated PxScene and used to impose the constraints during the next
PxScene::simulate() step.
\param[in] suspensionParams describes the suspension frame.
\param[in] suspensionLimitParams describes the restitution value applied to any constraint triggered by
the suspension travel limit.
\param[in] suspensionState describes the excess suspension compression beyond the suspension travel limit that will be
resolved with a constraint.
\param[in] suspensionComplianceState describes the effect of suspension compliance on the effective application point
of the suspension force.
\param[in] groundPlaneNormal The normal direction of the ground plane the wheel is driving on. A normalized vector is
expected.
\param[in] tireStickyDampingLong The damping coefficient to use in the constraint to approach a zero target velocity
along the longitudinal tire axis.
\param[in] tireStickyDampingLat Same concept as tireStickyDampingLong but for the lateral tire axis.
\param[in] tireDirectionState describes the longitudinal and lateral directions of the tire in the world frame.
\param[in] tireStickyState describes the low speed state of the tire in the longitudinal and lateral directions.
\param[in] rigidBodyState describes the pose of the rigid body.
\param[out] constraintState is the data structure that will be read by the associated PxScene in the next call to
PxScene::simulate().
\note Constraints include suspension constraints to account for suspension travel limit and sticky
tire constraints that bring the vehicle to rest at low longitudinal and lateral speed.
*/
void PxVehiclePhysXConstraintStatesUpdate
(const PxVehicleSuspensionParams& suspensionParams,
const PxVehiclePhysXSuspensionLimitConstraintParams& suspensionLimitParams,
const PxVehicleSuspensionState& suspensionState, const PxVehicleSuspensionComplianceState& suspensionComplianceState,
const PxVec3& groundPlaneNormal,
const PxReal tireStickyDampingLong, const PxReal tireStickyDampingLat,
const PxVehicleTireDirectionState& tireDirectionState, const PxVehicleTireStickyState& tireStickyState,
const PxVehicleRigidBodyState& rigidBodyState,
PxVehiclePhysXConstraintState& constraintState);
#if !PX_DOXYGEN
} // namespace vehicle2
} // namespace physx
#endif
/** @} */
| 4,563 | C | 48.075268 | 119 | 0.804734 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle2/physxRoadGeometry/PxVehiclePhysXRoadGeometryParams.h | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#pragma once
/** \addtogroup vehicle2
@{
*/
#include "foundation/PxFoundation.h"
#include "PxQueryFiltering.h"
#if !PX_DOXYGEN
namespace physx
{
class PxMaterial;
namespace vehicle2
{
#endif
struct PxVehicleFrame;
struct PxVehicleScale;
/**
\brief PhysX scene queries may be raycasts or sweeps.
\note eNONE will result in no PhysX scene query. This option will not overwrite the associated PxVehicleRoadGeometryState.
*/
struct PxVehiclePhysXRoadGeometryQueryType
{
enum Enum
{
eNONE = 0, //!< Info about the road geometry below the wheel is provided by the user
eRAYCAST, //!< The road geometry below the wheel is analyzed using a raycast query
eSWEEP, //!< The road geometry below the wheel is analyzed using a sweep query
eMAX_NB
};
};
/**
\brief A description of type of PhysX scene query and the filter data to apply to the query.
*/
struct PxVehiclePhysXRoadGeometryQueryParams
{
/**
\brief The default filter data to use for the physx scene query.
If per wheel filter data is provided in #filterDataEntries, then this member
will be ignored.
@see PxSceneQuerySystemBase::raycast
@see PxSceneQuerySystemBase::sweep
*/
PxQueryFilterData defaultFilterData;
/**
\brief Array of filter data entries (one per wheel) to use for the physx scene query.
A null pointer is allowed in which case #defaultFilterData will be used for all wheels.
@see PxSceneQuerySystemBase::raycast
@see PxSceneQuerySystemBase::sweep
*/
PxQueryFilterData* filterDataEntries;
/**
\brief A filter callback to be used by the physx scene query
\note A null pointer is allowed.
@see PxSceneQuerySystemBase::raycast
@see PxSceneQuerySystemBase::sweep
*/
PxQueryFilterCallback* filterCallback;
/**
\brief A description of the type of physx scene query to employ.
@see PxSceneQuerySystemBase::raycast
@see PxSceneQuerySystemBase::sweep
*/
PxVehiclePhysXRoadGeometryQueryType::Enum roadGeometryQueryType;
PX_FORCE_INLINE PxVehiclePhysXRoadGeometryQueryParams transformAndScale(
const PxVehicleFrame& srcFrame, const PxVehicleFrame& trgFrame, const PxVehicleScale& srcScale, const PxVehicleScale& trgScale) const
{
PX_UNUSED(srcFrame);
PX_UNUSED(trgFrame);
PX_UNUSED(srcScale);
PX_UNUSED(trgScale);
return *this;
}
PX_FORCE_INLINE bool isValid() const
{
PX_CHECK_AND_RETURN_VAL(roadGeometryQueryType < PxVehiclePhysXRoadGeometryQueryType::eMAX_NB, "PxVehiclePhysXRoadGeometryQueryParams.roadGeometryQueryType has illegal value", false);
return true;
}
};
/**
A mapping between PxMaterial and a friction value to be used by the tire model.
@see PxVehiclePhysXMaterialFrictionParams
*/
struct PxVehiclePhysXMaterialFriction
{
/**
\brief A PxMaterial instance that is to be mapped to a friction value.
*/
const PxMaterial* material;
/**
\brief A friction value that is to be mapped to a PxMaterial instance.
\note friction must have value greater than or equal to zero.
<b>Range:</b> [0, inf)<br>
@see PxVehicleTireGripState::friction
*/
PxReal friction;
PX_FORCE_INLINE bool isValid() const
{
PX_CHECK_AND_RETURN_VAL(friction >= 0.0f, "PxVehiclePhysXMaterialFriction.friction must be greater than or equal to zero", false);
return true;
}
};
/**
\brief A mappping between PxMaterial instance and friction for multiple PxMaterial intances.
*/
struct PxVehiclePhysXMaterialFrictionParams
{
PxVehiclePhysXMaterialFriction* materialFrictions; //!< An array of mappings between PxMaterial and friction.
PxU32 nbMaterialFrictions; //!< The number of mappings between PxMaterial and friction.
PxReal defaultFriction; //!< A default friction value to be used in the event that the PxMaterial under the tire is not found in the array #materialFrictions.
PX_FORCE_INLINE bool isValid() const
{
for (PxU32 i = 0; i < nbMaterialFrictions; i++)
{
if (!materialFrictions[i].isValid())
return false;
}
PX_CHECK_AND_RETURN_VAL(defaultFriction >= 0.0f, "PxVehiclePhysXMaterialFrictionParams.defaultFriction must be greater than or equal to zero", false);
return true;
}
};
#if !PX_DOXYGEN
} // namespace vehicle2
} // namespace physx
#endif
/** @} */
| 5,835 | C | 31.603352 | 184 | 0.762982 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle2/physxRoadGeometry/PxVehiclePhysXRoadGeometryComponents.h | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#pragma once
/** \addtogroup vehicle2
@{
*/
#include "vehicle2/PxVehicleParams.h"
#include "vehicle2/PxVehicleComponent.h"
#include "vehicle2/commands/PxVehicleCommandHelpers.h"
#include "vehicle2/roadGeometry/PxVehicleRoadGeometryState.h"
#include "vehicle2/suspension/PxVehicleSuspensionParams.h"
#include "vehicle2/wheel/PxVehicleWheelParams.h"
#include "vehicle2/physxRoadGeometry/PxVehiclePhysXRoadGeometryFunctions.h"
#include "vehicle2/physxRoadGeometry/PxVehiclePhysXRoadGeometryParams.h"
#include "vehicle2/physxRoadGeometry/PxVehiclePhysXRoadGeometryState.h"
#include "common/PxProfileZone.h"
#if !PX_DOXYGEN
namespace physx
{
namespace vehicle2
{
#endif
class PxVehiclePhysXRoadGeometrySceneQueryComponent : public PxVehicleComponent
{
public:
PxVehiclePhysXRoadGeometrySceneQueryComponent() : PxVehicleComponent() {}
virtual ~PxVehiclePhysXRoadGeometrySceneQueryComponent() {}
/**
\brief Provide vehicle data items for this component.
\param[out] axleDescription identifies the wheels on each axle.
\param[out] roadGeomParams The road geometry parameters of the vehicle.
\param[out] steerResponseStates The steer response state of the wheels.
\param[out] rigidBodyState The pose, velocity etc. of the vehicle rigid body.
\param[out] wheelParams The wheel parameters for the wheels.
\param[out] suspensionParams The suspension parameters for the wheels.
\param[out] materialFrictionParams The tire friction tables for the wheels.
\param[out] roadGeometryStates The detected ground surface plane, friction value etc. for the wheels.
\param[out] physxRoadGeometryStates Optional buffer to store additional information about the query (like actor/shape that got hit etc.).
Set to empty if not desired.
*/
virtual void getDataForPhysXRoadGeometrySceneQueryComponent(
const PxVehicleAxleDescription*& axleDescription,
const PxVehiclePhysXRoadGeometryQueryParams*& roadGeomParams,
PxVehicleArrayData<const PxReal>& steerResponseStates,
const PxVehicleRigidBodyState*& rigidBodyState,
PxVehicleArrayData<const PxVehicleWheelParams>& wheelParams,
PxVehicleArrayData<const PxVehicleSuspensionParams>& suspensionParams,
PxVehicleArrayData<const PxVehiclePhysXMaterialFrictionParams>& materialFrictionParams,
PxVehicleArrayData<PxVehicleRoadGeometryState>& roadGeometryStates,
PxVehicleArrayData<PxVehiclePhysXRoadGeometryQueryState>& physxRoadGeometryStates) = 0;
virtual bool update(const PxReal dt, const PxVehicleSimulationContext& context)
{
PX_UNUSED(dt);
PX_PROFILE_ZONE("PxVehiclePhysXRoadGeometrySceneQueryComponent::update", 0);
const PxVehicleAxleDescription* axleDescription;
const PxVehiclePhysXRoadGeometryQueryParams* roadGeomParams;
PxVehicleArrayData<const PxReal> steerResponseStates;
const PxVehicleRigidBodyState* rigidBodyState;
PxVehicleArrayData<const PxVehicleWheelParams> wheelParams;
PxVehicleArrayData<const PxVehicleSuspensionParams> suspensionParams;
PxVehicleArrayData<const PxVehiclePhysXMaterialFrictionParams> materialFrictionParams;
PxVehicleArrayData<PxVehicleRoadGeometryState> roadGeometryStates;
PxVehicleArrayData<PxVehiclePhysXRoadGeometryQueryState> physxRoadGeometryStates;
getDataForPhysXRoadGeometrySceneQueryComponent(axleDescription,
roadGeomParams, steerResponseStates, rigidBodyState,
wheelParams, suspensionParams, materialFrictionParams,
roadGeometryStates, physxRoadGeometryStates);
if (context.getType() == PxVehicleSimulationContextType::ePHYSX)
{
const PxVehiclePhysXSimulationContext& physxContext = static_cast<const PxVehiclePhysXSimulationContext&>(context);
for(PxU32 i = 0; i < axleDescription->nbWheels; i++)
{
const PxU32 wheelId = axleDescription->wheelIdsInAxleOrder[i];
const PxQueryFilterData* fdPtr = roadGeomParams->filterDataEntries ? (roadGeomParams->filterDataEntries + wheelId) : &roadGeomParams->defaultFilterData;
PxVehiclePhysXRoadGeometryQueryUpdate(
wheelParams[wheelId], suspensionParams[wheelId],
roadGeomParams->roadGeometryQueryType, roadGeomParams->filterCallback, *fdPtr,
materialFrictionParams[wheelId],
steerResponseStates[wheelId], *rigidBodyState,
*physxContext.physxScene, physxContext.physxUnitCylinderSweepMesh, context.frame,
roadGeometryStates[wheelId],
!physxRoadGeometryStates.isEmpty() ? &physxRoadGeometryStates[wheelId] : NULL);
}
}
else
{
PX_ALWAYS_ASSERT();
for(PxU32 i = 0; i < axleDescription->nbWheels; i++)
{
const PxU32 wheelId = axleDescription->wheelIdsInAxleOrder[i];
roadGeometryStates[wheelId].setToDefault();
}
}
return true;
}
};
#if !PX_DOXYGEN
} // namespace vehicle2
} // namespace physx
#endif
/** @} */
| 6,419 | C | 42.087248 | 156 | 0.796697 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle2/physxRoadGeometry/PxVehiclePhysXRoadGeometryFunctions.h | // 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-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#pragma once
/** \addtogroup vehicle2
@{
*/
#include "foundation/PxSimpleTypes.h"
#include "vehicle2/physxRoadGeometry/PxVehiclePhysXRoadGeometryParams.h"
#if !PX_DOXYGEN
namespace physx
{
class PxScene;
class PxConvexMesh;
namespace vehicle2
{
#endif
struct PxVehicleWheelParams;
struct PxVehicleSuspensionParams;
struct PxVehiclePhysXRoadGeometryQueryState;
struct PxVehicleRigidBodyState;
struct PxVehicleFrame;
struct PxVehicleRoadGeometryState;
/**
\brief Compute the plane of the road geometry under a wheel and the tire friction of the contact.
\param[in] wheelParams describes the radius and halfwidth of the wheel.
\param[in] suspParams describes the frame of the suspension and wheel and the maximum suspension travel.
\param[in] queryType describes what type of PhysX scene query to use (see #PxVehiclePhysXRoadGeometryQueryType).
If PxVehiclePhysXRoadGeometryQueryType::eNONE is used, no work will be done.
\param[in] filterCallback describes the filter callback to use for the PhysX scene query. NULL is a valid input.
\param[in] filterData describes the filter data to use for the PhysX scene query.
\param[in] materialFrictionParams describes a mapping between PxMaterial and friction in order to compute a tire friction value.
\param[in] wheelYawAngle is the yaw angle (in radians) of the wheel.
\param[in] rigidBodyState describes the pose of the rigid body.
\param[in] scene is the PhysX scene that will be queried by the scene query.
\param[in] unitCylinderSweepMesh is a convex cylindrical mesh of unit radius and half-width to be used in
the event that a sweep query is to be used.
\param[in] frame describes the lateral, longitudinal and vertical axes and is used to scale unitCylinderSweepMesh
by the wheel's radius and half-width.
\param[out] roadGeomState contains the plane and friction of the road geometry under the wheel.
\param[out] physxRoadGeometryState Optional buffer to store additional information about the query (like actor/shape that got hit etc.).
Set to NULL if not needed.
\note PxVehicleRoadGeometryState::hitState will have value false in the event that the there is no reachable road geometry under the wheel and
true if there is reachable road geometry under the wheel. Road geometry is considered reachable if the suspension can elongate from its
reference pose far enough to place wheel on the ground.
*/
void PxVehiclePhysXRoadGeometryQueryUpdate
(const PxVehicleWheelParams& wheelParams, const PxVehicleSuspensionParams& suspParams,
const PxVehiclePhysXRoadGeometryQueryType::Enum queryType,
PxQueryFilterCallback* filterCallback, const PxQueryFilterData& filterData,
const PxVehiclePhysXMaterialFrictionParams& materialFrictionParams,
const PxReal wheelYawAngle, const PxVehicleRigidBodyState& rigidBodyState,
const PxScene& scene, const PxConvexMesh* unitCylinderSweepMesh,
const PxVehicleFrame& frame,
PxVehicleRoadGeometryState& roadGeomState,
PxVehiclePhysXRoadGeometryQueryState* physxRoadGeometryState);
#if !PX_DOXYGEN
} // namespace vehicle2
} // namespace physx
#endif
/** @} */
| 4,783 | C | 48.833333 | 143 | 0.795317 |
NVIDIA-Omniverse/PhysX/physx/include/cudamanager/PxCudaContextManager.h | // 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-2023 NVIDIA Corporation. All rights reserved.
#ifndef PX_CUDA_CONTEXT_MANAGER_H
#define PX_CUDA_CONTEXT_MANAGER_H
#include "foundation/PxPreprocessor.h"
#if PX_SUPPORT_GPU_PHYSX
#include "foundation/PxSimpleTypes.h"
#include "foundation/PxErrorCallback.h"
#include "foundation/PxFlags.h"
#include "PxCudaTypes.h"
#if !PX_DOXYGEN
namespace physx
{
#endif
class PxCudaContext;
struct PxCudaInteropRegisterFlag
{
enum Enum
{
eNONE = 0x00,
eREAD_ONLY = 0x01,
eWRITE_DISCARD = 0x02,
eSURFACE_LDST = 0x04,
eTEXTURE_GATHER = 0x08
};
};
/**
\brief An interface class that the user can implement in order for PhysX to use a user-defined device memory allocator.
*/
class PxDeviceAllocatorCallback
{
public:
/**
\brief Allocated device memory.
\param[in] ptr Pointer to store the allocated address
\param[in] size The amount of memory required
\return A boolean indicates the operation succeed or fail
*/
virtual bool memAlloc(void** ptr, size_t size) = 0;
/**
\brief Frees device memory.
\param[in] ptr The memory to free
\return A boolean indicates the operation succeed or fail
*/
virtual bool memFree(void* ptr) = 0;
protected:
virtual ~PxDeviceAllocatorCallback() {}
};
/**
\brief collection of set bits defined in NxCudaInteropRegisterFlag.
@see NxCudaInteropRegisterFlag
*/
typedef PxFlags<PxCudaInteropRegisterFlag::Enum, uint32_t> PxCudaInteropRegisterFlags;
PX_FLAGS_OPERATORS(PxCudaInteropRegisterFlag::Enum, uint32_t)
//! \brief Descriptor used to create a PxCudaContextManager
class PxCudaContextManagerDesc
{
public:
/**
* \brief The CUDA context to manage
*
* If left NULL, the PxCudaContextManager will create a new context. If
* graphicsDevice is also not NULL, this new CUDA context will be bound to
* that graphics device, enabling the use of CUDA/Graphics interop features.
*
* If ctx is not NULL, the specified context must be applied to the thread
* that is allocating the PxCudaContextManager at creation time (aka, it
* cannot be popped). The PxCudaContextManager will take ownership of the
* context until the manager is released. All access to the context must be
* gated by lock acquisition.
*
* If the user provides a context for the PxCudaContextManager, the context
* _must_ have either been created on the GPU ordinal returned by
* PxGetSuggestedCudaDeviceOrdinal() or on your graphics device.
*/
CUcontext* ctx;
/**
* \brief D3D device pointer or OpenGl context handle
*
* Only applicable when ctx is NULL, thus forcing a new context to be
* created. In that case, the created context will be bound to this
* graphics device.
*/
void* graphicsDevice;
/**
* \brief Application-specific GUID
*
* If your application employs PhysX modules that use CUDA you need to use a GUID
* so that patches for new architectures can be released for your game.You can obtain a GUID for your
* application from Nvidia.
*/
const char* appGUID;
/**
* \brief Application-specific device memory allocator
*
* the application can implement an device memory allocator, which inherites PxDeviceAllocatorCallback, and
* pass that to the PxCudaContextManagerDesc. The SDK will use that allocator to allocate device memory instead of
* using the defaul CUDA device memory allocator.
*/
PxDeviceAllocatorCallback* deviceAllocator;
PX_INLINE PxCudaContextManagerDesc() :
ctx (NULL),
graphicsDevice (NULL),
appGUID (NULL),
deviceAllocator (NULL)
{
}
};
/**
\brief A cuda kernel index providing an index to the cuda module and the function name
*/
struct PxKernelIndex
{
PxU32 moduleIndex;
const char* functionName;
};
/**
* \brief Manages thread locks, and task scheduling for a CUDA context
*
* A PxCudaContextManager manages access to a single CUDA context, allowing it to
* be shared between multiple scenes.
* The context must be acquired from the manager before using any CUDA APIs unless stated differently.
*
* The PxCudaContextManager is based on the CUDA driver API and explicitly does not
* support the CUDA runtime API (aka, CUDART).
*/
class PxCudaContextManager
{
public:
/**
* \brief Schedules clear operation for a device memory buffer on the specified stream
*
* The cuda context will get acquired automatically
*/
template<typename T>
void clearDeviceBufferAsync(T* deviceBuffer, PxU32 numElements, CUstream stream, PxI32 value = 0)
{
clearDeviceBufferAsyncInternal(deviceBuffer, numElements * sizeof(T), stream, value);
}
/**
* \brief Copies a device buffer to the host
*
* The cuda context will get acquired automatically
*/
template<typename T>
void copyDToH(T* hostBuffer, const T* deviceBuffer, PxU32 numElements)
{
copyDToHInternal(hostBuffer, deviceBuffer, numElements * sizeof(T));
}
/**
* \brief Copies a host buffer to the device
*
* The cuda context will get acquired automatically
*/
template<typename T>
void copyHToD(T* deviceBuffer, const T* hostBuffer, PxU32 numElements)
{
copyHToDInternal(deviceBuffer, hostBuffer, numElements * sizeof(T));
}
/**
* \brief Schedules device to host copy operation on the specified stream
*
* The cuda context will get acquired automatically
*/
template<typename T>
void copyDToHAsync(T* hostBuffer, const T* deviceBuffer, PxU32 numElements, CUstream stream)
{
copyDToHAsyncInternal(hostBuffer, deviceBuffer, numElements * sizeof(T), stream);
}
/**
* \brief Schedules host to device copy operation on the specified stream
*
* The cuda context will get acquired automatically
*/
template<typename T>
void copyHToDAsync(T* deviceBuffer, const T* hostBuffer, PxU32 numElements, CUstream stream)
{
copyHToDAsyncInternal(deviceBuffer, hostBuffer, numElements * sizeof(T), stream);
}
/**
* \brief Schedules device to device copy operation on the specified stream
*
* The cuda context will get acquired automatically
*/
template<typename T>
void copyDToDAsync(T* dstDeviceBuffer, const T* srcDeviceBuffer, PxU32 numElements, CUstream stream)
{
copyDToDAsyncInternal(dstDeviceBuffer, srcDeviceBuffer, numElements * sizeof(T), stream);
}
/**
* \brief Schedules a memset operation on the device on the specified stream. Only supported for 1 byte or 4 byte data types.
*
* The cuda context will get acquired automatically
*/
template<typename T>
void memsetAsync(T* dstDeviceBuffer, const T& value, PxU32 numElements, CUstream stream)
{
PX_COMPILE_TIME_ASSERT(sizeof(value) == sizeof(PxU32) || sizeof(value) == sizeof(PxU8));
if (sizeof(value) == sizeof(PxU32))
memsetD32AsyncInternal(dstDeviceBuffer, reinterpret_cast<const PxU32&>(value), numElements, stream);
else
memsetD8AsyncInternal(dstDeviceBuffer, reinterpret_cast<const PxU8&>(value), numElements, stream);
}
/**
* \brief Allocates a device buffer
*
* The cuda context will get acquired automatically
*/
template<typename T>
void allocDeviceBuffer(T*& deviceBuffer, PxU32 numElements, const char* filename = __FILE__, PxI32 line = __LINE__)
{
void* ptr = allocDeviceBufferInternal(PxU64(numElements) * sizeof(T), filename, line);
deviceBuffer = reinterpret_cast<T*>(ptr);
}
/**
* \brief Allocates a device buffer and returns the pointer to the memory
*
* The cuda context will get acquired automatically
*/
template<typename T>
T* allocDeviceBuffer(PxU32 numElements, const char* filename = __FILE__, PxI32 line = __LINE__)
{
void* ptr = allocDeviceBufferInternal(PxU64(numElements) * sizeof(T), filename, line);
return reinterpret_cast<T*>(ptr);
}
/**
* \brief Frees a device buffer
*
* The cuda context will get acquired automatically
*/
template<typename T>
void freeDeviceBuffer(T*& deviceBuffer)
{
freeDeviceBufferInternal(deviceBuffer);
deviceBuffer = NULL;
}
/**
* \brief Allocates a pinned host buffer
*
* A pinned host buffer can be used on the gpu after getting a mapped device pointer from the pinned host buffer pointer, see getMappedDevicePtr
* The cuda context will get acquired automatically
* @see getMappedDevicePtr
*/
template<typename T>
void allocPinnedHostBuffer(T*& pinnedHostBuffer, PxU32 numElements, const char* filename = __FILE__, PxI32 line = __LINE__)
{
void* ptr = allocPinnedHostBufferInternal(PxU64(numElements) * sizeof(T), filename, line);
pinnedHostBuffer = reinterpret_cast<T*>(ptr);
}
/**
* \brief Allocates a pinned host buffer and returns the pointer to the memory
*
* A pinned host buffer can be used on the gpu after getting a mapped device pointer from the pinned host buffer pointer, see getMappedDevicePtr
* The cuda context will get acquired automatically
* @see getMappedDevicePtr
*/
template<typename T>
T* allocPinnedHostBuffer(PxU32 numElements, const char* filename = __FILE__, PxI32 line = __LINE__)
{
void* ptr = allocPinnedHostBufferInternal(PxU64(numElements) * sizeof(T), filename, line);
return reinterpret_cast<T*>(ptr);
}
/**
* \brief Frees a pinned host buffer
*
* The cuda context will get acquired automatically
*/
template<typename T>
void freePinnedHostBuffer(T*& pinnedHostBuffer)
{
freePinnedHostBufferInternal(pinnedHostBuffer);
pinnedHostBuffer = NULL;
}
/**
* \brief Gets a mapped pointer from a pinned host buffer that can be used in cuda kernels directly
*
* Data access performance with a mapped pinned host pointer will be slower than using a device pointer directly
* but the changes done in the kernel will be available on the host immediately.
* The cuda context will get acquired automatically
*/
virtual CUdeviceptr getMappedDevicePtr(void* pinnedHostBuffer) = 0;
/**
* \brief Acquire the CUDA context for the current thread
*
* Acquisitions are allowed to be recursive within a single thread.
* You can acquire the context multiple times so long as you release
* it the same count.
*
* The context must be acquired before using most CUDA functions.
*/
virtual void acquireContext() = 0;
/**
* \brief Release the CUDA context from the current thread
*
* The CUDA context should be released as soon as practically
* possible, to allow other CPU threads to work efficiently.
*/
virtual void releaseContext() = 0;
/**
* \brief Return the CUcontext
*/
virtual CUcontext getContext() = 0;
/**
* \brief Return the CudaContext
*/
virtual PxCudaContext* getCudaContext() = 0;
/**
* \brief Context manager has a valid CUDA context
*
* This method should be called after creating a PxCudaContextManager,
* especially if the manager was responsible for allocating its own
* CUDA context (desc.ctx == NULL).
*/
virtual bool contextIsValid() const = 0;
/* Query CUDA context and device properties, without acquiring context */
virtual bool supportsArchSM10() const = 0; //!< G80
virtual bool supportsArchSM11() const = 0; //!< G92
virtual bool supportsArchSM12() const = 0; //!< GT200
virtual bool supportsArchSM13() const = 0; //!< GT260
virtual bool supportsArchSM20() const = 0; //!< GF100
virtual bool supportsArchSM30() const = 0; //!< GK100
virtual bool supportsArchSM35() const = 0; //!< GK110
virtual bool supportsArchSM50() const = 0; //!< GM100
virtual bool supportsArchSM52() const = 0; //!< GM200
virtual bool supportsArchSM60() const = 0; //!< GP100
virtual bool isIntegrated() const = 0; //!< true if GPU is an integrated (MCP) part
virtual bool canMapHostMemory() const = 0; //!< true if GPU map host memory to GPU (0-copy)
virtual int getDriverVersion() const = 0; //!< returns cached value of cuGetDriverVersion()
virtual size_t getDeviceTotalMemBytes() const = 0; //!< returns cached value of device memory size
virtual int getMultiprocessorCount() const = 0; //!< returns cache value of SM unit count
virtual unsigned int getClockRate() const = 0; //!< returns cached value of SM clock frequency
virtual int getSharedMemPerBlock() const = 0; //!< returns total amount of shared memory available per block in bytes
virtual int getSharedMemPerMultiprocessor() const = 0; //!< returns total amount of shared memory available per multiprocessor in bytes
virtual unsigned int getMaxThreadsPerBlock() const = 0; //!< returns the maximum number of threads per block
virtual const char *getDeviceName() const = 0; //!< returns device name retrieved from driver
virtual CUdevice getDevice() const = 0; //!< returns device handle retrieved from driver
virtual void setUsingConcurrentStreams(bool) = 0; //!< turn on/off using concurrent streams for GPU work
virtual bool getUsingConcurrentStreams() const = 0; //!< true if GPU work can run in concurrent streams
/* End query methods that don't require context to be acquired */
virtual void getDeviceMemoryInfo(size_t& free, size_t& total) const = 0; //!< get currently available and total memory
/**
* \brief Determine if the user has configured a dedicated PhysX GPU in the NV Control Panel
* \note If using CUDA Interop, this will always return false
* \returns 1 if there is a dedicated GPU
* 0 if there is NOT a dedicated GPU
* -1 if the routine is not implemented
*/
virtual int usingDedicatedGPU() const = 0;
/**
* \brief Get the cuda modules that have been loaded into this context on construction
* \return Pointer to the cuda modules
*/
virtual CUmodule* getCuModules() = 0;
/**
* \brief Release the PxCudaContextManager
*
* If the PxCudaContextManager created the CUDA context it was
* responsible for, it also frees that context.
*
* Do not release the PxCudaContextManager if there are any scenes
* using it. Those scenes must be released first.
*
*/
virtual void release() = 0;
protected:
/**
* \brief protected destructor, use release() method
*/
virtual ~PxCudaContextManager() {}
virtual void* allocDeviceBufferInternal(PxU64 numBytes, const char* filename = NULL, PxI32 line = -1) = 0;
virtual void* allocPinnedHostBufferInternal(PxU64 numBytes, const char* filename = NULL, PxI32 line = -1) = 0;
virtual void freeDeviceBufferInternal(void* deviceBuffer) = 0;
virtual void freePinnedHostBufferInternal(void* pinnedHostBuffer) = 0;
virtual void clearDeviceBufferAsyncInternal(void* deviceBuffer, PxU32 numBytes, CUstream stream, PxI32 value) = 0;
virtual void copyDToHAsyncInternal(void* hostBuffer, const void* deviceBuffer, PxU32 numBytes, CUstream stream) = 0;
virtual void copyHToDAsyncInternal(void* deviceBuffer, const void* hostBuffer, PxU32 numBytes, CUstream stream) = 0;
virtual void copyDToDAsyncInternal(void* dstDeviceBuffer, const void* srcDeviceBuffer, PxU32 numBytes, CUstream stream) = 0;
virtual void copyDToHInternal(void* hostBuffer, const void* deviceBuffer, PxU32 numBytes) = 0;
virtual void copyHToDInternal(void* deviceBuffer, const void* hostBuffer, PxU32 numBytes) = 0;
virtual void memsetD8AsyncInternal(void* dstDeviceBuffer, const PxU8& value, PxU32 numBytes, CUstream stream) = 0;
virtual void memsetD32AsyncInternal(void* dstDeviceBuffer, const PxU32& value, PxU32 numIntegers, CUstream stream) = 0;
};
#define PX_DEVICE_ALLOC(cudaContextManager, deviceBuffer, numElements) cudaContextManager->allocDeviceBuffer(deviceBuffer, numElements, PX_FL)
#define PX_DEVICE_ALLOC_T(T, cudaContextManager, numElements) cudaContextManager->allocDeviceBuffer<T>(numElements, PX_FL)
#define PX_DEVICE_FREE(cudaContextManager, deviceBuffer) cudaContextManager->freeDeviceBuffer(deviceBuffer);
#define PX_PINNED_HOST_ALLOC(cudaContextManager, pinnedHostBuffer, numElements) cudaContextManager->allocPinnedHostBuffer(pinnedHostBuffer, numElements, PX_FL)
#define PX_PINNED_HOST_ALLOC_T(T, cudaContextManager, numElements) cudaContextManager->allocPinnedHostBuffer<T>(numElements, PX_FL)
#define PX_PINNED_HOST_FREE(cudaContextManager, pinnedHostBuffer) cudaContextManager->freePinnedHostBuffer(pinnedHostBuffer);
/**
* \brief Convenience class for holding CUDA lock within a scope
*/
class PxScopedCudaLock
{
public:
/**
* \brief ScopedCudaLock constructor
*/
PxScopedCudaLock(PxCudaContextManager& ctx) : mCtx(&ctx)
{
mCtx->acquireContext();
}
/**
* \brief ScopedCudaLock destructor
*/
~PxScopedCudaLock()
{
mCtx->releaseContext();
}
protected:
/**
* \brief CUDA context manager pointer (initialized in the constructor)
*/
PxCudaContextManager* mCtx;
};
#if !PX_DOXYGEN
} // namespace physx
#endif
#endif // PX_SUPPORT_GPU_PHYSX
#endif
| 18,190 | C | 35.021782 | 159 | 0.734634 |
NVIDIA-Omniverse/PhysX/physx/include/cudamanager/PxCudaContext.h | // 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-2023 NVIDIA Corporation. All rights reserved.
#ifndef PX_CUDA_CONTEX_H
#define PX_CUDA_CONTEX_H
#include "foundation/PxPreprocessor.h"
#if PX_SUPPORT_GPU_PHYSX
#include "PxCudaTypes.h"
#if !PX_DOXYGEN
namespace physx
{
#endif
struct PxCudaKernelParam
{
void* data;
size_t size;
};
// workaround for not being able to forward declare enums in PxCudaTypes.h.
// provides different automatic casting depending on whether cuda.h was included beforehand or not.
template<typename CUenum>
struct PxCUenum
{
PxU32 value;
PxCUenum(CUenum e) { value = PxU32(e); }
operator CUenum() const { return CUenum(value); }
};
#ifdef CUDA_VERSION
typedef PxCUenum<CUjit_option> PxCUjit_option;
typedef PxCUenum<CUresult> PxCUresult;
#else
typedef PxCUenum<PxU32> PxCUjit_option;
typedef PxCUenum<PxU32> PxCUresult;
#endif
#define PX_CUDA_KERNEL_PARAM(X) { (void*)&X, sizeof(X) }
#define PX_CUDA_KERNEL_PARAM2(X) (void*)&X
class PxDeviceAllocatorCallback;
/**
Cuda Context
*/
class PxCudaContext
{
protected:
virtual ~PxCudaContext() {}
PxDeviceAllocatorCallback* mAllocatorCallback;
public:
virtual void release() = 0;
virtual PxCUresult memAlloc(CUdeviceptr *dptr, size_t bytesize) = 0;
virtual PxCUresult memFree(CUdeviceptr dptr) = 0;
virtual PxCUresult memHostAlloc(void **pp, size_t bytesize, unsigned int Flags) = 0;
virtual PxCUresult memFreeHost(void *p) = 0;
virtual PxCUresult memHostGetDevicePointer(CUdeviceptr *pdptr, void *p, unsigned int Flags) = 0;
virtual PxCUresult moduleLoadDataEx(CUmodule *module, const void *image, unsigned int numOptions, PxCUjit_option *options, void **optionValues) = 0;
virtual PxCUresult moduleGetFunction(CUfunction *hfunc, CUmodule hmod, const char *name) = 0;
virtual PxCUresult moduleUnload(CUmodule hmod) = 0;
virtual PxCUresult streamCreate(CUstream *phStream, unsigned int Flags) = 0;
virtual PxCUresult streamCreateWithPriority(CUstream *phStream, unsigned int flags, int priority) = 0;
virtual PxCUresult streamFlush(CUstream hStream) = 0;
virtual PxCUresult streamWaitEvent(CUstream hStream, CUevent hEvent, unsigned int Flags) = 0;
virtual PxCUresult streamDestroy(CUstream hStream) = 0;
virtual PxCUresult streamSynchronize(CUstream hStream) = 0;
virtual PxCUresult eventCreate(CUevent *phEvent, unsigned int Flags) = 0;
virtual PxCUresult eventRecord(CUevent hEvent, CUstream hStream) = 0;
virtual PxCUresult eventQuery(CUevent hEvent) = 0;
virtual PxCUresult eventSynchronize(CUevent hEvent) = 0;
virtual PxCUresult eventDestroy(CUevent hEvent) = 0;
virtual PxCUresult launchKernel(
CUfunction f,
unsigned int gridDimX,
unsigned int gridDimY,
unsigned int gridDimZ,
unsigned int blockDimX,
unsigned int blockDimY,
unsigned int blockDimZ,
unsigned int sharedMemBytes,
CUstream hStream,
PxCudaKernelParam* kernelParams,
size_t kernelParamsSizeInBytes,
void** extra,
const char* file,
int line
) = 0;
// PT: same as above but without copying the kernel params to a local stack before the launch
// i.e. the kernelParams data is passed directly to the kernel.
virtual PxCUresult launchKernel(
CUfunction f,
PxU32 gridDimX, PxU32 gridDimY, PxU32 gridDimZ,
PxU32 blockDimX, PxU32 blockDimY, PxU32 blockDimZ,
PxU32 sharedMemBytes,
CUstream hStream,
void** kernelParams,
void** extra,
const char* file,
int line
) = 0;
virtual PxCUresult memcpyDtoH(void *dstHost, CUdeviceptr srcDevice, size_t ByteCount) = 0;
virtual PxCUresult memcpyDtoHAsync(void* dstHost, CUdeviceptr srcDevice, size_t ByteCount, CUstream hStream) = 0;
virtual PxCUresult memcpyHtoD(CUdeviceptr dstDevice, const void *srcHost, size_t ByteCount) = 0;
virtual PxCUresult memcpyHtoDAsync(CUdeviceptr dstDevice, const void *srcHost, size_t ByteCount, CUstream hStream) = 0;
virtual PxCUresult memcpyDtoDAsync(CUdeviceptr dstDevice, CUdeviceptr srcDevice, size_t ByteCount, CUstream hStream) = 0;
virtual PxCUresult memcpyDtoD(CUdeviceptr dstDevice, CUdeviceptr srcDevice, size_t ByteCount) = 0;
virtual PxCUresult memcpyPeerAsync(CUdeviceptr dstDevice, CUcontext dstContext, CUdeviceptr srcDevice, CUcontext srcContext, size_t ByteCount, CUstream hStream) = 0;
virtual PxCUresult memsetD32Async(CUdeviceptr dstDevice, unsigned int ui, size_t N, CUstream hStream) = 0;
virtual PxCUresult memsetD8Async(CUdeviceptr dstDevice, unsigned char uc, size_t N, CUstream hStream) = 0;
virtual PxCUresult memsetD32(CUdeviceptr dstDevice, unsigned int ui, size_t N) = 0;
virtual PxCUresult memsetD16(CUdeviceptr dstDevice, unsigned short uh, size_t N) = 0;
virtual PxCUresult memsetD8(CUdeviceptr dstDevice, unsigned char uc, size_t N) = 0;
virtual PxCUresult getLastError() = 0;
PxDeviceAllocatorCallback* getAllocatorCallback() { return mAllocatorCallback; }
};
#if !PX_DOXYGEN
} // namespace physx
#endif
#endif // PX_SUPPORT_GPU_PHYSX
#endif
| 6,486 | C | 33.689839 | 167 | 0.760099 |
NVIDIA-Omniverse/PhysX/physx/include/cudamanager/PxCudaTypes.h | // 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-2023 NVIDIA Corporation. All rights reserved.
#ifndef PX_CUDA_TYPES_H
#define PX_CUDA_TYPES_H
//type definitions to avoid forced inclusion of cuda.h
//if cuda.h is needed anyway, please include it before PxCudaContextManager.h, PxCudaContext.h or PxCudaTypes.h
#include "foundation/PxPreprocessor.h"
#if PX_SUPPORT_GPU_PHYSX
#ifndef CUDA_VERSION
#include "foundation/PxSimpleTypes.h"
#if PX_CLANG
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
#endif
#if PX_P64_FAMILY
typedef unsigned long long CUdeviceptr;
#else
typedef unsigned int CUdeviceptr;
#endif
#if PX_CLANG
#pragma clang diagnostic pop
#endif
typedef int CUdevice;
typedef struct CUctx_st* CUcontext;
typedef struct CUmod_st* CUmodule;
typedef struct CUfunc_st* CUfunction;
typedef struct CUstream_st* CUstream;
typedef struct CUevent_st* CUevent;
typedef struct CUgraphicsResource_st* CUgraphicsResource;
#endif
#else
typedef struct CUstream_st* CUstream; // We declare some callbacks taking CUstream as an argument even when building with PX_SUPPORT_GPU_PHYSX = 0.
typedef struct CUevent_st* CUevent;
#endif // PX_SUPPORT_GPU_PHYSX
#endif
| 2,674 | C | 36.152777 | 147 | 0.777487 |
NVIDIA-Omniverse/PhysX/physx/include/pvd/PxPvdTransport.h | // 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-2023 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 PX_PVD_TRANSPORT_H
#define PX_PVD_TRANSPORT_H
/** \addtogroup pvd
@{
*/
#include "foundation/PxErrors.h"
#include "foundation/PxFlags.h"
#include "pvd/PxPvd.h"
#if !PX_DOXYGEN
namespace physx
{
#endif
/**
\brief PxPvdTransport is an interface representing the data transport mechanism.
This class defines all services associated with the transport: configuration, connection, reading, writing etc.
It is owned by the application, and can be realized as a file or a socket (using one-line PxDefault<...> methods in
PhysXExtensions) or in a custom implementation. This is a class that is intended for use by PVD, not by the
application, the application entry points are PxPvd and PvdClient.
*/
class PxPvdTransport
{
public:
// connect, isConnected, disconnect, read, write, flush
/**
Connects to the Visual Debugger application.
return True if success
*/
virtual bool connect() = 0;
/**
Disconnects from the Visual Debugger application.
If we are still connected, this will kill the entire debugger connection.
*/
virtual void disconnect() = 0;
/**
* Return if connection to PVD is created.
*/
virtual bool isConnected() = 0;
/**
* write bytes to the other endpoint of the connection. should lock before witre. If an error occurs
* this connection will assume to be dead.
*/
virtual bool write(const uint8_t* inBytes, uint32_t inLength) = 0;
/*
lock this transport and return it
*/
virtual PxPvdTransport& lock() = 0;
/*
unlock this transport
*/
virtual void unlock() = 0;
/**
* send any data and block until we know it is at least on the wire.
*/
virtual void flush() = 0;
/**
* Return size of written data.
*/
virtual uint64_t getWrittenDataSize() = 0;
virtual void release() = 0;
protected:
virtual ~PxPvdTransport()
{
}
};
/**
\brief Create a default socket transport.
\param host host address of the pvd application.
\param port ip port used for pvd, should same as the port setting in pvd application.
\param timeoutInMilliseconds timeout when connect to pvd host.
*/
PX_C_EXPORT PxPvdTransport* PX_CALL_CONV
PxDefaultPvdSocketTransportCreate(const char* host, int port, unsigned int timeoutInMilliseconds);
/**
\brief Create a default file transport.
\param name full path filename used save captured pvd data, or NULL for a fake/test file transport.
*/
PX_C_EXPORT PxPvdTransport* PX_CALL_CONV PxDefaultPvdFileTransportCreate(const char* name);
#if !PX_DOXYGEN
} // namespace physx
#endif
/** @} */
#endif
| 4,203 | C | 31.338461 | 115 | 0.743279 |
NVIDIA-Omniverse/PhysX/physx/include/pvd/PxPvd.h | // 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-2023 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 PX_PVD_H
#define PX_PVD_H
/** \addtogroup pvd
@{
*/
#include "foundation/PxFlags.h"
#include "foundation/PxProfiler.h"
#if !PX_DOXYGEN
namespace physx
{
#endif
class PxFoundation;
class PxPvdTransport;
/**
\brief types of instrumentation that PVD can do.
*/
struct PxPvdInstrumentationFlag
{
enum Enum
{
/**
\brief Send debugging information to PVD.
This information is the actual object data of the rigid statics, shapes,
articulations, etc. Sending this information has a noticeable impact on
performance and thus this flag should not be set if you want an accurate
performance profile.
*/
eDEBUG = 1 << 0,
/**
\brief Send profile information to PVD.
This information populates PVD's profile view. It has (at this time) negligible
cost compared to Debug information and makes PVD *much* more useful so it is quite
highly recommended.
This flag works together with a PxCreatePhysics parameter.
Using it allows the SDK to send profile events to PVD.
*/
ePROFILE = 1 << 1,
/**
\brief Send memory information to PVD.
The PVD sdk side hooks into the Foundation memory controller and listens to
allocation/deallocation events. This has a noticable hit on the first frame,
however, this data is somewhat compressed and the PhysX SDK doesn't allocate much
once it hits a steady state. This information also has a fairly negligible
impact and thus is also highly recommended.
This flag works together with a PxCreatePhysics parameter,
trackOutstandingAllocations. Using both of them together allows users to have
an accurate view of the overall memory usage of the simulation at the cost of
a hashtable lookup per allocation/deallocation. Again, PhysX makes a best effort
attempt not to allocate or deallocate during simulation so this hashtable lookup
tends to have no effect past the first frame.
Sending memory information without tracking outstanding allocations means that
PVD will accurate information about the state of the memory system before the
actual connection happened.
*/
eMEMORY = 1 << 2,
eALL = (eDEBUG | ePROFILE | eMEMORY)
};
};
/**
\brief Bitfield that contains a set of raised flags defined in PxPvdInstrumentationFlag.
@see PxPvdInstrumentationFlag
*/
typedef PxFlags<PxPvdInstrumentationFlag::Enum, uint8_t> PxPvdInstrumentationFlags;
PX_FLAGS_OPERATORS(PxPvdInstrumentationFlag::Enum, uint8_t)
/**
\brief PxPvd is the top-level class for the PVD framework, and the main customer interface for PVD
configuration.It is a singleton class, instantiated and owned by the application.
*/
class PxPvd : public physx::PxProfilerCallback
{
public:
/**
Connects the SDK to the PhysX Visual Debugger application.
\param transport transport for pvd captured data.
\param flags Flags to set.
return True if success
*/
virtual bool connect(PxPvdTransport& transport, PxPvdInstrumentationFlags flags) = 0;
/**
Disconnects the SDK from the PhysX Visual Debugger application.
If we are still connected, this will kill the entire debugger connection.
*/
virtual void disconnect() = 0;
/**
* Return if connection to PVD is created.
\param useCachedStatus
1> When useCachedStaus is false, isConnected() checks the lowlevel network status.
This can be slow because it needs to lock the lowlevel network stream. If isConnected() is
called frequently, the expense of locking can be significant.
2> When useCachedStatus is true, isConnected() checks the highlevel cached status with atomic access.
It is faster than locking, but the status may be different from the lowlevel network with latency of up to
one frame.
The reason for this is that the cached status is changed inside socket listener, which is not
called immediately when the lowlevel connection status changes.
*/
virtual bool isConnected(bool useCachedStatus = true) = 0;
/**
returns the PVD data transport
returns NULL if no transport is present.
*/
virtual PxPvdTransport* getTransport() = 0;
/**
Retrieves the PVD flags. See PxPvdInstrumentationFlags.
*/
virtual PxPvdInstrumentationFlags getInstrumentationFlags() = 0;
/**
\brief Releases the pvd instance.
*/
virtual void release() = 0;
protected:
virtual ~PxPvd()
{
}
};
/**
\brief Create a pvd instance.
\param foundation is the foundation instance that stores the allocator and error callbacks.
*/
PX_C_EXPORT PxPvd* PX_CALL_CONV PxCreatePvd(PxFoundation& foundation);
#if !PX_DOXYGEN
} // namespace physx
#endif
/** @} */
#endif
| 6,302 | C | 34.21229 | 114 | 0.749921 |
NVIDIA-Omniverse/PhysX/physx/include/pvd/PxPvdSceneClient.h | // 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-2023 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 PX_PVD_SCENE_CLIENT_H
#define PX_PVD_SCENE_CLIENT_H
/** \addtogroup pvd
@{
*/
#include "foundation/PxFlags.h"
#if !PX_DOXYGEN
namespace physx
{
#endif
namespace pvdsdk
{
class PvdClient;
}
struct PxDebugPoint;
struct PxDebugLine;
struct PxDebugTriangle;
struct PxDebugText;
#if !PX_DOXYGEN
} // namespace physx
#endif
#if !PX_DOXYGEN
namespace physx
{
#endif
/**
\brief PVD scene Flags. They are disabled by default, and only works if PxPvdInstrumentationFlag::eDEBUG is set.
*/
struct PxPvdSceneFlag
{
enum Enum
{
eTRANSMIT_CONTACTS = (1 << 0), //! Transmits contact stream to PVD.
eTRANSMIT_SCENEQUERIES = (1 << 1), //! Transmits scene query stream to PVD.
eTRANSMIT_CONSTRAINTS = (1 << 2) //! Transmits constraints visualize stream to PVD.
};
};
/**
\brief Bitfield that contains a set of raised flags defined in PxPvdSceneFlag.
@see PxPvdSceneFlag
*/
typedef PxFlags<PxPvdSceneFlag::Enum, PxU8> PxPvdSceneFlags;
PX_FLAGS_OPERATORS(PxPvdSceneFlag::Enum, PxU8)
/**
\brief Special client for PxScene.
It provides access to the PxPvdSceneFlag.
It also provides simple user debug services that associated scene position such as immediate rendering and camera updates.
*/
class PxPvdSceneClient
{
public:
/**
Sets the PVD flag. See PxPvdSceneFlag.
\param flag Flag to set.
\param value value the flag gets set to.
*/
virtual void setScenePvdFlag(PxPvdSceneFlag::Enum flag, bool value) = 0;
/**
Sets the PVD flags. See PxPvdSceneFlags.
\param flags Flags to set.
*/
virtual void setScenePvdFlags(PxPvdSceneFlags flags) = 0;
/**
Retrieves the PVD flags. See PxPvdSceneFlags.
*/
virtual PxPvdSceneFlags getScenePvdFlags() const = 0;
/**
update camera on PVD application's render window
*/
virtual void updateCamera(const char* name, const PxVec3& origin, const PxVec3& up, const PxVec3& target) = 0;
/**
draw points on PVD application's render window
*/
virtual void drawPoints(const physx::PxDebugPoint* points, PxU32 count) = 0;
/**
draw lines on PVD application's render window
*/
virtual void drawLines(const physx::PxDebugLine* lines, PxU32 count) = 0;
/**
draw triangles on PVD application's render window
*/
virtual void drawTriangles(const physx::PxDebugTriangle* triangles, PxU32 count) = 0;
/**
draw text on PVD application's render window
*/
virtual void drawText(const physx::PxDebugText& text) = 0;
/**
get the underlying client, for advanced users
*/
virtual physx::pvdsdk::PvdClient* getClientInternal() = 0;
protected:
virtual ~PxPvdSceneClient(){}
};
#if !PX_DOXYGEN
} // namespace physx
#endif
/** @} */
#endif
| 4,313 | C | 28.547945 | 122 | 0.743102 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle/PxVehicleTireFriction.h | // 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-2023 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 PX_VEHICLE_TIREFRICTION_H
#define PX_VEHICLE_TIREFRICTION_H
#include "foundation/PxSimpleTypes.h"
#include "common/PxSerialFramework.h"
#if !PX_DOXYGEN
namespace physx
{
#endif
class PxMaterial;
class PxCollection;
class PxOutputStream;
/**
\brief Driving surface type. Each PxMaterial is associated with a corresponding PxVehicleDrivableSurfaceType.
@see PxMaterial, PxVehicleDrivableSurfaceToTireFrictionPairs
*/
struct PX_DEPRECATED PxVehicleDrivableSurfaceType
{
enum
{
eSURFACE_TYPE_UNKNOWN=0xffffffff
};
PxU32 mType;
};
/**
\brief Friction for each combination of driving surface type and tire type.
@see PxVehicleDrivableSurfaceType, PxVehicleTireData::mType
*/
class PX_DEPRECATED PxVehicleDrivableSurfaceToTireFrictionPairs
{
public:
friend class VehicleSurfaceTypeHashTable;
enum
{
eMAX_NB_SURFACE_TYPES=256
};
/**
\brief Allocate the memory for a PxVehicleDrivableSurfaceToTireFrictionPairs instance
that can hold data for combinations of tire type and surface type with up to maxNbTireTypes types of tire and maxNbSurfaceTypes types of surface.
\param[in] maxNbTireTypes is the maximum number of allowed tire types.
\param[in] maxNbSurfaceTypes is the maximum number of allowed surface types. Must be less than or equal to eMAX_NB_SURFACE_TYPES
\return a PxVehicleDrivableSurfaceToTireFrictionPairs instance that can be reused later with new type and friction data.
@see setup
*/
static PxVehicleDrivableSurfaceToTireFrictionPairs* allocate
(const PxU32 maxNbTireTypes, const PxU32 maxNbSurfaceTypes);
/**
\brief Set up a PxVehicleDrivableSurfaceToTireFrictionPairs instance for combinations of nbTireTypes tire types and nbSurfaceTypes surface types.
\param[in] nbTireTypes is the number of different types of tire. This value must be less than or equal to maxNbTireTypes specified in allocate().
\param[in] nbSurfaceTypes is the number of different types of surface. This value must be less than or equal to maxNbSurfaceTypes specified in allocate().
\param[in] drivableSurfaceMaterials is an array of PxMaterial pointers of length nbSurfaceTypes.
\param[in] drivableSurfaceTypes is an array of PxVehicleDrivableSurfaceType instances of length nbSurfaceTypes.
\note If the pointer to the PxMaterial that touches the tire is found in drivableSurfaceMaterials[x] then the surface type is drivableSurfaceTypes[x].mType
and the friction is the value that is set with setTypePairFriction(drivableSurfaceTypes[x].mType, PxVehicleTireData::mType, frictionValue).
\note A friction value of 1.0 will be assigned as default to each combination of tire and surface type. To override this use setTypePairFriction.
@see release, setTypePairFriction, getTypePairFriction, PxVehicleTireData.mType
*/
void setup
(const PxU32 nbTireTypes, const PxU32 nbSurfaceTypes,
const PxMaterial** drivableSurfaceMaterials, const PxVehicleDrivableSurfaceType* drivableSurfaceTypes);
/**
\brief Deallocate a PxVehicleDrivableSurfaceToTireFrictionPairs instance
*/
void release();
/**
\brief Set the friction for a specified pair of tire type and drivable surface type.
\param[in] surfaceType describes the surface type
\param[in] tireType describes the tire type.
\param[in] value describes the friction coefficient for the combination of surface type and tire type.
*/
void setTypePairFriction(const PxU32 surfaceType, const PxU32 tireType, const PxReal value);
/**
\brief Compute the surface type associated with a specified PxMaterial instance.
\param[in] surfaceMaterial is the material to be queried for its associated surface type.
\note The surface type may be used to query the friction of a surface type/tire type pair using getTypePairFriction()
\return The surface type associated with a specified PxMaterial instance.
If surfaceMaterial is not referenced by the PxVehicleDrivableSurfaceToTireFrictionPairs a value of 0 will be returned.
@see setup
@see getTypePairFriction
*/
PxU32 getSurfaceType(const PxMaterial& surfaceMaterial) const;
/**
\brief Return the friction for a specified combination of surface type and tire type.
\return The friction for a specified combination of surface type and tire type.
\note The final friction value used by the tire model is the value returned by getTypePairFriction
multiplied by the value computed from PxVehicleTireData::mFrictionVsSlipGraph
\note The surface type is associated with a PxMaterial. The mapping between the two may be queried using getSurfaceType().
@see PxVehicleTireData::mFrictionVsSlipGraph
@see getSurfaceType
*/
PxReal getTypePairFriction(const PxU32 surfaceType, const PxU32 tireType) const;
/**
\brief Return the friction for a specified combination of PxMaterial and tire type.
\return The friction for a specified combination of PxMaterial and tire type.
\note The final friction value used by the tire model is the value returned by getTypePairFriction
multiplied by the value computed from PxVehicleTireData::mFrictionVsSlipGraph
\note If surfaceMaterial is not referenced by the PxVehicleDrivableSurfaceToTireFrictionPairs
a surfaceType of value 0 will be assumed and the corresponding friction value will be returned.
@see PxVehicleTireData::mFrictionVsSlipGraph
*/
PxReal getTypePairFriction(const PxMaterial& surfaceMaterial, const PxU32 tireType) const;
/**
\brief Return the maximum number of surface types
\return The maximum number of surface types
@see allocate
*/
PX_FORCE_INLINE PxU32 getMaxNbSurfaceTypes() const {return mMaxNbSurfaceTypes;}
/**
\brief Return the maximum number of tire types
\return The maximum number of tire types
@see allocate
*/
PX_FORCE_INLINE PxU32 getMaxNbTireTypes() const {return mMaxNbTireTypes;}
/**
\brief Binary serialization of a PxVehicleDrivableSurfaceToTireFrictionPairs instance.
The PxVehicleDrivableSurfaceToTireFrictionPairs instance is serialized to a PxOutputStream.
The materials referenced by the PxVehicleDrivableSurfaceToTireFrictionPairs instance are
serialized to a PxCollection.
\param[in] frictionTable is the PxVehicleDrivableSurfaceToTireFrictionPairs instance to be serialized.
\param[in] materialIds are unique ids that will be used to add the materials to the collection.
\param[in] nbMaterialIds is the length of the materialIds array. It must be sufficient to cover all materials.
\param[out] collection is the PxCollection instance that is to be used to serialize the PxMaterial instances referenced by the
PxVehicleDrivableSurfaceToTireFrictionPairs instance.
\param[out] stream contains the memory block for the binary serialized friction table.
\note If a material has already been added to the collection with a PxSerialObjectId, it will not be added again.
\note If all materials have already been added to the collection with a PxSerialObjectId, it is legal to pass a NULL ptr for the materialIds array.
\note frictionTable references PxMaterial instances, which are serialized using PxCollection.
The PxCollection instance may be used to serialize an entire scene that also references some or none of those material instances
or particular objects in a scene or nothing at all. The complementary deserialize() function requires the same collection instance
or more typically a deserialized copy of the collection to be passed as a function argument.
@see deserializeFromBinary
*/
static void serializeToBinary(const PxVehicleDrivableSurfaceToTireFrictionPairs& frictionTable, const PxSerialObjectId* materialIds, const PxU32 nbMaterialIds, PxCollection* collection, PxOutputStream& stream);
/**
\brief Deserialize from a memory block to create a PxVehicleDrivableSurfaceToTireFrictionPairs instance.
\param[in] collection contains the PxMaterial instances that will be referenced by the friction table.
\param[in] memBlock is a binary array that may be retrieved or copied from the stream in the complementary serializeToBinary function.
\return A PxVehicleDrivableSurfaceToTireFrictionPairs instance whose base address is equal to the memBlock ptr.
@see serializeToBinary
*/
static PxVehicleDrivableSurfaceToTireFrictionPairs* deserializeFromBinary(const PxCollection& collection, void* memBlock);
private:
/**
\brief Ptr to base address of a 2d PxReal array with dimensions [mNbSurfaceTypes][mNbTireTypes]
\note Each element of the array describes the maximum friction provided by a surface type-tire type combination.
eg the friction corresponding to a combination of surface type x and tire type y is mPairs[x][y]
*/
PxReal* mPairs;
/**
\brief Ptr to 1d array of material ptrs that is of length mNbSurfaceTypes.
\note If the PxMaterial that touches the tire corresponds to mDrivableSurfaceMaterials[x] then the drivable surface
type is mDrivableSurfaceTypes[x].mType and the friction for that contact is mPairs[mDrivableSurfaceTypes[x].mType][y],
assuming a tire type y.
\note If the PxMaterial that touches the tire is not found in mDrivableSurfaceMaterials then the friction is
mPairs[0][y], assuming a tire type y.
*/
const PxMaterial** mDrivableSurfaceMaterials;
/**
\brief Ptr to 1d array of PxVehicleDrivableSurfaceType that is of length mNbSurfaceTypes.
\note If the PxMaterial that touches the tire is found in mDrivableSurfaceMaterials[x] then the drivable surface
type is mDrivableSurfaceTypes[x].mType and the friction for that contact is mPairs[mDrivableSurfaceTypes[x].mType][y],
assuming a tire type y.
\note If the PxMaterial that touches the tire is not found in mDrivableSurfaceMaterials then the friction is
mPairs[0][y], assuming a tire type y.
*/
PxVehicleDrivableSurfaceType* mDrivableSurfaceTypes;
/**
\brief A PxSerialObjectId per surface type used internally for serialization.
*/
PxSerialObjectId* mMaterialSerialIds;
/**
\brief Number of different driving surface types.
\note mDrivableSurfaceMaterials and mDrivableSurfaceTypes are both 1d arrays of length mMaxNbSurfaceTypes.
\note mNbSurfaceTypes must be less than or equal to mMaxNbSurfaceTypes.
*/
PxU32 mNbSurfaceTypes;
/**
\brief Maximum number of different driving surface types.
\note mMaxNbSurfaceTypes must be less than or equal to eMAX_NB_SURFACE_TYPES.
*/
PxU32 mMaxNbSurfaceTypes;
/**
\brief Number of different tire types.
\note Tire types stored in PxVehicleTireData.mType
*/
PxU32 mNbTireTypes;
/**
\brief Maximum number of different tire types.
\note Tire types stored in PxVehicleTireData.mType
*/
PxU32 mMaxNbTireTypes;
PxVehicleDrivableSurfaceToTireFrictionPairs(){}
~PxVehicleDrivableSurfaceToTireFrictionPairs(){}
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleDrivableSurfaceToTireFrictionPairs) & 15));
#if !PX_DOXYGEN
} // namespace physx
#endif
#endif
| 12,491 | C | 44.425454 | 211 | 0.798175 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle/PxVehicleDriveTank.h | // 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-2023 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 PX_VEHICLE_DRIVE_TANK_H
#define PX_VEHICLE_DRIVE_TANK_H
#include "vehicle/PxVehicleDrive.h"
#include "vehicle/PxVehicleWheels.h"
#include "vehicle/PxVehicleComponents.h"
#if !PX_DOXYGEN
namespace physx
{
#endif
struct PxFilterData;
class PxGeometry;
class PxPhysics;
class PxVehicleDrivableSurfaceToTireFrictionPairs;
class PxShape;
class PxMaterial;
class PxRigidDynamic;
/**
\brief The ordering of the wheels of a PxVehicleDriveTank.
@see PxVehicleWheelsSimData, PxVehicleWheelsDynData
*/
struct PX_DEPRECATED PxVehicleDriveTankWheelOrder
{
enum Enum
{
eFRONT_LEFT=0,
eFRONT_RIGHT,
e1ST_FROM_FRONT_LEFT,
e1ST_FROM_FRONT_RIGHT,
e2ND_FROM_FRONT_LEFT,
e2ND_FROM_FRONT_RIGHT,
e3RD_FROM_FRONT_LEFT,
e3RD_FROM_FRONT_RIGHT,
e4TH_FROM_FRONT_LEFT,
e4TH_FROM_FRONT_RIGHT,
e5TH_FROM_FRONT_LEFT,
e5TH_FROM_FRONT_RIGHT,
e6TH_FROM_FRONT_LEFT,
e6TH_FROM_FRONT_RIGHT,
e7TH_FROM_FRONT_LEFT,
e7TH_FROM_FRONT_RIGHT,
e8TH_FROM_FRONT_LEFT,
e8TH_FROM_FRONT_RIGHT,
e9TH_FROM_FRONT_LEFT,
e9TH_FROM_FRONT_RIGHT
};
};
/**
\brief The control inputs for a PxVehicleDriveTank.
\note The values of eANALOG_INPUT_THRUST_LEFT and eANALOG_INPUT_THRUST_RIGHT determine how much
of the total available drive torque is diverted to the left and right wheels. These entries in the
enumerated list represent the state of the left and right control sticks of a tank. The total available
drive torque available is controlled by eANALOG_INPUT_ACCEL, which represents the state of the acceleration
pedal and controls how much torque will be applied to the engine.
\note To accelerate forwards eANALOG_INPUT_ACCEL must be greater than zero so that torque is applied to drive the
engine, while eANALOG_INPUT_THRUST_LEFT and eANALOG_INPUT_THRUST_RIGHT must also be greater than zero
to divert the available drive torque to the left and wheels. If eANALOG_INPUT_THRUST_LEFT > eANALOG_INPUT_THRUST_RIGHT
the tank will turn to the right. If eANALOG_INPUT_THRUST_RIGHT > eANALOG_INPUT_THRUST_LEFT
the tank will turn to the left.
@see PxVehicleDriveDynData::setAnalogInput, PxVehicleDriveDynData::getAnalogInput
*/
struct PX_DEPRECATED PxVehicleDriveTankControl
{
enum Enum
{
eANALOG_INPUT_ACCEL=0,
eANALOG_INPUT_BRAKE_LEFT,
eANALOG_INPUT_BRAKE_RIGHT,
eANALOG_INPUT_THRUST_LEFT,
eANALOG_INPUT_THRUST_RIGHT,
eMAX_NB_DRIVETANK_ANALOG_INPUTS
};
};
/**
\brief Two driving models are supported.
\note If eSTANDARD is chosen the left and right wheels are always driven in the same direction. If the tank is in
a forward gear the left and right wheels will all be driven forwards, while in reverse gear the left and right wheels
will all be driven backwards. With eSTANDARD the legal range of left and right thrust is (0,1).
\note If eSPECIAL is chosen it is possible to drive the left and right wheels in different directions.
With eSPECIAL the legal range of left and right thrust is (-1,1). In forward(reverse) gear negative thrust values drive the wheels
backwards(forwards), while positive thrust values drives the wheels forwards(backwards).
\note A sharp left turn can be achieved in eSTANDARD mode by braking with the left wheels and thrusting forward with the
right wheels. A smaller turning circle can theoretically be achieved in eSPECIAL mode by applying negative thrust to the left wheels and positive
thrust to the right wheels.
\note In both modes the legal ranges of acceleration and left/right brake are all (0,1).
@see PxVehicleDriveTank::setDriveModel
*/
struct PX_DEPRECATED PxVehicleDriveTankControlModel
{
enum Enum
{
eSTANDARD=0,
eSPECIAL
};
};
/**
\brief Data structure with instanced dynamics data and configuration data of a tank.
*/
class PX_DEPRECATED PxVehicleDriveTank : public PxVehicleDrive
{
public:
friend class PxVehicleUpdate;
/**
\brief Allocate a PxVehicleTankDrive instance for a tank with nbWheels
\param[in] nbWheels is the number of wheels on the vehicle.
\note It is assumed that all wheels are driven wheels.
\return The instantiated vehicle.
@see free, setup
*/
static PxVehicleDriveTank* allocate(const PxU32 nbWheels);
/**
\brief Deallocate a PxVehicleDriveTank instance.
@see allocate
*/
void free();
/**
\brief Set up a tank using simulation data for the wheels and drive model.
\param[in] physics is a PxPhysics instance that is needed to create special vehicle constraints that are maintained by the vehicle.
\param[in] vehActor is a PxRigidDynamic instance that is used to represent the tank in the PhysX SDK.
\param[in] wheelsData describes the configuration of all suspension/tires/wheels of the tank. The tank instance takes a copy of this data.
\param[in] driveData describes the properties of the tank's drive model (gears/engine/clutch/autobox). The tank instance takes a copy of this data.
\param[in] nbDrivenWheels is the number of wheels on the tank.
\note It is assumed that the first shapes of the actor are the wheel shapes, followed by the chassis shapes. To break this assumption use PxVehicleWheelsSimData::setWheelShapeMapping.
@see allocate, free, setToRestState, PxVehicleWheelsSimData::setWheelShapeMapping
\note nbDrivenWheels must be an even number
\note The wheels must be arranged according to PxVehicleDriveTankWheelOrder; that is,
the even wheels are on the left side of the tank and the odd wheels are on the right side of the tank.
*/
void setup
(PxPhysics* physics, PxRigidDynamic* vehActor,
const PxVehicleWheelsSimData& wheelsData, const PxVehicleDriveSimData& driveData,
const PxU32 nbDrivenWheels);
/**
\brief Allocate and set up a tank using simulation data for the wheels and drive model.
\param[in] physics is a PxPhysics instance that is needed to create special vehicle constraints that are maintained by the tank.
\param[in] vehActor is a PxRigidDynamic instance that is used to represent the tank in the PhysX SDK.
\param[in] wheelsData describes the configuration of all suspension/tires/wheels of the tank. The tank instance takes a copy of this data.
\param[in] driveData describes the properties of the tank's drive model (gears/engine/clutch/differential/autobox). The tank instance takes a copy of this data.
\param[in] nbDrivenWheels is the number of wheels on the tank.
\note It is assumed that the first shapes of the actor are the wheel shapes, followed by the chassis shapes. To break this assumption use PxVehicleWheelsSimData::setWheelShapeMapping.
\return The instantiated vehicle.
@see allocate, free, setToRestState, PxVehicleWheelsSimData::setWheelShapeMapping
*/
static PxVehicleDriveTank* create
(PxPhysics* physics, PxRigidDynamic* vehActor,
const PxVehicleWheelsSimData& wheelsData, const PxVehicleDriveSimData& driveData,
const PxU32 nbDrivenWheels);
/**
\brief Set the control model used by the tank.
\note eDRIVE_MODEL_STANDARD: turning achieved by braking on one side, accelerating on the other side.
\note eDRIVE_MODEL_SPECIAL: turning achieved by accelerating forwards on one side, accelerating backwards on the other side.
\note The default value is eDRIVE_MODEL_STANDARD
*/
void setDriveModel(const PxVehicleDriveTankControlModel::Enum driveModel)
{
mDriveModel=driveModel;
}
/**
\brief Return the control model used by the tank.
*/
PxVehicleDriveTankControlModel::Enum getDriveModel() const {return mDriveModel;}
/**
\brief Set a vehicle to its rest state. Aside from the rigid body transform, this will set the vehicle and rigid body
to the state they were in immediately after setup or create.
\note Calling setToRestState invalidates the cached raycast hit planes under each wheel meaning that suspension line
raycasts need to be performed at least once with PxVehicleSuspensionRaycasts before calling PxVehicleUpdates.
@see setup, create, PxVehicleSuspensionRaycasts, PxVehicleUpdates
*/
void setToRestState();
/**
\brief Simulation data that models vehicle components
@see setup, create
*/
PxVehicleDriveSimData mDriveSimData;
private:
/**
\brief Test if the instanced dynamics and configuration data has legal values.
*/
bool isValid() const;
/**
\brief Drive model
@see setDriveModel, getDriveModel, PxVehicleDriveTankControlModel
*/
PxVehicleDriveTankControlModel::Enum mDriveModel;
PxU32 mPad[3];
//serialization
public:
PxVehicleDriveTank(PxBaseFlags baseFlags) : PxVehicleDrive(baseFlags) {}
static PxVehicleDriveTank* createObject(PxU8*& address, PxDeserializationContext& context);
static void getBinaryMetaData(PxOutputStream& stream);
virtual const char* getConcreteTypeName() const { return "PxVehicleDriveTank"; }
virtual bool isKindOf(const char* name) const { PX_IS_KIND_OF(name, "PxVehicleDriveTank", PxVehicleDrive); }
protected:
PxVehicleDriveTank();
~PxVehicleDriveTank(){}
//~serialization
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleDriveTank) & 15));
#if !PX_DOXYGEN
} // namespace physx
#endif
#endif
| 10,691 | C | 38.6 | 185 | 0.77598 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle/PxVehicleComponents.h | // 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-2023 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 PX_VEHICLE_COMPONENTS_H
#define PX_VEHICLE_COMPONENTS_H
#include "foundation/PxMemory.h"
#include "foundation/PxVec3.h"
#include "common/PxCoreUtilityTypes.h"
#include "vehicle/PxVehicleSDK.h"
#include "common/PxTypeInfo.h"
#if !PX_DOXYGEN
namespace physx
{
#endif
class PX_DEPRECATED PxVehicleChassisData
{
public:
friend class PxVehicleDriveSimData4W;
PxVehicleChassisData()
: mMOI(PxVec3(0,0,0)),
mMass(1500),
mCMOffset(PxVec3(0,0,0))
{
}
/**
\brief Moment of inertia of vehicle rigid body actor.
\note Specified in kilograms metres-squared (kg m^2).
*/
PxVec3 mMOI;
/**
\brief Mass of vehicle rigid body actor.
\note Specified in kilograms (kg).
*/
PxReal mMass;
/**
\brief Center of mass offset of vehicle rigid body actor.
\note Specified in metres (m).
*/
PxVec3 mCMOffset;
private:
PxReal pad;
bool isValid() const;
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleChassisData)& 0x0f));
class PX_DEPRECATED PxVehicleEngineData
{
public:
friend class PxVehicleDriveSimData;
enum
{
eMAX_NB_ENGINE_TORQUE_CURVE_ENTRIES = 8
};
PxVehicleEngineData()
: mMOI(1.0f),
mPeakTorque(500.0f),
mMaxOmega(600.0f),
mDampingRateFullThrottle(0.15f),
mDampingRateZeroThrottleClutchEngaged(2.0f),
mDampingRateZeroThrottleClutchDisengaged(0.35f)
{
mTorqueCurve.addPair(0.0f, 0.8f);
mTorqueCurve.addPair(0.33f, 1.0f);
mTorqueCurve.addPair(1.0f, 0.8f);
mRecipMOI=1.0f/mMOI;
mRecipMaxOmega=1.0f/mMaxOmega;
}
/**
\brief Graph of normalized torque (torque/mPeakTorque) against normalized engine speed ( engineRotationSpeed / mMaxOmega ).
\note The normalized engine speed is the x-axis of the graph, while the normalized torque is the y-axis of the graph.
*/
PxFixedSizeLookupTable<eMAX_NB_ENGINE_TORQUE_CURVE_ENTRIES> mTorqueCurve;
/**
\brief Moment of inertia of the engine around the axis of rotation.
\note Specified in kilograms metres-squared (kg m^2)
*/
PxReal mMOI;
/**
\brief Maximum torque available to apply to the engine when the accelerator pedal is at maximum.
\note The torque available is the value of the accelerator pedal (in range [0, 1]) multiplied by the normalized torque as computed from mTorqueCurve multiplied by mPeakTorque.
\note Specified in kilograms metres-squared per second-squared (kg m^2 s^-2).
<b>Range:</b> [0, PX_MAX_F32)<br>
*/
PxReal mPeakTorque;
/**
\brief Maximum rotation speed of the engine.
\note Specified in radians per second (s^-1).
<b>Range:</b> [0, PX_MAX_F32)<br>
*/
PxReal mMaxOmega;
/**
\brief Damping rate of engine when full throttle is applied.
\note If the clutch is engaged (any gear except neutral) then the damping rate applied at run-time is an interpolation
between mDampingRateZeroThrottleClutchEngaged and mDampingRateFullThrottle:
mDampingRateZeroThrottleClutchEngaged + (mDampingRateFullThrottle-mDampingRateZeroThrottleClutchEngaged)*acceleratorPedal;
\note If the clutch is disengaged (in neutral gear) the damping rate applied at run-time is an interpolation
between mDampingRateZeroThrottleClutchDisengaged and mDampingRateFullThrottle:
mDampingRateZeroThrottleClutchDisengaged + (mDampingRateFullThrottle-mDampingRateZeroThrottleClutchDisengaged)*acceleratorPedal;
\note Specified in kilograms metres-squared per second (kg m^2 s^-1).
<b>Range:</b> [0, PX_MAX_F32)<br>
*/
PxReal mDampingRateFullThrottle;
/**
\brief Damping rate of engine when full throttle is applied.
\note If the clutch is engaged (any gear except neutral) then the damping rate applied at run-time is an interpolation
between mDampingRateZeroThrottleClutchEngaged and mDampingRateFullThrottle:
mDampingRateZeroThrottleClutchEngaged + (mDampingRateFullThrottle-mDampingRateZeroThrottleClutchEngaged)*acceleratorPedal;
\note If the clutch is disengaged (in neutral gear) the damping rate applied at run-time is an interpolation
between mDampingRateZeroThrottleClutchDisengaged and mDampingRateFullThrottle:
mDampingRateZeroThrottleClutchDisengaged + (mDampingRateFullThrottle-mDampingRateZeroThrottleClutchDisengaged)*acceleratorPedal;
\note Specified in kilograms metres-squared per second (kg m^2 s^-1).
<b>Range:</b> [0, PX_MAX_F32)<br>
*/
PxReal mDampingRateZeroThrottleClutchEngaged;
/**
\brief Damping rate of engine when full throttle is applied.
\note If the clutch is engaged (any gear except neutral) then the damping rate applied at run-time is an interpolation
between mDampingRateZeroThrottleClutchEngaged and mDampingRateFullThrottle:
mDampingRateZeroThrottleClutchEngaged + (mDampingRateFullThrottle-mDampingRateZeroThrottleClutchEngaged)*acceleratorPedal;
\note If the clutch is disengaged (in neutral gear) the damping rate applied at run-time is an interpolation
between mDampingRateZeroThrottleClutchDisengaged and mDampingRateFullThrottle:
mDampingRateZeroThrottleClutchDisengaged + (mDampingRateFullThrottle-mDampingRateZeroThrottleClutchDisengaged)*acceleratorPedal;
\note Specified in kilograms metres-squared per second (kg m^2 s^-1).
<b>Range:</b> [0, PX_MAX_F32)<br>
*/
PxReal mDampingRateZeroThrottleClutchDisengaged;
/**
\brief Return value of mRecipMOI(=1.0f/mMOI) that is automatically set by PxVehicleDriveSimData::setEngineData
*/
PX_FORCE_INLINE PxReal getRecipMOI() const {return mRecipMOI;}
/**
\brief Return value of mRecipMaxOmega( = 1.0f / mMaxOmega ) that is automatically set by PxVehicleDriveSimData::setEngineData
*/
PX_FORCE_INLINE PxReal getRecipMaxOmega() const {return mRecipMaxOmega;}
private:
/**
\brief Reciprocal of the engine moment of inertia.
\note Not necessary to set this value because it is set by PxVehicleDriveSimData::setEngineData
<b>Range:</b> [0, PX_MAX_F32)<br>
*/
PxReal mRecipMOI;
/**
\brief Reciprocal of the maximum rotation speed of the engine.
\note Not necessary to set this value because it is set by PxVehicleDriveSimData::setEngineData
<b>Range:</b> [0, PX_MAX_F32)<br>
*/
PxReal mRecipMaxOmega;
bool isValid() const;
//serialization
public:
PxVehicleEngineData(const PxEMPTY) : mTorqueCurve(PxEmpty) {}
//~serialization
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleEngineData)& 0x0f));
class PX_DEPRECATED PxVehicleGearsData
{
public:
friend class PxVehicleDriveSimData;
enum Enum
{
eREVERSE=0,
eNEUTRAL,
eFIRST,
eSECOND,
eTHIRD,
eFOURTH,
eFIFTH,
eSIXTH,
eSEVENTH,
eEIGHTH,
eNINTH,
eTENTH,
eELEVENTH,
eTWELFTH,
eTHIRTEENTH,
eFOURTEENTH,
eFIFTEENTH,
eSIXTEENTH,
eSEVENTEENTH,
eEIGHTEENTH,
eNINETEENTH,
eTWENTIETH,
eTWENTYFIRST,
eTWENTYSECOND,
eTWENTYTHIRD,
eTWENTYFOURTH,
eTWENTYFIFTH,
eTWENTYSIXTH,
eTWENTYSEVENTH,
eTWENTYEIGHTH,
eTWENTYNINTH,
eTHIRTIETH,
eGEARSRATIO_COUNT
};
PxVehicleGearsData()
: mFinalRatio(4.0f),
mNbRatios(7),
mSwitchTime(0.5f)
{
mRatios[PxVehicleGearsData::eREVERSE]=-4.0f;
mRatios[PxVehicleGearsData::eNEUTRAL]=0.0f;
mRatios[PxVehicleGearsData::eFIRST]=4.0f;
mRatios[PxVehicleGearsData::eSECOND]=2.0f;
mRatios[PxVehicleGearsData::eTHIRD]=1.5f;
mRatios[PxVehicleGearsData::eFOURTH]=1.1f;
mRatios[PxVehicleGearsData::eFIFTH]=1.0f;
for(PxU32 i = PxVehicleGearsData::eSIXTH; i < PxVehicleGearsData::eGEARSRATIO_COUNT; ++i)
mRatios[i]=0.f;
}
/**
\brief Gear ratios
<b>Range:</b> [0, PX_MAX_F32)<br>
*/
PxReal mRatios[PxVehicleGearsData::eGEARSRATIO_COUNT];
/**
\brief Gear ratio applied is mRatios[currentGear]*finalRatio
<b>Range:</b> [0, PX_MAX_F32)<br>
*/
PxReal mFinalRatio;
/**
\brief Number of gears (including reverse and neutral).
<b>Range:</b> (0, MAX_NB_GEAR_RATIOS)<br>
*/
PxU32 mNbRatios;
/**
\brief Time it takes to switch gear.
\note Specified in seconds (s).
<b>Range:</b> [0, PX_MAX_F32)<br>
*/
PxReal mSwitchTime;
private:
PxReal mPad;
bool isValid() const;
//serialization
public:
PxVehicleGearsData(const PxEMPTY) {}
PxReal getGearRatio(PxVehicleGearsData::Enum a) const {return mRatios[a];}
void setGearRatio(PxVehicleGearsData::Enum a, PxReal ratio) { mRatios[a] = ratio;}
//~serialization
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleGearsData)& 0x0f));
class PX_DEPRECATED PxVehicleAutoBoxData
{
public:
friend class PxVehicleDriveSimData;
PxVehicleAutoBoxData()
{
for(PxU32 i=0;i<PxVehicleGearsData::eGEARSRATIO_COUNT;i++)
{
mUpRatios[i]=0.65f;
mDownRatios[i]=0.50f;
}
//Not sure how important this is but we want to kick out of neutral very quickly.
mUpRatios[PxVehicleGearsData::eNEUTRAL]=0.15f;
//Set the latency time in an unused element of one of the arrays.
mDownRatios[PxVehicleGearsData::eREVERSE]=2.0f;
}
/**
\brief Value of ( engineRotationSpeed / PxVehicleEngineData::mMaxOmega ) that is high enough to increment gear.
\note When ( engineRotationSpeed / PxVehicleEngineData::mMaxOmega ) > mUpRatios[currentGear] the autobox will begin
a transition to currentGear+1 unless currentGear is the highest possible gear or neutral or reverse.
<b>Range:</b> [0, 1]<br>
*/
PxReal mUpRatios[PxVehicleGearsData::eGEARSRATIO_COUNT];
/**
\brief Value of engineRevs/maxEngineRevs that is low enough to decrement gear.
\note When ( engineRotationSpeed / PxVehicleEngineData::mMaxOmega ) < mDownRatios[currentGear] the autobox will begin
a transition to currentGear-1 unless currentGear is first gear or neutral or reverse.
<b>Range:</b> [0, 1]<br>
*/
PxReal mDownRatios[PxVehicleGearsData::eGEARSRATIO_COUNT];
/**
\brief Set the latency time of the autobox.
\note Latency time is the minimum time that must pass between each gear change that is initiated by the autobox.
The auto-box will only attempt to initiate another gear change up or down if the simulation time that has passed since the most recent
automated gear change is greater than the specified latency.
\note Specified in seconds (s).
@see getLatency
*/
void setLatency(const PxReal latency)
{
mDownRatios[PxVehicleGearsData::eREVERSE]=latency;
}
/**
\brief Get the latency time of the autobox.
\note Specified in seconds (s).
@see setLatency
*/
PxReal getLatency() const
{
return mDownRatios[PxVehicleGearsData::eREVERSE];
}
private:
bool isValid() const;
//serialization
public:
PxVehicleAutoBoxData(const PxEMPTY) {}
PxReal getUpRatios(PxVehicleGearsData::Enum a) const {return mUpRatios[a];}
void setUpRatios(PxVehicleGearsData::Enum a, PxReal ratio) { mUpRatios[a] = ratio;}
PxReal getDownRatios(PxVehicleGearsData::Enum a) const {return mDownRatios[a];}
void setDownRatios(PxVehicleGearsData::Enum a, PxReal ratio) { mDownRatios[a] = ratio;}
//~serialization
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleAutoBoxData)& 0x0f));
class PX_DEPRECATED PxVehicleDifferential4WData
{
public:
friend class PxVehicleDriveSimData4W;
enum Enum
{
eDIFF_TYPE_LS_4WD, //limited slip differential for car with 4 driven wheels
eDIFF_TYPE_LS_FRONTWD, //limited slip differential for car with front-wheel drive
eDIFF_TYPE_LS_REARWD, //limited slip differential for car with rear-wheel drive
eDIFF_TYPE_OPEN_4WD, //open differential for car with 4 driven wheels
eDIFF_TYPE_OPEN_FRONTWD, //open differential for car with front-wheel drive
eDIFF_TYPE_OPEN_REARWD, //open differential for car with rear-wheel drive
eMAX_NB_DIFF_TYPES
};
PxVehicleDifferential4WData()
: mFrontRearSplit(0.45f),
mFrontLeftRightSplit(0.5f),
mRearLeftRightSplit(0.5f),
mCentreBias(1.3f),
mFrontBias(1.3f),
mRearBias(1.3f),
mType(PxVehicleDifferential4WData::eDIFF_TYPE_LS_4WD)
{
}
/**
\brief Ratio of torque split between front and rear (>0.5 means more to front, <0.5 means more to rear).
\note Only applied to DIFF_TYPE_LS_4WD and eDIFF_TYPE_OPEN_4WD
<b>Range:</b> [0, 1]<br>
*/
PxReal mFrontRearSplit;
/**
\brief Ratio of torque split between front-left and front-right (>0.5 means more to front-left, <0.5 means more to front-right).
\note Only applied to DIFF_TYPE_LS_4WD and eDIFF_TYPE_OPEN_4WD and eDIFF_TYPE_LS_FRONTWD
<b>Range:</b> [0, 1]<br>
*/
PxReal mFrontLeftRightSplit;
/**
\brief Ratio of torque split between rear-left and rear-right (>0.5 means more to rear-left, <0.5 means more to rear-right).
\note Only applied to DIFF_TYPE_LS_4WD and eDIFF_TYPE_OPEN_4WD and eDIFF_TYPE_LS_REARWD
<b>Range:</b> [0, 1]<br>
*/
PxReal mRearLeftRightSplit;
/**
\brief Maximum allowed ratio of average front wheel rotation speed and rear wheel rotation speeds
The differential will divert more torque to the slower wheels when the bias is exceeded.
\note Only applied to DIFF_TYPE_LS_4WD
<b>Range:</b> [1, PX_MAX_F32)<br>
*/
PxReal mCentreBias;
/**
\brief Maximum allowed ratio of front-left and front-right wheel rotation speeds.
The differential will divert more torque to the slower wheel when the bias is exceeded.
\note Only applied to DIFF_TYPE_LS_4WD and DIFF_TYPE_LS_FRONTWD
<b>Range:</b> [1, PX_MAX_F32)<br>
*/
PxReal mFrontBias;
/**
\brief Maximum allowed ratio of rear-left and rear-right wheel rotation speeds.
The differential will divert more torque to the slower wheel when the bias is exceeded.
\note Only applied to DIFF_TYPE_LS_4WD and DIFF_TYPE_LS_REARWD
<b>Range:</b> [1, PX_MAX_F32)<br>
*/
PxReal mRearBias;
/**
\brief Type of differential.
<b>Range:</b> [DIFF_TYPE_LS_4WD, DIFF_TYPE_OPEN_FRONTWD]<br>
*/
PxVehicleDifferential4WData::Enum mType;
private:
PxReal mPad[1];
bool isValid() const;
//serialization
public:
PxVehicleDifferential4WData(const PxEMPTY) {}
//~serialization
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleDifferential4WData)& 0x0f));
class PX_DEPRECATED PxVehicleDifferentialNWData
{
public:
friend class PxVehicleDriveSimDataNW;
friend class PxVehicleUpdate;
PxVehicleDifferentialNWData()
{
PxMemSet(mBitmapBuffer, 0, sizeof(PxU32) * (((PX_MAX_NB_WHEELS + 31) & ~31) >> 5));
mNbDrivenWheels=0;
mInvNbDrivenWheels=0.0f;
}
/**
\brief Set a specific wheel to be driven or non-driven by the differential.
\note The available drive torque will be split equally between all driven wheels.
Zero torque will be applied to non-driven wheels.
The default state of each wheel is to be uncoupled to the differential.
*/
void setDrivenWheel(const PxU32 wheelId, const bool drivenState);
/**
\brief Test if a specific wheel has been configured as a driven or non-driven wheel.
*/
bool getIsDrivenWheel(const PxU32 wheelId) const;
private:
PxU32 mBitmapBuffer[((PX_MAX_NB_WHEELS + 31) & ~31) >> 5];
PxU32 mNbDrivenWheels;
PxReal mInvNbDrivenWheels;
PxU32 mPad;
bool isValid() const;
//serialization
public:
PxVehicleDifferentialNWData(const PxEMPTY) {}
PxU32 getDrivenWheelStatus() const;
void setDrivenWheelStatus(PxU32 status);
//~serialization
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleDifferentialNWData)& 0x0f));
class PX_DEPRECATED PxVehicleAckermannGeometryData
{
public:
friend class PxVehicleDriveSimData4W;
PxVehicleAckermannGeometryData()
: mAccuracy(1.0f),
mFrontWidth(0.0f), //Must be filled out
mRearWidth(0.0f), //Must be filled out
mAxleSeparation(0.0f) //Must be filled out
{
}
/**
\brief Accuracy of Ackermann steer calculation.
\note Accuracy with value 0.0 results in no Ackermann steer-correction, while
accuracy with value 1.0 results in perfect Ackermann steer-correction.
\note Perfect Ackermann steer correction modifies the steer angles applied to the front-left and
front-right wheels so that the perpendiculars to the wheels' longitudinal directions cross the
extended vector of the rear axle at the same point. It is also applied to any steer angle applied
to the rear wheels but instead using the extended vector of the front axle.
\note In general, more steer correction produces better cornering behavior.
<b>Range:</b> [0, 1]<br>
*/
PxReal mAccuracy;
/**
\brief Distance between center-point of the two front wheels.
\note Specified in metres (m).
<b>Range:</b> [0, PX_MAX_F32)<br>
*/
PxReal mFrontWidth;
/**
\brief Distance between center-point of the two rear wheels.
\note Specified in metres (m).
<b>Range:</b> [0, PX_MAX_F32)<br>
*/
PxReal mRearWidth;
/**
\brief Distance between center of front axle and center of rear axle.
\note Specified in metres (m).
<b>Range:</b> [0, PX_MAX_F32)<br>
*/
PxReal mAxleSeparation;
private:
bool isValid() const;
//serialization
public:
PxVehicleAckermannGeometryData(const PxEMPTY) {}
//~serialization
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleAckermannGeometryData)& 0x0f));
/**
\brief Choose between a potentially more expensive but more accurate solution to the clutch model or a potentially cheaper but less accurate solution.
@see PxVehicleClutchData
*/
struct PX_DEPRECATED PxVehicleClutchAccuracyMode
{
enum Enum
{
eESTIMATE = 0,
eBEST_POSSIBLE
};
};
class PX_DEPRECATED PxVehicleClutchData
{
public:
friend class PxVehicleDriveSimData;
PxVehicleClutchData()
: mStrength(10.0f),
mAccuracyMode(PxVehicleClutchAccuracyMode::eBEST_POSSIBLE),
mEstimateIterations(5)
{
}
/**
\brief Strength of clutch.
\note The clutch is the mechanism that couples the engine to the wheels.
A stronger clutch more strongly couples the engine to the wheels, while a
clutch of strength zero completely decouples the engine from the wheels.
Stronger clutches more quickly bring the wheels and engine into equilibrium, while weaker
clutches take longer, resulting in periods of clutch slip and delays in power transmission
from the engine to the wheels.
The torque generated by the clutch is proportional to the clutch strength and
the velocity difference between the engine's rotational speed and the rotational speed of the
driven wheels after accounting for the gear ratio.
The torque at the clutch is applied negatively to the engine and positively to the driven wheels.
\note Specified in kilograms metres-squared per second (kg m^2 s^-1)
<b>Range:</b> [0,PX_MAX_F32)<br>
*/
PxReal mStrength;
/**
\brief The engine and wheel rotation speeds that are coupled through the clutch can be updated by choosing
one of two modes: eESTIMATE and eBEST_POSSIBLE.
\note If eESTIMATE is chosen the vehicle sdk will update the wheel and engine rotation speeds
with estimated values to the implemented clutch model.
\note If eBEST_POSSIBLE is chosen the vehicle sdk will compute the best possible
solution (within floating point tolerance) to the implemented clutch model.
This is the recommended mode.
\note The clutch model remains the same if either eESTIMATE or eBEST_POSSIBLE is chosen but the accuracy and
computational cost of the solution to the model can be tuned as required.
*/
PxVehicleClutchAccuracyMode::Enum mAccuracyMode;
/**
\brief Tune the mathematical accuracy and computational cost of the computed estimate to the wheel and
engine rotation speeds if eESTIMATE is chosen.
\note As mEstimateIterations increases the computational cost of the clutch also increases and the solution
approaches the solution that would be computed if eBEST_POSSIBLE was chosen instead.
\note This has no effect if eBEST_POSSIBLE is chosen as the accuracy mode.
\note A value of zero is not allowed if eESTIMATE is chosen as the accuracy mode.
*/
PxU32 mEstimateIterations;
private:
PxU8 mPad[4];
bool isValid() const;
//serialization
public:
PxVehicleClutchData(const PxEMPTY) {}
//~serialization
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleClutchData)& 0x0f));
/**
\brief Tire load variation can be strongly dependent on the time-step so it is a good idea to filter it
to give less jerky handling behavior.
\note The x-axis of the graph is normalized tire load, while the y-axis is the filtered normalized tire load.
\note The normalized load is the force acting downwards on the tire divided by the force experienced by the tire when the car is at rest on the ground.
\note The rest load is approximately the product of the value of gravitational acceleration and PxVehicleSuspensionData::mSprungMass.
\note The minimum possible normalized load is zero.
\note There are two points on the graph: (mMinNormalisedLoad, mMinNormalisedFilteredLoad) and (mMaxNormalisedLoad, mMaxFilteredNormalisedLoad).
\note Normalized loads less than mMinNormalisedLoad have filtered normalized load = mMinNormalisedFilteredLoad.
\note Normalized loads greater than mMaxNormalisedLoad have filtered normalized load = mMaxFilteredNormalisedLoad.
\note Normalized loads in-between are linearly interpolated between mMinNormalisedFilteredLoad and mMaxFilteredNormalisedLoad.
\note The tire load applied as input to the tire force computation is the filtered normalized load multiplied by the rest load.
*/
class PX_DEPRECATED PxVehicleTireLoadFilterData
{
public:
friend class PxVehicleWheelsSimData;
PxVehicleTireLoadFilterData()
: mMinNormalisedLoad(0),
mMinFilteredNormalisedLoad(0.2308f),
mMaxNormalisedLoad(3.0f),
mMaxFilteredNormalisedLoad(3.0f)
{
mDenominator=1.0f/(mMaxNormalisedLoad - mMinNormalisedLoad);
}
/**
\brief Graph point (mMinNormalisedLoad,mMinFilteredNormalisedLoad)
*/
PxReal mMinNormalisedLoad;
/**
\brief Graph point (mMinNormalisedLoad,mMinFilteredNormalisedLoad)
*/
PxReal mMinFilteredNormalisedLoad;
/**
\brief Graph point (mMaxNormalisedLoad,mMaxFilteredNormalisedLoad)
*/
PxReal mMaxNormalisedLoad;
/**
\brief Graph point (mMaxNormalisedLoad,mMaxFilteredNormalisedLoad)
*/
PxReal mMaxFilteredNormalisedLoad;
PX_FORCE_INLINE PxReal getDenominator() const {return mDenominator;}
private:
/**
\brief Not necessary to set this value.
*/
//1.0f/(mMaxNormalisedLoad-mMinNormalisedLoad) for quick calculations
PxReal mDenominator;
PxU32 mPad[3];
bool isValid() const;
//serialization
public:
PxVehicleTireLoadFilterData(const PxEMPTY) {}
//~serialization
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleTireLoadFilterData)& 0x0f));
class PX_DEPRECATED PxVehicleWheelData
{
public:
friend class PxVehicleWheels4SimData;
PxVehicleWheelData()
: mRadius(0.0f), //Must be filled out
mWidth(0.0f),
mMass(20.0f),
mMOI(0.0f), //Must be filled out
mDampingRate(0.25f),
mMaxBrakeTorque(1500.0f),
mMaxHandBrakeTorque(0.0f),
mMaxSteer(0.0f),
mToeAngle(0.0f),
mRecipRadius(0.0f), //Must be filled out
mRecipMOI(0.0f) //Must be filled out
{
}
/**
\brief Radius of unit that includes metal wheel plus rubber tire.
\note Specified in metres (m).
<b>Range:</b> [0, PX_MAX_F32)<br>
*/
PxReal mRadius;
/**
\brief Maximum width of unit that includes wheel plus tire.
\note Specified in metres (m).
<b>Range:</b> [0, PX_MAX_F32)<br>
*/
PxReal mWidth;
/**
\brief Mass of unit that includes wheel plus tire.
\note Specified in kilograms (kg).
<b>Range:</b> [0, PX_MAX_F32)<br>
*/
PxReal mMass;
/**
\brief Moment of inertia of unit that includes wheel plus tire about the rolling axis.
\note Specified in kilograms metres-squared (kg m^2).
<b>Range:</b> [0, PX_MAX_F32)<br>
*/
PxReal mMOI;
/**
\brief Damping rate applied to wheel.
\note Specified in kilograms metres-squared per second (kg m^2 s^-1).
<b>Range:</b> [0, PX_MAX_F32)<br>
*/
PxReal mDampingRate;
/**
\brief Max brake torque that can be applied to wheel.
\note Specified in kilograms metres-squared per second-squared (kg m^2 s^-2)
<b>Range:</b> [0, PX_MAX_F32)<br>
*/
PxReal mMaxBrakeTorque;
/**
\brief Max handbrake torque that can be applied to wheel.
\note Specified in kilograms metres-squared per second-squared (kg m^2 s^-2)
<b>Range:</b> [0, PX_MAX_F32)<br>
*/
PxReal mMaxHandBrakeTorque;
/**
\brief Max steer angle that can be achieved by the wheel.
\note Specified in radians.
<b>Range:</b> [0, PX_MAX_F32)<br>
*/
PxReal mMaxSteer;
/**
\brief Wheel toe angle. This value is ignored by PxVehicleDriveTank and PxVehicleNoDrive.
\note Specified in radians.
<b>Range:</b> [0, Pi/2]<br>
*/
PxReal mToeAngle;//in radians
/**
\brief Return value equal to 1.0f/mRadius
@see PxVehicleWheelsSimData::setWheelData
*/
PX_FORCE_INLINE PxReal getRecipRadius() const {return mRecipRadius;}
/**
\brief Return value equal to 1.0f/mRecipMOI
@see PxVehicleWheelsSimData::setWheelData
*/
PX_FORCE_INLINE PxReal getRecipMOI() const {return mRecipMOI;}
private:
/**
\brief Reciprocal of radius of unit that includes metal wheel plus rubber tire.
\note Not necessary to set this value because it is set by PxVehicleWheelsSimData::setWheelData
<b>Range:</b> [0, PX_MAX_F32)<br>
*/
PxReal mRecipRadius;
/**
\brief Reciprocal of moment of inertia of unit that includes wheel plus tire about single allowed axis of rotation.
\note Not necessary to set this value because it is set by PxVehicleWheelsSimData::setWheelData
<b>Range:</b> [0, PX_MAX_F32)<br>
*/
PxReal mRecipMOI;
PxReal mPad[1];
bool isValid() const;
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleWheelData)& 0x0f));
class PX_DEPRECATED PxVehicleSuspensionData
{
public:
friend class PxVehicleWheels4SimData;
PxVehicleSuspensionData()
: mSpringStrength(0.0f),
mSpringDamperRate(0.0f),
mMaxCompression(0.3f),
mMaxDroop(0.1f),
mSprungMass(0.0f),
mCamberAtRest(0.0f),
mCamberAtMaxCompression(0.0f),
mCamberAtMaxDroop(0.0f),
mRecipMaxCompression(1.0f),
mRecipMaxDroop(1.0f)
{
}
/**
\brief Spring strength of suspension unit.
\note Specified in kilograms per second-squared (kg s^-2).
<b>Range:</b> [0, PX_MAX_F32)<br>
*/
PxReal mSpringStrength;
/**
\brief Spring damper rate of suspension unit.
\note Specified in kilograms per second (kg s^-1).
<b>Range:</b> [0, PX_MAX_F32)<br>
*/
PxReal mSpringDamperRate;
/**
\brief Maximum compression allowed by suspension spring.
\note Specified in metres (m).
<b>Range:</b> [0, PX_MAX_F32)<br>
*/
PxReal mMaxCompression;
/**
\brief Maximum elongation allowed by suspension spring.
\note Specified in metres (m).
<b>Range:</b> [0, PX_MAX_F32)<br>
*/
PxReal mMaxDroop;
/**
\brief Mass of vehicle that is supported by suspension spring.
\note Specified in kilograms (kg).
\note Each suspension is guaranteed to generate an upwards force of |gravity|*mSprungMass along the suspension direction when the wheel is perfectly
at rest and sitting at the rest pose defined by the wheel centre offset.
\note The sum of the sprung masses of all suspensions of a vehicle should match the mass of the PxRigidDynamic associated with the vehicle.
When this condition is satisfied for a vehicle on a horizontal plane the wheels of the vehicle are guaranteed to sit at the rest pose
defined by the wheel centre offset. For special cases, where this condition can not be met easily, the flag
#PxVehicleWheelsSimFlag::eDISABLE_SPRUNG_MASS_SUM_CHECK allows to provide sprung mass values that do not sum up to the mass of the PxRigidDynamic.
\note As the wheel compresses or elongates along the suspension direction the force generated by the spring is
F = |gravity|*mSprungMass + deltaX*mSpringStrength + deltaXDot*mSpringDamperRate
where deltaX is the deviation from the defined rest pose and deltaXDot is the velocity of the sprung mass along the suspension direction.
In practice, deltaXDot is computed by comparing the current and previous deviation from the rest pose and dividing the difference
by the simulation timestep.
\note If a single suspension spring is hanging in the air and generates zero force the remaining springs of the vehicle will necessarily
sit in a compressed configuration. In summary, the sum of the remaining suspension forces cannot balance the downwards gravitational force
acting on the vehicle without extra force arising from the deltaX*mSpringStrength force term.
\note Theoretically, a suspension spring should generate zero force at maximum elongation and increase linearly as the suspension approaches the rest pose.
PxVehicleSuspensionData will only enforce this physical law if the spring is configured so that |gravity|*mSprungMass == mMaxDroop*mSpringStrength.
To help decouple vehicle handling from visual wheel positioning this condition is not enforced.
In practice, the value of |gravity|*mSprungMass + deltaX*mSpringStrength is clamped at zero to ensure it never falls negative.
@see PxVehicleComputeSprungMasses, PxVehicleWheelsSimData::setWheelCentreOffset, PxVehicleSuspensionData::mSpringStrength, PxVehicleSuspensionData::mSpringDamperRate, PxVehicleSuspensionData::mMaxDroop
<b>Range:</b> [0, PX_MAX_F32)<br>
*/
PxReal mSprungMass;
/**
\brief Camber angle (in radians) of wheel when the suspension is at its rest position.
\note Specified in radians.
<b>Range:</b> [-pi/2, pi/2]<br>
*/
PxReal mCamberAtRest;
/**
\brief Camber angle (in radians) of wheel when the suspension is at maximum compression.
\note For compressed suspensions the camber angle is a linear interpolation of
mCamberAngleAtRest and mCamberAtMaxCompression
\note Specified in radians.
<b>Range:</b> [-pi/2, pi/2]<br>
*/
PxReal mCamberAtMaxCompression;
/**
\brief Camber angle (in radians) of wheel when the suspension is at maximum droop.
\note For extended suspensions the camber angle is linearly interpolation of
mCamberAngleAtRest and mCamberAtMaxDroop
\note Specified in radians.
<b>Range:</b> [-pi/2, pi/2]<br>
*/
PxReal mCamberAtMaxDroop;
/**
\brief Reciprocal of maximum compression.
\note Not necessary to set this value because it is set by PxVehicleWheelsSimData::setSuspensionData
<b>Range:</b> [0, PX_MAX_F32)<br>
*/
PX_FORCE_INLINE PxReal getRecipMaxCompression() const {return mRecipMaxCompression;}
/**
\brief Reciprocal of maximum droop.
\note Not necessary to set this value because it is set by PxVehicleWheelsSimData::setSuspensionData
<b>Range:</b> [0, PX_MAX_F32)<br>
*/
PX_FORCE_INLINE PxReal getRecipMaxDroop() const {return mRecipMaxDroop;}
/**
\brief Set a new sprung mass for the suspension and modify the spring strength so that the natural frequency
of the spring is preserved.
\param[in] newSprungMass is the new mass that the suspension spring will support.
*/
void setMassAndPreserveNaturalFrequency(const PxReal newSprungMass)
{
const PxF32 oldStrength = mSpringStrength;
const PxF32 oldSprungMass = mSprungMass;
const PxF32 newStrength = oldStrength * (newSprungMass / oldSprungMass);
mSpringStrength = newStrength;
mSprungMass = newSprungMass;
}
private:
/**
\brief Cached value of 1.0f/mMaxCompression
\note Not necessary to set this value because it is set by PxVehicleWheelsSimData::setSuspensionData
*/
PxReal mRecipMaxCompression;
/**
\brief Cached value of 1.0f/mMaxDroop
\note Not necessary to set this value because it is set by PxVehicleWheelsSimData::setSuspensionData
*/
PxReal mRecipMaxDroop;
//padding
PxReal mPad[2];
bool isValid() const;
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleSuspensionData)& 0x0f));
class PX_DEPRECATED PxVehicleAntiRollBarData
{
public:
friend class PxVehicleWheelsSimData;
PxVehicleAntiRollBarData()
: mWheel0(0xffffffff),
mWheel1(0xffffffff),
mStiffness(0.0f)
{
}
/*
\brief The anti-roll bar connects two wheels with indices mWheel0 and mWheel1
*/
PxU32 mWheel0;
/*
\brief The anti-roll bar connects two wheels with indices mWheel0 and mWheel1
*/
PxU32 mWheel1;
/*
\brief The stiffness of the anti-roll bar.
\note Specified in kilograms per second-squared (kg s^-2).
<b>Range:</b> [0, PX_MAX_F32)<br>
*/
PxF32 mStiffness;
private:
PxF32 mPad[1];
bool isValid() const;
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleAntiRollBarData)& 0x0f));
class PX_DEPRECATED PxVehicleTireData
{
public:
friend class PxVehicleWheels4SimData;
PxVehicleTireData()
: mLatStiffX(2.0f),
mLatStiffY(0.3125f*(180.0f / PxPi)),
mLongitudinalStiffnessPerUnitGravity(1000.0f),
mCamberStiffnessPerUnitGravity(0.1f*(180.0f / PxPi)),
mType(0)
{
mFrictionVsSlipGraph[0][0]=0.0f;
mFrictionVsSlipGraph[0][1]=1.0f;
mFrictionVsSlipGraph[1][0]=0.1f;
mFrictionVsSlipGraph[1][1]=1.0f;
mFrictionVsSlipGraph[2][0]=1.0f;
mFrictionVsSlipGraph[2][1]=1.0f;
mRecipLongitudinalStiffnessPerUnitGravity=1.0f/mLongitudinalStiffnessPerUnitGravity;
mFrictionVsSlipGraphRecipx1Minusx0=1.0f/(mFrictionVsSlipGraph[1][0]-mFrictionVsSlipGraph[0][0]);
mFrictionVsSlipGraphRecipx2Minusx1=1.0f/(mFrictionVsSlipGraph[2][0]-mFrictionVsSlipGraph[1][0]);
}
/**
\brief Tire lateral stiffness is a graph of tire load that has linear behavior near zero load and
flattens at large loads. mLatStiffX describes the minimum normalized load (load/restLoad) that gives a
flat lateral stiffness response to load.
<b>Range:</b> [0, PX_MAX_F32)<br>
*/
PxReal mLatStiffX;
/**
\brief Tire lateral stiffness is a graph of tire load that has linear behavior near zero load and
flattens at large loads. mLatStiffY describes the maximum possible value of lateralStiffness/restLoad that occurs
when (load/restLoad)>= mLatStiffX.
\note If load/restLoad is greater than mLatStiffX then the lateral stiffness is mLatStiffY*restLoad.
\note If load/restLoad is less than mLatStiffX then the lateral stiffness is mLastStiffY*(load/mLatStiffX)
\note Lateral force can be approximated as lateralStiffness * lateralSlip.
\note Specified in per radian.
<b>Range:</b> [0, PX_MAX_F32)<br>
*/
PxReal mLatStiffY;
/**
\brief Tire Longitudinal stiffness per unit gravitational acceleration.
\note Longitudinal stiffness of the tire is calculated as gravitationalAcceleration*mLongitudinalStiffnessPerUnitGravity.
\note Longitudinal force can be approximated as gravitationalAcceleration*mLongitudinalStiffnessPerUnitGravity*longitudinalSlip.
\note Specified in kilograms per radian.
<b>Range:</b> [0, PX_MAX_F32)<br>
*/
PxReal mLongitudinalStiffnessPerUnitGravity;
/**
\brief tire Tire camber stiffness per unity gravitational acceleration.
\note Camber stiffness of the tire is calculated as gravitationalAcceleration*mCamberStiffnessPerUnitGravity
\note Camber force can be approximated as gravitationalAcceleration*mCamberStiffnessPerUnitGravity*camberAngle.
\note Specified in kilograms per radian.
<b>Range:</b> [0, PX_MAX_F32)<br>
*/
PxReal mCamberStiffnessPerUnitGravity;
/**
\brief Graph of friction vs longitudinal slip with 3 points.
\note mFrictionVsSlipGraph[0][0] is always zero.
\note mFrictionVsSlipGraph[0][1] is the friction available at zero longitudinal slip.
\note mFrictionVsSlipGraph[1][0] is the value of longitudinal slip with maximum friction.
\note mFrictionVsSlipGraph[1][1] is the maximum friction.
\note mFrictionVsSlipGraph[2][0] is the end point of the graph.
\note mFrictionVsSlipGraph[2][1] is the value of friction for slips greater than mFrictionVsSlipGraph[2][0].
\note The friction value computed from the friction vs longitudinal slip graph is used to scale the friction
value for the combination of material and tire type (PxVehicleDrivableSurfaceToTireFrictionPairs).
\note mFrictionVsSlipGraph[2][0] > mFrictionVsSlipGraph[1][0] > mFrictionVsSlipGraph[0][0]
\note mFrictionVsSlipGraph[1][1] is typically greater than mFrictionVsSlipGraph[0][1]
\note mFrictionVsSlipGraph[2][1] is typically smaller than mFrictionVsSlipGraph[1][1]
\note longitudinal slips > mFrictionVsSlipGraph[2][0] use friction multiplier mFrictionVsSlipGraph[2][1]
\note The final friction value used by the tire model is the value returned by PxVehicleDrivableSurfaceToTireFrictionPairs
multiplied by the value computed from mFrictionVsSlipGraph.
@see PxVehicleDrivableSurfaceToTireFrictionPairs, PxVehicleComputeTireForce
<b>Range:</b> [0, PX_MAX_F32)<br>
*/
PxReal mFrictionVsSlipGraph[3][2];
/**
\brief Tire type denoting slicks, wets, snow, winter, summer, all-terrain, mud etc.
@see PxVehicleDrivableSurfaceToTireFrictionPairs
<b>Range:</b> [0, PX_MAX_F32)<br>
*/
PxU32 mType;
/**
\brief Return Cached value of 1.0/mLongitudinalStiffnessPerUnitGravity
@see PxVehicleWheelsSimData::setTireData
*/
PX_FORCE_INLINE PxReal getRecipLongitudinalStiffnessPerUnitGravity() const {return mRecipLongitudinalStiffnessPerUnitGravity;}
/**
\brief Return Cached value of 1.0f/(mFrictionVsSlipGraph[1][0]-mFrictionVsSlipGraph[0][0])
@see PxVehicleWheelsSimData::setTireData
*/
PX_FORCE_INLINE PxReal getFrictionVsSlipGraphRecipx1Minusx0() const {return mFrictionVsSlipGraphRecipx1Minusx0;}
/**
\brief Return Cached value of 1.0f/(mFrictionVsSlipGraph[2][0]-mFrictionVsSlipGraph[1][0])
@see PxVehicleWheelsSimData::setTireData
*/
PX_FORCE_INLINE PxReal getFrictionVsSlipGraphRecipx2Minusx1() const {return mFrictionVsSlipGraphRecipx2Minusx1;}
private:
/**
\brief Cached value of 1.0/mLongitudinalStiffnessPerUnitGravity.
\note Not necessary to set this value because it is set by PxVehicleWheelsSimData::setTireData
@see PxVehicleWheelsSimData::setTireData
*/
PxReal mRecipLongitudinalStiffnessPerUnitGravity;
/**
\brief Cached value of 1.0f/(mFrictionVsSlipGraph[1][0]-mFrictionVsSlipGraph[0][0])
\note Not necessary to set this value because it is set by PxVehicleWheelsSimData::setTireData
@see PxVehicleWheelsSimData::setTireData
*/
PxReal mFrictionVsSlipGraphRecipx1Minusx0;
/**
\brief Cached value of 1.0f/(mFrictionVsSlipGraph[2][0]-mFrictionVsSlipGraph[1][0])
\note Not necessary to set this value because it is set by PxVehicleWheelsSimData::setTireData
@see PxVehicleWheelsSimData::setTireData
*/
PxReal mFrictionVsSlipGraphRecipx2Minusx1;
PxReal mPad[2];
bool isValid() const;
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleTireData)& 0x0f));
#if !PX_DOXYGEN
} // namespace physx
#endif
#endif
| 39,557 | C | 28.172566 | 202 | 0.755618 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle/PxVehicleUtilSetup.h | // 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-2023 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 PX_VEHICLE_UTIL_SETUP_H
#define PX_VEHICLE_UTIL_SETUP_H
#include "foundation/PxSimpleTypes.h"
#include "vehicle/PxVehicleSDK.h"
#if !PX_DOXYGEN
namespace physx
{
#endif
class PxVehicleWheelsSimData;
class PxVehicleWheelsDynData;
class PxVehicleDriveSimData4W;
class PxVehicleWheels;
/**
\brief Reconfigure a PxVehicle4W instance as a three-wheeled car with tadpole config (2 front wheels, 1 rear wheel)
\note The rear-left wheel is removed and the rear-right wheel is positioned at the centre of the rear axle.
The suspension of the rear-right wheel is modified to support the entire mass of the front car while preserving its natural frequency and damping ratio.
\param[in,out] wheelsSimData is the data describing the wheels/suspensions/tires of the vehicle.
\param[in,out] wheelsDynData is the data describing the dynamic state of the wheels of the vehicle.
\param[in,out] driveSimData is the data describing the drive model of the vehicle.
\param[in] context the vehicle context to use for the setup.
*/
PX_DEPRECATED void PxVehicle4WEnable3WTadpoleMode(PxVehicleWheelsSimData& wheelsSimData, PxVehicleWheelsDynData& wheelsDynData, PxVehicleDriveSimData4W& driveSimData,
const PxVehicleContext& context = PxVehicleGetDefaultContext());
/**
\brief Reconfigure a PxVehicle4W instance as a three-wheeled car with delta config (1 front wheel, 2 rear wheels)
\note The front-left wheel is removed and the front-right wheel is positioned at the centre of the front axle.
The suspension of the front-right wheel is modified to support the entire mass of the front car while preserving its natural frequency and damping ratio.
\param[in,out] wheelsSimData is the data describing the wheels/suspensions/tires of the vehicle.
\param[in,out] wheelsDynData is the data describing the dynamic state of the wheels of the vehicle.
\param[in,out] driveSimData is the data describing the drive model of the vehicle.
\param[in] context the vehicle context to use for the setup.
*/
PX_DEPRECATED void PxVehicle4WEnable3WDeltaMode(PxVehicleWheelsSimData& wheelsSimData, PxVehicleWheelsDynData& wheelsDynData, PxVehicleDriveSimData4W& driveSimData,
const PxVehicleContext& context = PxVehicleGetDefaultContext());
/**
\brief Compute the sprung masses of the suspension springs given (i) the number of sprung masses,
(ii) coordinates of the sprung masses, (iii) the center of mass offset of the rigid body, (iv) the
total mass of the rigid body, and (v) the direction of gravity (0 for x-axis, 1 for y-axis, 2 for z-axis).
\param[in] nbSprungMasses is the number of sprung masses of the vehicle. This value corresponds to the number of wheels on the vehicle.
\param[in] sprungMassCoordinates are the coordinates of the sprung masses relative to the actor. The array sprungMassCoordinates must be of
length nbSprungMasses or greater.
\param[in] centreOfMass is the coordinate of the center of mass of the rigid body relative to the actor. This value corresponds to
the value set by PxRigidBody::setCMassLocalPose.
\param[in] totalMass is the total mass of all the sprung masses. This value corresponds to the value set by PxRigidBody::setMass.
\param[in] gravityDirection is an integer describing the direction of gravitational acceleration. A value of 0 corresponds to (-1,0,0),
a value of 1 corresponds to (0,-1,0) and a value of 2 corresponds to (0,0,-1).
\param[out] sprungMasses are the masses to set in the associated suspension data with PxVehicleSuspensionData::mSprungMass. The sprungMasses array must be of length
nbSprungMasses or greater. Each element in the sprungMasses array corresponds to the suspension located at the same array element in sprungMassCoordinates.
The center of mass of the masses in sprungMasses with the coordinates in sprungMassCoordinates satisfy the specified centerOfMass.
*/
PX_DEPRECATED void PxVehicleComputeSprungMasses(const PxU32 nbSprungMasses, const PxVec3* sprungMassCoordinates, const PxVec3& centreOfMass, const PxReal totalMass, const PxU32 gravityDirection, PxReal* sprungMasses);
/**
\brief Reconfigure the vehicle to reflect a new center of mass local pose that has been applied to the actor. The function requires
(i) the center of mass local pose that was last used to configure the vehicle and the vehicle's actor, (ii) the new center of mass local pose that
has been applied to the vehicle's actor and will now be applied to the vehicle, and (iii) the direction of gravity (0 for x-axis, 1 for y-axis, 2 for z-axis)
\param[in] oldCMassLocalPose is the center of mass local pose that was last used to configure the vehicle.
\param[in] newCMassLocalPose is the center of mass local pose that will be used to configure the vehicle so that it matches the vehicle's actor.
\param[in] gravityDirection is an integer describing the direction of gravitational acceleration. A value of 0 corresponds to (0,0,-1),
a value of 1 corresponds to (0,-1,0) and a value of 2 corresponds to (0,0,-1).
\param[in,out] vehicle is the vehicle to be updated with a new center of mass local pose.
\note This function does not update the center of mass of the vehicle actor. That needs to updated separately with PxRigidBody::setCMassLocalPose
\note The suspension sprung masses are updated so that the natural frequency and damping ratio of the springs are preserved. This involves altering the
stiffness and damping rate of the suspension springs.
*/
PX_DEPRECATED void PxVehicleUpdateCMassLocalPose(const PxTransform& oldCMassLocalPose, const PxTransform& newCMassLocalPose, const PxU32 gravityDirection, PxVehicleWheels* vehicle);
/**
\brief Used by PxVehicleCopyDynamicsData
@see PxVehicleCopyDynamicsData
*/
class PX_DEPRECATED PxVehicleCopyDynamicsMap
{
public:
PxVehicleCopyDynamicsMap()
{
for(PxU32 i = 0; i < PX_MAX_NB_WHEELS; i++)
{
sourceWheelIds[i] = PX_MAX_U8;
targetWheelIds[i] = PX_MAX_U8;
}
}
PxU8 sourceWheelIds[PX_MAX_NB_WHEELS];
PxU8 targetWheelIds[PX_MAX_NB_WHEELS];
};
/**
\brief Copy dynamics data from src to trg, including wheel rotation speed, wheel rotation angle, engine rotation speed etc.
\param[in] wheelMap - describes the mapping between the wheels in src and the wheels in trg.
\param[in] src - according to the wheel mapping stored in wheelMap, the dynamics data in src wheels are copied to the corresponding wheels in trg.
\param[out] trg - according to wheel mapping stored in wheelMap, the wheels in trg are given the dynamics data of the corresponding wheels in src.
\note wheelMap must specify a unique mapping between the wheels in src and the wheels in trg.
\note In the event that src has fewer wheels than trg, wheelMap must specify a unique mapping between each src wheel to a trg wheel.
\note In the event that src has more wheels than trg, wheelMap must specify a unique mapping to each trg wheel from a src wheel.
\note In the event that src has fewer wheels than trg, the trg wheels that are not mapped to a src wheel are given the average wheel rotation
speed of all enabled src wheels.
\note src and trg must be the same vehicle type.
*/
PX_DEPRECATED void PxVehicleCopyDynamicsData(const PxVehicleCopyDynamicsMap& wheelMap, const PxVehicleWheels& src, PxVehicleWheels* trg);
#if !PX_DOXYGEN
} // namespace physx
#endif
#endif
| 8,967 | C | 54.701863 | 217 | 0.787777 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle/PxVehicleUtilControl.h | // 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-2023 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 PX_VEHICLE_UTIL_CONTROL_H
#define PX_VEHICLE_UTIL_CONTROL_H
#include "vehicle/PxVehicleSDK.h"
#include "vehicle/PxVehicleDrive4W.h"
#include "vehicle/PxVehicleDriveNW.h"
#include "vehicle/PxVehicleDriveTank.h"
#if !PX_DOXYGEN
namespace physx
{
#endif
#if PX_CHECKED
void testValidAnalogValue(const PxF32 actualValue, const PxF32 minVal, const PxF32 maxVal, const char* errorString);
#endif
/**
\brief Used to produce smooth steering values in the presence of discontinuities when a vehicle e.g. lands on the ground.
Use a zero sharpness value to disable the feature (backward compatibility with previous PhysX versions).
*/
struct PX_DEPRECATED PxVehicleSteerFilter
{
PxVehicleSteerFilter(float sharpness=0.0f) : mSharpness(sharpness), mFilteredMaxSteer(0.0f) {}
static PX_FORCE_INLINE float feedbackFilter(float val, float& memory, float sharpness)
{
if(sharpness<0.0f) sharpness = 0.0f;
else if(sharpness>1.0f) sharpness = 1.0f;
return memory = val * sharpness + memory * (1.0f - sharpness);
}
PX_FORCE_INLINE float computeMaxSteer(const bool isVehicleInAir, const PxFixedSizeLookupTable<8>& steerVsForwardSpeedTable,
const PxF32 vzAbs, const PxF32 timestep) const
{
const PxF32 targetMaxSteer = (isVehicleInAir ? 1.0f : steerVsForwardSpeedTable.getYVal(vzAbs));
if(mSharpness==0.0f)
return targetMaxSteer;
else
return feedbackFilter(targetMaxSteer, mFilteredMaxSteer, mSharpness*timestep);
}
PxReal mSharpness;
mutable PxReal mFilteredMaxSteer;
};
/**
\brief Used to produce smooth vehicle driving control values from key inputs.
@see PxVehicle4WSmoothDigitalRawInputsAndSetAnalogInputs, PxVehicle4WSmoothAnalogRawInputsAndSetAnalogInputs
*/
struct PX_DEPRECATED PxVehicleKeySmoothingData
{
/**
\brief Rise rate of each analog value if digital value is 1
*/
PxReal mRiseRates[PxVehicleDriveDynData::eMAX_NB_ANALOG_INPUTS];
/**
\brief Fall rate of each analog value if digital value is 0
*/
PxReal mFallRates[PxVehicleDriveDynData::eMAX_NB_ANALOG_INPUTS];
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleKeySmoothingData)& 0x0f));
/**
\brief Used to produce smooth analog vehicle control values from analog inputs.
@see PxVehicleDrive4WSmoothDigitalRawInputsAndSetAnalogInputs, PxVehicleDrive4WSmoothAnalogRawInputsAndSetAnalogInputs
*/
struct PX_DEPRECATED PxVehiclePadSmoothingData
{
/**
\brief Rise rate of each analog value from previous value towards target if target>previous
*/
PxReal mRiseRates[PxVehicleDriveDynData::eMAX_NB_ANALOG_INPUTS];
/**
\brief Rise rate of each analog value from previous value towards target if target<previous
*/
PxReal mFallRates[PxVehicleDriveDynData::eMAX_NB_ANALOG_INPUTS];
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehiclePadSmoothingData)& 0x0f));
/**
\brief Used to produce smooth vehicle driving control values from analog and digital inputs.
@see PxVehicleDrive4WSmoothDigitalRawInputsAndSetAnalogInputs, PxVehicleDrive4WSmoothAnalogRawInputsAndSetAnalogInputs
*/
class PX_DEPRECATED PxVehicleDrive4WRawInputData
{
public:
PxVehicleDrive4WRawInputData()
{
for(PxU32 i=0;i<PxVehicleDrive4WControl::eMAX_NB_DRIVE4W_ANALOG_INPUTS;i++)
{
mRawDigitalInputs[i]=false;
mRawAnalogInputs[i]=0.0f;
}
mGearUp = false;
mGearDown = false;
}
virtual ~PxVehicleDrive4WRawInputData()
{
}
/**
\brief Record if the accel button has been pressed on keyboard.
\param[in] accelKeyPressed is true if the accelerator key has been pressed and false otherwise.
*/
void setDigitalAccel(const bool accelKeyPressed) {mRawDigitalInputs[PxVehicleDrive4WControl::eANALOG_INPUT_ACCEL]=accelKeyPressed;}
/**
\brief Record if the brake button has been pressed on keyboard.
\param[in] brakeKeyPressed is true if the brake key has been pressed and false otherwise.
*/
void setDigitalBrake(const bool brakeKeyPressed) {mRawDigitalInputs[PxVehicleDrive4WControl::eANALOG_INPUT_BRAKE]=brakeKeyPressed;}
/**
\brief Record if the handbrake button has been pressed on keyboard.
\param[in] handbrakeKeyPressed is true if the handbrake key has been pressed and false otherwise.
*/
void setDigitalHandbrake(const bool handbrakeKeyPressed) {mRawDigitalInputs[PxVehicleDrive4WControl::eANALOG_INPUT_HANDBRAKE]=handbrakeKeyPressed;}
/**
\brief Record if the left steer button has been pressed on keyboard.
\param[in] steerLeftKeyPressed is true if the steer-left key has been pressed and false otherwise.
*/
void setDigitalSteerLeft(const bool steerLeftKeyPressed) {mRawDigitalInputs[PxVehicleDrive4WControl::eANALOG_INPUT_STEER_LEFT]=steerLeftKeyPressed;}
/**
\brief Record if the right steer button has been pressed on keyboard.
\param[in] steerRightKeyPressed is true if the steer-right key has been pressed and false otherwise.
*/
void setDigitalSteerRight(const bool steerRightKeyPressed) {mRawDigitalInputs[PxVehicleDrive4WControl::eANALOG_INPUT_STEER_RIGHT]=steerRightKeyPressed;}
/**
\brief Return if the accel button has been pressed on keyboard.
\return True if the accel button has been pressed, false otherwise.
*/
bool getDigitalAccel() const {return mRawDigitalInputs[PxVehicleDrive4WControl::eANALOG_INPUT_ACCEL];}
/**
\brief Return if the brake button has been pressed on keyboard.
\return True if the brake button has been pressed, false otherwise.
*/
bool getDigitalBrake() const {return mRawDigitalInputs[PxVehicleDrive4WControl::eANALOG_INPUT_BRAKE];}
/**
\brief Return if the handbrake button has been pressed on keyboard.
\return True if the handbrake button has been pressed, false otherwise.
*/
bool getDigitalHandbrake() const {return mRawDigitalInputs[PxVehicleDrive4WControl::eANALOG_INPUT_HANDBRAKE];}
/**
\brief Return if the left steer button has been pressed on keyboard.
\return True if the steer-left button has been pressed, false otherwise.
*/
bool getDigitalSteerLeft() const {return mRawDigitalInputs[PxVehicleDrive4WControl::eANALOG_INPUT_STEER_LEFT];}
/**
\brief Return if the right steer button has been pressed on keyboard.
\return True if the steer-right button has been pressed, false otherwise.
*/
bool getDigitalSteerRight() const {return mRawDigitalInputs[PxVehicleDrive4WControl::eANALOG_INPUT_STEER_RIGHT];}
/**
\brief Set the analog accel value from the gamepad
\param[in] accel is the analog accelerator pedal value in range(0,1) where 1 represents the pedal fully pressed and 0 represents the pedal in its rest state.
*/
void setAnalogAccel(const PxReal accel)
{
#if PX_CHECKED
testValidAnalogValue(accel, 0.0f, 1.0f, "Analog accel must be in range (0,1)");
#endif
mRawAnalogInputs[PxVehicleDrive4WControl::eANALOG_INPUT_ACCEL]=accel;
}
/**
\brief Set the analog brake value from the gamepad
\param[in] brake is the analog brake pedal value in range(0,1) where 1 represents the pedal fully pressed and 0 represents the pedal in its rest state.
*/
void setAnalogBrake(const PxReal brake)
{
#if PX_CHECKED
testValidAnalogValue(brake, 0.0f, 1.0f, "Analog brake must be in range (0,1)");
#endif
mRawAnalogInputs[PxVehicleDrive4WControl::eANALOG_INPUT_BRAKE]=brake;
}
/**
\brief Set the analog handbrake value from the gamepad
\param[in] handbrake is the analog handbrake value in range(0,1) where 1 represents the handbrake fully engaged and 0 represents the handbrake in its rest state.
*/
void setAnalogHandbrake(const PxReal handbrake)
{
#if PX_CHECKED
testValidAnalogValue(handbrake, 0.0f, 1.0f, "Analog handbrake must be in range (0,1)");
#endif
mRawAnalogInputs[PxVehicleDrive4WControl::eANALOG_INPUT_HANDBRAKE]=handbrake;
}
/**
\brief Set the analog steer value from the gamepad
\param[in] steer is the analog steer value in range(-1,1) where -1 represents the steering wheel at left lock and +1 represents the steering wheel at right lock.
*/
void setAnalogSteer(const PxReal steer)
{
#if PX_CHECKED
testValidAnalogValue(steer, -1.0f, 1.0f, "Analog steer must be in range (-1,1)");
#endif
mRawAnalogInputs[PxVehicleDrive4WControl::eANALOG_INPUT_STEER_RIGHT]=steer;
}
/**
\brief Return the analog accel value from the gamepad
\return The analog accel value.
*/
PxReal getAnalogAccel() const {return mRawAnalogInputs[PxVehicleDrive4WControl::eANALOG_INPUT_ACCEL];}
/**
\brief Return the analog brake value from the gamepad
\return The analog brake value.
*/
PxReal getAnalogBrake() const {return mRawAnalogInputs[PxVehicleDrive4WControl::eANALOG_INPUT_BRAKE];}
/**
\brief Return the analog handbrake value from the gamepad
\return The analog handbrake value.
*/
PxReal getAnalogHandbrake() const {return mRawAnalogInputs[PxVehicleDrive4WControl::eANALOG_INPUT_HANDBRAKE];}
/**
\brief Return the analog steer value from the gamepad
*/
PxReal getAnalogSteer() const {return mRawAnalogInputs[PxVehicleDrive4WControl::eANALOG_INPUT_STEER_RIGHT];}
/**
\brief Record if the gearup button has been pressed on keyboard or gamepad
\param[in] gearUpKeyPressed is true if the gear-up button has been pressed, false otherwise.
*/
void setGearUp(const bool gearUpKeyPressed) {mGearUp=gearUpKeyPressed;}
/**
\brief Record if the geardown button has been pressed on keyboard or gamepad
\param[in] gearDownKeyPressed is true if the gear-down button has been pressed, false otherwise.
*/
void setGearDown(const bool gearDownKeyPressed) {mGearDown=gearDownKeyPressed;}
/**
\brief Return if the gearup button has been pressed on keyboard or gamepad
\return The value of the gear-up button.
*/
bool getGearUp() const {return mGearUp;}
/**
\brief Record if the geardown button has been pressed on keyboard or gamepad
\return The value of the gear-down button.
*/
bool getGearDown() const {return mGearDown;}
private:
bool mRawDigitalInputs[PxVehicleDrive4WControl::eMAX_NB_DRIVE4W_ANALOG_INPUTS];
PxReal mRawAnalogInputs[PxVehicleDrive4WControl::eMAX_NB_DRIVE4W_ANALOG_INPUTS];
bool mGearUp;
bool mGearDown;
};
/**
\brief Used to smooth and set analog vehicle control values (accel,brake,handbrake,steer) from digital inputs (keyboard).
Also used to set boolean gearup, geardown values.
\param[in] keySmoothing describes the rise and fall rates of the corresponding analog values when keys are pressed on and off.
\param[in] steerVsForwardSpeedTable is a table of maximum allowed steer versus forward vehicle speed.
\param[in] rawInputData is the state of all digital inputs that control the vehicle.
\param[in] timestep is the time that has passed since the last call to PxVehicleDrive4WSmoothDigitalRawInputsAndSetAnalogInputs
\param[in] isVehicleInAir describes if the vehicle is in the air or on the ground and is used to decide whether or not to apply steerVsForwardSpeedTable.
\param[in] focusVehicle is the vehicle that will be given analog and gearup/geardown control values arising from the digital inputs.
\param[in] steerFilter is an optional smoothing filter for the steering angle.
\param[in] forwardAxis The axis denoting the local space forward direction of the vehicle.
*/
PX_DEPRECATED void PxVehicleDrive4WSmoothDigitalRawInputsAndSetAnalogInputs
(const PxVehicleKeySmoothingData& keySmoothing, const PxFixedSizeLookupTable<8>& steerVsForwardSpeedTable,
const PxVehicleDrive4WRawInputData& rawInputData, const PxReal timestep, const bool isVehicleInAir,
PxVehicleDrive4W& focusVehicle, const PxVehicleSteerFilter& steerFilter = PxVehicleSteerFilter(),
const PxVec3& forwardAxis = PxVehicleGetDefaultContext().forwardAxis);
/**
\brief Used to smooth and set analog vehicle control values from analog inputs (gamepad).
Also used to set boolean gearup, geardown values.
\param[in] padSmoothing describes how quickly the control values applied to the vehicle blend from the current vehicle values towards the raw analog values from the gamepad.
\param[in] steerVsForwardSpeedTable is a table of maximum allowed steer versus forward vehicle speed.
\param[in] rawInputData is the state of all gamepad analog inputs that will be used control the vehicle.
\param[in] timestep is the time that has passed since the last call to PxVehicleDrive4WSmoothAnalogRawInputsAndSetAnalogInputs
\param[in] isVehicleInAir describes if the vehicle is in the air or on the ground and is used to decide whether or not to apply steerVsForwardSpeedTable.
\param[in] focusVehicle is the vehicle that will be given analog control values arising from the gamepad inputs.
\param[in] steerFilter is an optional smoothing filter for the steering angle.
\param[in] forwardAxis The axis denoting the local space forward direction of the vehicle.
*/
PX_DEPRECATED void PxVehicleDrive4WSmoothAnalogRawInputsAndSetAnalogInputs
(const PxVehiclePadSmoothingData& padSmoothing, const PxFixedSizeLookupTable<8>& steerVsForwardSpeedTable,
const PxVehicleDrive4WRawInputData& rawInputData, const PxReal timestep, const bool isVehicleInAir,
PxVehicleDrive4W& focusVehicle, const PxVehicleSteerFilter& steerFilter = PxVehicleSteerFilter(),
const PxVec3& forwardAxis = PxVehicleGetDefaultContext().forwardAxis);
/**
\brief Used to produce smooth vehicle driving control values from analog and digital inputs.
@see PxVehicleDriveNWSmoothDigitalRawInputsAndSetAnalogInputs, PxVehicleDriveNWSmoothAnalogRawInputsAndSetAnalogInputs
*/
class PX_DEPRECATED PxVehicleDriveNWRawInputData : public PxVehicleDrive4WRawInputData
{
public:
PxVehicleDriveNWRawInputData() : PxVehicleDrive4WRawInputData(){}
~PxVehicleDriveNWRawInputData(){}
};
/**
\brief Used to smooth and set analog vehicle control values (accel,brake,handbrake,steer) from digital inputs (keyboard).
Also used to set boolean gearup, geardown values.
\param[in] keySmoothing describes the rise and fall rates of the corresponding analog values when keys are pressed on and off.
\param[in] steerVsForwardSpeedTable is a table of maximum allowed steer versus forward vehicle speed.
\param[in] rawInputData is the state of all digital inputs that control the vehicle.
\param[in] timestep is the time that has passed since the last call to PxVehicleDriveNWSmoothDigitalRawInputsAndSetAnalogInputs
\param[in] isVehicleInAir describes if the vehicle is in the air or on the ground and is used to decide whether or not to apply steerVsForwardSpeedTable.
\param[in] focusVehicle is the vehicle that will be given analog and gearup/geardown control values arising from the digital inputs.
\param[in] steerFilter is an optional smoothing filter for the steering angle.
\param[in] forwardAxis The axis denoting the local space forward direction of the vehicle.
*/
PX_DEPRECATED void PxVehicleDriveNWSmoothDigitalRawInputsAndSetAnalogInputs
(const PxVehicleKeySmoothingData& keySmoothing, const PxFixedSizeLookupTable<8>& steerVsForwardSpeedTable,
const PxVehicleDriveNWRawInputData& rawInputData, const PxReal timestep, const bool isVehicleInAir,
PxVehicleDriveNW& focusVehicle, const PxVehicleSteerFilter& steerFilter = PxVehicleSteerFilter(),
const PxVec3& forwardAxis = PxVehicleGetDefaultContext().forwardAxis);
/**
\brief Used to smooth and set analog vehicle control values from analog inputs (gamepad).
Also used to set boolean gearup, geardown values.
\param[in] padSmoothing describes how quickly the control values applied to the vehicle blend from the current vehicle values towards the raw analog values from the gamepad.
\param[in] steerVsForwardSpeedTable is a table of maximum allowed steer versus forward vehicle speed.
\param[in] rawInputData is the state of all gamepad analog inputs that will be used control the vehicle.
\param[in] timestep is the time that has passed since the last call to PxVehicleDriveNWSmoothAnalogRawInputsAndSetAnalogInputs
\param[in] isVehicleInAir describes if the vehicle is in the air or on the ground and is used to decide whether or not to apply steerVsForwardSpeedTable.
\param[in] focusVehicle is the vehicle that will be given analog control values arising from the gamepad inputs.
\param[in] steerFilter is an optional smoothing filter for the steering angle.
\param[in] forwardAxis The axis denoting the local space forward direction of the vehicle.
*/
PX_DEPRECATED void PxVehicleDriveNWSmoothAnalogRawInputsAndSetAnalogInputs
(const PxVehiclePadSmoothingData& padSmoothing, const PxFixedSizeLookupTable<8>& steerVsForwardSpeedTable,
const PxVehicleDriveNWRawInputData& rawInputData, const PxReal timestep, const bool isVehicleInAir,
PxVehicleDriveNW& focusVehicle, const PxVehicleSteerFilter& steerFilter = PxVehicleSteerFilter(),
const PxVec3& forwardAxis = PxVehicleGetDefaultContext().forwardAxis);
/**
\brief Used to produce smooth analog tank control values from analog and digital inputs.
@see PxVehicleDriveTankSmoothDigitalRawInputsAndSetAnalogInputs, PxVehicleDriveTankSmoothAnalogRawInputsAndSetAnalogInputs
*/
class PX_DEPRECATED PxVehicleDriveTankRawInputData
{
public:
PxVehicleDriveTankRawInputData(const PxVehicleDriveTankControlModel::Enum mode)
: mMode(mode)
{
for(PxU32 i=0;i<PxVehicleDriveTankControl::eMAX_NB_DRIVETANK_ANALOG_INPUTS;i++)
{
mRawAnalogInputs[i]=0.0f;
mRawDigitalInputs[i]=false;
}
mGearUp=false;
mGearDown=false;
}
~PxVehicleDriveTankRawInputData()
{
}
/**
\brief Return the drive model (eDRIVE_MODEL_SPECIAL or eDRIVE_MODEL_STANDARD)
\return The chosen tank drive model.
*/
PxVehicleDriveTankControlModel::Enum getDriveModel() const
{
return mMode;
}
/**
\brief Set if the accel button has been pressed on the keyboard
\param[in] b is true if the digital accel button has been pressed, false otherwise.
*/
void setDigitalAccel(const bool b) {mRawDigitalInputs[PxVehicleDriveTankControl::eANALOG_INPUT_ACCEL]=b;}
/**
\brief Set if the left thrust button has been pressed on the keyboard
\param[in] b is true if the digital left thrust button has been pressed, false otherwise.
*/
void setDigitalLeftThrust(const bool b) {mRawDigitalInputs[PxVehicleDriveTankControl::eANALOG_INPUT_THRUST_LEFT]=b;}
/**
\brief Set if the right thrust button has been pressed on the keyboard
\param[in] b is true if the digital right thrust button has been pressed, false otherwise.
*/
void setDigitalRightThrust(const bool b) {mRawDigitalInputs[PxVehicleDriveTankControl::eANALOG_INPUT_THRUST_RIGHT]=b;}
/**
\brief Set if the left brake button has been pressed on the keyboard
\param[in] b is true if the digital left brake button has been pressed, false otherwise.
*/
void setDigitalLeftBrake(const bool b) {mRawDigitalInputs[PxVehicleDriveTankControl::eANALOG_INPUT_BRAKE_LEFT]=b;}
/**
\brief Set if the right brake button has been pressed on the keyboard
\param[in] b is true if the digital right brake button has been pressed, false otherwise.
*/
void setDigitalRightBrake(const bool b) {mRawDigitalInputs[PxVehicleDriveTankControl::eANALOG_INPUT_BRAKE_RIGHT]=b;}
/**
\brief Return if the accel button has been pressed on the keyboard
\return True if the accel button has been pressed, false otherwise.
*/
bool getDigitalAccel() const {return mRawDigitalInputs[PxVehicleDriveTankControl::eANALOG_INPUT_ACCEL];}
/**
\brief Return if the left thrust button has been pressed on the keyboard
\return True if the left thrust button has been pressed, false otherwise.
*/
bool getDigitalLeftThrust() const {return mRawDigitalInputs[PxVehicleDriveTankControl::eANALOG_INPUT_THRUST_LEFT];}
/**
\brief Return if the right thrust button has been pressed on the keyboard
\return True if the right thrust button has been pressed, false otherwise.
*/
bool getDigitalRightThrust() const {return mRawDigitalInputs[PxVehicleDriveTankControl::eANALOG_INPUT_THRUST_RIGHT];}
/**
\brief Return if the left brake button has been pressed on the keyboard
\return True if the left brake button has been pressed, false otherwise.
*/
bool getDigitalLeftBrake() const {return mRawDigitalInputs[PxVehicleDriveTankControl::eANALOG_INPUT_BRAKE_LEFT];}
/**
\brief Return if the right brake button has been pressed on the keyboard
\return True if the right brake button has been pressed, false otherwise.
*/
bool getDigitalRightBrake() const {return mRawDigitalInputs[PxVehicleDriveTankControl::eANALOG_INPUT_BRAKE_RIGHT];}
/**
\brief Set the analog accel value from the gamepad
\param[in] accel is a value in range (0,1) where 1 represents the accelerator pedal fully pressed and 0 represents the pedal in its rest state.
In range (0,1).
*/
void setAnalogAccel(const PxF32 accel)
{
#if PX_CHECKED
testValidAnalogValue(accel, 0.0f, 1.0f, "Tank analog accel must be in range (-1,1)");
#endif
mRawAnalogInputs[PxVehicleDriveTankControl::eANALOG_INPUT_ACCEL]=accel;
}
/**
\brief Set the analog left thrust value from the gamepad
\param[in] leftThrust represents the state of the left stick.
\note In range (0,1) for standard mode (eSTANDARD), in range (-1,1) for special mode (eSPECIAL)
*/
void setAnalogLeftThrust(const PxF32 leftThrust)
{
#if PX_CHECKED
if(mMode == PxVehicleDriveTankControlModel::eSPECIAL)
{
testValidAnalogValue(leftThrust, -1.0f, 1.0f, "Tank left thrust must be in range (-1,1) in eSPECIAL mode.");
}
else
{
testValidAnalogValue(leftThrust, 0.0f, 1.0f, "Tank left thrust must be in range (0,1) in eSTANDARD mode.");
}
#endif
mRawAnalogInputs[PxVehicleDriveTankControl::eANALOG_INPUT_THRUST_LEFT]=leftThrust;
}
/**
\brief Set the analog right thrust value from the gamepad
\param[in] rightThrust represents the state of the right stick.
\note In range (0,1) for standard mode (eSTANDARD), in range (-1,1) for special mode (eSPECIAL)
*/
void setAnalogRightThrust(const PxF32 rightThrust)
{
#if PX_CHECKED
if(mMode == PxVehicleDriveTankControlModel::eSPECIAL)
{
testValidAnalogValue(rightThrust, -1.0f, 1.0f, "Tank right thrust must be in range (-1,1) in eSPECIAL mode.");
}
else
{
testValidAnalogValue(rightThrust, 0.0f, 1.0f, "Tank right thrust must be in range (0,1) in eSTANDARD mode.");
}
#endif
mRawAnalogInputs[PxVehicleDriveTankControl::eANALOG_INPUT_THRUST_RIGHT]=rightThrust;
}
/**
\brief Set the analog left brake value from the gamepad
\param[in] leftBrake is a value in range (0,1) where 1 represents the left brake pedal fully pressed and 0 represents the left brake pedal in its rest state.
\note In range (0,1).
*/
void setAnalogLeftBrake(const PxF32 leftBrake)
{
#if PX_CHECKED
testValidAnalogValue(leftBrake, 0.0f, 1.0f, "Tank left brake must be in range (0,1).");
#endif
mRawAnalogInputs[PxVehicleDriveTankControl::eANALOG_INPUT_BRAKE_LEFT]=leftBrake;
}
/**
\brief Set the analog right brake value from the gamepad
\param[in] rightBrake is a value in range (0,1) where 1 represents the right brake pedal fully pressed and 0 represents the right brake pedal in its rest state.
\note In range (0,1).
*/
void setAnalogRightBrake(const PxF32 rightBrake)
{
#if PX_CHECKED
testValidAnalogValue(rightBrake, 0.0f, 1.0f, "Tank right brake must be in range (0,1).");
#endif
mRawAnalogInputs[PxVehicleDriveTankControl::eANALOG_INPUT_BRAKE_RIGHT]=rightBrake;
}
/**
\brief Return the analog accel value from the gamepad
\return The analog accel value.
*/
PxF32 getAnalogAccel() const
{
return mRawAnalogInputs[PxVehicleDriveTankControl::eANALOG_INPUT_ACCEL];
}
/**
\brief Return the analog left thrust value from the gamepad
\return The analog left thrust value.
*/
PxF32 getAnalogLeftThrust() const
{
return mRawAnalogInputs[PxVehicleDriveTankControl::eANALOG_INPUT_THRUST_LEFT];
}
/**
\brief Return the analog right thrust value from the gamepad
\return The analog right thrust value.
*/
PxF32 getAnalogRightThrust() const
{
return mRawAnalogInputs[PxVehicleDriveTankControl::eANALOG_INPUT_THRUST_RIGHT];
}
/**
\brief Return the analog left brake value from the gamepad
\return The analog left brake value.
*/
PxF32 getAnalogLeftBrake() const
{
return mRawAnalogInputs[PxVehicleDriveTankControl::eANALOG_INPUT_BRAKE_LEFT];
}
/**
\brief Return the analog right brake value from the gamepad
\return The analog right brake value.
*/
PxF32 getAnalogRightBrake() const
{
return mRawAnalogInputs[PxVehicleDriveTankControl::eANALOG_INPUT_BRAKE_RIGHT];
}
/**
\brief Record if the gear-up button has been pressed on keyboard or gamepad
\param[in] gearUp is true if the gear-up button has been pressed, false otherwise.
*/
void setGearUp(const bool gearUp) {mGearUp=gearUp;}
/**
\brief Record if the gear-down button has been pressed on keyboard or gamepad
\param[in] gearDown is true if the gear-down button has been pressed, false otherwise.
*/
void setGearDown(const bool gearDown) {mGearDown=gearDown;}
/**
\brief Return if the gear-up button has been pressed on keyboard or gamepad
\return True if the gear-up button has been pressed, false otherwise.
*/
bool getGearUp() const {return mGearUp;}
/**
\brief Return if the gear-down button has been pressed on keyboard or gamepad
\return True if the gear-down button has been pressed, false otherwise.
*/
bool getGearDown() const {return mGearDown;}
private:
PxVehicleDriveTankControlModel::Enum mMode;
PxReal mRawAnalogInputs[PxVehicleDriveTankControl::eMAX_NB_DRIVETANK_ANALOG_INPUTS];
bool mRawDigitalInputs[PxVehicleDriveTankControl::eMAX_NB_DRIVETANK_ANALOG_INPUTS];
bool mGearUp;
bool mGearDown;
};
/**
\brief Used to smooth and set analog tank control values from digital inputs (keyboard).
Also used to set boolean gearup, geardown values.
\param[in] keySmoothing describes the rise and fall rates of the corresponding analog values when keys are pressed on and off.
\param[in] rawInputData is the state of all digital inputs that control the vehicle.
\param[in] timestep is the time that has passed since the last call to PxVehicleDriveTankSmoothDigitalRawInputsAndSetAnalogInputs
\param[in] focusVehicle is the vehicle that will be given analog and gearup/geardown control values arising from the digital inputs.
*/
PX_DEPRECATED void PxVehicleDriveTankSmoothDigitalRawInputsAndSetAnalogInputs
(const PxVehicleKeySmoothingData& keySmoothing,
const PxVehicleDriveTankRawInputData& rawInputData,
const PxReal timestep,
PxVehicleDriveTank& focusVehicle);
/**
\brief Used to smooth and set analog tank control values from analog inputs (gamepad).
Also used to set boolean gearup, geardown values.
\param[in] padSmoothing describes how quickly the control values applied to the vehicle blend from the current vehicle values towards the raw analog values from the gamepad.
\param[in] rawInputData is the state of all gamepad analog inputs that will be used control the vehicle.
\param[in] timestep is the time that has passed since the last call to PxVehicleDriveTankSmoothAnalogRawInputsAndSetAnalogInputs
\param[in] focusVehicle is the vehicle that will be given analog control values arising from the gamepad inputs.
*/
PX_DEPRECATED void PxVehicleDriveTankSmoothAnalogRawInputsAndSetAnalogInputs
(const PxVehiclePadSmoothingData& padSmoothing,
const PxVehicleDriveTankRawInputData& rawInputData,
const PxReal timestep,
PxVehicleDriveTank& focusVehicle);
#if !PX_DOXYGEN
} // namespace physx
#endif
#endif
| 29,013 | C | 41.856721 | 173 | 0.780857 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle/PxVehicleNoDrive.h | // 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-2023 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 PX_VEHICLE_NO_DRIVE_H
#define PX_VEHICLE_NO_DRIVE_H
#include "vehicle/PxVehicleWheels.h"
#include "vehicle/PxVehicleComponents.h"
#if !PX_DOXYGEN
namespace physx
{
#endif
struct PxFilterData;
class PxGeometry;
class PxPhysics;
class PxVehicleDrivableSurfaceToTireFrictionPairs;
class PxShape;
class PxMaterial;
class PxRigidDynamic;
/**
\brief Data structure with instanced dynamics data and configuration data of a vehicle with no drive model.
*/
class PX_DEPRECATED PxVehicleNoDrive : public PxVehicleWheels
{
public:
friend class PxVehicleUpdate;
/**
\brief Allocate a PxVehicleNoDrive instance for a vehicle without drive model and with nbWheels
\param[in] nbWheels is the number of wheels on the vehicle.
\return The instantiated vehicle.
@see free, setup
*/
static PxVehicleNoDrive* allocate(const PxU32 nbWheels);
/**
\brief Deallocate a PxVehicleNoDrive instance.
@see allocate
*/
void free();
/**
\brief Set up a vehicle using simulation data for the wheels.
\param[in] physics is a PxPhysics instance that is needed to create special vehicle constraints that are maintained by the vehicle.
\param[in] vehActor is a PxRigidDynamic instance that is used to represent the vehicle in the PhysX SDK.
\param[in] wheelsData describes the configuration of all suspension/tires/wheels of the vehicle. The vehicle instance takes a copy of this data.
\note It is assumed that the first shapes of the actor are the wheel shapes, followed by the chassis shapes. To break this assumption use PxVehicleWheels::setWheelShapeMapping.
@see allocate, free, setToRestState, PxVehicleWheels::setWheelShapeMapping
*/
void setup
(PxPhysics* physics, PxRigidDynamic* vehActor, const PxVehicleWheelsSimData& wheelsData);
/**
\brief Allocate and set up a vehicle using simulation data for the wheels.
\param[in] physics is a PxPhysics instance that is needed to create special vehicle constraints that are maintained by the vehicle.
\param[in] vehActor is a PxRigidDynamic instance that is used to represent the vehicle in the PhysX SDK.
\param[in] wheelsData describes the configuration of all suspension/tires/wheels of the vehicle. The vehicle instance takes a copy of this data.
\note It is assumed that the first shapes of the actor are the wheel shapes, followed by the chassis shapes. To break this assumption use PxVehicleWheels::setWheelShapeMapping.
\return The instantiated vehicle.
@see allocate, free, setToRestState, PxVehicleWheels::setWheelShapeMapping
*/
static PxVehicleNoDrive* create
(PxPhysics* physics, PxRigidDynamic* vehActor, const PxVehicleWheelsSimData& wheelsData);
/**
\brief Set a vehicle to its rest state. Aside from the rigid body transform, this will set the vehicle and rigid body
to the state they were in immediately after setup or create.
\note Calling setToRestState invalidates the cached raycast hit planes under each wheel meaning that suspension line
raycasts need to be performed at least once with PxVehicleSuspensionRaycasts before calling PxVehicleUpdates.
@see setup, create, PxVehicleSuspensionRaycasts, PxVehicleUpdates
*/
void setToRestState();
/**
\brief Set the brake torque to be applied to a specific wheel
\note The applied brakeTorque persists until the next call to setBrakeTorque
\note The brake torque is specified in Newton metres.
\param[in] id is the wheel being given the brake torque
\param[in] brakeTorque is the value of the brake torque
*/
void setBrakeTorque(const PxU32 id, const PxReal brakeTorque);
/**
\brief Set the drive torque to be applied to a specific wheel
\note The applied driveTorque persists until the next call to setDriveTorque
\note The brake torque is specified in Newton metres.
\param[in] id is the wheel being given the brake torque
\param[in] driveTorque is the value of the brake torque
*/
void setDriveTorque(const PxU32 id, const PxReal driveTorque);
/**
\brief Set the steer angle to be applied to a specific wheel
\note The applied steerAngle persists until the next call to setSteerAngle
\note The steer angle is specified in radians.
\param[in] id is the wheel being given the steer angle
\param[in] steerAngle is the value of the steer angle in radians.
*/
void setSteerAngle(const PxU32 id, const PxReal steerAngle);
/**
\brief Get the brake torque that has been applied to a specific wheel
\param[in] id is the wheel being queried for its brake torque
\return The brake torque applied to the queried wheel.
*/
PxReal getBrakeTorque(const PxU32 id) const;
/**
\brief Get the drive torque that has been applied to a specific wheel
\param[in] id is the wheel being queried for its drive torque
\return The drive torque applied to the queried wheel.
*/
PxReal getDriveTorque(const PxU32 id) const;
/**
\brief Get the steer angle that has been applied to a specific wheel
\param[in] id is the wheel being queried for its steer angle
\return The steer angle (in radians) applied to the queried wheel.
*/
PxReal getSteerAngle(const PxU32 id) const;
private:
PxReal* mSteerAngles;
PxReal* mDriveTorques;
PxReal* mBrakeTorques;
#if PX_P64_FAMILY
PxU32 mPad[2];
#else
PxU32 mPad[1];
#endif
/**
\brief Test if the instanced dynamics and configuration data has legal values.
*/
bool isValid() const;
//serialization
public:
PxVehicleNoDrive(PxBaseFlags baseFlags) : PxVehicleWheels(baseFlags) {}
virtual void exportExtraData(PxSerializationContext&);
void importExtraData(PxDeserializationContext&);
static PxVehicleNoDrive* createObject(PxU8*& address, PxDeserializationContext& context);
static void getBinaryMetaData(PxOutputStream& stream);
virtual const char* getConcreteTypeName() const { return "PxVehicleNoDrive"; }
virtual bool isKindOf(const char* name) const { PX_IS_KIND_OF(name, "PxVehicleNoDrive", PxVehicleWheels); }
PxU32 getNbSteerAngle() const { return mWheelsSimData.getNbWheels(); }
PxU32 getNbDriveTorque() const { return mWheelsSimData.getNbWheels(); }
PxU32 getNbBrakeTorque() const { return mWheelsSimData.getNbWheels(); }
protected:
PxVehicleNoDrive();
~PxVehicleNoDrive() {}
//~serialization
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleNoDrive) & 15));
#if !PX_DOXYGEN
} // namespace physx
#endif
#endif
| 8,036 | C | 38.014563 | 178 | 0.768417 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle/PxVehicleUtilTelemetry.h | // 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-2023 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 PX_VEHICLE_UTIL_TELEMETRY_H
#define PX_VEHICLE_UTIL_TELEMETRY_H
#include "vehicle/PxVehicleSDK.h"
#include "foundation/PxSimpleTypes.h"
#include "foundation/PxVec3.h"
#if !PX_DOXYGEN
namespace physx
{
#endif
#if PX_DEBUG_VEHICLE_ON
class PX_DEPRECATED PxVehicleGraphDesc
{
friend class PxVehicleGraph;
PxVehicleGraphDesc();
/**
\brief x-coord of graph centre.
<b>Range:</b> (0,1)<br>
*/
PxReal mPosX;
/**
\brief y-coord of graph centre.
<b>Range:</b> (0,1)<br>
*/
PxReal mPosY;
/**
\brief x-extents of graph (from mPosX-0.5f*mSizeX to mPosX+0.5f*mSizeX).
<b>Range:</b> (0,1)<br>
*/
PxReal mSizeX;
/**
\brief y-extents of graph (from mPosY-0.5f*mSizeY to mPosY+0.5f*mSizeY).
<b>Range:</b> (0,1)<br>
*/
PxReal mSizeY;
/**
\brief Background color of graph.
*/
PxVec3 mBackgroundColor;
/**
\brief Alpha value of background color.
*/
PxReal mAlpha;
private:
bool isValid() const;
};
struct PX_DEPRECATED PxVehicleGraphChannelDesc
{
public:
friend class PxVehicleGraph;
PxVehicleGraphChannelDesc();
/**
\brief Data values less than mMinY will be clamped at mMinY.
*/
PxReal mMinY;
/**
\brief Data values greater than mMaxY will be clamped at mMaxY.
*/
PxReal mMaxY;
/**
\brief Data values greater than mMidY will be drawn with color mColorHigh.
Data values less than mMidY will be drawn with color mColorLow.
*/
PxReal mMidY;
/**
\brief Color used to render data values lower than mMidY.
*/
PxVec3 mColorLow;
/**
\brief Color used to render data values greater than mMidY.
*/
PxVec3 mColorHigh;
/**
\brief String to describe data channel.
*/
char* mTitle;
private:
bool isValid() const;
};
struct PX_DEPRECATED PxVehicleWheelGraphChannel
{
enum Enum
{
eJOUNCE=0,
eSUSPFORCE,
eTIRELOAD,
eNORMALIZED_TIRELOAD,
eWHEEL_OMEGA,
eTIRE_FRICTION,
eTIRE_LONG_SLIP,
eNORM_TIRE_LONG_FORCE,
eTIRE_LAT_SLIP,
eNORM_TIRE_LAT_FORCE,
eNORM_TIRE_ALIGNING_MOMENT,
eMAX_NB_WHEEL_CHANNELS
};
};
struct PX_DEPRECATED PxVehicleDriveGraphChannel
{
enum Enum
{
eENGINE_REVS=0,
eENGINE_DRIVE_TORQUE,
eCLUTCH_SLIP,
eACCEL_CONTROL, //TANK_ACCEL
eBRAKE_CONTROL, //TANK_BRAKE_LEFT
eHANDBRAKE_CONTROL, //TANK_BRAKE_RIGHT
eSTEER_LEFT_CONTROL, //TANK_THRUST_LEFT
eSTEER_RIGHT_CONTROL, //TANK_THRUST_RIGHT
eGEAR_RATIO,
eMAX_NB_DRIVE_CHANNELS
};
};
struct PX_DEPRECATED PxVehicleGraphType
{
enum Enum
{
eWHEEL=0,
eDRIVE
};
};
class PX_DEPRECATED PxVehicleGraph
{
public:
friend class PxVehicleTelemetryData;
friend class PxVehicleUpdate;
enum
{
eMAX_NB_SAMPLES=256
};
enum
{
eMAX_NB_TITLE_CHARS=256
};
enum
{
eMAX_NB_CHANNELS=12
};
/**
\brief Setup a graph from a descriptor.
*/
void setup(const PxVehicleGraphDesc& desc, const PxVehicleGraphType::Enum graphType);
/**
\brief Clear all data recorded in a graph.
*/
void clearRecordedChannelData();
/**
\brief Get the color of the graph background. Used for rendering a graph.
*/
const PxVec3& getBackgroundColor() const {return mBackgroundColor;}
/**
\brief Get the alpha transparency of the color of the graph background. Used for rendering a graph.
*/
PxReal getBackgroundAlpha() const {return mBackgroundAlpha;}
/**
\brief Get the coordinates of the graph background. Used for rendering a graph
\param[out] xMin is the x-coord of the lower-left corner
\param[out] yMin is the y-coord of the lower-left corner
\param[out] xMax is the x-coord of the upper-right corner
\param[out] yMax is the y-coord of the upper-right corner
*/
void getBackgroundCoords(PxReal& xMin, PxReal& yMin, PxReal& xMax, PxReal& yMax) const {xMin = mBackgroundMinX;xMax = mBackgroundMaxX;yMin = mBackgroundMinY;yMax = mBackgroundMaxY;}
/**
\brief Compute the coordinates of the graph data of a specific graph channel.
\param[out] xy is an array of graph sample coordinates stored in order x0,y0,x1,y1,x2,y2...xn,yn.
\param[out] colors stores the color of each point on the graph.
\param[out] title is the title of the graph.
*/
void computeGraphChannel(const PxU32 channel, PxReal* xy, PxVec3* colors, char* title) const;
/**
\brief Return the latest value stored in the specified graph channel
*/
PxF32 getLatestValue(const PxU32 channel) const ;
/**
\brief Get the raw data of a specific graph channel.
\param[in] channel is the ID of the graph channel to get data from.
\param[out] values is the buffer to write the data to. Minimum required size is eMAX_NB_SAMPLES.
*/
void getRawData(const PxU32 channel, PxReal* values) const;
private:
//Min and max of each sample.
PxReal mChannelMinY[eMAX_NB_CHANNELS];
PxReal mChannelMaxY[eMAX_NB_CHANNELS];
//Discriminate between high and low values with different colors.
PxReal mChannelMidY[eMAX_NB_CHANNELS];
//Different colors for values than midY and less than midY.
PxVec3 mChannelColorLow[eMAX_NB_CHANNELS];
PxVec3 mChannelColorHigh[eMAX_NB_CHANNELS];
//Title of graph
char mChannelTitle[eMAX_NB_CHANNELS][eMAX_NB_TITLE_CHARS];
//Graph data.
PxReal mChannelSamples[eMAX_NB_CHANNELS][eMAX_NB_SAMPLES];
//Background color,alpha,coords
PxVec3 mBackgroundColor;
PxReal mBackgroundAlpha;
PxReal mBackgroundMinX;
PxReal mBackgroundMaxX;
PxReal mBackgroundMinY;
PxReal mBackgroundMaxY;
PxU32 mSampleTide;
PxU32 mNbChannels;
PxU32 mPad[2];
void setup
(const PxF32 graphSizeX, const PxF32 graphSizeY,
const PxF32 engineGraphPosX, const PxF32 engineGraphPosY,
const PxF32* const wheelGraphPosX, const PxF32* const wheelGraphPosY,
const PxVec3& backgroundColor, const PxVec3& lineColorHigh, const PxVec3& lineColorLow);
void updateTimeSlice(const PxReal* const samples);
void setChannel(PxVehicleGraphChannelDesc& desc, const PxU32 channel);
void setupEngineGraph
(const PxF32 sizeX, const PxF32 sizeY, const PxF32 posX, const PxF32 posY,
const PxVec3& backgoundColor, const PxVec3& lineColorHigh, const PxVec3& lineColorLow);
void setupWheelGraph
(const PxF32 sizeX, const PxF32 sizeY, const PxF32 posX, const PxF32 posY,
const PxVec3& backgoundColor, const PxVec3& lineColorHigh, const PxVec3& lineColorLow);
PxVehicleGraph();
~PxVehicleGraph();
};
PX_COMPILE_TIME_ASSERT(PxU32(PxVehicleGraph::eMAX_NB_CHANNELS) >= PxU32(PxVehicleWheelGraphChannel::eMAX_NB_WHEEL_CHANNELS) && PxU32(PxVehicleGraph::eMAX_NB_CHANNELS) >= PxU32(PxVehicleDriveGraphChannel::eMAX_NB_DRIVE_CHANNELS));
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleGraph) & 15));
class PX_DEPRECATED PxVehicleTelemetryData
{
public:
friend class PxVehicleUpdate;
/**
\brief Allocate a PxVehicleNWTelemetryData instance for a vehicle with nbWheels
@see PxVehicleNWTelemetryDataFree
*/
static PxVehicleTelemetryData* allocate(const PxU32 nbWheels);
/**
\brief Free a PxVehicleNWTelemetryData instance for a vehicle.
@see PxVehicleNWTelemetryDataAllocate
*/
void free();
/**
\brief Set up all the graphs so that they are ready to record data.
*/
void setup
(const PxReal graphSizeX, const PxReal graphSizeY,
const PxReal engineGraphPosX, const PxReal engineGraphPosY,
const PxReal* const wheelGraphPosX, const PxReal* const wheelGraphPosY,
const PxVec3& backGroundColor, const PxVec3& lineColorHigh, const PxVec3& lineColorLow);
/**
\brief Clear the graphs of recorded data.
*/
void clear();
/**
\brief Get the graph data for the engine
*/
const PxVehicleGraph& getEngineGraph() const {return *mEngineGraph;}
/**
\brief Get the number of wheel graphs
*/
PxU32 getNbWheelGraphs() const {return mNbActiveWheels;}
/**
\brief Get the graph data for the kth wheel
*/
const PxVehicleGraph& getWheelGraph(const PxU32 k) const {return mWheelGraphs[k];}
/**
\brief Get the array of tire force application points so they can be rendered
*/
const PxVec3* getTireforceAppPoints() const {return mTireforceAppPoints;}
/**
\brief Get the array of susp force application points so they can be rendered
*/
const PxVec3* getSuspforceAppPoints() const {return mSuspforceAppPoints;}
private:
/**
\brief Graph data for engine.
Used for storing single timeslices of debug data for engine graph.
@see PxVehicleGraph
*/
PxVehicleGraph* mEngineGraph;
/**
\brief Graph data for each wheel.
Used for storing single timeslices of debug data for wheel graphs.
@see PxVehicleGraph
*/
PxVehicleGraph* mWheelGraphs;
/**
\brief Application point of tire forces.
*/
PxVec3* mTireforceAppPoints;
/**
\brief Application point of susp forces.
*/
PxVec3* mSuspforceAppPoints;
/**
\brief Total number of active wheels
*/
PxU32 mNbActiveWheels;
PxU32 mPad[3];
private:
PxVehicleTelemetryData(){}
~PxVehicleTelemetryData(){}
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleTelemetryData) & 15));
#endif //PX_DEBUG_VEHICLE_ON
//#endif // PX_DEBUG_VEHICLE_ON
#if !PX_DOXYGEN
} // namespace physx
#endif
#endif
| 10,565 | C | 24.521739 | 229 | 0.741316 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle/PxVehicleSDK.h | // 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-2023 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 PX_VEHICLE_SDK_H
#define PX_VEHICLE_SDK_H
#include "foundation/Px.h"
#include "foundation/PxVec3.h"
#include "common/PxTypeInfo.h"
#if !PX_DOXYGEN
namespace physx
{
#endif
class PxPhysics;
class PxSerializationRegistry;
/**
\brief Initialize the PhysXVehicle library.
Call this before using any of the vehicle functions.
\param physics The PxPhysics instance.
\param serializationRegistry PxSerializationRegistry instance, if NULL vehicle serialization is not supported.
\note This function must be called after PxFoundation and PxPhysics instances have been created.
\note If a PxSerializationRegistry instance is specified then PhysXVehicle is also dependent on PhysXExtensions.
@see PxCloseVehicleSDK
*/
PX_DEPRECATED PX_C_EXPORT bool PX_CALL_CONV PxInitVehicleSDK(PxPhysics& physics, PxSerializationRegistry* serializationRegistry = NULL);
/**
\brief Shut down the PhysXVehicle library.
Call this function as part of the physx shutdown process.
\param serializationRegistry PxSerializationRegistry instance, if non-NULL must be the same as passed into PxInitVehicleSDK.
\note This function must be called prior to shutdown of PxFoundation and PxPhysics.
\note If the PxSerializationRegistry instance is specified this function must additionally be called prior to shutdown of PhysXExtensions.
@see PxInitVehicleSDK
*/
PX_DEPRECATED PX_C_EXPORT void PX_CALL_CONV PxCloseVehicleSDK(PxSerializationRegistry* serializationRegistry = NULL);
/**
\brief This number is the maximum number of wheels allowed for a vehicle.
*/
#define PX_MAX_NB_WHEELS (20)
/**
\brief Compiler setting to enable recording of telemetry data
@see PxVehicleUpdateSingleVehicleAndStoreTelemetryData, PxVehicleTelemetryData
*/
#define PX_DEBUG_VEHICLE_ON (1)
/**
@see PxVehicleDrive4W, PxVehicleDriveTank, PxVehicleDriveNW, PxVehicleNoDrive, PxVehicleWheels::getVehicleType
*/
struct PX_DEPRECATED PxVehicleTypes
{
enum Enum
{
eDRIVE4W=0,
eDRIVENW,
eDRIVETANK,
eNODRIVE,
eUSER1,
eUSER2,
eUSER3,
eMAX_NB_VEHICLE_TYPES
};
};
/**
\brief An enumeration of concrete vehicle classes inheriting from PxBase.
\note This enum can be used to identify a vehicle object stored in a PxCollection.
@see PxBase, PxTypeInfo, PxBase::getConcreteType
*/
struct PX_DEPRECATED PxVehicleConcreteType
{
enum Enum
{
eVehicleNoDrive = PxConcreteType::eFIRST_VEHICLE_EXTENSION,
eVehicleDrive4W,
eVehicleDriveNW,
eVehicleDriveTank
};
};
/**
\brief Set the basis vectors of the vehicle simulation
See PxVehicleContext for the default values.
Call this function before using PxVehicleUpdates unless the default values are correct
or the settings structure is explicitly provided.
@see PxVehicleContext
*/
PX_DEPRECATED void PxVehicleSetBasisVectors(const PxVec3& up, const PxVec3& forward);
/**
@see PxVehicleSetUpdateMode
*/
struct PX_DEPRECATED PxVehicleUpdateMode
{
enum Enum
{
eVELOCITY_CHANGE,
eACCELERATION
};
};
/**
\brief Set the effect of PxVehicleUpdates to be either to modify each vehicle's rigid body actor
with an acceleration to be applied in the next PhysX SDK update or as an immediate velocity modification.
See PxVehicleContext for the default value.
Call this function before using PxVehicleUpdates for the first time if the default is not the desired behavior
or if the settings structure is not explicitly provided.
@see PxVehicleUpdates, PxVehicleContext
*/
PX_DEPRECATED void PxVehicleSetUpdateMode(PxVehicleUpdateMode::Enum vehicleUpdateMode);
/**
\brief Set threshold angles that are used to determine if a wheel hit is to be resolved by vehicle suspension or by rigid body collision.
\note ^
N ___
|**
**
**
%%% %%% **
%%% %%% ** /
/
%%% %%% /
/
%%% %%% /
C /
%%% | ** %%% /
| ** /
%%% | **%%%/
| X**
%%% | %%% / **_| ^
| / D
%%% | %%% /
| /
| /
| /
|
^ |
S \|/
The diagram above depicts a wheel centered at "C" that has hit an inclined plane at point "X".
The inclined plane has unit normal "N", while the suspension direction has unit vector "S".
The unit vector from the wheel center to the hit point is "D".
Hit points are analyzed by comparing the unit vectors D and N with the suspension direction S.
This analysis is performed in the contact modification callback PxVehicleModifyWheelContacts (when enabled) and in
PxVehicleUpdates (when non-blocking sweeps are enabled).
If the angle between D and S is less than pointRejectAngle the hit is accepted by the suspension in PxVehicleUpdates and rejected
by the contact modification callback PxVehicleModifyWheelContacts.
If the angle between -N and S is less than normalRejectAngle the hit is accepted by the suspension in PxVehicleUpdates and rejected
by the contact modification callback PxVehicleModifyWheelContacts.
\param pointRejectAngle is the threshold angle used when comparing the angle between D and S.
\param normalRejectAngle is the threshold angle used when comparing the angle between -N and S.
\note PxVehicleUpdates ignores the rejection angles for raycasts and for sweeps that return blocking hits.
\note Both angles have default values of Pi/4.
@see PxVehicleSuspensionSweeps, PxVehicleModifyWheelContacts, PxVehicleContext
*/
PX_DEPRECATED void PxVehicleSetSweepHitRejectionAngles(const PxF32 pointRejectAngle, const PxF32 normalRejectAngle);
/**
\brief Determine the maximum acceleration experienced by PxRigidDynamic instances that are found to be in contact
with a wheel.
\note Newton's Third Law states that every force has an equal and opposite force. As a consequence, forces applied to
the suspension must be applied to dynamic objects that lie under the wheel. This can lead to instabilities, particularly
when a heavy wheel is driving on a light object. The value of maxHitActorAcceleration clamps the applied force so that it never
generates an acceleration greater than the specified value.
See PxVehicleContext for the default value.
@see PxVehicleContext
*/
PX_DEPRECATED void PxVehicleSetMaxHitActorAcceleration(const PxF32 maxHitActorAcceleration);
/**
\brief Common parameters and settings used for the vehicle simulation.
To be passed into PxVehicleUpdates(), for example.
@see PxVehicleUpdates()
*/
class PX_DEPRECATED PxVehicleContext
{
public:
/**
\brief The axis denoting the up direction for vehicles.
<b>Range:</b> unit length vector<br>
<b>Default:</b> PxVec3(0,1,0)
@see PxVehicleSetBasisVectors()
*/
PxVec3 upAxis;
/**
\brief The axis denoting the forward direction for vehicles.
<b>Range:</b> unit length vector<br>
<b>Default:</b> PxVec3(0,0,1)
@see PxVehicleSetBasisVectors()
*/
PxVec3 forwardAxis;
/**
\brief The axis denoting the side direction for vehicles.
Has to be the cross product of the up- and forward-axis. The method
computeSideAxis() can be used to do that computation for you.
<b>Range:</b> unit length vector<br>
<b>Default:</b> PxVec3(1,0,0)
@see PxVehicleSetBasisVectors(), computeSideAxis()
*/
PxVec3 sideAxis;
/**
\brief Apply vehicle simulation results as acceleration or velocity modification.
See PxVehicleSetUpdateMode() for details.
<b>Default:</b> eVELOCITY_CHANGE
@see PxVehicleSetUpdateMode()
*/
PxVehicleUpdateMode::Enum updateMode;
/**
\brief Cosine of threshold angle for rejecting sweep hits.
See PxVehicleSetSweepHitRejectionAngles() for details.
<b>Range:</b> (1, -1)<br>
<b>Default:</b> 0.707f (cosine of 45 degrees)
@see PxVehicleSetSweepHitRejectionAngles()
*/
PxF32 pointRejectAngleThresholdCosine;
/**
\brief Cosine of threshold angle for rejecting sweep hits.
See PxVehicleSetSweepHitRejectionAngles() for details.
<b>Range:</b> (1, -1)<br>
<b>Default:</b> 0.707f (cosine of 45 degrees)
@see PxVehicleSetSweepHitRejectionAngles()
*/
PxF32 normalRejectAngleThresholdCosine;
/**
\brief Maximum acceleration experienced by PxRigidDynamic instances that are found to be in contact with a wheel.
See PxVehicleSetMaxHitActorAcceleration() for details.
<b>Range:</b> [0, PX_MAX_REAL]<br>
<b>Default:</b> PX_MAX_REAL
@see PxVehicleSetMaxHitActorAcceleration()
*/
PxF32 maxHitActorAcceleration;
public:
/**
\brief Constructor sets to default.
*/
PX_INLINE PxVehicleContext();
/**
\brief (re)sets the structure to the default.
*/
PX_INLINE void setToDefault();
/**
\brief Check if the settings descriptor is valid.
\return True if the current settings are valid.
*/
PX_INLINE bool isValid() const;
/**
\brief Compute the side-axis from the up- and forward-axis
*/
PX_INLINE void computeSideAxis();
};
PX_INLINE PxVehicleContext::PxVehicleContext():
upAxis(0.0f, 1.0f, 0.0f),
forwardAxis(0.0f, 0.0f, 1.0f),
sideAxis(1.0f, 0.0f, 0.0f),
updateMode(PxVehicleUpdateMode::eVELOCITY_CHANGE),
pointRejectAngleThresholdCosine(0.707f), // cosine of 45 degrees
normalRejectAngleThresholdCosine(0.707f), // cosine of 45 degrees
maxHitActorAcceleration(PX_MAX_REAL)
{
}
PX_INLINE void PxVehicleContext::setToDefault()
{
*this = PxVehicleContext();
}
PX_INLINE bool PxVehicleContext::isValid() const
{
if (!upAxis.isNormalized())
return false;
if (!forwardAxis.isNormalized())
return false;
if (!sideAxis.isNormalized())
return false;
if (((upAxis.cross(forwardAxis)) - sideAxis).magnitude() > 0.02f) // somewhat above 1 degree assuming both have unit length
return false;
if ((pointRejectAngleThresholdCosine >= 1) || (pointRejectAngleThresholdCosine <= -1))
return false;
if ((normalRejectAngleThresholdCosine >= 1) || (normalRejectAngleThresholdCosine <= -1))
return false;
if (maxHitActorAcceleration < 0.0f)
return false;
return true;
}
PX_INLINE void PxVehicleContext::computeSideAxis()
{
sideAxis = upAxis.cross(forwardAxis);
}
/**
\brief Get the default vehicle context.
Will be used if the corresponding parameters are not specified in methods like
PxVehicleUpdates() etc.
To set the default values, see the methods PxVehicleSetBasisVectors(),
PxVehicleSetUpdateMode() etc.
\return The default vehicle context.
@see PxVehicleSetBasisVectors() PxVehicleSetUpdateMode()
*/
PX_DEPRECATED const PxVehicleContext& PxVehicleGetDefaultContext();
#if !PX_DOXYGEN
} // namespace physx
#endif
#endif
| 12,441 | C | 28.553444 | 138 | 0.728478 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle/PxVehicleShaders.h | // 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-2023 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 PX_VEHICLE_SHADERS_H
#define PX_VEHICLE_SHADERS_H
#include "foundation/PxSimpleTypes.h"
#if !PX_DOXYGEN
namespace physx
{
#endif
/**
\brief Prototype of shader function that is used to compute wheel torque and tire forces.
\param[in] shaderData is the shader data for the tire being processed. The shader data describes the tire data in the format required by the tire model that is implemented by the shader function.
\param[in] tireFriction is the value of friction for the contact between the tire and the ground.
\param[in] longSlip is the value of longitudinal slip experienced by the tire.
\param[in] latSlip is the value of lateral slip experienced by the tire.
\param[in] camber is the camber angle of the tire in radians.
\param[in] wheelOmega is the rotational speed of the wheel.
\param[in] wheelRadius is the distance from the tire surface to the center of the wheel.
\param[in] recipWheelRadius is the reciprocal of wheelRadius.
\param[in] restTireLoad is the load force experienced by the tire when the vehicle is at rest.
\param[in] normalisedTireLoad is a pre-computed value equal to the load force on the tire divided by restTireLoad.
\param[in] tireLoad is the load force currently experienced by the tire (= restTireLoad*normalisedTireLoad)
\param[in] gravity is the magnitude of gravitational acceleration.
\param[in] recipGravity is the reciprocal of the magnitude of gravitational acceleration.
\param[out] wheelTorque is the torque that is to be applied to the wheel around the wheel's axle.
\param[out] tireLongForceMag is the magnitude of the longitudinal tire force to be applied to the vehicle's rigid body.
\param[out] tireLatForceMag is the magnitude of the lateral tire force to be applied to the vehicle's rigid body.
\param[out] tireAlignMoment is the aligning moment of the tire that is to be applied to the vehicle's rigid body (not currently used).
@see PxVehicleWheelsDynData::setTireForceShaderFunction, PxVehicleWheelsDynData::setTireForceShaderData
*/
PX_DEPRECATED typedef void (*PxVehicleComputeTireForce)
(const void* shaderData,
const PxF32 tireFriction,
const PxF32 longSlip, const PxF32 latSlip, const PxF32 camber,
const PxF32 wheelOmega, const PxF32 wheelRadius, const PxF32 recipWheelRadius,
const PxF32 restTireLoad, const PxF32 normalisedTireLoad, const PxF32 tireLoad,
const PxF32 gravity, const PxF32 recipGravity,
PxF32& wheelTorque, PxF32& tireLongForceMag, PxF32& tireLatForceMag, PxF32& tireAlignMoment);
#if !PX_DOXYGEN
} // namespace physx
#endif
#endif
| 4,246 | C | 55.626666 | 197 | 0.784032 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle/PxVehicleDrive.h | // 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-2023 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 PX_VEHICLE_DRIVE_H
#define PX_VEHICLE_DRIVE_H
#include "vehicle/PxVehicleWheels.h"
#include "vehicle/PxVehicleComponents.h"
#if !PX_DOXYGEN
namespace physx
{
#endif
struct PxFilterData;
class PxGeometry;
class PxPhysics;
class PxVehicleDrivableSurfaceToTireFrictionPairs;
class PxShape;
class PxMaterial;
class PxRigidDynamic;
/**
\brief Data structure describing non-wheel configuration data of a vehicle that has engine, gears, clutch, and auto-box.
@see PxVehicleWheelsSimData for wheels configuration data.
*/
class PX_DEPRECATED PxVehicleDriveSimData
{
public:
friend class PxVehicleDriveTank;
/**
\brief Return the engine data
*/
PX_FORCE_INLINE const PxVehicleEngineData& getEngineData() const
{
return mEngine;
}
/**
\brief Set the engine data
\param[in] engine - the data stored in engine is copied to the vehicle's engine.
*/
void setEngineData(const PxVehicleEngineData& engine);
/**
\brief Return the gears data
*/
PX_FORCE_INLINE const PxVehicleGearsData& getGearsData() const
{
return mGears;
}
/**
\brief Set the gears data
\param[in] gears - the data stored in gears is copied to the vehicle's gears.
*/
void setGearsData(const PxVehicleGearsData& gears);
/**
\brief Return the clutch data
*/
PX_FORCE_INLINE const PxVehicleClutchData& getClutchData() const
{
return mClutch;
}
/**
\brief Set the clutch data
\param[in] clutch - the data stored in clutch is copied to the vehicle's clutch.
*/
void setClutchData(const PxVehicleClutchData& clutch);
/**
\brief Return the autobox data
*/
PX_FORCE_INLINE const PxVehicleAutoBoxData& getAutoBoxData() const
{
return mAutoBox;
}
/**
\brief Set the autobox data
\param[in] autobox - the data stored in autobox is copied to the vehicle's autobox.
*/
void setAutoBoxData(const PxVehicleAutoBoxData& autobox);
protected:
/*
\brief Engine simulation data
@see setEngineData, getEngineData
*/
PxVehicleEngineData mEngine;
/*
\brief Gear simulation data
@see setGearsData, getGearsData
*/
PxVehicleGearsData mGears;
/*
\brief Clutch simulation data
@see setClutchData, getClutchData
*/
PxVehicleClutchData mClutch;
/*
\brief Autobox simulation data
@see setAutoboxData, getAutoboxData
*/
PxVehicleAutoBoxData mAutoBox;
/**
\brief Test that a PxVehicleDriveSimData instance has been configured with legal data.
Call only after setting all components with setEngineData,setGearsData,setClutchData,setAutoBoxData
@see PxVehicleDrive4W::setup, PxVehicleDriveTank::setup
*/
bool isValid() const;
//serialization
public:
PxVehicleDriveSimData() {}
PxVehicleDriveSimData(const PxEMPTY) : mEngine(PxEmpty), mGears(PxEmpty), mClutch(PxEmpty), mAutoBox(PxEmpty) {}
static void getBinaryMetaData(PxOutputStream& stream);
//~serialization
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleDriveSimData) & 15));
/**
\brief Data structure with instanced dynamics data for vehicle with engine, clutch, gears, autobox
@see PxVehicleWheelsDynData for wheels dynamics data.
*/
class PX_DEPRECATED PxVehicleDriveDynData
{
public:
enum
{
eMAX_NB_ANALOG_INPUTS=16
};
friend class PxVehicleDrive;
/**
\brief Set all dynamics data to zero to bring the vehicle to rest.
*/
void setToRestState();
/**
\brief Set an analog control value to drive the vehicle.
\param[in] type describes the type of analog control being modified
\param[in] analogVal is the new value of the specific analog control.
@see PxVehicleDrive4WControl, PxVehicleDriveNWControl, PxVehicleDriveTankControl
*/
void setAnalogInput(const PxU32 type, const PxReal analogVal);
/**
\brief Get the analog control value that has been applied to the vehicle.
\return The value of the specified analog control value.
@see PxVehicleDrive4WControl, PxVehicleDriveNWControl, PxVehicleDriveTankControl
*/
PxReal getAnalogInput(const PxU32 type) const;
/**
\brief Inform the vehicle that the gear-up button has been pressed.
\param[in] digitalVal is the state of the gear-up button.
\note If digitalVal is true the vehicle will attempt to initiate a gear change at the next call to PxVehicleUpdates.
\note The value of mGearUpPressed is not reset by PxVehicleUpdates
*/
void setGearUp(const bool digitalVal)
{
mGearUpPressed = digitalVal;
}
/**
\brief Set that the gear-down button has been pressed.
\param[in] digitalVal is the state of the gear-down button.
\note If digitalVal is true the vehicle will attempt to initiate a gear change at the next call to PxVehicleUpdates.
\note The value of mGearDownPressed is not reset by PxVehicleUpdates
*/
void setGearDown(const bool digitalVal)
{
mGearDownPressed = digitalVal;
}
/**
\brief Check if the gear-up button has been pressed
\return The state of the gear-up button.
*/
bool getGearUp() const
{
return mGearUpPressed;
}
/**
\brief Check if the gear-down button has been pressed
\return The state of the gear-down button.
*/
bool getGearDown() const
{
return mGearDownPressed;
}
/**
\brief Set the flag that will be used to select auto-gears
If useAutoGears is true the auto-box will be active.
\param[in] useAutoGears is the active state of the auto-box.
*/
PX_FORCE_INLINE void setUseAutoGears(const bool useAutoGears)
{
mUseAutoGears=useAutoGears;
}
/**
\brief Get the flag status that is used to select auto-gears
\return The active status of the auto-box.
*/
PX_FORCE_INLINE bool getUseAutoGears() const
{
return mUseAutoGears;
}
/**
\brief Toggle the auto-gears flag
If useAutoGears is true the auto-box will be active.
*/
PX_FORCE_INLINE void toggleAutoGears()
{
mUseAutoGears = !mUseAutoGears;
}
/**
\brief Set the current gear.
\param[in] currentGear is the vehicle's gear.
\note If the target gear is different from the current gear the vehicle will
attempt to start a gear change from the current gear that has just been set
towards the target gear at the next call to PxVehicleUpdates.
@see setTargetGear, PxVehicleGearsData
*/
PX_FORCE_INLINE void setCurrentGear(PxU32 currentGear)
{
mCurrentGear = currentGear;
}
/**
\brief Get the current gear.
\return The vehicle's current gear.
@see getTargetGear, PxVehicleGearsData
*/
PX_FORCE_INLINE PxU32 getCurrentGear() const
{
return mCurrentGear;
}
/**
\brief Set the target gear.
\param[in] targetGear is the vehicle's target gear.
\note If the target gear is different from the current gear the vehicle will
attempt to start a gear change towards the target gear at the next call to
PxVehicleUpdates.
@see PxVehicleGearsData
*/
PX_FORCE_INLINE void setTargetGear(PxU32 targetGear)
{
mTargetGear = targetGear;
}
/**
\brief Get the target gear.
\return The vehicle's target gear.
@see setTargetGear, PxVehicleGearsData
*/
PX_FORCE_INLINE PxU32 getTargetGear() const
{
return mTargetGear;
}
/**
\brief Start a gear change to a target gear.
\param[in] targetGear is the gear the vehicle will begin a transition towards.
\note The gear change will begin at the next call to PxVehicleUpadates.
@see PxVehicleGearsData
*/
PX_FORCE_INLINE void startGearChange(const PxU32 targetGear)
{
mTargetGear=targetGear;
}
/**
\brief Force an immediate gear change to a target gear
\param[in] targetGear is the gear the vehicle will be given immediately.
@see PxVehicleGearsData
*/
PX_FORCE_INLINE void forceGearChange(const PxU32 targetGear)
{
mTargetGear=targetGear;
mCurrentGear=targetGear;
}
/**
\brief Set the rotation speed of the engine (radians per second)
\param[in] speed is the rotational speed (radians per second) to apply to the engine.
*/
PX_FORCE_INLINE void setEngineRotationSpeed(const PxF32 speed)
{
mEnginespeed = speed;
}
/**
\brief Return the rotation speed of the engine (radians per second)
\return The rotational speed (radians per second) of the engine.
*/
PX_FORCE_INLINE PxReal getEngineRotationSpeed() const
{
return mEnginespeed;
}
/**
\brief Return the time that has passed since the current gear change was initiated.
\return The time that has passed since the current gear change was initiated.
\note If no gear change is in process the gear switch time will be zero.
@see PxVehicleGearsData.mSwitchTime
*/
PX_FORCE_INLINE PxReal getGearSwitchTime() const
{
return mGearSwitchTime;
}
/**
\brief Return the time that has passed since the autobox last initiated a gear change.
\return The time that has passed since the autobox last initiated a gear change.
@see PxVehicleAutoBoxData::setLatency, PxVehicleAutoBoxData::getLatency
*/
PX_FORCE_INLINE PxReal getAutoBoxSwitchTime() const
{
return mAutoBoxSwitchTime;
}
/**
\brief All dynamic data values are public for fast access.
*/
/**
\brief Analog control values used by vehicle simulation.
@see setAnalogInput, getAnalogInput, PxVehicleDrive4WControl, PxVehicleDriveNWControl, PxVehicleDriveTankControl
*/
PxReal mControlAnalogVals[eMAX_NB_ANALOG_INPUTS];
/**
\brief Auto-gear flag used by vehicle simulation. Set true to enable the autobox, false to disable the autobox.
@see setUseAutoGears, setUseAutoGears, toggleAutoGears, PxVehicleAutoBoxData
*/
bool mUseAutoGears;
/**
\brief Gear-up digital control value used by vehicle simulation.
\note If true a gear change will be initiated towards currentGear+1 (or to first gear if in reverse).
@see setDigitalInput, getDigitalInput
*/
bool mGearUpPressed;
/**
\brief Gear-down digital control value used by vehicle simulation.
\note If true a gear change will be initiated towards currentGear-1 (or to reverse if in first).
@see setDigitalInput, getDigitalInput
*/
bool mGearDownPressed;
/**
\brief Current gear
@see startGearChange, forceGearChange, getCurrentGear, PxVehicleGearsData
*/
PxU32 mCurrentGear;
/**
\brief Target gear (different from current gear if a gear change is underway)
@see startGearChange, forceGearChange, getTargetGear, PxVehicleGearsData
*/
PxU32 mTargetGear;
/**
\brief Rotation speed of engine
@see setToRestState, getEngineRotationSpeed
*/
PxReal mEnginespeed;
/**
\brief Reported time that has passed since gear change started.
@see setToRestState, startGearChange, PxVehicleGearsData::mSwitchTime
*/
PxReal mGearSwitchTime;
/**
\brief Reported time that has passed since last autobox gearup/geardown decision.
@see setToRestState, PxVehicleAutoBoxData::setLatency
*/
PxReal mAutoBoxSwitchTime;
private:
PxU32 mPad[2];
/**
\brief Test that a PxVehicleDriveDynData instance has legal values.
@see setToRestState
*/
bool isValid() const;
//serialization
public:
PxVehicleDriveDynData();
PxVehicleDriveDynData(const PxEMPTY) {}
PxU32 getNbAnalogInput() const { return eMAX_NB_ANALOG_INPUTS; }
PX_FORCE_INLINE void setGearChange(const PxU32 gearChange) { mTargetGear= gearChange; }
PX_FORCE_INLINE PxU32 getGearChange() const { return mTargetGear; }
PX_FORCE_INLINE void setGearSwitchTime(const PxReal switchTime) { mGearSwitchTime = switchTime; }
PX_FORCE_INLINE void setAutoBoxSwitchTime(const PxReal autoBoxSwitchTime) { mAutoBoxSwitchTime = autoBoxSwitchTime; }
//~serialization
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleDriveDynData) & 15));
/**
\brief A complete vehicle with instance dynamics data and configuration data for wheels and engine,clutch,gears,autobox.
@see PxVehicleDrive4W, PxVehicleDriveTank
*/
class PX_DEPRECATED PxVehicleDrive : public PxVehicleWheels
{
public:
friend class PxVehicleUpdate;
/**
\brief Dynamics data of vehicle instance.
@see setup
*/
PxVehicleDriveDynData mDriveDynData;
protected:
/**
\brief Test that all instanced dynamics data and configuration data have legal values.
*/
bool isValid() const;
/**
\brief Set vehicle to rest.
*/
void setToRestState();
/**
@see PxVehicleDrive4W::allocate, PxVehicleDriveTank::allocate
*/
static PxU32 computeByteSize(const PxU32 numWheels);
static PxU8* patchupPointers(const PxU32 nbWheels, PxVehicleDrive* vehDrive, PxU8* ptr);
virtual void init(const PxU32 numWheels);
/**
\brief Deallocate a PxVehicle4WDrive instance.
@see PxVehicleDrive4W::free, PxVehicleDriveTank::free
*/
void free();
/**
@see PxVehicleDrive4W::setup, PxVehicleDriveTank::setup
*/
void setup
(PxPhysics* physics, PxRigidDynamic* vehActor,
const PxVehicleWheelsSimData& wheelsData,
const PxU32 nbDrivenWheels, const PxU32 nbNonDrivenWheels);
//serialization
public:
static void getBinaryMetaData(PxOutputStream& stream);
PxVehicleDrive(PxBaseFlags baseFlags) : PxVehicleWheels(baseFlags), mDriveDynData(PxEmpty) {}
virtual const char* getConcreteTypeName() const { return "PxVehicleDrive"; }
protected:
PxVehicleDrive(PxType concreteType, PxBaseFlags baseFlags) : PxVehicleWheels(concreteType, baseFlags) {}
~PxVehicleDrive() {}
virtual bool isKindOf(const char* name) const { PX_IS_KIND_OF(name, "PxVehicleDrive", PxVehicleWheels); }
//~serialization
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleDrive) & 15));
#if !PX_DOXYGEN
} // namespace physx
#endif
#endif
| 14,805 | C | 25.969035 | 120 | 0.757109 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle/PxVehicleWheels.h | // 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-2023 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 PX_VEHICLE_WHEELS_H
#define PX_VEHICLE_WHEELS_H
#include "foundation/PxSimpleTypes.h"
#include "vehicle/PxVehicleShaders.h"
#include "vehicle/PxVehicleComponents.h"
#include "common/PxBase.h"
#include "PxRigidDynamic.h"
#if !PX_DOXYGEN
namespace physx
{
#endif
class PxVehicleWheels4SimData;
class PxVehicleWheels4DynData;
class PxVehicleTireForceCalculator;
class PxShape;
class PxPhysics;
class PxMaterial;
/**
\brief Flags to configure the vehicle wheel simulation.
@see PxVehicleWheelsSimData::setFlags(), PxVehicleWheelsSimData::getFlags()
*/
struct PX_DEPRECATED PxVehicleWheelsSimFlag
{
enum Enum
{
/**
\brief Limit the suspension expansion velocity.
For extreme damping ratios, large damping forces might result in the vehicle sticking to the ground where
one would rather expect to see the vehicle lift off. While it is highly recommended to use somewhat realistic
damping ratios, this flag can be used to limit the velocity of the suspension. In more detail, the simulation
will check whether the suspension can extend to the target length in the given simulation time step. If that
is the case, the suspension force will be computed as usual, else the force will be set to zero. Enabling
this feature gives a slightly more realisitic behavior at the potential cost of more easily losing control
when steering the vehicle.
*/
eLIMIT_SUSPENSION_EXPANSION_VELOCITY = (1 << 0),
/**
\brief Disable internal cylinder-plane intersection test.
By default the internal code runs a post-process on sweep results, approximating the wheel shape with a
cylinder and tweaking the sweep hit results accordingly. This can produce artefacts in certain cases, in
particular when the swept shape is very different from a cylinder - e.g. with swept spheres. This flag
tells the system to disable this internal test, and reuse the direct user-provided sweep results.
The default code refines the sweep results in each substep. Enabling this flag makes the system partially
reuse the same sweep results over each substep, which could potentially create other artefacts.
*/
eDISABLE_INTERNAL_CYLINDER_PLANE_INTERSECTION_TEST = (1 << 1),
/**
\brief Disable suspension force projection.
By default the internal code modulates the suspension force with the contact normal, i.e. the more the contact
normal is aligned with the suspension direction, the bigger the force. This can create issues when using a
single blocking hit, whose unique contact normal sometimes does not accurately capture the reality of the
surrounding geometry. For example it can weaken the suspension force too much, which visually makes the wheel
move up and down against e.g. a kerb. Enabling this flag tells the system to disable the modulation of the
suspension force by the contact normal.
The rationale is that a real tire has a deformed contact patch containing multiple normals, and even if some
of these normals are bent when colliding against a kerb, there would still be a large area of the contact patch
touching the ground, and getting normals aligned with the suspension. This is difficult to capture with simple
sweep results, especially with a single sweep hit whose normal is computed by a less than accurate algorithm
like GJK. Using this flag shortcuts these issues, which can improves the behavior when driving over kerbs or
small obstacles.
*/
eDISABLE_SUSPENSION_FORCE_PROJECTION = (1 << 2),
/**
\brief Disable check for sprung mass values summing up to chassis mass.
Generally, the sum of the suspension sprung mass values should match the chassis mass. However, there can be
scenarios where this is not necessarily desired. Taking a semi-trailer truck as an example, a large part of
the trailer mass will rest on the tractor unit and not the trailer wheels. This flag allows the user to set
the values as desired without error messages being sent.
*/
eDISABLE_SPRUNG_MASS_SUM_CHECK = (1 << 3)
};
};
/**
\brief Collection of set bits defined in #PxVehicleWheelsSimFlag.
@see PxVehicleWheelsSimFlag
*/
typedef PxFlags<PxVehicleWheelsSimFlag::Enum, PxU32> PxVehicleWheelsSimFlags;
PX_FLAGS_OPERATORS(PxVehicleWheelsSimFlag::Enum, PxU32)
/**
\brief Data structure describing configuration data of a vehicle with up to 20 wheels.
*/
class PX_DEPRECATED PxVehicleWheelsSimData
{
public:
friend class PxVehicleWheels;
friend class PxVehicleNoDrive;
friend class PxVehicleDrive4W;
friend class PxVehicleDriveTank;
friend class PxVehicleUpdate;
/**
\brief Allocate a PxVehicleWheelsSimData instance for with nbWheels.
@see free
*/
static PxVehicleWheelsSimData* allocate(const PxU32 nbWheels);
/**
\brief Setup with mass information that can be applied to the default values of the suspensions, wheels, and tires
set in their respective constructors.
\param chassisMass is the mass of the chassis.
\note This function assumes that the suspensions equally share the load of the chassis mass. It also
assumes that the suspension will have a particular natural frequency and damping ratio that is typical
of a standard car. If either of these assumptions is broken then each suspension will need to
be individually configured with custom strength, damping rate, and sprung mass.
@see allocate
*/
void setChassisMass(const PxF32 chassisMass);
/**
\brief Free a PxVehicleWheelsSimData instance
@see allocate
*/
void free();
/**
\brief Copy wheel simulation data.
\note The number of wheels on both instances of PxVehicleWheelsSimData must match.
*/
PxVehicleWheelsSimData& operator=(const PxVehicleWheelsSimData& src);
/**
\brief Copy the data of a single wheel unit (wheel, suspension, tire) from srcWheel of src to trgWheel.
\param[in] src is the data to be copied.
\param[in] srcWheel is the wheel whose data will be copied from src.
\param[in] trgWheel is the wheel that will be assigned the copied data.
*/
void copy(const PxVehicleWheelsSimData& src, const PxU32 srcWheel, const PxU32 trgWheel);
/**
\brief Return the number of wheels
@see allocate
*/
PxU32 getNbWheels() const {return mNbActiveWheels;}
/**
\brief Return the suspension data of the idth wheel
*/
const PxVehicleSuspensionData& getSuspensionData(const PxU32 id) const;
/**
\brief Return the wheel data of the idth wheel
*/
const PxVehicleWheelData& getWheelData(const PxU32 id) const;
/**
\brief Return the tire data of the idth wheel
*/
const PxVehicleTireData& getTireData(const PxU32 id) const;
/**
\brief Return the direction of travel of the suspension of the idth wheel
*/
const PxVec3& getSuspTravelDirection(const PxU32 id) const;
/**
\brief Return the application point of the suspension force of the suspension of the idth wheel as an offset from the rigid body center of mass.
\note Specified relative to the center of mass of the rigid body
*/
const PxVec3& getSuspForceAppPointOffset(const PxU32 id) const;
/**
\brief Return the application point of the tire force of the tire of the idth wheel as an offset from the rigid body center of mass.
\note Specified relative to the centre of mass of the rigid body
*/
const PxVec3& getTireForceAppPointOffset(const PxU32 id) const;
/**
\brief Return the offset from the rigid body centre of mass to the centre of the idth wheel.
*/
const PxVec3& getWheelCentreOffset(const PxU32 id) const;
/**
\brief Return the wheel mapping for the ith wheel.
\note The return value is the element in the array of
shapes of the vehicle's PxRigidDynamic that corresponds to the ith wheel. A return value of -1 means
that the wheel is not mapped to a PxShape.
@see PxRigidActor.getShapes
*/
PxI32 getWheelShapeMapping(const PxU32 wheelId) const;
/**
\brief Return the scene query filter data used by the specified suspension line
*/
const PxFilterData& getSceneQueryFilterData(const PxU32 suspId) const;
/**
\brief Return the number of unique anti-roll bars that have been added with addAntiRollBarData
@see PxVehicleWheelsSimData::addAntiRollBarData
*/
PxU32 getNbAntiRollBars() const
{
return mNbActiveAntiRollBars;
}
/**
\brief Return a specific anti-roll bar.
\param antiRollId is the unique id of the anti-roll bar
\note The return value of addAntiRollBarData is a unique id for that specific anti-roll bar
and can be used as input parameter for getAntiRollBarData in order to query the same anti-roll bar.
Alternatively, it is possible to iterate over all anti-roll bars by choosing antiRollId
in range (0, getNbAntiRollBars()).
*/
const PxVehicleAntiRollBarData& getAntiRollBarData(const PxU32 antiRollId) const;
/**
\brief Return the data that describes the filtering of the tire load to produce smoother handling at large time-steps.
*/
PX_FORCE_INLINE const PxVehicleTireLoadFilterData& getTireLoadFilterData() const
{
return mNormalisedLoadFilter;
}
/**
\brief Set the suspension data of the idth wheel
\param[in] id is the wheel index.
\param[in] susp is the suspension data to be applied.
*/
void setSuspensionData(const PxU32 id, const PxVehicleSuspensionData& susp);
/**
\brief Set the wheel data of the idth wheel
\param[in] id is the wheel index.
\param[in] wheel is the wheel data to be applied.
*/
void setWheelData(const PxU32 id, const PxVehicleWheelData& wheel);
/**
\brief Set the tire data of the idth wheel
\param[in] id is the wheel index.
\param[in] tire is the tire data to be applied.
*/
void setTireData(const PxU32 id, const PxVehicleTireData& tire);
/**
\brief Set the direction of travel of the suspension of the idth wheel
\param[in] id is the wheel index
\param[in] dir is the suspension travel direction to be applied.
*/
void setSuspTravelDirection(const PxU32 id, const PxVec3& dir);
/**
\brief Set the application point of the suspension force of the suspension of the idth wheel.
\param[in] id is the wheel index
\param[in] offset is the offset from the rigid body center of mass to the application point of the suspension force.
\note Specified relative to the centre of mass of the rigid body
*/
void setSuspForceAppPointOffset(const PxU32 id, const PxVec3& offset);
/**
\brief Set the application point of the tire force of the tire of the idth wheel.
\param[in] id is the wheel index
\param[in] offset is the offset from the rigid body center of mass to the application point of the tire force.
\note Specified relative to the centre of mass of the rigid body
*/
void setTireForceAppPointOffset(const PxU32 id, const PxVec3& offset);
/**
\brief Set the offset from the rigid body centre of mass to the centre of the idth wheel.
\param[in] id is the wheel index
\param[in] offset is the offset from the rigid body center of mass to the center of the wheel at rest.
\note Specified relative to the centre of mass of the rigid body
*/
void setWheelCentreOffset(const PxU32 id, const PxVec3& offset);
/**
\brief Set mapping between wheel id and position of corresponding wheel shape in the list of actor shapes.
\note This mapping is used to pose the correct wheel shapes with the latest wheel rotation angle, steer angle, and suspension travel
while allowing arbitrary ordering of the wheel shapes in the actor's list of shapes.
\note Use setWheelShapeMapping(i,-1) to register that there is no wheel shape corresponding to the ith wheel
\note Set setWheelShapeMapping(i,k) to register that the ith wheel corresponds to the kth shape in the actor's list of shapes.
\note The default values correspond to setWheelShapeMapping(i,i) for all wheels.
\note Calling this function will also pose the relevant PxShape at the rest position of the wheel.
\param wheelId is the wheel index
\param shapeId is the shape index.
@see PxVehicleUpdates, PxVehicleDrive4W::setup, PxVehicleDriveTank::setup, PxVehicleNoDrive::setup, setSceneQueryFilterData, PxRigidActor::getShapes
*/
void setWheelShapeMapping(const PxU32 wheelId, const PxI32 shapeId);
/**
\brief Set the scene query filter data that will be used for raycasts along the travel
direction of the specified suspension. The default value is PxFilterData(0,0,0,0)
\param suspId is the wheel index
\param sqFilterData is the raycast filter data for the suspension raycast.
@see setWheelShapeMapping
*/
void setSceneQueryFilterData(const PxU32 suspId, const PxFilterData& sqFilterData);
/**
\brief Set the data that describes the filtering of the tire load to produce smoother handling at large timesteps.
\param tireLoadFilter is the smoothing function data.
*/
void setTireLoadFilterData(const PxVehicleTireLoadFilterData& tireLoadFilter);
/**
\brief Set the anti-roll suspension for a pair of wheels.
\param antiRoll is the anti-roll suspension.
\note If an anti-roll bar has already been set for the same logical wheel pair
(independent of wheel index order specified by PxVehicleAntiRollBar.mWheel0 and PxVehicleAntiRollBar.mWheel0)
then the existing anti-roll bar is updated with a new stiffness parameter antiRoll.mStiffness.
\note If the wheel pair specified by antiRoll does not yet have an anti-roll bar then antiRoll is added to
a list of anti-roll bars for the vehicle.
\return If antiRoll represents a new wheel pair then a unique id is assigned to the anti-roll bar and returned.
If antiRoll represents an existing wheel pair then the unique id of the existing anti-roll bar is returned.
The return value is always in range (0, getNbAntiRollBars()).
\note The return value can be used to query the anti-roll bar with getAntiRollBarData(id).
\note The number of possible anti-roll bars is limited to half the wheel count.
\note An existing anti-roll bar can be disabled by calling antiRoll.mStiffness to zero.
@see PxVehicleWheelsSimData::getAntiRollBarData, PxVehicleAntiRollBarData
*/
PxU32 addAntiRollBarData(const PxVehicleAntiRollBarData& antiRoll);
/**
\brief Disable a wheel so that zero suspension forces and zero tire forces are applied to the rigid body from this wheel.
\note If the vehicle has a differential (PxVehicleNW/PxVehicle4W) then the differential (PxVehicleDifferentialNWData/PxVehicleDifferential4WData)
needs to be configured so that no drive torque is delivered to the disabled wheel.
\note If the vehicle is of type PxVehicleNoDrive then zero drive torque must be applied to the disabled wheel.
\note For tanks (PxVehicleDriveTank) any drive torque that could be delivered to the wheel through the tank differential will be
re-directed to the remaining enabled wheels.
@see enableWheel
@see PxVehicleDifferentialNWData::setDrivenWheel
@see PxVehicleDifferential4WData::mFrontLeftRightSplit, PxVehicleDifferential4WData::mRearLeftRightSplit, PxVehicleDifferential4WData::mType
@see PxVehicleNoDrive::setDriveTorque
@see PxVehicle4WEnable3WTadpoleMode, PxVehicle4WEnable3WDeltaMode
\note If a PxShape is associated with the disabled wheel then the association must be broken by calling setWheelShapeMapping(wheelId, -1).
@see setWheelShapeMapping
\note A wheel that is disabled must also simultaneously be given zero wheel rotation speed.
@see PxVehicleWheelsDynData::setWheelRotationSpeed
\note Care must be taken with the sprung mass supported by the remaining enabled wheels. Depending on the desired effect, the mass of the rigid body
might need to be distributed among the remaining enabled wheels and suspensions.
\param[in] wheel is the wheel index.
*/
void disableWheel(const PxU32 wheel);
/**
\brief Enable a wheel so that suspension forces and tire forces are applied to the rigid body.
All wheels are enabled by default and remain enabled until they are disabled.
\param[in] wheel is the wheel index.
@see disableWheel
*/
void enableWheel(const PxU32 wheel);
/**
\brief Test if a wheel has been disabled.
\param[in] wheel is the wheel index.
*/
bool getIsWheelDisabled(const PxU32 wheel) const;
/**
\brief Set the number of vehicle sub-steps that will be performed when the vehicle's longitudinal
speed is below and above a threshold longitudinal speed.
\note More sub-steps provides better stability but with greater computational cost.
\note Typically, vehicles require more sub-steps at very low forward speeds.
\note The threshold longitudinal speed has a default value that is the equivalent of 5 metres per second after accounting for
the length scale set in PxTolerancesScale.
\note The sub-step count below the threshold longitudinal speed has a default of 3.
\note The sub-step count above the threshold longitudinal speed has a default of 1.
\note Each sub-step has time advancement equal to the time-step passed to PxVehicleUpdates divided by the number of required sub-steps.
\note The contact planes of the most recent suspension line raycast are reused across all sub-steps.
\note Each sub-step computes tire and suspension forces and then advances a velocity, angular velocity and transform.
\note At the end of all sub-steps the vehicle actor is given the velocity and angular velocity that would move the actor from its start transform prior
to the first sub-step to the transform computed at the end of the last substep, assuming it doesn't collide with anything along the way in the next PhysX SDK update.
\note The global pose of the actor is left unchanged throughout the sub-steps.
\param[in] thresholdLongitudinalSpeed is a threshold speed that is used to categorize vehicle speed as low speed or high speed.
\param[in] lowForwardSpeedSubStepCount is the number of sub-steps performed in PxVehicleUpates for vehicles that have longitudinal speed lower than thresholdLongitudinalSpeed.
\param[in] highForwardSpeedSubStepCount is the number of sub-steps performed in PxVehicleUpdates for vehicles that have longitudinal speed graeter than thresholdLongitudinalSpeed.
*/
void setSubStepCount(const PxReal thresholdLongitudinalSpeed, const PxU32 lowForwardSpeedSubStepCount, const PxU32 highForwardSpeedSubStepCount);
/**
\brief Set the minimum denominator used in the longitudinal slip calculation.
\note The longitudinal slip has a theoretical value of (w*r - vz)/|vz|, where w is the angular speed of the wheel; r is the radius of the wheel;
and vz is the component of rigid body velocity (computed at the wheel base) that lies along the longitudinal wheel direction. The term |vz|
normalizes the slip, while preserving the sign of the longitudinal tire slip. The difficulty here is that when |vz| approaches zero the
longitudinal slip approaches infinity. A solution to this problem is to replace the denominator (|vz|) with a value that never falls below a chosen threshold.
The longitudinal slip is then calculated with (w*r - vz)/PxMax(|vz|, minLongSlipDenominator).
\note The default value is the equivalent of 4 metres per second after accounting for the length scale set in PxTolerancesScale.
\note Adjust this value upwards if a vehicle has difficulty coming to rest.
\note Decreasing the timestep (or increasing the number of sub-steps at low longitudinal speed with setSubStepCount) should allow stable stable
behavior with smaller values of minLongSlipDenominator.
*/
void setMinLongSlipDenominator(const PxReal minLongSlipDenominator);
/**
\brief Set the vehicle wheel simulation flags.
\param[in] flags The flags to set (see #PxVehicleWheelsSimFlags).
<b>Default:</b> no flag set
@see PxVehicleWheelsSimFlag
*/
void setFlags(PxVehicleWheelsSimFlags flags);
/**
\brief Return the vehicle wheel simulation flags.
\return The values of the flags.
@see PxVehicleWheelsSimFlag
*/
PxVehicleWheelsSimFlags getFlags() const;
private:
/**
\brief Graph to filter normalised load
@see setTireLoadFilterData, getTireLoadFilterData
*/
PxVehicleTireLoadFilterData mNormalisedLoadFilter;
/**
\brief Wheels data organised in blocks of 4 wheels.
*/
PxVehicleWheels4SimData* mWheels4SimData;
/**
\brief Number of blocks of 4 wheels.
*/
PxU32 mNbWheels4;
/**
\brief Number of actual wheels (<=(mNbWheels4*4))
*/
PxU32 mNbActiveWheels;
/**
\brief Anti-roll bars
*/
PxVehicleAntiRollBarData* mAntiRollBars;
/**
\brief 2 anti-rollbars allocated for each block of 4 wheels.
*/
PxU32 mNbAntiRollBars4;
/**
\brief Number of active anti-roll bars.
*/
PxU32 mNbActiveAntiRollBars;
/**
\brief Which of the mNbActiveWheels are active or disabled?
The default is that all mNbActiveWheels wheels are active.
*/
PxU32 mActiveWheelsBitmapBuffer[((PX_MAX_NB_WHEELS + 31) & ~31) >> 5];
/**
\brief Threshold longitudinal speed used to decide whether to use
mLowForwardSpeedSubStepCount or mHighForwardSpeedSubStepCount as the
number of sub-steps that will be peformed.
*/
PxF32 mThresholdLongitudinalSpeed;
/**
\brief Number of sub-steps that will be performed if the longitudinal speed
of the vehicle is smaller than mThresholdLongitudinalSpeed.
*/
PxU32 mLowForwardSpeedSubStepCount;
/**
\brief Number of sub-steps that will be performed if the longitudinal speed
of the vehicle is greater than or equal to mThresholdLongitudinalSpeed.
*/
PxU32 mHighForwardSpeedSubStepCount;
/**
\brief Minimum long slip denominator
*/
PxF32 mMinLongSlipDenominator;
/**
\brief The vehicle wheel simulation flags.
@see PxVehicleWheelsSimFlags
*/
PxU32 mFlags;
#if PX_P64_FAMILY
PxU32 mPad[1];
#endif
/**
\brief Test if wheel simulation data has been setup with legal values.
*/
bool isValid() const;
/**
\brief see PxVehicleWheels::allocate
*/
static PxU32 computeByteSize(const PxU32 numWheels);
static PxU8* patchUpPointers(const PxU32 numWheels, PxVehicleWheelsSimData* simData, PxU8* ptrIn);
PxVehicleWheelsSimData(const PxU32 numWheels);
//serialization
public:
PxVehicleWheelsSimData(const PxEMPTY) : mNormalisedLoadFilter(PxEmpty) {}
static void getBinaryMetaData(PxOutputStream& stream);
PxU32 getNbWheels4() const { return mNbWheels4; }
PxU32 getNbSuspensionData() const { return mNbActiveWheels; }
PxU32 getNbWheelData() const { return mNbActiveWheels; }
PxU32 getNbSuspTravelDirection() const { return mNbActiveWheels; }
PxU32 getNbTireData() const { return mNbActiveWheels; }
PxU32 getNbSuspForceAppPointOffset() const { return mNbActiveWheels; }
PxU32 getNbTireForceAppPointOffset() const { return mNbActiveWheels; }
PxU32 getNbWheelCentreOffset() const { return mNbActiveWheels; }
PxU32 getNbWheelShapeMapping() const { return mNbActiveWheels; }
PxU32 getNbSceneQueryFilterData() const { return mNbActiveWheels; }
PxF32 getMinLongSlipDenominator() const {return mMinLongSlipDenominator;}
void setThresholdLongSpeed(const PxF32 f) {mThresholdLongitudinalSpeed = f;}
PxF32 getThresholdLongSpeed() const {return mThresholdLongitudinalSpeed;}
void setLowForwardSpeedSubStepCount(const PxU32 f) {mLowForwardSpeedSubStepCount = f;}
PxU32 getLowForwardSpeedSubStepCount() const {return mLowForwardSpeedSubStepCount;}
void setHighForwardSpeedSubStepCount(const PxU32 f) {mHighForwardSpeedSubStepCount = f;}
PxU32 getHighForwardSpeedSubStepCount() const {return mHighForwardSpeedSubStepCount;}
void setWheelEnabledState(const PxU32 wheel, const bool state) {if(state) {enableWheel(wheel);} else {disableWheel(wheel);}}
bool getWheelEnabledState(const PxU32 wheel) const {return !getIsWheelDisabled(wheel);}
PxU32 getNbWheelEnabledState() const {return mNbActiveWheels;}
PxU32 getNbAntiRollBars4() const { return mNbAntiRollBars4; }
PxU32 getNbAntiRollBarData() const {return mNbActiveAntiRollBars;}
void setAntiRollBarData(const PxU32 id, const PxVehicleAntiRollBarData& antiRoll);
PxVehicleWheelsSimData(){}
~PxVehicleWheelsSimData(){}
//~serialization
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleWheelsSimData) & 15));
/**
\brief Description of the per wheel intersection method to be used by PxVehicleWheelsDynData::setTireContacts()
*/
struct PX_DEPRECATED PxTireContactIntersectionMethod
{
enum Enum
{
eRAY = 0,
eCYLINDER
};
};
/**
\brief Data structure with instanced dynamics data for wheels
*/
class PX_DEPRECATED PxVehicleWheelsDynData
{
public:
friend class PxVehicleWheels;
friend class PxVehicleDrive4W;
friend class PxVehicleDriveTank;
friend class PxVehicleUpdate;
PxVehicleWheelsDynData(){}
~PxVehicleWheelsDynData(){}
/**
\brief Set all wheels to their rest state.
@see setup
*/
void setToRestState();
/**
\brief Set the tire force shader function
\param[in] tireForceShaderFn is the shader function that will be used to compute tire forces.
*/
void setTireForceShaderFunction(PxVehicleComputeTireForce tireForceShaderFn);
/**
\brief Set the tire force shader data for a specific tire
\param[in] tireId is the wheel index
\param[in] tireForceShaderData is the data describing the tire.
*/
void setTireForceShaderData(const PxU32 tireId, const void* tireForceShaderData);
/**
\brief Get the tire force shader data for a specific tire
*/
const void* getTireForceShaderData(const PxU32 tireId) const;
/**
\brief Set the wheel rotation speed (radians per second) about the rolling axis for the specified wheel.
\param[in] wheelIdx is the wheel index
\param[in] speed is the rotation speed to be applied to the wheel.
*/
void setWheelRotationSpeed(const PxU32 wheelIdx, const PxReal speed);
/**
\brief Return the rotation speed about the rolling axis of a specified wheel .
*/
PxReal getWheelRotationSpeed(const PxU32 wheelIdx) const;
/**
\brief Set the wheel rotation angle (radians) about the rolling axis of the specified wheel.
\param[in] wheelIdx is the wheel index
\param[in] angle is the rotation angle to be applied to the wheel.
*/
void setWheelRotationAngle(const PxU32 wheelIdx, const PxReal angle);
/**
\brief Return the rotation angle about the rolling axis for the specified wheel.
*/
PxReal getWheelRotationAngle(const PxU32 wheelIdx) const;
/**
\brief Set the user data pointer for the specified wheel
It has a default value of NULL.
\param[in] tireIdx is the wheel index
\param[in] userData is the data to be associated with the wheel.
*/
void setUserData(const PxU32 tireIdx, void* userData);
/**
\brief Get the user data pointer that was set for the specified wheel
*/
void* getUserData(const PxU32 tireIdx) const;
/**
\brief Copy the dynamics data of a single wheel unit (wheel, suspension, tire) from srcWheel of src to trgWheel.
\param[in] src is the data to be copied.
\param[in] srcWheel is the wheel whose data will be copied from src.
\param[in] trgWheel is the wheel that will be assigned the copied data.
*/
void copy(const PxVehicleWheelsDynData& src, const PxU32 srcWheel, const PxU32 trgWheel);
/**
\brief Directly set tire contact plane and friction for all tires on the vehicle as an alternative to using PxVehicleSuspensionSweeps() or PxVehicleSuspensionRaycasts().
\param[in] nbHits is an array describing whether each tire has a contact plane or not. Each element of the array is either 0 (no contact) or 1 (contact).
\param[in] contactPlanes is an array of contact planes describing the contact plane per tire.
\param[in] contactFrictions is the friction value of each tire contact with the drivable surface.
\param[in] intersectionMethods describes how each tire will individually interact with its contact plane in order to compute the spring
compression that places the tire on the contact plane. A value of eCYLINDER will compute the spring compression by intersecting the wheel's
cylindrical shape with the contact plane. A value of eRAY will compute the spring compression by casting a ray through the wheel center
and along the suspension direction until it hits the contact plane.
\param[in] nbWheels is the length of the arrays nbContacts, contactPlanes, contactFrictions and intersectionMethods.
\note Each contact plane (n, d) obeys the rule that all points P on the plane satisfy n.dot(P) + d = 0.0.
\note The contact planes specified by setTireContacts() will persist as driving surfaces until either the next call to setTireContacts() or the next call to
\note The friction values are scaled by PxVehicleTireData::mFrictionVsSlipGraph before being applied to the tire.
\note The vehicle model assumes that the tire contacts are with static objects.
PxVehicleSuspensionSweeps() or PxVehicleSuspensionRaycasts().
*/
void setTireContacts(const PxU32* nbHits, const PxPlane* contactPlanes, const PxReal* contactFrictions, const PxTireContactIntersectionMethod::Enum* intersectionMethods, const PxU32 nbWheels);
private:
/**
\brief Dynamics data arranged in blocks of 4 wheels.
*/
PxVehicleWheels4DynData* mWheels4DynData;
/**
\brief Test if wheel dynamics data have legal values.
*/
bool isValid() const;
/**
\brief Shader data and function for tire force calculations.
*/
PxVehicleTireForceCalculator* mTireForceCalculators;
/**
\brief A userData pointer can be stored for each wheel.
@see setUserData, getUserData
*/
void** mUserDatas;
/**
\brief Number of blocks of 4 wheels.
*/
PxU32 mNbWheels4;
/**
\brief Number of wheels (mNbActiveWheels <= (mNbWheels4*4))
*/
PxU32 mNbActiveWheels;
PxU32 mPad[3];
/**
\brief see PxVehicleWheels::allocate
*/
static PxU32 computeByteSize(const PxU32 numWheels);
static PxU8* patchUpPointers(const PxU32 numWheels, PxVehicleWheelsDynData* dynData, PxU8* ptr);
PxVehicleWheelsDynData(const PxU32 numWheels);
//serialization
public:
static void getBinaryMetaData(PxOutputStream& stream);
PxU32 getNbWheelRotationSpeed() const { return mNbActiveWheels; }
PxU32 getNbWheelRotationAngle() const { return mNbActiveWheels; }
PxVehicleWheels4DynData* getWheel4DynData() const { return mWheels4DynData; }
//~serialization
/**
\brief Retrieve the number of PxConstraint objects associated with the vehicle.
You can use #getConstraints() to retrieve the constraint pointers.
\return Number of constraints associated with this vehicle.
@see PxConstraint getConstraints()
*/
PxU32 getNbConstraints() const { return mNbWheels4; }
/**
\brief Retrieve all the PxConstraint objects associated with the vehicle.
There is one PxConstraint per block of 4 wheels. The count can be extracted through #getNbConstraints()
\param[out] userBuffer The buffer to store the constraint pointers.
\param[in] bufferSize Size of provided user buffer.
\param[in] startIndex Index of first constraint pointer to be retrieved
\return Number of constraint pointers written to the buffer.
@see PxConstraint getNbConstraints()
*/
PxU32 getConstraints(PxConstraint** userBuffer, PxU32 bufferSize, PxU32 startIndex = 0) const;
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleWheelsDynData) & 15));
/**
\brief Data structure with instanced dynamics data and configuration data of a vehicle with just wheels
@see PxVehicleDrive, PxVehicleDrive4W, PxVehicleDriveTank
*/
class PX_DEPRECATED PxVehicleWheels : public PxBase
{
public:
friend class PxVehicleUpdate;
friend class PxVehicleConstraintShader;
/**
\brief Return the type of vehicle
@see PxVehicleTypes
*/
PX_FORCE_INLINE PxU32 getVehicleType() const {return mType;}
/**
\brief Get non-const ptr to PxRigidDynamic instance that is the vehicle's physx representation
*/
PX_FORCE_INLINE PxRigidDynamic* getRigidDynamicActor() {return mActor;}
/**
\brief Get const ptr to PxRigidDynamic instance that is the vehicle's physx representation
*/
PX_FORCE_INLINE const PxRigidDynamic* getRigidDynamicActor() const {return mActor;}
/**
\brief Compute the rigid body velocity component along the forward vector of the rigid body transform.
\param[in] forwardAxis The axis denoting the local space forward direction of the vehicle.
@see PxVehicleSetBasisVectors
*/
PxReal computeForwardSpeed(const PxVec3& forwardAxis = PxVehicleGetDefaultContext().forwardAxis) const;
/**
\brief Compute the rigid body velocity component along the right vector of the rigid body transform.
\param[in] sideAxis The axis denoting the local space side direction of the vehicle.
@see PxVehicleSetBasisVectors
*/
PxReal computeSidewaysSpeed(const PxVec3& sideAxis = PxVehicleGetDefaultContext().sideAxis) const;
/**
\brief Data describing the setup of all the wheels/suspensions/tires.
*/
PxVehicleWheelsSimData mWheelsSimData;
/**
\brief Data describing the dynamic state of all wheels/suspension/tires.
*/
PxVehicleWheelsDynData mWheelsDynData;
protected:
/**
\brief Set all wheels to their rest state
*/
void setToRestState();
/**
\brief Test that all configuration and instanced dynamics data is valid.
*/
bool isValid() const;
/**
@see PxVehicleDrive4W::allocate, PxVehicleDriveTank::allocate
*/
static PxU32 computeByteSize(const PxU32 nbWheels);
static PxU8* patchupPointers(const PxU32 nbWheels, PxVehicleWheels* vehWheels, PxU8* ptr);
virtual void init(const PxU32 numWheels);
/**
\brief Deallocate a PxVehicleWheels instance.
@see PxVehicleDrive4W::free, PxVehicleDriveTank::free
*/
void free();
/*
\brief Deferred deletion.
*/
void onConstraintRelease();
/**
@see PxVehicleDrive4W::setup, PxVehicleDriveTank::setup
*/
void setup
(PxPhysics* physics, PxRigidDynamic* vehActor,
const PxVehicleWheelsSimData& wheelsData,
const PxU32 nbDrivenWheels, const PxU32 nbNonDrivenWheels);
/**
\brief The rigid body actor that represents the vehicle in the PhysX SDK.
*/
PxRigidDynamic* mActor;
private:
/**
\brief Count the number of constraint connectors that have hit their callback when deleting a vehicle.
Can only delete the vehicle's memory when all constraint connectors have hit their callback.
*/
PxU32 mNbNonDrivenWheels;
PxU8 mOnConstraintReleaseCounter;
protected:
/**
\brief Vehicle type (eVehicleDriveTypes)
*/
PxU8 mType;
#if PX_P64_FAMILY
PxU8 mPad0[14];
#else
PxU8 mPad0[8];
#endif
//serialization
public:
virtual void requiresObjects(PxProcessPxBaseCallback& c);
virtual const char* getConcreteTypeName() const { return "PxVehicleWheels"; }
virtual bool isKindOf(const char* name) const { PX_IS_KIND_OF(name, "PxVehicleWheels", PxBase); }
virtual void preExportDataReset() {}
virtual void exportExtraData(PxSerializationContext&);
void importExtraData(PxDeserializationContext&);
void resolveReferences(PxDeserializationContext&);
static void getBinaryMetaData(PxOutputStream& stream);
PX_FORCE_INLINE PxU32 getNbNonDrivenWheels() const { return mNbNonDrivenWheels; }
PxVehicleWheels(PxType concreteType, PxBaseFlags baseFlags) : PxBase(concreteType, baseFlags) {}
PxVehicleWheels(PxBaseFlags baseFlags) : PxBase(baseFlags), mWheelsSimData(PxEmpty) {}
virtual ~PxVehicleWheels() {}
virtual void release() { free(); }
//~serialization
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleWheels) & 15));
#if !PX_DOXYGEN
} // namespace physx
#endif
#endif
| 36,587 | C | 37.312042 | 193 | 0.776095 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle/PxVehicleDrive4W.h | // 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-2023 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 PX_VEHICLE_4WDRIVE_H
#define PX_VEHICLE_4WDRIVE_H
#include "vehicle/PxVehicleDrive.h"
#include "vehicle/PxVehicleWheels.h"
#include "vehicle/PxVehicleComponents.h"
#if !PX_DOXYGEN
namespace physx
{
#endif
struct PxFilterData;
class PxGeometry;
class PxPhysics;
class PxVehicleDrivableSurfaceToTireFrictionPairs;
class PxShape;
class PxMaterial;
class PxRigidDynamic;
/**
\brief Data structure describing the drive model components of a vehicle with up to 4 driven wheels and up to 16 un-driven wheels.
The drive model incorporates engine, clutch, gears, autobox, differential, and Ackermann steer correction.
@see PxVehicleDriveSimData
*/
class PX_DEPRECATED PxVehicleDriveSimData4W : public PxVehicleDriveSimData
{
public:
friend class PxVehicleDrive4W;
PxVehicleDriveSimData4W()
: PxVehicleDriveSimData()
{
}
/**
\brief Return the data describing the differential.
@see PxVehicleDifferential4WData
*/
PX_FORCE_INLINE const PxVehicleDifferential4WData& getDiffData() const
{
return mDiff;
}
/**
\brief Return the data describing the Ackermann steer-correction.
@see PxVehicleAckermannGeometryData
*/
PX_FORCE_INLINE const PxVehicleAckermannGeometryData& getAckermannGeometryData() const
{
return mAckermannGeometry;
}
/**
\brief Set the data describing the differential.
@see PxVehicleDifferential4WData
*/
void setDiffData(const PxVehicleDifferential4WData& diff);
/**
\brief Set the data describing the Ackermann steer-correction.
@see PxVehicleAckermannGeometryData
*/
void setAckermannGeometryData(const PxVehicleAckermannGeometryData& ackermannData);
private:
/**
\brief Differential simulation data
@see setDiffData, getDiffData
*/
PxVehicleDifferential4WData mDiff;
/**
\brief Data for ackermann steer angle computation.
@see setAckermannGeometryData, getAckermannGeometryData
*/
PxVehicleAckermannGeometryData mAckermannGeometry;
/**
\brief Test if the 4W-drive simulation data has been setup with legal data.
\note Call only after setting all components.
@see setEnginedata, setClutchData, setGearsData, setAutoboxData, setDiffData, setAckermannGeometryData
*/
bool isValid() const;
//serialization
public:
PxVehicleDriveSimData4W(const PxEMPTY) : PxVehicleDriveSimData(PxEmpty), mDiff(PxEmpty), mAckermannGeometry(PxEmpty) {}
static void getBinaryMetaData(PxOutputStream& stream);
//~serialization
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleDriveSimData4W) & 15));
/**
\brief The ordering of the driven and steered wheels of a PxVehicleDrive4W.
@see PxVehicleWheelsSimData, PxVehicleWheelsDynData
*/
struct PX_DEPRECATED PxVehicleDrive4WWheelOrder
{
enum Enum
{
eFRONT_LEFT=0,
eFRONT_RIGHT,
eREAR_LEFT,
eREAR_RIGHT
};
};
/**
\brief The control inputs for a PxVehicleDrive4W.
@see PxVehicleDriveDynData::setAnalogInput, PxVehicleDriveDynData::getAnalogInput
*/
struct PX_DEPRECATED PxVehicleDrive4WControl
{
enum Enum
{
eANALOG_INPUT_ACCEL=0,
eANALOG_INPUT_BRAKE,
eANALOG_INPUT_HANDBRAKE,
eANALOG_INPUT_STEER_LEFT,
eANALOG_INPUT_STEER_RIGHT,
eMAX_NB_DRIVE4W_ANALOG_INPUTS
};
};
/**
\brief Data structure with instanced dynamics data and configuration data of a vehicle with up to 4 driven wheels and up to 16 non-driven wheels.
*/
class PX_DEPRECATED PxVehicleDrive4W : public PxVehicleDrive
{
public:
friend class PxVehicleUpdate;
/**
\brief Allocate a PxVehicleDrive4W instance for a 4WDrive vehicle with nbWheels (= 4 + number of un-driven wheels)
\param[in] nbWheels is the number of vehicle wheels (= 4 + number of un-driven wheels)
\return The instantiated vehicle.
@see free, setup
*/
static PxVehicleDrive4W* allocate(const PxU32 nbWheels);
/**
\brief Deallocate a PxVehicleDrive4W instance.
@see allocate
*/
void free();
/**
\brief Set up a vehicle using simulation data for the wheels and drive model.
\param[in] physics is a PxPhysics instance that is needed to create special vehicle constraints that are maintained by the vehicle.
\param[in] vehActor is a PxRigidDynamic instance that is used to represent the vehicle in the PhysX SDK.
\param[in] wheelsData describes the configuration of all suspension/tires/wheels of the vehicle. The vehicle instance takes a copy of this data.
\param[in] driveData describes the properties of the vehicle's drive model (gears/engine/clutch/differential/autobox). The vehicle instance takes a copy of this data.
\param[in] nbNonDrivenWheels is the number of wheels on the vehicle that cannot be connected to the differential (= numWheels - 4).
\note It is assumed that the first shapes of the actor are the wheel shapes, followed by the chassis shapes. To break this assumption use PxVehicleWheelsSimData::setWheelShapeMapping.
\note wheelsData must contain data for at least 4 wheels. Unwanted wheels can be disabled with PxVehicleWheelsSimData::disableWheel after calling setup.
@see allocate, free, setToRestState, PxVehicleWheelsSimData::setWheelShapeMapping
*/
void setup
(PxPhysics* physics, PxRigidDynamic* vehActor,
const PxVehicleWheelsSimData& wheelsData, const PxVehicleDriveSimData4W& driveData,
const PxU32 nbNonDrivenWheels);
/**
\brief Allocate and set up a vehicle using simulation data for the wheels and drive model.
\param[in] physics is a PxPhysics instance that is needed to create special vehicle constraints that are maintained by the vehicle.
\param[in] vehActor is a PxRigidDynamic instance that is used to represent the vehicle in the PhysX SDK.
\param[in] wheelsData describes the configuration of all suspension/tires/wheels of the vehicle. The vehicle instance takes a copy of this data.
\param[in] driveData describes the properties of the vehicle's drive model (gears/engine/clutch/differential/autobox). The vehicle instance takes a copy of this data.
\param[in] nbNonDrivenWheels is the number of wheels on the vehicle that cannot be connected to the differential (= numWheels - 4).
\note It is assumed that the first shapes of the actor are the wheel shapes, followed by the chassis shapes. To break this assumption use PxVehicleWheelsSimData::setWheelShapeMapping.
\note wheelsData must contain data for at least 4 wheels. Unwanted wheels can be disabled with PxVehicleWheelsSimData::disableWheel after calling setup.
\return The instantiated vehicle.
@see allocate, free, setToRestState, PxVehicleWheelsSimData::setWheelShapeMapping
*/
static PxVehicleDrive4W* create
(PxPhysics* physics, PxRigidDynamic* vehActor,
const PxVehicleWheelsSimData& wheelsData, const PxVehicleDriveSimData4W& driveData,
const PxU32 nbNonDrivenWheels);
/**
\brief Set a vehicle to its rest state. Aside from the rigid body transform, this will set the vehicle and rigid body
to the state they were in immediately after setup or create.
\note Calling setToRestState invalidates the cached raycast hit planes under each wheel meaning that suspension line
raycasts need to be performed at least once with PxVehicleSuspensionRaycasts before calling PxVehicleUpdates.
@see setup, create, PxVehicleSuspensionRaycasts, PxVehicleUpdates
*/
void setToRestState();
/**
\brief Simulation data that describes the configuration of the vehicle's drive model.
@see setup, create
*/
PxVehicleDriveSimData4W mDriveSimData;
private:
/**
\brief Test if the instanced dynamics and configuration data has legal values.
*/
bool isValid() const;
//serialization
protected:
PxVehicleDrive4W();
~PxVehicleDrive4W(){}
virtual bool isKindOf(const char* name) const { PX_IS_KIND_OF(name, "PxVehicleDrive4W", PxVehicleDrive); }
public:
static PxVehicleDrive4W* createObject(PxU8*& address, PxDeserializationContext& context);
static void getBinaryMetaData(PxOutputStream& stream);
PxVehicleDrive4W(PxBaseFlags baseFlags) : PxVehicleDrive(baseFlags), mDriveSimData(PxEmpty) {}
virtual const char* getConcreteTypeName() const { return "PxVehicleDrive4W"; }
//~serialization
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleDrive4W) & 15));
#if !PX_DOXYGEN
} // namespace physx
#endif
#endif
| 9,797 | C | 36.396946 | 185 | 0.780443 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle/PxVehicleUpdate.h | // 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-2023 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 PX_VEHICLE_UPDATE_H
#define PX_VEHICLE_UPDATE_H
#include "vehicle/PxVehicleSDK.h"
#include "vehicle/PxVehicleTireFriction.h"
#include "foundation/PxSimpleTypes.h"
#include "foundation/PxMemory.h"
#include "foundation/PxTransform.h"
#include "PxQueryFiltering.h"
#if !PX_DOXYGEN
namespace physx
{
#endif
class PxContactModifyPair;
class PxVehicleWheels;
class PxVehicleDrivableSurfaceToTireFrictionPairs;
class PxVehicleTelemetryData;
class PxBatchQueryExt;
/**
\brief Structure containing data describing the non-persistent state of each suspension/wheel/tire unit.
This structure is filled out in PxVehicleUpdates and PxVehicleUpdateSingleVehicleAndStoreTelemetryData
@see PxVehicleUpdates, PxVehicleUpdateSingleVehicleAndStoreTelemetryData
*/
struct PX_DEPRECATED PxWheelQueryResult
{
PxWheelQueryResult()
{
PxMemZero(this, sizeof(PxWheelQueryResult));
isInAir=true;
tireSurfaceType = PxU32(PxVehicleDrivableSurfaceType::eSURFACE_TYPE_UNKNOWN);
localPose = PxTransform(PxIdentity);
}
/**
\brief Start point of suspension line raycast/sweep used in the raycast/sweep completed immediately before PxVehicleUpdates.
\note If no raycast/sweep for the corresponding suspension was performed immediately prior to PxVehicleUpdates then (0,0,0) is stored.
@see PxVehicleSuspensionRaycasts, PxVehicleSuspensionRaycasts
*/
PxVec3 suspLineStart;
/**
\brief Directions of suspension line raycast/sweep used in the raycast/sweep completed immediately before PxVehicleUpdates.
\note If no raycast/sweep for the corresponding suspension was performed immediately prior to PxVehicleUpdates then (0,0,0) is stored.
@see PxVehicleSuspensionRaycasts, PxVehicleSuspensionRaycasts
*/
PxVec3 suspLineDir;
/**
\brief Lengths of suspension line raycast/sweep used in raycast/sweep completed immediately before PxVehicleUpdates.
\note If no raycast/sweep for the corresponding suspension was performed immediately prior to PxVehicleUpdates then 0 is stored.
@see PxVehicleSuspensionRaycasts, PxVehicleSuspensionRaycasts
*/
PxReal suspLineLength;
/**
\brief If suspension travel limits forbid the wheel from touching the drivable surface then isInAir is true.
\note If the wheel can be placed on the contact plane of the most recent suspension line raycast/sweep then isInAir is false.
\note If #PxVehicleWheelsSimFlag::eLIMIT_SUSPENSION_EXPANSION_VELOCITY is set, then isInAir will also be true if the suspension
force is not large enough to expand to the target length in the given simulation time step.
\note If no raycast/sweep for the corresponding suspension was performed immediately prior to PxVehicleUpdates then isInAir
is computed using the contact plane that was hit by the most recent suspension line raycast/sweep.
*/
bool isInAir;
/**
\brief PxActor instance of the driving surface under the corresponding vehicle wheel.
\note If suspension travel limits forbid the wheel from touching the drivable surface then tireContactActor is NULL.
\note If no raycast/sweep for the corresponding suspension was performed immediately prior to PxVehicleUpdates then NULL is stored.
*/
PxActor* tireContactActor;
/**
\brief PxShape instance of the driving surface under the corresponding vehicle wheel.
\note If suspension travel limits forbid the wheel from touching the drivable surface then tireContactShape is NULL.
\note If no raycast/sweep for the corresponding suspension was performed immediately prior to PxVehicleUpdates then NULL is stored.
*/
PxShape* tireContactShape;
/**
\brief PxMaterial instance of the driving surface under the corresponding vehicle wheel.
\note If suspension travel limits forbid the wheel from touching the drivable surface then tireSurfaceMaterial is NULL.
\note If no raycast/sweep for the corresponding suspension was performed immediately prior to PxVehicleUpdates then NULL is stored.
*/
const PxMaterial* tireSurfaceMaterial;
/**
\brief Surface type integer that corresponds to the mapping between tireSurfaceMaterial and integer as
described in PxVehicleDrivableSurfaceToTireFrictionPairs.
\note If suspension travel limits forbid the wheel from touching the drivable surface then tireSurfaceType is
PxVehicleDrivableSurfaceType::eSURFACE_TYPE_UNKNOWN.
\note If no raycast/sweep for the corresponding suspension was performed immediately prior to PxVehicleUpdates then
PxVehicleDrivableSurfaceType::eSURFACE_TYPE_UNKNOWN is stored.
@see PxVehicleDrivableSurfaceToTireFrictionPairs
*/
PxU32 tireSurfaceType;
/**
\brief Point on the drivable surface hit by the most recent suspension raycast or sweep.
\note If suspension travel limits forbid the wheel from touching the drivable surface then the contact point is (0,0,0).
\note If no raycast or sweep for the corresponding suspension was performed immediately prior to PxVehicleUpdates then (0,0,0) is stored.
*/
PxVec3 tireContactPoint;
/**
\brief Normal on the drivable surface at the hit point of the most recent suspension raycast or sweep.
\note If suspension travel limits forbid the wheel from touching the drivable surface then the contact normal is (0,0,0).
\note If no raycast or sweep for the corresponding suspension was performed immediately prior to PxVehicleUpdates then (0,0,0) is stored.
*/
PxVec3 tireContactNormal;
/**
\brief Friction experienced by the tire for the combination of tire type and surface type after accounting
for the friction vs slip graph.
\note If suspension travel limits forbid the wheel from touching the drivable surface then the tire friction is 0.
\note If no raycast or sweep for the corresponding suspension was performed immediately prior to PxVehicleUpdates then the
stored tire friction is the value computed in PxVehicleUpdates that immediately followed the last raycast or sweep.
@see PxVehicleDrivableSurfaceToTireFrictionPairs, PxVehicleTireData
*/
PxReal tireFriction;
/**
\brief Compression of the suspension spring.
\note If suspension travel limits forbid the wheel from touching the drivable surface then the jounce is -PxVehicleSuspensionData.mMaxDroop
The jounce can never exceed PxVehicleSuspensionData.mMaxCompression. Positive values result when the suspension is compressed from
the rest position, while negative values mean the suspension is elongated from the rest position.
\note If no raycast or sweep for the corresponding suspension was performed immediately prior to PxVehicleUpdates then the
suspension compression is computed using the contact plane that was hit by the most recent suspension line raycast or sweep.
*/
PxReal suspJounce;
/**
\brief Magnitude of force applied by the suspension spring along the direction of suspension travel.
\note If suspension travel limits forbid the wheel from touching the drivable surface then the force is 0
\note If no raycast or sweep for the corresponding suspension was performed immediately prior to PxVehicleUpdates then the
suspension spring force is computed using the contact plane that was hit by the most recent suspension line raycast or sweep.
@see PxVehicleWheelsSimData::getSuspTravelDirection
*/
PxReal suspSpringForce;
/**
\brief Forward direction of the wheel/tire accounting for steer/toe/camber angle projected on to the contact plane of the drivable surface.
\note If suspension travel limits forbid the wheel from touching the drivable surface then tireLongitudinalDir is (0,0,0)
\note If no raycast or sweep for the corresponding suspension was performed immediately prior to PxVehicleUpdates then the
tire longitudinal direction is computed using the contact plane that was hit by the most recent suspension line raycast or sweep.
*/
PxVec3 tireLongitudinalDir;
/**
\brief Lateral direction of the wheel/tire accounting for steer/toe/camber angle projected on to the contact plan of the drivable surface.
\note If suspension travel limits forbid the wheel from touching the drivable surface then tireLateralDir is (0,0,0)
\note If no raycast or sweep for the corresponding suspension was performed immediately prior to PxVehicleUpdates then the
tire lateral direction is computed using the contact plane that was hit by the most recent suspension line raycast or sweep.
*/
PxVec3 tireLateralDir;
/**
\brief Longitudinal slip of the tire.
\note If suspension travel limits forbid the wheel from touching the drivable surface then longitudinalSlip is 0.0
\note The longitudinal slip is approximately (w*r - vz) / PxAbs(vz) where w is the angular speed of the wheel, r is the radius of the wheel, and
vz component of rigid body velocity computed at the wheel base along the longitudinal direction of the tire.
\note If no raycast or sweep for the corresponding suspension was performed immediately prior to PxVehicleUpdates then the
tire longitudinal slip is computed using the contact plane that was hit by the most recent suspension line raycast or sweep.
*/
PxReal longitudinalSlip;
/**
\brief Lateral slip of the tire.
\note If suspension travel limits forbid the wheel from touching the drivable surface then lateralSlip is 0.0
\note The lateral slip angle is approximately PxAtan(vx / PxAbs(vz)) where vx and vz are the components of rigid body velocity at the wheel base
along the wheel's lateral and longitudinal directions, respectively.
\note If no raycast or sweep for the corresponding suspension was performed immediately prior to PxVehicleUpdates then the
tire lateral slip is computed using the contact plane that was hit by the most recent suspension line raycast or sweep.
*/
PxReal lateralSlip;
/**
\brief Steer angle of the wheel about the "up" vector accounting for input steer and toe and, if applicable, Ackermann steer correction.
@see PxVehicleWheelData::mToeAngle
*/
PxReal steerAngle;
/**
\brief Local pose of the wheel.
*/
PxTransform localPose;
};
struct PX_DEPRECATED PxVehicleWheelQueryResult
{
/**
\brief Pointer to an PxWheelQueryResult buffer of length nbWheelQueryResults
The wheelQueryResults buffer must persist until the end of PxVehicleUpdates
A NULL pointer is permitted.
The wheelQueryResults buffer is left unmodified in PxVehicleUpdates for vehicles with sleeping rigid bodies
whose control inputs indicate they should remain inert.
@see PxVehicleUpdates
*/
PxWheelQueryResult* wheelQueryResults;
/**
\brief The length of the wheelQueryResults buffer. This value corresponds to the
number of wheels in the associated vehicle in PxVehicleUpdates.
*/
PxU32 nbWheelQueryResults;
};
/**
\brief Structure containing data that is computed for a wheel during concurrent calls to PxVehicleUpdates or
PxVehicleUpdateSingleVehicleAndStoreTelemetryData but which cannot be safely concurrently applied.
@see PxVehicleUpdates, PxVehicleUpdateSingleVehicleAndStoreTelemetryData, PxVehiclePostUpdates, PxVehicleConcurrentUpdate
*/
struct PX_DEPRECATED PxVehicleWheelConcurrentUpdateData
{
friend class PxVehicleUpdate;
PxVehicleWheelConcurrentUpdateData()
: localPose(PxTransform(PxIdentity)),
hitActor(NULL),
hitActorForce(PxVec3(0,0,0)),
hitActorForcePosition(PxVec3(0,0,0))
{
}
private:
PxTransform localPose;
PxRigidDynamic* hitActor;
PxVec3 hitActorForce;
PxVec3 hitActorForcePosition;
};
/**
\brief Structure containing data that is computed for a vehicle and its wheels during concurrent calls to PxVehicleUpdates or
PxVehicleUpdateSingleVehicleAndStoreTelemetryData but which cannot be safely concurrently applied.
@see PxVehicleUpdates, PxVehicleUpdateSingleVehicleAndStoreTelemetryData, PxVehiclePostUpdates, PxVehicleWheelConcurrentUpdateData
*/
struct PX_DEPRECATED PxVehicleConcurrentUpdateData
{
friend class PxVehicleUpdate;
PxVehicleConcurrentUpdateData()
: concurrentWheelUpdates(NULL),
nbConcurrentWheelUpdates(0),
linearMomentumChange(PxVec3(0,0,0)),
angularMomentumChange(PxVec3(0,0,0)),
staySleeping(false),
wakeup(false)
{
}
/**
\brief Pointer to an PxVehicleWheelConcurrentUpdate buffer of length nbConcurrentWheelUpdates
The concurrentWheelUpdates buffer must persist until the end of PxVehiclePostUpdates
A NULL pointer is not permitted.
@see PxVehicleUpdates, PxVehiclePostUpdates
*/
PxVehicleWheelConcurrentUpdateData* concurrentWheelUpdates;
/**
\brief The length of the concurrentWheelUpdates buffer. This value corresponds to the
number of wheels in the associated vehicle passed to PxVehicleUpdates.
*/
PxU32 nbConcurrentWheelUpdates;
private:
PxVec3 linearMomentumChange;
PxVec3 angularMomentumChange;
bool staySleeping;
bool wakeup;
};
/**
\brief Perform raycasts for all suspension lines for all vehicles.
\param[in] batchQuery is a PxBatchQueryExt instance used to specify shader data and functions for the raycast scene queries.
\param[in] nbVehicles is the number of vehicles in the vehicles array.
\param[in] vehicles is an array of all vehicles that are to have a raycast issued from each wheel.
\param[in] vehiclesToRaycast is an array of bools of length nbVehicles that is used to decide if raycasts will be performed for the corresponding vehicle
in the vehicles array. If vehiclesToRaycast[i] is true then suspension line raycasts will be performed for vehicles[i]. If vehiclesToRaycast[i] is
false then suspension line raycasts will not be performed for vehicles[i].
\param[in] queryFlags filter flags for the batched scene queries
\note If vehiclesToRaycast is NULL then raycasts are performed for all vehicles in the vehicles array.
\note If vehiclesToRaycast[i] is false then the vehicle stored in vehicles[i] will automatically use the raycast or sweep hit planes recorded by the most recent
suspension sweeps or raycasts for that vehicle. For vehicles far from the camera or not visible on the screen it can be
optimal to only perform suspension line raycasts every Nth update rather than every single update. The accuracy of the cached contact plane
naturally diminishes as N increase, meaning that wheels might start to hover or intersect the ground for large values of N or even with values close to 1 in
conjunction with large vehicle speeds and/or geometry that has low spatial coherence.
\note Calling setToRestState invalidates any cached hit planes. Prior to calling PxVehicleUpdates each vehicle needs to perform suspension line raycasts
or sweeps at least once after instantiation and at least once after calling setToRestState.
\note Each raycast casts along the suspension travel direction from the position of the top of the wheel at maximum suspension compression
to the position of the base of the wheel at maximum droop. Raycasts that start inside a PxShape are subsequently ignored by the
corresponding vehicle.
\note Only blocking hits are supported (PxQueryHitType::eBLOCK).
@see PxVehicleDrive4W::setToRestState, PxVehicleDriveNW::setToRestState, PxVehicleDriveTank::setToRestState, PxVehicleNoDrive::setToRestState
@see PxBatchQueryExt::raycast
*/
PX_DEPRECATED void PxVehicleSuspensionRaycasts( PxBatchQueryExt* batchQuery,
const PxU32 nbVehicles, PxVehicleWheels** vehicles,
const bool* vehiclesToRaycast = NULL,
const PxQueryFlags queryFlags = PxQueryFlag::eSTATIC | PxQueryFlag::eDYNAMIC | PxQueryFlag::ePREFILTER);
/**
\brief Perform sweeps for all suspension lines for all vehicles.
\param[in] batchQuery is a PxBatchQueryExt instance used to specify shader data and functions for the sweep scene queries.
\param[in] nbVehicles is the number of vehicles in the vehicles array.
\param[in] vehicles is an array of all vehicles that are to have a sweep issued from each wheel.
\param[in] nbHitsPerQuery is the maximum numbers of hits that will be returned for each query.
\param[in] vehiclesToSweep is an array of bools of length nbVehicles that is used to decide if sweeps will be performed for the corresponding vehicle
in the vehicles array. If vehiclesToSweep[i] is true then suspension sweeps will be performed for vehicles[i]. If vehiclesToSweep[i] is
false then suspension sweeps will not be performed for vehicles[i].
\param[in] sweepWidthScale scales the geometry of the wheel used in the sweep. Values < 1 result in a thinner swept wheel, while values > 1 result in a fatter swept wheel.
\param[in] sweepRadiusScale scales the geometry of the wheel used in the sweep. Values < 1 result in a smaller swept wheel, while values > 1 result in a larger swept wheel.
\param[in] sweepInflation Inflation parameter for sweeps. This is the inflation parameter from PxScene::sweep(). It inflates the shape and makes it rounder,
which gives smoother and more reliable normals.
\param[in] queryFlags filter flags for the batched scene queries
\param[in] context the vehicle context to use for the suspension sweeps.
\note If vehiclesToSweep is NULL then sweeps are performed for all vehicles in the vehicles array.
\note If vehiclesToSweep[i] is false then the vehicle stored in vehicles[i] will automatically use the most recent sweep or raycast hit planes
recorded by the most recent suspension sweeps or raycasts for that vehicle. For vehicles far from the camera or not visible on the screen it can be
optimal to only perform suspension queries every Nth update rather than every single update. The accuracy of the cached contact plane
naturally diminishes as N increase, meaning that wheels might start to hover or intersect the ground for large values of N or even with values close to 1 in
conjunction with large vehicle speeds and/or geometry that has low spatial coherence.
\note Calling setToRestState invalidates any cached hit planes. Prior to calling PxVehicleUpdates each vehicle needs to perform suspension raycasts
or sweeps at least once after instantiation and at least once after calling setToRestState.
\note Each sweep casts the wheel's shape along the suspension travel direction from the position of the top of the wheel at maximum suspension compression
to the position of the base of the wheel at maximum droop. Sweeps that start inside a PxShape are subsequently ignored by the
corresponding vehicle.
\note A scale can be applied to the shape so that a modified shape is swept through the scene. The parameters sweepWidthScale and sweepRadiusScale scale the
swept wheel shape in the width and radial directions. It is sometimes a good idea to sweep a thinner wheel to allow contact with other dynamic actors to be resolved
first before attempting to drive on them.
\note Blocking hits (PxQueryHitType::eBLOCK) and non-blocking hits (PxQueryHitType::TOUCH) are supported. If the pre-and post-filter functions of the PxBatchQuery
instance are set up to return blocking hits it is recommended to set nbHitsPerQuery = 1. If the filter functions returns touch hits then it is recommended to
set nbHitsPerQuery > 1. The exact value depends on the expected complexity of the geometry that lies under the wheel. For complex geometry, especially with dynamic
objects, it is recommended to use non-blocking hits. The vehicle update function will analyze all returned hits and choose the most appropriate using the thresholds
set in PxVehicleSetSweepHitRejectionAngles.
@see PxVehicleDrive4W::setToRestState, PxVehicleDriveNW::setToRestState, PxVehicleDriveTank::setToRestState, PxVehicleNoDrive::setToRestState
@see PxBatchQueryExt::sweep PxScene::sweep()
@see PxVehicleSetSweepHitRejectionAngles
*/
PX_DEPRECATED void PxVehicleSuspensionSweeps( PxBatchQueryExt* batchQuery,
const PxU32 nbVehicles, PxVehicleWheels** vehicles,
const PxU16 nbHitsPerQuery,
const bool* vehiclesToSweep = NULL,
const PxF32 sweepWidthScale = 1.0f, const PxF32 sweepRadiusScale = 1.0f, const PxF32 sweepInflation = 0.0f,
const PxQueryFlags queryFlags = PxQueryFlag::eSTATIC | PxQueryFlag::eDYNAMIC | PxQueryFlag::ePREFILTER,
const PxVehicleContext& context = PxVehicleGetDefaultContext());
/**
\brief A function called from PxContactModifyCallback::onContactModify. The function determines if rigid body contact points
recorded for the wheel's PxShape are likely to be duplicated and resolved by the wheel's suspension raycast. Contact points that will be
resolved by the suspension are ignored. Contact points that are accepted (rather than ignored) are modified to account for the effect of the
suspension geometry and the angular speed of the wheel.
\param[in] vehicle is a reference to the PxVehicleWheels instance that owns the wheel
\param[in] wheelId is the id of the wheel
\param[in] wheelTangentVelocityMultiplier determines the amount of wheel angular velocity that is used to modify the target relative velocity of the contact.
The target relative velocity is modified by adding a vector equal to the tangent velocity of the rotating wheel at the contact point and scaled by
wheelTangentVelocityMultiplier. The value of wheelTangentVelocityMultiplier is limited to the range (0,1). Higher values mimic higher values of friction
and tire load, while lower values mimic lower values of friction and tire load.
\param[in] maxImpulse determines the maximum impulse strength that the contacts can apply when a wheel is in contact with a PxRigidDynamic. This value is ignored for
contacts with PxRigidStatic instances.
\param[in,out] contactModifyPair describes the set of contacts involving the PxShape of the specified wheel and one other shape. The contacts in the contact set are
ignored or modified as required.
\param[in] context the vehicle context to use for the contact modification.
\note Contact points are accepted or rejected using the threshold angles specified in the function PxVehicleSetSweepHitRejectionAngles.
\note If a contact point is not rejected it is modified to account for the wheel rotation speed.
\note Set maxImpulse to PX_MAX_F32 to allow any impulse value to be applied.
\note Reduce maxImpulse if the wheels are frequently colliding with light objects with mass much less than the vehicle's mass.
Reducing this value encourages numerical stability.
@see PxContactModifyCallback::onContactModify, PxVehicleSetSweepHitRejectionAngles, PxVehicleContext
*/
PX_DEPRECATED PxU32 PxVehicleModifyWheelContacts
(const PxVehicleWheels& vehicle, const PxU32 wheelId,
const PxF32 wheelTangentVelocityMultiplier, const PxReal maxImpulse,
PxContactModifyPair& contactModifyPair,
const PxVehicleContext& context = PxVehicleGetDefaultContext());
/**
\brief Update an array of vehicles by either applying an acceleration to the rigid body actor associated with
each vehicle or by an immediate update of the velocity of the actor.
\note The update mode (acceleration or velocity change) can be selected with PxVehicleSetUpdateMode.
\param[in] timestep is the timestep of the update
\param[in] gravity is the value of gravitational acceleration
\param[in] vehicleDrivableSurfaceToTireFrictionPairs describes the mapping between each PxMaterial ptr and an integer representing a
surface type. It also stores the friction value for each combination of surface and tire type.
\param[in] nbVehicles is the number of vehicles pointers in the vehicles array
\param[in,out] vehicles is an array of length nbVehicles containing all vehicles to be updated by the specified timestep
\param[out] vehicleWheelQueryResults is an array of length nbVehicles storing the wheel query results of each corresponding vehicle and wheel in the
vehicles array. A NULL pointer is permitted.
\param[out] vehicleConcurrentUpdates is an array of length nbVehicles. It is only necessary to specify vehicleConcurrentUpdates if PxVehicleUpdates is
called concurrently (also concurrently with PxVehicleUpdateSingleVehicleAndStoreTelemetryData). The element vehicleConcurrentUpdates[i] of the array
stores data that is computed for vehicle[i] during PxVehicleUpdates but which cannot be safely written when concurrently called. The data computed and
stored in vehicleConcurrentUpdates must be passed to PxVehiclePostUpdates, where it is applied to all relevant actors in sequence. A NULL pointer is permitted.
\param[in] context the vehicle context to use for the vehicle update.
\note The vehicleWheelQueryResults buffer must persist until the end of PxVehicleUpdates.
\note The vehicleWheelQueryResults buffer is left unmodified for vehicles with sleeping rigid bodies whose control inputs indicate they should remain inert.
\note If PxVehicleUpdates is called concurrently then vehicleConcurrentUpdates must be specified. Do not specify vehicleConcurrentUpdates if PxVehicleUpdates
is not called concurrently.
\note The vehicleConcurrentUpdates buffer must persist until the end of PxVehiclePostUpdate.
\note If any vehicle has one or more disabled wheels (PxVehicleWheelsSimData::disableWheel) then the disabled wheels must not be associated
with a PxShape (PxVehicleWheelsSimData::setWheelShapeMapping); the differential of the vehicle must be configured so that no drive torque
is delivered to a disabled wheel; and the wheel must have zero rotation speed (PxVehicleWheelsDynData::setWheelRotationSpeed)
\note Concurrent calls to PxVehicleUpdates and PxVehicleUpdateSingleVehicleAndStoreTelemetryData are permitted if the parameter
vehicleConcurrentUpdates is used.
@see PxVehicleSetUpdateMode, PxVehicleWheelsSimData::disableWheel, PxVehicleWheelsSimData::setWheelShapeMapping, PxVehicleWheelsDynData::setWheelRotationSpeed,
PxVehiclePostUpdates
*/
PX_DEPRECATED void PxVehicleUpdates(
const PxReal timestep, const PxVec3& gravity,
const PxVehicleDrivableSurfaceToTireFrictionPairs& vehicleDrivableSurfaceToTireFrictionPairs,
const PxU32 nbVehicles, PxVehicleWheels** vehicles, PxVehicleWheelQueryResult* vehicleWheelQueryResults, PxVehicleConcurrentUpdateData* vehicleConcurrentUpdates = NULL,
const PxVehicleContext& context = PxVehicleGetDefaultContext());
/**
\brief Apply actor changes that were computed in concurrent calls to PxVehicleUpdates or PxVehicleUpdateSingleVehicleAndStoreTelemetryData but
which could not be safely applied due to the concurrency.
\param[in] vehicleConcurrentUpdates is an array of length nbVehicles where vehicleConcurrentUpdates[i] contains data describing actor changes that
were computed for vehicles[i] during concurrent calls to PxVehicleUpdates or PxVehicleUpdateSingleVehicleAndStoreTelemetryData.
\param[in] nbVehicles is the number of vehicles pointers in the vehicles array
\param[in,out] vehicles is an array of length nbVehicles containing all vehicles that were partially updated in concurrent calls to PxVehicleUpdates or
PxVehicleUpdateSingleVehicleAndStoreTelemetryData.
\param[in] context the vehicle context to use for the vehicle post update.
@see PxVehicleUpdates, PxVehicleUpdateSingleVehicleAndStoreTelemetryData
*/
PX_DEPRECATED void PxVehiclePostUpdates(
const PxVehicleConcurrentUpdateData* vehicleConcurrentUpdates, const PxU32 nbVehicles, PxVehicleWheels** vehicles,
const PxVehicleContext& context = PxVehicleGetDefaultContext());
/**
\brief Shift the origin of vehicles by the specified vector.
Call this method to adjust the internal data structures of vehicles to reflect the shifted origin location
(the shift vector will get subtracted from all world space spatial data).
\note It is the user's responsibility to keep track of the summed total origin shift and adjust all input/output to/from PhysXVehicle accordingly.
\note This call will not automatically shift the PhysX scene and its objects. You need to call PxScene::shiftOrigin() seperately to keep the systems in sync.
\param[in] shift is the translation vector to shift the origin by.
\param[in] nbVehicles is the number of vehicles in the vehicles array.
\param[in,out] vehicles is an array of all vehicles that should be updated to map to the new scene origin.
*/
PX_DEPRECATED void PxVehicleShiftOrigin(const PxVec3& shift, const PxU32 nbVehicles, PxVehicleWheels** vehicles);
#if PX_DEBUG_VEHICLE_ON
/**
\brief Update an single vehicle by either applying an acceleration to the rigid body actor associated with
each vehicle or by an immediate update of the velocity of the actor. Also record telemetry data from the
vehicle so that it may be visualized or queried.
\note The update mode (acceleration or velocity change) can be selected with PxVehicleSetUpdateMode.
\param[in] timestep is the timestep of the update
\param[in] gravity is the value of gravitational acceleration
\param[in] vehicleDrivableSurfaceToTireFrictionPairs describes the mapping between each PxMaterial ptr and an integer representing a
surface type. It also stores the friction value for each combination of surface and tire type.
\param[in,out] focusVehicle is the vehicle to be updated and have its telemetry data recorded
\param[out] vehicleWheelQueryResults is an array of length 1 storing the wheel query results of each wheel of the vehicle/
A NULL pointer is permitted.
\param[out] telemetryData is the data structure used to record telemetry data during the update for later query or visualization
\param[out] vehicleConcurrentUpdates is an array of length 1. It is only necessary to specify vehicleConcurrentUpdates if
PxVehicleUpdateSingleVehicleAndStoreTelemetryData is called concurrently (also concurrently with PxVehicleUpdates). The
PxVehicleConcurrentUpdateData struct stores data that cannot be safely written when concurrently called. The data computed and
stored in vehicleConcurrentUpdates must be passed to PxVehiclePostUpdates, where it is applied to the vehicle actor. A NULL
pointer is permitted.
\param[in] context the vehicle context to use for the vehicle update.
\note The vehicleWheelQueryResults buffer must persist until the end of PxVehicleUpdateSingleVehicleAndStoreTelemetryData
\note The vehicleWheelQueryResults buffer is left unmodified for vehicles with sleeping rigid bodies whose control inputs indicate they should remain inert.
\note Concurrent calls to PxVehicleUpdateSingleVehicleAndStoreTelemetryData and PxVehicleUpdates are permitted if the parameter
vehicleConcurrentUpdates is used.
@see PxVehiclePostUpdates, PxVehicleSetUpdateMode, PxVehicleTelemetryData
*/
PX_DEPRECATED void PxVehicleUpdateSingleVehicleAndStoreTelemetryData
(const PxReal timestep, const PxVec3& gravity,
const PxVehicleDrivableSurfaceToTireFrictionPairs& vehicleDrivableSurfaceToTireFrictionPairs,
PxVehicleWheels* focusVehicle, PxVehicleWheelQueryResult* vehicleWheelQueryResults,
PxVehicleTelemetryData& telemetryData,
PxVehicleConcurrentUpdateData* vehicleConcurrentUpdates = NULL,
const PxVehicleContext& context = PxVehicleGetDefaultContext());
#endif
#if !PX_DOXYGEN
} // namespace physx
#endif
#endif
| 32,818 | C | 53.789649 | 174 | 0.80209 |
NVIDIA-Omniverse/PhysX/physx/include/vehicle/PxVehicleDriveNW.h | // 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-2023 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 PX_VEHICLE_NWDRIVE_H
#define PX_VEHICLE_NWDRIVE_H
#include "vehicle/PxVehicleDrive.h"
#include "vehicle/PxVehicleWheels.h"
#include "vehicle/PxVehicleComponents.h"
#if !PX_DOXYGEN
namespace physx
{
#endif
struct PxFilterData;
class PxGeometry;
class PxPhysics;
class PxVehicleDrivableSurfaceToTireFrictionPairs;
class PxShape;
class PxMaterial;
class PxRigidDynamic;
/**
\brief Data structure describing configuration data of a vehicle with up to PX_MAX_NB_WHEELS driven equally through the differential. The vehicle has an
engine, clutch, gears, autobox, differential.
@see PxVehicleDriveSimData
*/
class PX_DEPRECATED PxVehicleDriveSimDataNW : public PxVehicleDriveSimData
{
public:
friend class PxVehicleDriveNW;
PxVehicleDriveSimDataNW()
: PxVehicleDriveSimData()
{
}
/**
\brief Return the data describing the differential of a vehicle with up to PX_MAX_NB_WHEELS driven wheels.
*/
const PxVehicleDifferentialNWData& getDiffData() const
{
return mDiff;
}
/**
\brief Set the data describing the differential of a vehicle with up to PX_MAX_NB_WHEELS driven wheels.
The differential data describes the set of wheels that are driven by the differential.
*/
void setDiffData(const PxVehicleDifferentialNWData& diff);
private:
/**
\brief Differential simulation data
@see setDiffData, getDiffData
*/
PxVehicleDifferentialNWData mDiff;
/**
\brief Test if the NW-drive simulation data has been setup with legal data.
Call only after setting all components.
@see setEngineData, setClutchData, setGearsData, setAutoboxData, setDiffData, setAckermannGeometryData
*/
bool isValid() const;
//serialization
public:
PxVehicleDriveSimDataNW(const PxEMPTY) : PxVehicleDriveSimData(PxEmpty), mDiff(PxEmpty) {}
static void getBinaryMetaData(PxOutputStream& stream);
//~serialization
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleDriveSimDataNW) & 15));
/**
\brief The control inputs for a PxVehicleDriveNW.
@see PxVehicleDriveDynData::setAnalogInput, PxVehicleDriveDynData::getAnalogInput
*/
struct PX_DEPRECATED PxVehicleDriveNWControl
{
enum Enum
{
eANALOG_INPUT_ACCEL=0,
eANALOG_INPUT_BRAKE,
eANALOG_INPUT_HANDBRAKE,
eANALOG_INPUT_STEER_LEFT,
eANALOG_INPUT_STEER_RIGHT,
eMAX_NB_DRIVENW_ANALOG_INPUTS
};
};
/**
\brief Data structure with instanced dynamics data and configuration data of a vehicle with up to PX_MAX_NB_WHEELS driven wheels.
*/
class PX_DEPRECATED PxVehicleDriveNW : public PxVehicleDrive
{
public:
friend class PxVehicleUpdate;
/**
\brief Allocate a PxVehicleDriveNW instance for a NWDrive vehicle with nbWheels
\param[in] nbWheels is the number of wheels on the vehicle.
\return The instantiated vehicle.
@see free, setup
*/
static PxVehicleDriveNW* allocate(const PxU32 nbWheels);
/**
\brief Deallocate a PxVehicleDriveNW instance.
@see allocate
*/
void free();
/**
\brief Set up a vehicle using simulation data for the wheels and drive model.
\param[in] physics is a PxPhysics instance that is needed to create special vehicle constraints that are maintained by the vehicle.
\param[in] vehActor is a PxRigidDynamic instance that is used to represent the vehicle in the PhysX SDK.
\param[in] wheelsData describes the configuration of all suspension/tires/wheels of the vehicle. The vehicle instance takes a copy of this data.
\param[in] driveData describes the properties of the vehicle's drive model (gears/engine/clutch/differential/autobox). The vehicle instance takes a copy of this data.
\param[in] nbWheels is the number of wheels on the vehicle.
\note It is assumed that the first shapes of the actor are the wheel shapes, followed by the chassis shapes. To break this assumption use PxVehicleWheelsSimData::setWheelShapeMapping.
@see allocate, free, setToRestState, PxVehicleWheelsSimData::setWheelShapeMapping
*/
void setup
(PxPhysics* physics, PxRigidDynamic* vehActor,
const PxVehicleWheelsSimData& wheelsData, const PxVehicleDriveSimDataNW& driveData,
const PxU32 nbWheels);
/**
\brief Allocate and set up a vehicle using simulation data for the wheels and drive model.
\param[in] physics is a PxPhysics instance that is needed to create special vehicle constraints that are maintained by the vehicle.
\param[in] vehActor is a PxRigidDynamic instance that is used to represent the vehicle in the PhysX SDK.
\param[in] wheelsData describes the configuration of all suspension/tires/wheels of the vehicle. The vehicle instance takes a copy of this data.
\param[in] driveData describes the properties of the vehicle's drive model (gears/engine/clutch/differential/autobox). The vehicle instance takes a copy of this data.
\param[in] nbWheels is the number of wheels on the vehicle.
\note It is assumed that the first shapes of the actor are the wheel shapes, followed by the chassis shapes. To break this assumption use PxVehicleWheelsSimData::setWheelShapeMapping.
\return The instantiated vehicle.
@see allocate, free, setToRestState, PxVehicleWheelsSimData::setWheelShapeMapping
*/
static PxVehicleDriveNW* create
(PxPhysics* physics, PxRigidDynamic* vehActor,
const PxVehicleWheelsSimData& wheelsData, const PxVehicleDriveSimDataNW& driveData,
const PxU32 nbWheels);
/**
\brief Set a vehicle to its rest state. Aside from the rigid body transform, this will set the vehicle and rigid body
to the state they were in immediately after setup or create.
\note Calling setToRestState invalidates the cached raycast hit planes under each wheel meaning that suspension line
raycasts need to be performed at least once with PxVehicleSuspensionRaycasts before calling PxVehicleUpdates.
@see setup, create, PxVehicleSuspensionRaycasts, PxVehicleUpdates
*/
void setToRestState();
/**
\brief Simulation data that describes the configuration of the vehicle's drive model.
@see setup, create
*/
PxVehicleDriveSimDataNW mDriveSimData;
private:
/**
\brief Test if the instanced dynamics and configuration data has legal values.
*/
bool isValid() const;
//serialization
public:
PxVehicleDriveNW(PxBaseFlags baseFlags) : PxVehicleDrive(baseFlags), mDriveSimData(PxEmpty) {}
PxVehicleDriveNW();
~PxVehicleDriveNW(){}
static PxVehicleDriveNW* createObject(PxU8*& address, PxDeserializationContext& context);
static void getBinaryMetaData(PxOutputStream& stream);
virtual const char* getConcreteTypeName() const { return "PxVehicleDriveNW"; }
virtual bool isKindOf(const char* name) const { PX_IS_KIND_OF(name, "PxVehicleDriveNW", PxVehicleDrive); }
//~serialization
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleDriveNW) & 15));
#if !PX_DOXYGEN
} // namespace physx
#endif
#endif
| 8,388 | C | 37.131818 | 185 | 0.778255 |
NVIDIA-Omniverse/PhysX/physx/include/task/PxTask.h | // 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-2023 NVIDIA Corporation. All rights reserved.
#ifndef PX_TASK_H
#define PX_TASK_H
#include "task/PxTaskManager.h"
#include "task/PxCpuDispatcher.h"
#include "foundation/PxAssert.h"
#if !PX_DOXYGEN
namespace physx
{
#endif
/**
* \brief Base class of all task types
*
* PxBaseTask defines a runnable reference counted task with built-in profiling.
*/
class PxBaseTask
{
public:
PxBaseTask() : mContextID(0), mTm(NULL) {}
virtual ~PxBaseTask() {}
/**
* \brief The user-implemented run method where the task's work should be performed
*
* run() methods must be thread safe, stack friendly (no alloca, etc), and
* must never block.
*/
virtual void run() = 0;
/**
* \brief Return a user-provided task name for profiling purposes.
*
* It does not have to be unique, but unique names are helpful.
*
* \return The name of this task
*/
virtual const char* getName() const = 0;
//! \brief Implemented by derived implementation classes
virtual void addReference() = 0;
//! \brief Implemented by derived implementation classes
virtual void removeReference() = 0;
//! \brief Implemented by derived implementation classes
virtual int32_t getReference() const = 0;
/** \brief Implemented by derived implementation classes
*
* A task may assume in its release() method that the task system no longer holds
* references to it - so it may safely run its destructor, recycle itself, etc.
* provided no additional user references to the task exist
*/
virtual void release() = 0;
/**
* \brief Return PxTaskManager to which this task was submitted
*
* Note, can return NULL if task was not submitted, or has been
* completed.
*/
PX_FORCE_INLINE PxTaskManager* getTaskManager() const
{
return mTm;
}
PX_FORCE_INLINE void setContextId(PxU64 id) { mContextID = id; }
PX_FORCE_INLINE PxU64 getContextId() const { return mContextID; }
protected:
PxU64 mContextID; //!< Context ID for profiler interface
PxTaskManager* mTm; //!< Owning PxTaskManager instance
friend class PxTaskMgr;
};
/**
* \brief A PxBaseTask implementation with deferred execution and full dependencies
*
* A PxTask must be submitted to a PxTaskManager to to be executed, Tasks may
* optionally be named when they are submitted.
*/
class PxTask : public PxBaseTask
{
public:
PxTask() : mTaskID(0) {}
virtual ~PxTask() {}
//! \brief Release method implementation
virtual void release() PX_OVERRIDE
{
PX_ASSERT(mTm);
// clear mTm before calling taskCompleted() for safety
PxTaskManager* save = mTm;
mTm = NULL;
save->taskCompleted(*this);
}
//! \brief Inform the PxTaskManager this task must finish before the given
// task is allowed to start.
PX_INLINE void finishBefore(PxTaskID taskID)
{
PX_ASSERT(mTm);
mTm->finishBefore(*this, taskID);
}
//! \brief Inform the PxTaskManager this task cannot start until the given
// task has completed.
PX_INLINE void startAfter(PxTaskID taskID)
{
PX_ASSERT(mTm);
mTm->startAfter(*this, taskID);
}
/**
* \brief Manually increment this task's reference count. The task will
* not be allowed to run until removeReference() is called.
*/
virtual void addReference() PX_OVERRIDE
{
PX_ASSERT(mTm);
mTm->addReference(mTaskID);
}
/**
* \brief Manually decrement this task's reference count. If the reference
* count reaches zero, the task will be dispatched.
*/
virtual void removeReference() PX_OVERRIDE
{
PX_ASSERT(mTm);
mTm->decrReference(mTaskID);
}
/**
* \brief Return the ref-count for this task
*/
virtual int32_t getReference() const PX_OVERRIDE
{
return mTm->getReference(mTaskID);
}
/**
* \brief Return the unique ID for this task
*/
PX_INLINE PxTaskID getTaskID() const
{
return mTaskID;
}
/**
* \brief Called by PxTaskManager at submission time for initialization
*
* Perform simulation step initialization here.
*/
virtual void submitted()
{
}
protected:
PxTaskID mTaskID; //!< ID assigned at submission
friend class PxTaskMgr;
};
/**
* \brief A PxBaseTask implementation with immediate execution and simple dependencies
*
* A PxLightCpuTask bypasses the PxTaskManager launch dependencies and will be
* submitted directly to your scene's CpuDispatcher. When the run() function
* completes, it will decrement the reference count of the specified
* continuation task.
*
* You must use a full-blown PxTask if you want your task to be resolved
* by another PxTask, or you need more than a single dependency to be
* resolved when your task completes, or your task will not run on the
* CpuDispatcher.
*/
class PxLightCpuTask : public PxBaseTask
{
public:
PxLightCpuTask()
: mCont( NULL )
, mRefCount( 0 )
{
}
virtual ~PxLightCpuTask()
{
mTm = NULL;
}
/**
* \brief Initialize this task and specify the task that will have its ref count decremented on completion.
*
* Submission is deferred until the task's mRefCount is decremented to zero.
* Note that we only use the PxTaskManager to query the appropriate dispatcher.
*
* \param[in] tm The PxTaskManager this task is managed by
* \param[in] c The task to be executed when this task has finished running
*/
PX_INLINE void setContinuation(PxTaskManager& tm, PxBaseTask* c)
{
PX_ASSERT(mRefCount == 0);
mRefCount = 1;
mCont = c;
mTm = &tm;
if(mCont)
mCont->addReference();
}
/**
* \brief Initialize this task and specify the task that will have its ref count decremented on completion.
*
* This overload of setContinuation() queries the PxTaskManager from the continuation
* task, which cannot be NULL.
* \param[in] c The task to be executed after this task has finished running
*/
PX_INLINE void setContinuation(PxBaseTask* c)
{
PX_ASSERT(c);
PX_ASSERT(mRefCount == 0);
mRefCount = 1;
mCont = c;
if(mCont)
{
mCont->addReference();
mTm = mCont->getTaskManager();
PX_ASSERT(mTm);
}
}
/**
* \brief Retrieves continuation task
*/
PX_INLINE PxBaseTask* getContinuation() const
{
return mCont;
}
/**
* \brief Manually decrement this task's reference count. If the reference
* count reaches zero, the task will be dispatched.
*/
virtual void removeReference() PX_OVERRIDE
{
mTm->decrReference(*this);
}
/** \brief Return the ref-count for this task */
virtual int32_t getReference() const PX_OVERRIDE
{
return mRefCount;
}
/**
* \brief Manually increment this task's reference count. The task will
* not be allowed to run until removeReference() is called.
*/
virtual void addReference() PX_OVERRIDE
{
mTm->addReference(*this);
}
/**
* \brief called by CpuDispatcher after run method has completed
*
* Decrements the continuation task's reference count, if specified.
*/
virtual void release() PX_OVERRIDE
{
if(mCont)
mCont->removeReference();
}
protected:
PxBaseTask* mCont; //!< Continuation task, can be NULL
volatile int32_t mRefCount; //!< PxTask is dispatched when reaches 0
friend class PxTaskMgr;
};
#if !PX_DOXYGEN
} // namespace physx
#endif
#endif
| 8,843 | C | 26.6375 | 111 | 0.695465 |
NVIDIA-Omniverse/PhysX/physx/include/task/PxTaskManager.h | // 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-2023 NVIDIA Corporation. All rights reserved.
#ifndef PX_TASK_MANAGER_H
#define PX_TASK_MANAGER_H
#include "foundation/PxSimpleTypes.h"
#include "foundation/PxErrorCallback.h"
#if !PX_DOXYGEN
namespace physx
{
#endif
class PxBaseTask;
class PxTask;
class PxLightCpuTask;
typedef unsigned int PxTaskID;
/**
\brief Identifies the type of each heavyweight PxTask object
\note This enum type is only used by PxTask objects, PxLightCpuTasks do not use this enum.
@see PxTask
@see PxLightCpuTask
*/
struct PxTaskType
{
/**
* \brief Identifies the type of each heavyweight PxTask object
*/
enum Enum
{
eCPU, //!< PxTask will be run on the CPU
eNOT_PRESENT, //!< Return code when attempting to find a task that does not exist
eCOMPLETED //!< PxTask execution has been completed
};
};
class PxCpuDispatcher;
/**
\brief The PxTaskManager interface
A PxTaskManager instance holds references to user-provided dispatcher objects. When tasks are
submitted the PxTaskManager routes them to the appropriate dispatcher and handles task profiling if enabled.
Users should not implement the PxTaskManager interface, the SDK creates its own concrete PxTaskManager object
per-scene which users can configure by passing dispatcher objects into the PxSceneDesc.
@see PxCpuDispatcher
*/
class PxTaskManager
{
public:
/**
\brief Set the user-provided dispatcher object for CPU tasks
\param[in] ref The dispatcher object.
@see PxCpuDispatcher
*/
virtual void setCpuDispatcher(PxCpuDispatcher& ref) = 0;
/**
\brief Get the user-provided dispatcher object for CPU tasks
\return The CPU dispatcher object.
@see PxCpuDispatcher
*/
virtual PxCpuDispatcher* getCpuDispatcher() const = 0;
/**
\brief Reset any dependencies between Tasks
\note Will be called at the start of every frame before tasks are submitted.
@see PxTask
*/
virtual void resetDependencies() = 0;
/**
\brief Called by the owning scene to start the task graph.
\note All tasks with ref count of 1 will be dispatched.
@see PxTask
*/
virtual void startSimulation() = 0;
/**
\brief Called by the owning scene at the end of a simulation step.
*/
virtual void stopSimulation() = 0;
/**
\brief Called by the worker threads to inform the PxTaskManager that a task has completed processing.
\param[in] task The task which has been completed
*/
virtual void taskCompleted(PxTask& task) = 0;
/**
\brief Retrieve a task by name
\param[in] name The unique name of a task
\return The ID of the task with that name, or eNOT_PRESENT if not found
*/
virtual PxTaskID getNamedTask(const char* name) = 0;
/**
\brief Submit a task with a unique name.
\param[in] task The task to be executed
\param[in] name The unique name of a task
\param[in] type The type of the task (default eCPU)
\return The ID of the task with that name, or eNOT_PRESENT if not found
*/
virtual PxTaskID submitNamedTask(PxTask* task, const char* name, PxTaskType::Enum type = PxTaskType::eCPU) = 0;
/**
\brief Submit an unnamed task.
\param[in] task The task to be executed
\param[in] type The type of the task (default eCPU)
\return The ID of the task with that name, or eNOT_PRESENT if not found
*/
virtual PxTaskID submitUnnamedTask(PxTask& task, PxTaskType::Enum type = PxTaskType::eCPU) = 0;
/**
\brief Retrieve a task given a task ID
\param[in] id The ID of the task to return, a valid ID must be passed or results are undefined
\return The task associated with the ID
*/
virtual PxTask* getTaskFromID(PxTaskID id) = 0;
/**
\brief Release the PxTaskManager object, referenced dispatchers will not be released
*/
virtual void release() = 0;
/**
\brief Construct a new PxTaskManager instance with the given [optional] dispatchers
*/
static PxTaskManager* createTaskManager(PxErrorCallback& errorCallback, PxCpuDispatcher* = NULL);
protected:
virtual ~PxTaskManager() {}
/*! \cond PRIVATE */
virtual void finishBefore(PxTask& task, PxTaskID taskID) = 0;
virtual void startAfter(PxTask& task, PxTaskID taskID) = 0;
virtual void addReference(PxTaskID taskID) = 0;
virtual void decrReference(PxTaskID taskID) = 0;
virtual int32_t getReference(PxTaskID taskID) const = 0;
virtual void decrReference(PxLightCpuTask&) = 0;
virtual void addReference(PxLightCpuTask&) = 0;
/*! \endcond */
friend class PxBaseTask;
friend class PxTask;
friend class PxLightCpuTask;
};
#if !PX_DOXYGEN
} // namespace physx
#endif
#endif
| 5,997 | C | 28.401961 | 113 | 0.745539 |
NVIDIA-Omniverse/PhysX/physx/include/task/PxCpuDispatcher.h | // 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-2023 NVIDIA Corporation. All rights reserved.
#ifndef PX_CPU_DISPATCHER_H
#define PX_CPU_DISPATCHER_H
#include "foundation/PxSimpleTypes.h"
#if !PX_DOXYGEN
namespace physx
{
#endif
class PxBaseTask;
/**
\brief A CpuDispatcher is responsible for scheduling the execution of tasks passed to it by the SDK.
A typical implementation would for example use a thread pool with the dispatcher
pushing tasks onto worker thread queues or a global queue.
@see PxBaseTask
@see PxTask
@see PxTaskManager
*/
class PxCpuDispatcher
{
public:
/**
\brief Called by the TaskManager when a task is to be queued for execution.
Upon receiving a task, the dispatcher should schedule the task to run.
After the task has been run, it should call the release() method and
discard its pointer.
\param[in] task The task to be run.
@see PxBaseTask
*/
virtual void submitTask(PxBaseTask& task) = 0;
/**
\brief Returns the number of available worker threads for this dispatcher.
The SDK will use this count to control how many tasks are submitted. By
matching the number of tasks with the number of execution units task
overhead can be reduced.
*/
virtual uint32_t getWorkerCount() const = 0;
virtual ~PxCpuDispatcher() {}
};
#if !PX_DOXYGEN
} // namespace physx
#endif
#endif
| 2,808 | C | 32.843373 | 101 | 0.759259 |
NVIDIA-Omniverse/PhysX/physx/include/geomutils/PxContactPoint.h | // 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-2023 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 PX_CONTACT_POINT_H
#define PX_CONTACT_POINT_H
#include "foundation/PxVec3.h"
#if !PX_DOXYGEN
namespace physx
{
#endif
struct PxContactPoint
{
/**
\brief The normal of the contacting surfaces at the contact point.
For two shapes s0 and s1, the normal points in the direction that s0 needs to move in to resolve the contact with s1.
*/
PX_ALIGN(16, PxVec3 normal);
/**
\brief The separation of the shapes at the contact point. A negative separation denotes a penetration.
*/
PxReal separation;
/**
\brief The point of contact between the shapes, in world space.
*/
PX_ALIGN(16, PxVec3 point);
/**
\brief The max impulse permitted at this point
*/
PxReal maxImpulse;
PX_ALIGN(16, PxVec3 targetVel);
/**
\brief The static friction coefficient
*/
PxReal staticFriction;
/**
\brief Material flags for this contact (eDISABLE_FRICTION, eDISABLE_STRONG_FRICTION). @see PxMaterialFlag
*/
PxU8 materialFlags;
/**
\brief The surface index of shape 1 at the contact point. This is used to identify the surface material.
\note This field is only supported by triangle meshes and heightfields, else it will be set to PXC_CONTACT_NO_FACE_INDEX.
*/
PxU32 internalFaceIndex1;
/**
\brief The dynamic friction coefficient
*/
PxReal dynamicFriction;
/**
\brief The restitution coefficient
*/
PxReal restitution;
/**
\brief Damping coefficient (for compliant contacts)
*/
PxReal damping;
};
#if !PX_DOXYGEN
} // namespace physx
#endif
#endif
| 3,236 | C | 30.427184 | 123 | 0.737021 |
NVIDIA-Omniverse/PhysX/physx/include/omnipvd/PxOmniPvd.h | // 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-2023 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 PX_OMNI_PVD_H
#define PX_OMNI_PVD_H
#include "PxPhysXConfig.h"
class OmniPvdWriter;
class OmniPvdFileWriteStream;
#if !PX_DOXYGEN
namespace physx
{
#endif
class PxFoundation;
class PxOmniPvd
{
public:
class ScopedExclusiveWriter
{
public:
PX_FORCE_INLINE ScopedExclusiveWriter(PxOmniPvd* omniPvd)
{
mOmniPvd = omniPvd;
mWriter = NULL;
if (mOmniPvd) {
mWriter = mOmniPvd->acquireExclusiveWriterAccess();
}
}
PX_FORCE_INLINE ~ScopedExclusiveWriter()
{
if (mOmniPvd && mWriter) {
mOmniPvd->releaseExclusiveWriterAccess();
}
}
PX_FORCE_INLINE OmniPvdWriter* operator-> ()
{
return mWriter;
}
PX_FORCE_INLINE OmniPvdWriter* getWriter()
{
return mWriter;
}
private:
OmniPvdWriter* mWriter;
PxOmniPvd* mOmniPvd;
};
virtual ~PxOmniPvd()
{
}
/**
\brief Get the OmniPvd writer.
Gets an instance of the OmniPvd writer. The writer access will not be thread safe since the OmniPVD API is not thread safe itself. Writing concurrently and simultaneously using the OmniPVD API is undefined.
For thread safe exlcusive access use the mechanism acquireExclusiveWriterAccess/releaseExclusiveWriterAccess.
\return OmniPvdWriter instance on succes, NULL otherwise.
*/
virtual OmniPvdWriter* getWriter() = 0;
/**
\brief Acquires an exclusive writer access.
This call blocks until exclusive access to the writer can be acquired. Once access has been granted, it is guaranteed that no other caller can access the writer through this method until releaseExclusiveWriterAccess() has been called.
This allows to safely write PVD data in environments with concurrent processing workflows.
\return OmniPvdWriter instance on succes, NULL otherwise.
*/
virtual OmniPvdWriter* acquireExclusiveWriterAccess() = 0;
/**
\brief Releases the exclusive writer access
Releases the access to the writer that was previously acquired using acquireExclusiveWriterAccess.
*/
virtual void releaseExclusiveWriterAccess() = 0;
/**
\brief Gets an instance to the OmniPvd file write stream
\return OmniPvdFileWriteStream instance on succes, NULL otherwise.
*/
virtual OmniPvdFileWriteStream* getFileWriteStream() = 0;
/**
\brief Starts the OmniPvd sampling
\return True if sampling started correctly, false if not.
*/
virtual bool startSampling() = 0;
/**
\brief Releases the PxOmniPvd object
*/
virtual void release() = 0;
};
#if !PX_DOXYGEN
} // namespace physx
#endif
/**
\brief Creates an instance of the OmniPvd object
Creates an instance of the OmniPvd class. There may be only one instance of this class per process. Calling this method after an instance
has been created already will return the same instance over and over.
\param foundation Foundation instance (see PxFoundation)
\return PxOmniPvd instance on succes, NULL otherwise.
*/
PX_C_EXPORT PX_PHYSX_CORE_API physx::PxOmniPvd* PX_CALL_CONV PxCreateOmniPvd(physx::PxFoundation& foundation);
#endif
| 4,671 | C | 29.736842 | 235 | 0.756369 |
NVIDIA-Omniverse/PhysX/physx/include/collision/PxCollisionDefs.h | // 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-2023 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 PX_COLLISION_DEFS_H
#define PX_COLLISION_DEFS_H
#include "PxPhysXConfig.h"
#include "foundation/PxSimpleTypes.h"
#if !PX_DOXYGEN
namespace physx
{
#endif
/**
\brief A callback class to allocate memory to cache information used in contact generation.
*/
class PxCacheAllocator
{
public:
/**
\brief Allocates cache data for contact generation. This data is stored inside PxCache objects.
The application can retain and provide this information for future contact generation passes
for a given pair to improve contact generation performance. It is the application's responsibility
to release this memory appropriately. If the memory is released, the application must ensure that
this memory is no longer referenced by any PxCache objects passed to PxGenerateContacts.
\param byteSize [in] size of the allocation in bytes
\return the newly-allocated memory. The returned address must be 16-byte aligned.
@see PxCache, PxGenerateContacts
*/
virtual PxU8* allocateCacheData(const PxU32 byteSize) = 0;
virtual ~PxCacheAllocator() {}
};
/**
\brief A structure to cache contact information produced by low-level contact generation functions.
*/
struct PxCache
{
PxU8* mCachedData; //!< Cached data pointer. Allocated via PxCacheAllocator
PxU16 mCachedSize; //!< The total size of the cached data
PxU8 mPairData; //!< Pair data information used and cached internally by some contact generation functions to accelerate performance.
PxU8 mManifoldFlags; //!< Manifold flags used to identify the format the cached data is stored in. @see Gu::ManifoldFlags
PX_FORCE_INLINE PxCache() : mCachedData(NULL), mCachedSize(0), mPairData(0), mManifoldFlags(0)
{
}
PX_FORCE_INLINE void reset()
{
mCachedData = NULL;
mCachedSize = 0;
mPairData = 0;
mManifoldFlags = 0;
}
};
#if !PX_DOXYGEN
}
#endif
#endif
| 3,535 | C | 37.021505 | 136 | 0.765205 |
NVIDIA-Omniverse/PhysX/physx/include/common/PxPhysXCommonConfig.h | // 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-2023 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 PX_PHYSX_COMMON_CONFIG_H
#define PX_PHYSX_COMMON_CONFIG_H
/** \addtogroup common
@{ */
#include "foundation/Px.h"
//Fills almost all allocated (host and device memory) with 0xcdcdcdcd (=3452816845)
#define PX_STOMP_ALLOCATED_MEMORY 0
/*Disable support for VS2017 prior version 15.5.1 for windows platform, because of a compiler bug:
https://developercommunity.visualstudio.com/content/problem/66047/possible-compiler-bug.html
*/
#if (PX_VC == 15) && PX_WINDOWS && (_MSC_FULL_VER < 191225830)
#error Visual studio 2017 prior to 15.5.1 is not supported because of a compiler bug.
#endif
// define API function declaration (public API only needed because of extensions)
#if defined PX_PHYSX_STATIC_LIB
#define PX_PHYSX_CORE_API
#else
#if PX_WINDOWS_FAMILY
#if defined PX_PHYSX_CORE_EXPORTS
#define PX_PHYSX_CORE_API __declspec(dllexport)
#else
#define PX_PHYSX_CORE_API __declspec(dllimport)
#endif
#elif PX_UNIX_FAMILY
#define PX_PHYSX_CORE_API PX_UNIX_EXPORT
#else
#define PX_PHYSX_CORE_API
#endif
#endif
#if PX_SUPPORT_GPU_PHYSX
// define API function declaration
#if defined PX_PHYSX_GPU_STATIC
#define PX_PHYSX_GPU_API
#else
#if PX_WINDOWS
#if defined PX_PHYSX_GPU_EXPORTS
#define PX_PHYSX_GPU_API __declspec(dllexport)
#else
#define PX_PHYSX_GPU_API __declspec(dllimport)
#endif
#elif PX_UNIX_FAMILY
#define PX_PHYSX_GPU_API PX_UNIX_EXPORT
#else
#define PX_PHYSX_GPU_API
#endif
#endif
#else // PX_SUPPORT_GPU_PHYSX
#define PX_PHYSX_GPU_API
#endif // PX_SUPPORT_GPU_PHYSX
#if defined PX_PHYSX_STATIC_LIB
#define PX_PHYSX_COMMON_API
#else
#if PX_WINDOWS_FAMILY && !defined(__CUDACC__)
#if defined PX_PHYSX_COMMON_EXPORTS
#define PX_PHYSX_COMMON_API __declspec(dllexport)
#else
#define PX_PHYSX_COMMON_API __declspec(dllimport)
#endif
#elif PX_UNIX_FAMILY
#define PX_PHYSX_COMMON_API PX_UNIX_EXPORT
#else
#define PX_PHYSX_COMMON_API
#endif
#endif
// PT: typical "invalid" value in various CD algorithms
#define PX_INVALID_U32 0xffffffff
#define PX_INVALID_U16 0xffff
// Changing these parameters requires recompilation of the SDK
// Enable debug visualization
#define PX_ENABLE_DEBUG_VISUALIZATION 1
#define PX_CATCH_UNDEFINED_ENABLE_DEBUG_VISUALIZATION
// Enable simulation statistics generation
#define PX_ENABLE_SIM_STATS 1
#define PX_CATCH_UNDEFINED_ENABLE_SIM_STATS
#if !PX_DOXYGEN
namespace physx
{
#endif
typedef PxU32 PxTriangleID;
typedef PxU16 PxMaterialTableIndex;
typedef PxU16 PxFEMMaterialTableIndex;
#if !PX_DOXYGEN
} // namespace physx
#endif
/** @} */
#endif
| 4,265 | C | 31.815384 | 98 | 0.753107 |
NVIDIA-Omniverse/PhysX/physx/include/common/PxCollection.h | // 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-2023 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 PX_COLLECTION_H
#define PX_COLLECTION_H
#include "common/PxSerialFramework.h"
/** \addtogroup common
@{
*/
#if !PX_DOXYGEN
namespace physx
{
#endif
class PxBase;
/**
\brief Collection class for serialization.
A collection is a set of PxBase objects. PxBase objects can be added to the collection
regardless of other objects they depend on. Objects may be named using PxSerialObjectId values in order
to resolve dependencies between objects of different collections.
Serialization and deserialization only work through collections.
A scene is typically serialized using the following steps:
-# create a serialization registry
-# create a collection for scene objects
-# complete the scene objects (adds all dependent objects, e.g. meshes)
-# serialize collection
-# release collection
-# release serialization registry
For example the code may look like this:
\code
PxPhysics* physics; // The physics
PxScene* scene; // The physics scene
SerialStream s; // The user-defined stream doing the actual write to disk
PxSerializationRegistry* registry = PxSerialization::createSerializationRegistry(*physics); // step 1)
PxCollection* collection = PxSerialization::createCollection(*scene); // step 2)
PxSerialization::complete(*collection, *registry); // step 3)
PxSerialization::serializeCollectionToBinary(s, *collection, *registry); // step 4)
collection->release(); // step 5)
registry->release(); // step 6)
\endcode
A scene is typically deserialized using the following steps:
-# load a serialized collection into memory
-# create a serialization registry
-# create a collection by passing the serialized memory block
-# add collected objects to scene
-# release collection
-# release serialization registry
For example the code may look like this:
\code
PxPhysics* physics; // The physics
PxScene* scene; // The physics scene
void* memory128; // a 128-byte aligned buffer previously loaded from disk by the user - step 1)
PxSerializationRegistry* registry = PxSerialization::createSerializationRegistry(*physics); // step 2)
PxCollection* collection = PxSerialization::createCollectionFromBinary(memory128, *registry); // step 3)
scene->addCollection(*collection); // step 4)
collection->release(); // step 5)
registry->release(); // step 6)
\endcode
@see PxBase, PxCreateCollection()
*/
class PxCollection
{
public:
/**
\brief Adds a PxBase object to the collection.
Adds a PxBase object to the collection. Optionally a PxSerialObjectId can be provided
in order to resolve dependencies between collections. A PxSerialObjectId value of PX_SERIAL_OBJECT_ID_INVALID
means the object remains without id. Objects can be added regardless of other objects they require. If the object
is already in the collection, the ID will be set if it was PX_SERIAL_OBJECT_ID_INVALID previously, otherwise the
operation fails.
\param[in] object Object to be added to the collection
\param[in] id Optional PxSerialObjectId id
*/
virtual void add(PxBase& object, PxSerialObjectId id = PX_SERIAL_OBJECT_ID_INVALID) = 0;
/**
\brief Removes a PxBase member object from the collection.
Object needs to be contained by the collection.
\param[in] object PxBase object to be removed
*/
virtual void remove(PxBase& object) = 0;
/**
\brief Returns whether the collection contains a certain PxBase object.
\param[in] object PxBase object
\return Whether object is contained.
*/
virtual bool contains(PxBase& object) const = 0;
/**
\brief Adds an id to a member PxBase object.
If the object is already associated with an id within the collection, the id is replaced.
May only be called for objects that are members of the collection. The id needs to be unique
within the collection.
\param[in] object Member PxBase object
\param[in] id PxSerialObjectId id to be given to the object
*/
virtual void addId(PxBase& object, PxSerialObjectId id) = 0;
/**
\brief Removes id from a contained PxBase object.
May only be called for ids that are associated with an object in the collection.
\param[in] id PxSerialObjectId value
*/
virtual void removeId(PxSerialObjectId id) = 0;
/**
\brief Adds all PxBase objects and their ids of collection to this collection.
PxBase objects already in this collection are ignored. Object ids need to be conflict
free, i.e. the same object may not have two different ids within the two collections.
\param[in] collection Collection to be added
*/
virtual void add(PxCollection& collection) = 0;
/**
\brief Removes all PxBase objects of collection from this collection.
PxBase objects not present in this collection are ignored. Ids of objects
which are removed are also removed.
\param[in] collection Collection to be removed
*/
virtual void remove(PxCollection& collection) = 0;
/**
\brief Gets number of PxBase objects in this collection.
\return Number of objects in this collection
*/
virtual PxU32 getNbObjects() const = 0;
/**
\brief Gets the PxBase object of this collection given its index.
\param[in] index PxBase index in [0, getNbObjects())
\return PxBase object at index index
*/
virtual PxBase& getObject(PxU32 index) const = 0;
/**
\brief Copies member PxBase pointers to a user specified buffer.
\param[out] userBuffer Array of PxBase pointers
\param[in] bufferSize Capacity of userBuffer
\param[in] startIndex Offset into list of member PxBase objects
\return number of members PxBase objects that have been written to the userBuffer
*/
virtual PxU32 getObjects(PxBase** userBuffer, PxU32 bufferSize, PxU32 startIndex=0) const = 0;
/**
\brief Looks for a PxBase object given a PxSerialObjectId value.
If there is no PxBase object in the collection with the given id, NULL is returned.
\param[in] id PxSerialObjectId value to look for
\return PxBase object with the given id value or NULL
*/
virtual PxBase* find(PxSerialObjectId id) const = 0;
/**
\brief Gets number of PxSerialObjectId names in this collection.
\return Number of PxSerialObjectId names in this collection
*/
virtual PxU32 getNbIds() const = 0;
/**
\brief Copies member PxSerialObjectId values to a user specified buffer.
\param[out] userBuffer Array of PxSerialObjectId values
\param[in] bufferSize Capacity of userBuffer
\param[in] startIndex Offset into list of member PxSerialObjectId values
\return number of members PxSerialObjectId values that have been written to the userBuffer
*/
virtual PxU32 getIds(PxSerialObjectId* userBuffer, PxU32 bufferSize, PxU32 startIndex=0) const = 0;
/**
\brief Gets the PxSerialObjectId name of a PxBase object within the collection.
The PxBase object needs to be a member of the collection.
\param[in] object PxBase object to get id for
\return PxSerialObjectId name of the object or PX_SERIAL_OBJECT_ID_INVALID if the object is unnamed
*/
virtual PxSerialObjectId getId(const PxBase& object) const = 0;
/**
\brief Deletes a collection object.
This function only deletes the collection object, i.e. the container class. It doesn't delete objects
that are part of the collection.
@see PxCreateCollection()
*/
virtual void release() = 0;
protected:
PxCollection() {}
virtual ~PxCollection() {}
};
#if !PX_DOXYGEN
} // namespace physx
#endif
/**
\brief Creates a collection object.
Objects can only be serialized or deserialized through a collection.
For serialization, users must add objects to the collection and serialize the collection as a whole.
For deserialization, the system gives back a collection of deserialized objects to users.
\return The new collection object.
@see PxCollection, PxCollection::release()
*/
PX_C_EXPORT PX_PHYSX_COMMON_API physx::PxCollection* PX_CALL_CONV PxCreateCollection();
/** @} */
#endif
| 9,674 | C | 33.802158 | 114 | 0.74478 |
NVIDIA-Omniverse/PhysX/physx/include/common/PxBase.h | // 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-2023 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 PX_BASE_H
#define PX_BASE_H
/** \addtogroup common
@{
*/
#include "foundation/PxFlags.h"
#include "foundation/PxString.h"
#include "foundation/PxFoundation.h"
#include "common/PxSerialFramework.h"
#include "common/PxCollection.h"
#include "common/PxTypeInfo.h"
#include "foundation/PxAssert.h"
#define PX_IS_KIND_OF(query, classname, baseclass) \
PX_ASSERT(query != NULL); \
if(query == NULL) \
{ \
PxGetFoundation().error(PxErrorCode::eINVALID_PARAMETER, PX_FL, "isKindOf called with invalid string"); \
return false; \
} \
return !Pxstrcmp(classname, query) || baseclass::isKindOf(query)
#if !PX_DOXYGEN
namespace physx
{
#endif
typedef PxU16 PxType;
/**
\brief Flags for PxBase.
*/
struct PxBaseFlag
{
enum Enum
{
eOWNS_MEMORY = (1<<0),
eIS_RELEASABLE = (1<<1)
};
};
typedef PxFlags<PxBaseFlag::Enum, PxU16> PxBaseFlags;
PX_FLAGS_OPERATORS(PxBaseFlag::Enum, PxU16)
/**
\brief Base class for objects that can be members of a PxCollection.
All PxBase sub-classes can be serialized.
@see PxCollection
*/
class PxBase
{
public:
/**
\brief Releases the PxBase instance, please check documentation of release in derived class.
*/
virtual void release() = 0;
/**
\brief Returns string name of dynamic type.
\return Class name of most derived type of this object.
*/
virtual const char* getConcreteTypeName() const = 0;
/* brief Implements dynamic cast functionality.
Example use:
if(actor->is<PxRigidDynamic>()) {...}
\return A pointer to the specified type if object matches, otherwise NULL
*/
template<class T> T* is() { return typeMatch<T>() ? static_cast<T*>(this) : NULL; }
/* brief Implements dynamic cast functionality for const objects.
Example use:
if(actor->is<PxRigidDynamic>()) {...}
\return A pointer to the specified type if object matches, otherwise NULL
*/
template<class T> const T* is() const { return typeMatch<T>() ? static_cast<const T*>(this) : NULL; }
/**
\brief Returns concrete type of object.
\return PxConcreteType::Enum of serialized object
@see PxConcreteType
*/
PX_FORCE_INLINE PxType getConcreteType() const { return mConcreteType; }
/**
\brief Set PxBaseFlag
\param[in] flag The flag to be set
\param[in] value The flags new value
*/
PX_FORCE_INLINE void setBaseFlag(PxBaseFlag::Enum flag, bool value) { mBaseFlags = value ? mBaseFlags|flag : mBaseFlags&~flag; }
/**
\brief Set PxBaseFlags
\param[in] inFlags The flags to be set
@see PxBaseFlags
*/
PX_FORCE_INLINE void setBaseFlags(PxBaseFlags inFlags) { mBaseFlags = inFlags; }
/**
\brief Returns PxBaseFlags
\return PxBaseFlags
@see PxBaseFlags
*/
PX_FORCE_INLINE PxBaseFlags getBaseFlags() const { return mBaseFlags; }
/**
\brief Whether the object is subordinate.
A class is subordinate, if it can only be instantiated in the context of another class.
\return Whether the class is subordinate
@see PxSerialization::isSerializable
*/
virtual bool isReleasable() const { return mBaseFlags & PxBaseFlag::eIS_RELEASABLE; }
protected:
/**
\brief Constructor setting concrete type and base flags.
*/
PX_INLINE PxBase(PxType concreteType, PxBaseFlags baseFlags)
: mConcreteType(concreteType), mBaseFlags(baseFlags), mBuiltInRefCount(1) {}
/**
\brief Deserialization constructor setting base flags.
*/
PX_INLINE PxBase(PxBaseFlags baseFlags) : mBaseFlags(baseFlags)
{
PX_ASSERT(mBuiltInRefCount == 1);
}
/**
\brief Destructor.
*/
virtual ~PxBase() {}
/**
\brief Returns whether a given type name matches with the type of this instance
*/
virtual bool isKindOf(const char* superClass) const { return !Pxstrcmp(superClass, "PxBase"); }
template<class T> bool typeMatch() const
{
return PxU32(PxTypeInfo<T>::eFastTypeId)!=PxU32(PxConcreteType::eUNDEFINED) ?
PxU32(getConcreteType()) == PxU32(PxTypeInfo<T>::eFastTypeId) : isKindOf(PxTypeInfo<T>::name());
}
private:
friend void getBinaryMetaData_PxBase(PxOutputStream& stream);
protected:
PxType mConcreteType; // concrete type identifier - see PxConcreteType.
PxBaseFlags mBaseFlags; // internal flags
PxU32 mBuiltInRefCount;
};
/**
\brief Base class for ref-counted objects.
*/
class PxRefCounted : public PxBase
{
public:
/**
\brief Decrements the reference count of the object and releases it if the new reference count is zero.
*/
virtual void release() = 0;
/**
\brief Returns the reference count of the object.
At creation, the reference count of the object is 1. Every other object referencing this object increments the
count by 1. When the reference count reaches 0, and only then, the object gets destroyed automatically.
\return the current reference count.
*/
virtual PxU32 getReferenceCount() const = 0;
/**
\brief Acquires a counted reference to this object.
This method increases the reference count of the object by 1. Decrement the reference count by calling release()
*/
virtual void acquireReference() = 0;
protected:
virtual void onRefCountZero() { delete this; }
PX_INLINE PxRefCounted(PxType concreteType, PxBaseFlags baseFlags) : PxBase(concreteType, baseFlags) {}
PX_INLINE PxRefCounted(PxBaseFlags baseFlags) : PxBase(baseFlags) {}
virtual ~PxRefCounted() {}
virtual bool isKindOf(const char* name) const { PX_IS_KIND_OF(name, "PxRefCounted", PxBase); }
};
#if !PX_DOXYGEN
} // namespace physx
#endif
/** @} */
#endif
| 7,921 | C | 31.467213 | 131 | 0.655599 |
NVIDIA-Omniverse/PhysX/physx/include/common/PxRenderBuffer.h | // 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-2023 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 PX_RENDER_BUFFER_H
#define PX_RENDER_BUFFER_H
/** \addtogroup common
@{
*/
#include "common/PxPhysXCommonConfig.h"
#include "foundation/PxVec3.h"
#include "foundation/PxMat33.h"
#include "foundation/PxBounds3.h"
#if !PX_DOXYGEN
namespace physx
{
#endif
/**
\brief Default color values used for debug rendering.
*/
struct PxDebugColor
{
enum Enum
{
eARGB_BLACK = 0xff000000,
eARGB_RED = 0xffff0000,
eARGB_GREEN = 0xff00ff00,
eARGB_BLUE = 0xff0000ff,
eARGB_YELLOW = 0xffffff00,
eARGB_MAGENTA = 0xffff00ff,
eARGB_CYAN = 0xff00ffff,
eARGB_WHITE = 0xffffffff,
eARGB_GREY = 0xff808080,
eARGB_DARKRED = 0xff880000,
eARGB_DARKGREEN = 0xff008800,
eARGB_DARKBLUE = 0xff000088
};
};
/**
\brief Used to store a single point and colour for debug rendering.
*/
struct PxDebugPoint
{
PxDebugPoint(const PxVec3& p, const PxU32& c)
: pos(p), color(c) {}
PxVec3 pos;
PxU32 color;
};
/**
\brief Used to store a single line and colour for debug rendering.
*/
struct PxDebugLine
{
PxDebugLine(const PxVec3& p0, const PxVec3& p1, const PxU32& c)
: pos0(p0), color0(c), pos1(p1), color1(c) {}
PxVec3 pos0;
PxU32 color0;
PxVec3 pos1;
PxU32 color1;
};
/**
\brief Used to store a single triangle and colour for debug rendering.
*/
struct PxDebugTriangle
{
PxDebugTriangle(const PxVec3& p0, const PxVec3& p1, const PxVec3& p2, const PxU32& c)
: pos0(p0), color0(c), pos1(p1), color1(c), pos2(p2), color2(c) {}
PxVec3 pos0;
PxU32 color0;
PxVec3 pos1;
PxU32 color1;
PxVec3 pos2;
PxU32 color2;
};
/**
\brief Used to store a text for debug rendering. Doesn't own 'string' array.
*/
struct PxDebugText
{
PxDebugText() : string(0)
{
}
PxDebugText(const PxVec3& pos, const PxReal& sz, const PxU32& clr, const char* str)
: position(pos), size(sz), color(clr), string(str)
{
}
PxVec3 position;
PxReal size;
PxU32 color;
const char* string;
};
/**
\brief Interface for points, lines, triangles, and text buffer.
*/
class PxRenderBuffer
{
public:
virtual ~PxRenderBuffer() {}
virtual PxU32 getNbPoints() const = 0;
virtual const PxDebugPoint* getPoints() const = 0;
virtual void addPoint(const PxDebugPoint& point) = 0;
virtual PxU32 getNbLines() const = 0;
virtual const PxDebugLine* getLines() const = 0;
virtual void addLine(const PxDebugLine& line) = 0;
virtual PxDebugLine* reserveLines(const PxU32 nbLines) = 0;
virtual PxDebugPoint* reservePoints(const PxU32 nbLines) = 0;
virtual PxU32 getNbTriangles() const = 0;
virtual const PxDebugTriangle* getTriangles() const = 0;
virtual void addTriangle(const PxDebugTriangle& triangle) = 0;
virtual void append(const PxRenderBuffer& other) = 0;
virtual void clear() = 0;
virtual void shift(const PxVec3& delta) = 0;
virtual bool empty() const = 0;
};
#if !PX_DOXYGEN
} // namespace physx
#endif
/** @} */
#endif
| 4,538 | C | 26.017857 | 86 | 0.728515 |
NVIDIA-Omniverse/PhysX/physx/include/common/PxSerializer.h | // 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-2023 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 PX_SERIALIZER_H
#define PX_SERIALIZER_H
/** \addtogroup extensions
@{
*/
#include "foundation/PxAssert.h"
#include "foundation/PxAllocatorCallback.h"
#include "foundation/PxFoundation.h"
#include "common/PxSerialFramework.h"
#include "common/PxCollection.h"
#if !PX_DOXYGEN
namespace physx
{
#endif
/**
\brief Serialization interface class.
PxSerializer is used to extend serializable PxBase classes with serialization functionality. The
interface is structured such that per-class adapter instances can be used as opposed to per-object
adapter instances, avoiding per object allocations. Hence the methods take a reference to PxBase as a parameter.
The PxSerializer interface needs to be implemented for binary or RepX serialization to work on custom
types. If only RepX serialization is needed, some methods can be left empty, as they are only needed
for binary serialization.
A default implementation is available as a template adapter (PxSerializerDefaultAdapter).
@see PxSerializerDefaultAdapter, PX_NEW_SERIALIZER_ADAPTER, PxSerializationRegistry::registerSerializer
*/
class PxSerializer
{
public:
/**********************************************************************************************************************/
/** @name Basics needed for Binary- and RepX-Serialization
*/
//@{
/**
\brief Returns string name of dynamic type.
\return Class name of most derived type of this object.
*/
virtual const char* getConcreteTypeName() const = 0;
/**
\brief Adds required objects to the collection.
This method does not add the required objects recursively, e.g. objects required by required objects.
@see PxCollection, PxSerialization::complete
*/
virtual void requiresObjects(PxBase&, PxProcessPxBaseCallback&) const = 0;
/**
\brief Whether the object is subordinate.
A class is subordinate, if it can only be instantiated in the context of another class.
\return Whether the class is subordinate
@see PxSerialization::isSerializable
*/
virtual bool isSubordinate() const = 0;
//@}
/**********************************************************************************************************************/
/**********************************************************************************************************************/
/** @name Functionality needed for Binary Serialization only
*/
//@{
/**
\brief Exports object's extra data to stream.
*/
virtual void exportExtraData(PxBase&, PxSerializationContext&) const = 0;
/**
\brief Exports object's data to stream.
*/
virtual void exportData(PxBase&, PxSerializationContext&) const = 0;
/**
\brief Register references that the object maintains to other objects.
*/
virtual void registerReferences(PxBase& obj, PxSerializationContext& s) const = 0;
/**
\brief Returns size needed to create the class instance.
\return sizeof class instance.
*/
virtual size_t getClassSize() const = 0;
/**
\brief Create object at a given address, resolve references and import extra data.
\param address Location at which object is created. Address is increased by the size of the created object.
\param context Context for reading external data and resolving references.
\return Created PxBase pointer (needs to be identical to address before increment).
*/
virtual PxBase* createObject(PxU8*& address, PxDeserializationContext& context) const = 0;
//@}
/**********************************************************************************************************************/
virtual ~PxSerializer() {}
};
/**
\brief Default PxSerializer implementation.
*/
template<class T>
class PxSerializerDefaultAdapter : public PxSerializer
{
public:
/************************************************************************************************/
/** @name Basics needed for Binary- and RepX-Serialization
*/
//@{
PxSerializerDefaultAdapter(const char* name) : mTypeName(name){}
virtual const char* getConcreteTypeName() const
{
return mTypeName;
}
virtual void requiresObjects(PxBase& obj, PxProcessPxBaseCallback& c) const
{
T& t = static_cast<T&>(obj);
t.requiresObjects(c);
}
virtual bool isSubordinate() const
{
return false;
}
//@}
/************************************************************************************************/
/** @name Functionality needed for Binary Serialization only
*/
//@{
// object methods
virtual void exportExtraData(PxBase& obj, PxSerializationContext& s) const
{
T& t = static_cast<T&>(obj);
t.exportExtraData(s);
}
virtual void exportData(PxBase& obj, PxSerializationContext& s) const
{
PxAllocatorCallback& allocator = *PxGetAllocatorCallback();
T* copy = reinterpret_cast<T*>(allocator.allocate(sizeof(T), "TmpAllocExportData", PX_FL));
PxMemCopy(copy, &obj, sizeof(T));
copy->preExportDataReset();
s.writeData(copy, sizeof(T));
allocator.deallocate(copy);
}
virtual void registerReferences(PxBase& obj, PxSerializationContext& s) const
{
T& t = static_cast<T&>(obj);
s.registerReference(obj, PX_SERIAL_REF_KIND_PXBASE, size_t(&obj));
struct RequiresCallback : public PxProcessPxBaseCallback
{
RequiresCallback(PxSerializationContext& c) : context(c) {}
RequiresCallback& operator=(RequiresCallback&) { PX_ASSERT(0); return *this; }
void process(physx::PxBase& base)
{
context.registerReference(base, PX_SERIAL_REF_KIND_PXBASE, size_t(&base));
}
PxSerializationContext& context;
};
RequiresCallback callback(s);
t.requiresObjects(callback);
}
// class methods
virtual size_t getClassSize() const
{
return sizeof(T);
}
virtual PxBase* createObject(PxU8*& address, PxDeserializationContext& context) const
{
return T::createObject(address, context);
}
//@}
/************************************************************************************************/
private:
const char* mTypeName;
};
/**
\brief Preprocessor Macro to simplify adapter creation.
Note: that the allocator used for creation needs to match with the one used in PX_DELETE_SERIALIZER_ADAPTER.
*/
#define PX_NEW_SERIALIZER_ADAPTER(x) \
*new( PxGetAllocatorCallback()->allocate(sizeof(PxSerializerDefaultAdapter<x>), \
"PxSerializerDefaultAdapter", PX_FL)) PxSerializerDefaultAdapter<x>(#x)
/**
\brief Preprocessor Macro to simplify adapter deletion.
*/
#define PX_DELETE_SERIALIZER_ADAPTER(x) \
{ PxSerializer* s = x; if (s) { s->~PxSerializer(); PxGetAllocatorCallback()->deallocate(s); } }
#if !PX_DOXYGEN
} // namespace physx
#endif
/** @} */
#endif
| 8,397 | C | 30.810606 | 121 | 0.660831 |
NVIDIA-Omniverse/PhysX/physx/include/common/PxMetaDataFlags.h | // 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-2023 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 PX_METADATA_FLAGS_H
#define PX_METADATA_FLAGS_H
#include "foundation/Px.h"
#if !PX_DOXYGEN
namespace physx
{
#endif
/**
\brief Flags used to configure binary meta data entries, typically set through PX_DEF_BIN_METADATA defines.
@see PxMetaDataEntry
*/
struct PxMetaDataFlag
{
enum Enum
{
eCLASS = (1<<0), //!< declares a class
eVIRTUAL = (1<<1), //!< declares class to be virtual
eTYPEDEF = (1<<2), //!< declares a typedef
ePTR = (1<<3), //!< declares a pointer
eHANDLE = (1<<4), //!< declares a handle
eEXTRA_DATA = (1<<5), //!< declares extra data exported with PxSerializer::exportExtraData
eEXTRA_ITEM = (1<<6), //!< specifies one element of extra data
eEXTRA_ITEMS = (1<<7), //!< specifies an array of extra data
eEXTRA_NAME = (1<<8), //!< specifies a name of extra data
eUNION = (1<<9), //!< declares a union
ePADDING = (1<<10), //!< declares explicit padding data
eALIGNMENT = (1<<11), //!< declares aligned data
eCOUNT_MASK_MSB = (1<<12), //!< specifies that the count value's most significant bit needs to be masked out
eCOUNT_SKIP_IF_ONE = (1<<13), //!< specifies that the count value is treated as zero for a variable value of one - special case for single triangle meshes
eCONTROL_FLIP = (1<<14), //!< specifies that the control value is the negate of the variable value
eCONTROL_MASK = (1<<15), //!< specifies that the control value is masked - mask bits are assumed to be within eCONTROL_MASK_RANGE
eCONTROL_MASK_RANGE = 0x000000FF, //!< mask range allowed for eCONTROL_MASK
eFORCE_DWORD = 0x7fffffff
};
};
#if !PX_DOXYGEN
}
#endif
#endif
| 3,415 | C | 45.162162 | 159 | 0.702196 |
NVIDIA-Omniverse/PhysX/physx/include/common/PxTolerancesScale.h | // 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-2023 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 PX_TOLERANCES_SCALE_H
#define PX_TOLERANCES_SCALE_H
/** \addtogroup common
@{
*/
#include "common/PxPhysXCommonConfig.h"
#if !PX_DOXYGEN
namespace physx
{
#endif
/**
\brief Class to define the scale at which simulation runs. Most simulation tolerances are
calculated in terms of the values here.
\note if you change the simulation scale, you will probably also wish to change the scene's
default value of gravity, and stable simulation will probably require changes to the scene's
bounceThreshold also.
*/
class PxTolerancesScale
{
public:
/**
\brief The approximate size of objects in the simulation.
For simulating roughly human-sized in metric units, 1 is a good choice.
If simulation is done in centimetres, use 100 instead. This is used to
estimate certain length-related tolerances.
*/
PxReal length;
/**
\brief The typical magnitude of velocities of objects in simulation. This is used to estimate
whether a contact should be treated as bouncing or resting based on its impact velocity,
and a kinetic energy threshold below which the simulation may put objects to sleep.
For normal physical environments, a good choice is the approximate speed of an object falling
under gravity for one second.
*/
PxReal speed;
/**
\brief constructor sets to default
\param[in] defaultLength Default length
\param[in] defaultSpeed Default speed
*/
PX_INLINE explicit PxTolerancesScale(float defaultLength=1.0f, float defaultSpeed=10.0f);
/**
\brief Returns true if the descriptor is valid.
\return true if the current settings are valid (returns always true).
*/
PX_INLINE bool isValid() const;
};
PX_INLINE PxTolerancesScale::PxTolerancesScale(float defaultLength, float defaultSpeed) :
length (defaultLength),
speed (defaultSpeed)
{
}
PX_INLINE bool PxTolerancesScale::isValid() const
{
return length>0.0f;
}
#if !PX_DOXYGEN
} // namespace physx
#endif
/** @} */
#endif
| 3,629 | C | 32.611111 | 95 | 0.761091 |
NVIDIA-Omniverse/PhysX/physx/include/common/PxRenderOutput.h | // 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-2023 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 PX_RENDER_OUTPUT_H
#define PX_RENDER_OUTPUT_H
#include "foundation/PxMat44.h"
#include "foundation/PxBasicTemplates.h"
#include "PxRenderBuffer.h"
#if !PX_DOXYGEN
namespace physx
{
#endif
#if PX_VC
#pragma warning(push)
#pragma warning( disable : 4251 ) // class needs to have dll-interface to be used by clients of class
#endif
/**
Output stream to fill RenderBuffer
*/
class PxRenderOutput
{
public:
enum Primitive
{
POINTS,
LINES,
LINESTRIP,
TRIANGLES,
TRIANGLESTRIP
};
PxRenderOutput(PxRenderBuffer& buffer)
: mPrim(POINTS),
mColor(0),
mVertex0(0.0f),
mVertex1(0.0f),
mVertexCount(0),
mTransform(PxIdentity),
mBuffer(buffer)
{
}
PX_INLINE PxRenderOutput& operator<<(Primitive prim);
PX_INLINE PxRenderOutput& operator<<(PxU32 color) ;
PX_INLINE PxRenderOutput& operator<<(const PxMat44& transform);
PX_INLINE PxRenderOutput& operator<<(const PxTransform& t);
PX_INLINE PxRenderOutput& operator<<(const PxVec3& vertex); //AM: Don't use this! Slow! Deprecated!
PX_INLINE PxDebugLine* reserveSegments(PxU32 nbSegments);
PX_INLINE PxDebugPoint* reservePoints(PxU32 nbSegments);
PX_INLINE void outputSegment(const PxVec3& v0, const PxVec3& v1);
PX_INLINE PxRenderOutput& outputCapsule(PxF32 radius, PxF32 halfHeight, const PxMat44& absPose);
private:
PxRenderOutput& operator=(const PxRenderOutput&);
Primitive mPrim;
PxU32 mColor;
PxVec3 mVertex0, mVertex1;
PxU32 mVertexCount;
PxMat44 mTransform;
PxRenderBuffer& mBuffer;
};
struct PxDebugBox
{
explicit PxDebugBox(const PxVec3& extents, bool wireframe_ = true)
: minimum(-extents), maximum(extents), wireframe(wireframe_) {}
explicit PxDebugBox(const PxVec3& pos, const PxVec3& extents, bool wireframe_ = true)
: minimum(pos - extents), maximum(pos + extents), wireframe(wireframe_) {}
explicit PxDebugBox(const PxBounds3& bounds, bool wireframe_ = true)
: minimum(bounds.minimum), maximum(bounds.maximum), wireframe(wireframe_) {}
PxVec3 minimum, maximum;
bool wireframe;
};
PX_FORCE_INLINE PxRenderOutput& operator<<(PxRenderOutput& out, const PxDebugBox& box)
{
if (box.wireframe)
{
out << PxRenderOutput::LINESTRIP;
out << PxVec3(box.minimum.x, box.minimum.y, box.minimum.z);
out << PxVec3(box.maximum.x, box.minimum.y, box.minimum.z);
out << PxVec3(box.maximum.x, box.maximum.y, box.minimum.z);
out << PxVec3(box.minimum.x, box.maximum.y, box.minimum.z);
out << PxVec3(box.minimum.x, box.minimum.y, box.minimum.z);
out << PxVec3(box.minimum.x, box.minimum.y, box.maximum.z);
out << PxVec3(box.maximum.x, box.minimum.y, box.maximum.z);
out << PxVec3(box.maximum.x, box.maximum.y, box.maximum.z);
out << PxVec3(box.minimum.x, box.maximum.y, box.maximum.z);
out << PxVec3(box.minimum.x, box.minimum.y, box.maximum.z);
out << PxRenderOutput::LINES;
out << PxVec3(box.maximum.x, box.minimum.y, box.minimum.z);
out << PxVec3(box.maximum.x, box.minimum.y, box.maximum.z);
out << PxVec3(box.maximum.x, box.maximum.y, box.minimum.z);
out << PxVec3(box.maximum.x, box.maximum.y, box.maximum.z);
out << PxVec3(box.minimum.x, box.maximum.y, box.minimum.z);
out << PxVec3(box.minimum.x, box.maximum.y, box.maximum.z);
}
else
{
out << PxRenderOutput::TRIANGLESTRIP;
out << PxVec3(box.minimum.x, box.minimum.y, box.minimum.z); // 0
out << PxVec3(box.minimum.x, box.maximum.y, box.minimum.z); // 2
out << PxVec3(box.maximum.x, box.minimum.y, box.minimum.z); // 1
out << PxVec3(box.maximum.x, box.maximum.y, box.minimum.z); // 3
out << PxVec3(box.maximum.x, box.maximum.y, box.maximum.z); // 7
out << PxVec3(box.minimum.x, box.maximum.y, box.minimum.z); // 2
out << PxVec3(box.minimum.x, box.maximum.y, box.maximum.z); // 6
out << PxVec3(box.minimum.x, box.minimum.y, box.minimum.z); // 0
out << PxVec3(box.minimum.x, box.minimum.y, box.maximum.z); // 4
out << PxVec3(box.maximum.x, box.minimum.y, box.minimum.z); // 1
out << PxVec3(box.maximum.x, box.minimum.y, box.maximum.z); // 5
out << PxVec3(box.maximum.x, box.maximum.y, box.maximum.z); // 7
out << PxVec3(box.minimum.x, box.minimum.y, box.maximum.z); // 4
out << PxVec3(box.minimum.x, box.maximum.y, box.maximum.z); // 6
}
return out;
}
struct PxDebugArrow
{
PxDebugArrow(const PxVec3& pos, const PxVec3& vec)
: base(pos), tip(pos + vec), headLength(vec.magnitude()*0.15f) {}
PxDebugArrow(const PxVec3& pos, const PxVec3& vec, PxReal headLength_)
: base(pos), tip(pos + vec), headLength(headLength_) {}
PxVec3 base, tip;
PxReal headLength;
};
PX_FORCE_INLINE void normalToTangents(const PxVec3& normal, PxVec3& tangent0, PxVec3& tangent1)
{
tangent0 = PxAbs(normal.x) < 0.70710678f ? PxVec3(0, -normal.z, normal.y) : PxVec3(-normal.y, normal.x, 0);
tangent0.normalize();
tangent1 = normal.cross(tangent0);
}
PX_FORCE_INLINE PxRenderOutput& operator<<(PxRenderOutput& out, const PxDebugArrow& arrow)
{
PxVec3 t0 = arrow.tip - arrow.base, t1, t2;
t0.normalize();
normalToTangents(t0, t1, t2);
const PxReal tipAngle = 0.25f;
t1 *= arrow.headLength * tipAngle;
t2 *= arrow.headLength * tipAngle * PxSqrt(3.0f);
PxVec3 headBase = arrow.tip - t0 * arrow.headLength;
out << PxRenderOutput::LINES;
out << arrow.base << arrow.tip;
out << PxRenderOutput::TRIANGLESTRIP;
out << arrow.tip;
out << headBase + t1 + t1;
out << headBase - t1 - t2;
out << headBase - t1 + t2;
out << arrow.tip;
out << headBase + t1 + t1;
return out;
}
struct PxDebugBasis
{
PxDebugBasis(const PxVec3& ext, PxU32 cX = PxU32(PxDebugColor::eARGB_RED),
PxU32 cY = PxU32(PxDebugColor::eARGB_GREEN), PxU32 cZ = PxU32(PxDebugColor::eARGB_BLUE))
: extends(ext), colorX(cX), colorY(cY), colorZ(cZ) {}
PxVec3 extends;
PxU32 colorX, colorY, colorZ;
};
PX_FORCE_INLINE PxRenderOutput& operator<<(PxRenderOutput& out, const PxDebugBasis& basis)
{
const PxReal headLength = basis.extends.magnitude() * 0.15f;
out << basis.colorX << PxDebugArrow(PxVec3(0.0f), PxVec3(basis.extends.x, 0, 0), headLength);
out << basis.colorY << PxDebugArrow(PxVec3(0.0f), PxVec3(0, basis.extends.y, 0), headLength);
out << basis.colorZ << PxDebugArrow(PxVec3(0.0f), PxVec3(0, 0, basis.extends.z), headLength);
return out;
}
struct PxDebugCircle
{
PxDebugCircle(PxU32 s, PxReal r)
: nSegments(s), radius(r) {}
PxU32 nSegments;
PxReal radius;
};
PX_FORCE_INLINE PxRenderOutput& operator<<(PxRenderOutput& out, const PxDebugCircle& circle)
{
const PxF32 step = PxTwoPi / PxF32(circle.nSegments);
PxF32 angle = 0;
out << PxRenderOutput::LINESTRIP;
for (PxU32 i = 0; i < circle.nSegments; i++, angle += step)
out << PxVec3(circle.radius * PxSin(angle), circle.radius * PxCos(angle), 0);
out << PxVec3(0, circle.radius, 0);
return out;
}
struct PxDebugArc
{
PxDebugArc(PxU32 s, PxReal r, PxReal minAng, PxReal maxAng)
: nSegments(s), radius(r), minAngle(minAng), maxAngle(maxAng) {}
PxU32 nSegments;
PxReal radius;
PxReal minAngle, maxAngle;
};
PX_FORCE_INLINE PxRenderOutput& operator<<(PxRenderOutput& out, const PxDebugArc& arc)
{
const PxF32 step = (arc.maxAngle - arc.minAngle) / PxF32(arc.nSegments);
PxF32 angle = arc.minAngle;
out << PxRenderOutput::LINESTRIP;
for (PxU32 i = 0; i < arc.nSegments; i++, angle += step)
out << PxVec3(arc.radius * PxSin(angle), arc.radius * PxCos(angle), 0);
out << PxVec3(arc.radius * PxSin(arc.maxAngle), arc.radius * PxCos(arc.maxAngle), 0);
return out;
}
PX_INLINE PxRenderOutput& PxRenderOutput::operator<<(Primitive prim)
{
mPrim = prim;
mVertexCount = 0;
return *this;
}
PX_INLINE PxRenderOutput& PxRenderOutput::operator<<(PxU32 color)
{
mColor = color;
return *this;
}
PX_INLINE PxRenderOutput& PxRenderOutput::operator<<(const PxMat44& transform)
{
mTransform = transform;
return *this;
}
PX_INLINE PxRenderOutput& PxRenderOutput::operator<<(const PxTransform& t)
{
mTransform = PxMat44(t);
return *this;
}
PX_INLINE PxRenderOutput& PxRenderOutput::operator<<(const PxVec3& vertexIn)
{
// apply transformation
const PxVec3 vertex = mTransform.transform(vertexIn);
++mVertexCount;
// add primitive to render buffer
switch (mPrim)
{
case POINTS:
mBuffer.addPoint(PxDebugPoint(vertex, mColor)); break;
case LINES:
if (mVertexCount == 2)
{
mBuffer.addLine(PxDebugLine(mVertex0, vertex, mColor));
mVertexCount = 0;
}
break;
case LINESTRIP:
if (mVertexCount >= 2)
mBuffer.addLine(PxDebugLine(mVertex0, vertex, mColor));
break;
case TRIANGLES:
if (mVertexCount == 3)
{
mBuffer.addTriangle(PxDebugTriangle(mVertex1, mVertex0, vertex, mColor));
mVertexCount = 0;
}
break;
case TRIANGLESTRIP:
if (mVertexCount >= 3)
mBuffer.addTriangle(PxDebugTriangle(
(mVertexCount & 0x1) ? mVertex0 : mVertex1,
(mVertexCount & 0x1) ? mVertex1 : mVertex0, vertex, mColor));
break;
}
// cache the last 2 vertices (for strips)
if (1 < mVertexCount)
{
mVertex1 = mVertex0;
mVertex0 = vertex;
}
else
{
mVertex0 = vertex;
}
return *this;
}
PX_INLINE PxDebugLine* PxRenderOutput::reserveSegments(PxU32 nbSegments)
{
return mBuffer.reserveLines(nbSegments);
}
PX_INLINE PxDebugPoint* PxRenderOutput::reservePoints(PxU32 nbPoints)
{
return mBuffer.reservePoints(nbPoints);
}
// PT: using the operators is just too slow.
PX_INLINE void PxRenderOutput::outputSegment(const PxVec3& v0, const PxVec3& v1)
{
PxDebugLine* segment = mBuffer.reserveLines(1);
segment->pos0 = v0;
segment->pos1 = v1;
segment->color0 = segment->color1 = mColor;
}
PX_INLINE PxRenderOutput& PxRenderOutput::outputCapsule(PxF32 radius, PxF32 halfHeight, const PxMat44& absPose)
{
PxRenderOutput& out = *this;
const PxVec3 vleft2(-halfHeight, 0.0f, 0.0f);
PxMat44 left2 = absPose;
left2.column3 += PxVec4(left2.rotate(vleft2), 0.0f);
out << left2 << PxDebugArc(100, radius, PxPi, PxTwoPi);
PxMat44 rotPose = left2;
PxSwap(rotPose.column1, rotPose.column2);
rotPose.column1 = -rotPose.column1;
out << rotPose << PxDebugArc(100, radius, PxPi, PxTwoPi);
PxSwap(rotPose.column0, rotPose.column2);
rotPose.column0 = -rotPose.column0;
out << rotPose << PxDebugCircle(100, radius);
const PxVec3 vright2(halfHeight, 0.0f, 0.0f);
PxMat44 right2 = absPose;
right2.column3 += PxVec4(right2.rotate(vright2), 0.0f);
out << right2 << PxDebugArc(100, radius, 0.0f, PxPi);
rotPose = right2;
PxSwap(rotPose.column1, rotPose.column2);
rotPose.column1 = -rotPose.column1;
out << rotPose << PxDebugArc(100, radius, 0.0f, PxPi);
PxSwap(rotPose.column0, rotPose.column2);
rotPose.column0 = -rotPose.column0;
out << rotPose << PxDebugCircle(100, radius);
out << absPose;
out.outputSegment(absPose.transform(PxVec3(-halfHeight, radius, 0)),
absPose.transform(PxVec3(halfHeight, radius, 0)));
out.outputSegment(absPose.transform(PxVec3(-halfHeight, -radius, 0)),
absPose.transform(PxVec3(halfHeight, -radius, 0)));
out.outputSegment(absPose.transform(PxVec3(-halfHeight, 0, radius)),
absPose.transform(PxVec3(halfHeight, 0, radius)));
out.outputSegment(absPose.transform(PxVec3(-halfHeight, 0, -radius)),
absPose.transform(PxVec3(halfHeight, 0, -radius)));
return *this;
}
#if PX_VC
#pragma warning(pop)
#endif
#if !PX_DOXYGEN
} // namespace physx
#endif
#endif
| 13,153 | C | 31.479012 | 112 | 0.699156 |
NVIDIA-Omniverse/PhysX/physx/include/common/PxMetaData.h | // 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-2023 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 PX_METADATA_H
#define PX_METADATA_H
/** \addtogroup physics
@{
*/
#include "foundation/Px.h"
#include "foundation/PxIO.h"
#include "PxMetaDataFlags.h"
#if !PX_DOXYGEN
namespace physx
{
#endif
/**
\brief Struct to store meta data definitions.
Note: The individual fields have different meaning depending on the meta data entry configuration.
*/
struct PxMetaDataEntry
{
const char* type; //!< Field type (bool, byte, quaternion, etc)
const char* name; //!< Field name (appears exactly as in the source file)
PxU32 offset; //!< Offset from the start of the class (ie from "this", field is located at "this"+Offset)
PxU32 size; //!< sizeof(Type)
PxU32 count; //!< Number of items of type Type (0 for dynamic sizes)
PxU32 offsetSize; //!< Offset of dynamic size param, for dynamic arrays
PxU32 flags; //!< Field parameters
PxU32 alignment; //!< Explicit alignment
};
#define PX_STORE_METADATA(stream, metaData) stream.write(&metaData, sizeof(PxMetaDataEntry))
#define PX_SIZE_OF(Class, Member) sizeof((reinterpret_cast<Class*>(0))->Member)
/**
\brief specifies a binary metadata entry for a member variable of a class
*/
#define PX_DEF_BIN_METADATA_ITEM(stream, Class, type, name, flags) \
{ \
PxMetaDataEntry tmp = { #type, #name, PxU32(PX_OFFSET_OF_RT(Class, name)), PX_SIZE_OF(Class, name), \
1, 0, flags, 0}; \
PX_STORE_METADATA(stream, tmp); \
}
/**
\brief specifies a binary metadata entry for a member array variable of a class
\details similar to PX_DEF_BIN_METADATA_ITEMS_AUTO but for cases with mismatch between specified type and array type
*/
#define PX_DEF_BIN_METADATA_ITEMS(stream, Class, type, name, flags, count) \
{ \
PxMetaDataEntry tmp = { #type, #name, PxU32(PX_OFFSET_OF_RT(Class, name)), PX_SIZE_OF(Class, name), \
count, 0, flags, 0}; \
PX_STORE_METADATA(stream, tmp); \
}
/**
\brief specifies a binary metadata entry for a member array variable of a class
\details similar to PX_DEF_BIN_METADATA_ITEMS but automatically detects the array length, which only works when the specified
type matches the type of the array - does not support PxMetaDataFlag::ePTR
*/
#define PX_DEF_BIN_METADATA_ITEMS_AUTO(stream, Class, type, name, flags) \
{ \
PxMetaDataEntry tmp = { #type, #name, PxU32(PX_OFFSET_OF_RT(Class, name)), PX_SIZE_OF(Class, name), \
sizeof((reinterpret_cast<Class*>(0))->name)/sizeof(type), 0, flags, 0}; \
PX_STORE_METADATA(stream, tmp); \
}
/**
\brief specifies a binary metadata entry for a class
*/
#define PX_DEF_BIN_METADATA_CLASS(stream, Class) \
{ \
PxMetaDataEntry tmp = { #Class, 0, 0, sizeof(Class), 0, 0, PxMetaDataFlag::eCLASS, 0 }; \
PX_STORE_METADATA(stream, tmp); \
}
/**
\brief specifies a binary metadata entry for a virtual class
*/
#define PX_DEF_BIN_METADATA_VCLASS(stream, Class) \
{ \
PxMetaDataEntry tmp = { #Class, 0, 0, sizeof(Class), 0, 0, PxMetaDataFlag::eCLASS|PxMetaDataFlag::eVIRTUAL, 0}; \
PX_STORE_METADATA(stream, tmp); \
}
/**
\brief specifies a binary metadata entry for a typedef
*/
#define PX_DEF_BIN_METADATA_TYPEDEF(stream, newType, oldType) \
{ \
PxMetaDataEntry tmp = { #newType, #oldType, 0, 0, 0, 0, PxMetaDataFlag::eTYPEDEF, 0 }; \
PX_STORE_METADATA(stream, tmp); \
}
/**
\brief specifies a binary metadata entry for declaring a base class
*/
#define PX_DEF_BIN_METADATA_BASE_CLASS(stream, Class, BaseClass) \
{ \
Class* myClass = reinterpret_cast<Class*>(42); \
BaseClass* s = static_cast<BaseClass*>(myClass); \
const PxU32 offset = PxU32(size_t(s) - size_t(myClass)); \
PxMetaDataEntry tmp = { #Class, #BaseClass, offset, sizeof(Class), 0, 0, PxMetaDataFlag::eCLASS, 0 }; \
PX_STORE_METADATA(stream, tmp); \
}
/**
\brief specifies a binary metadata entry for a union
*/
#define PX_DEF_BIN_METADATA_UNION(stream, Class, name) \
{ \
PxMetaDataEntry tmp = { #Class, 0, PxU32(PX_OFFSET_OF_RT(Class, name)), PX_SIZE_OF(Class, name), \
1, 0, PxMetaDataFlag::eUNION, 0 }; \
PX_STORE_METADATA(stream, tmp); \
}
/**
\brief specifies a binary metadata entry for a particular member type of a union
*/
#define PX_DEF_BIN_METADATA_UNION_TYPE(stream, Class, type, enumValue) \
{ \
PxMetaDataEntry tmp = { #Class, #type, enumValue, 0, 0, 0, PxMetaDataFlag::eUNION, 0 }; \
PX_STORE_METADATA(stream, tmp); \
}
/**
\brief specifies a binary metadata entry for extra data
*/
#define PX_DEF_BIN_METADATA_EXTRA_ITEM(stream, Class, type, control, align) \
{ \
PxMetaDataEntry tmp = { #type, 0, PxU32(PX_OFFSET_OF_RT(Class, control)), sizeof(type), 0, PxU32(PX_SIZE_OF(Class, control)), \
PxMetaDataFlag::eEXTRA_DATA|PxMetaDataFlag::eEXTRA_ITEM, align }; \
PX_STORE_METADATA(stream, tmp); \
}
/**
\brief specifies a binary metadata entry for an array of extra data
*/
#define PX_DEF_BIN_METADATA_EXTRA_ITEMS(stream, Class, type, control, count, flags, align) \
{ \
PxMetaDataEntry tmp = { #type, 0, PxU32(PX_OFFSET_OF_RT(Class, control)), PxU32(PX_SIZE_OF(Class, control)), \
PxU32(PX_OFFSET_OF_RT(Class, count)), PxU32(PX_SIZE_OF(Class, count)), \
PxMetaDataFlag::eEXTRA_DATA|PxMetaDataFlag::eEXTRA_ITEMS|flags, align }; \
PX_STORE_METADATA(stream, tmp); \
}
/**
\brief specifies a binary metadata entry for an array of extra data
additional to PX_DEF_BIN_METADATA_EXTRA_ITEMS a mask can be specified to interpret the control value
@see PxMetaDataFlag::eCONTROL_MASK
*/
#define PX_DEF_BIN_METADATA_EXTRA_ITEMS_MASKED_CONTROL(stream, Class, type, control, controlMask ,count, flags, align) \
{ \
PxMetaDataEntry tmp = { #type, 0, PxU32(PX_OFFSET_OF_RT(Class, control)), PxU32(PX_SIZE_OF(Class, control)), \
PxU32(PX_OFFSET_OF_RT(Class, count)), PxU32(PX_SIZE_OF(Class, count)), \
PxMetaDataFlag::eCONTROL_MASK|PxMetaDataFlag::eEXTRA_DATA|PxMetaDataFlag::eEXTRA_ITEMS|flags|(controlMask & PxMetaDataFlag::eCONTROL_MASK_RANGE) << 16, \
align}; \
PX_STORE_METADATA(stream, tmp); \
}
/**
\brief specifies a binary metadata entry for an array of extra data
\details similar to PX_DEF_BIN_METADATA_EXTRA_ITEMS, but supporting no control - PxMetaDataFlag::ePTR is also not supported
*/
#define PX_DEF_BIN_METADATA_EXTRA_ARRAY(stream, Class, type, dyn_count, align, flags) \
{ \
PxMetaDataEntry tmp = { #type, 0, PxU32(PX_OFFSET_OF_RT(Class, dyn_count)), PX_SIZE_OF(Class, dyn_count), align, 0, \
PxMetaDataFlag::eEXTRA_DATA|flags, align }; \
PX_STORE_METADATA(stream, tmp); \
}
/**
\brief specifies a binary metadata entry for an string of extra data
*/
#define PX_DEF_BIN_METADATA_EXTRA_NAME(stream, Class, control, align) \
{ \
PxMetaDataEntry tmp = { "char", "string", 0, 0, 0, 0, PxMetaDataFlag::eEXTRA_DATA|PxMetaDataFlag::eEXTRA_NAME, align }; \
PX_STORE_METADATA(stream, tmp); \
}
/**
\brief specifies a binary metadata entry declaring an extra data alignment for a class
*/
#define PX_DEF_BIN_METADATA_EXTRA_ALIGN(stream, Class, align) \
{ \
PxMetaDataEntry tmp = { "PxU8", "Alignment", 0, 0, 0, 0, PxMetaDataFlag::eEXTRA_DATA|PxMetaDataFlag::eALIGNMENT, align}; \
PX_STORE_METADATA(stream, tmp); \
}
#if !PX_DOXYGEN
} // namespace physx
#endif
/** @} */
#endif
| 9,013 | C | 38.709251 | 160 | 0.695329 |
NVIDIA-Omniverse/PhysX/physx/include/common/PxTypeInfo.h | // 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-2023 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 PX_TYPE_INFO_H
#define PX_TYPE_INFO_H
/** \addtogroup common
@{
*/
#include "common/PxPhysXCommonConfig.h"
#if !PX_DOXYGEN
namespace physx
{
#endif
/**
\brief an enumeration of concrete classes inheriting from PxBase
Enumeration space is reserved for future PhysX core types, PhysXExtensions,
PhysXVehicle and Custom application types.
@see PxBase, PxTypeInfo
*/
struct PxConcreteType
{
enum Enum
{
eUNDEFINED,
eHEIGHTFIELD,
eCONVEX_MESH,
eTRIANGLE_MESH_BVH33, // PX_DEPRECATED
eTRIANGLE_MESH_BVH34,
eTETRAHEDRON_MESH,
eSOFTBODY_MESH,
eRIGID_DYNAMIC,
eRIGID_STATIC,
eSHAPE,
eMATERIAL,
eSOFTBODY_MATERIAL,
eCLOTH_MATERIAL,
ePBD_MATERIAL,
eFLIP_MATERIAL,
eMPM_MATERIAL,
eCONSTRAINT,
eAGGREGATE,
eARTICULATION_REDUCED_COORDINATE,
eARTICULATION_LINK,
eARTICULATION_JOINT_REDUCED_COORDINATE,
eARTICULATION_SENSOR,
eARTICULATION_SPATIAL_TENDON,
eARTICULATION_FIXED_TENDON,
eARTICULATION_ATTACHMENT,
eARTICULATION_TENDON_JOINT,
ePRUNING_STRUCTURE,
eBVH,
eSOFT_BODY,
eSOFT_BODY_STATE,
ePBD_PARTICLESYSTEM,
eFLIP_PARTICLESYSTEM,
eMPM_PARTICLESYSTEM,
eFEM_CLOTH,
eHAIR_SYSTEM,
ePARTICLE_BUFFER,
ePARTICLE_DIFFUSE_BUFFER,
ePARTICLE_CLOTH_BUFFER,
ePARTICLE_RIGID_BUFFER,
ePHYSX_CORE_COUNT,
eFIRST_PHYSX_EXTENSION = 256,
eFIRST_VEHICLE_EXTENSION = 512,
eFIRST_USER_EXTENSION = 1024
};
};
/**
\brief a structure containing per-type information for types inheriting from PxBase
@see PxBase, PxConcreteType
*/
template<typename T> struct PxTypeInfo {};
#define PX_DEFINE_TYPEINFO(_name, _fastType) \
class _name; \
template <> struct PxTypeInfo<_name> { static const char* name() { return #_name; } enum { eFastTypeId = _fastType }; };
/* the semantics of the fastType are as follows: an object A can be cast to a type B if B's fastType is defined, and A has the same fastType.
* This implies that B has no concrete subclasses or superclasses.
*/
PX_DEFINE_TYPEINFO(PxBase, PxConcreteType::eUNDEFINED)
PX_DEFINE_TYPEINFO(PxMaterial, PxConcreteType::eMATERIAL)
PX_DEFINE_TYPEINFO(PxFEMSoftBodyMaterial, PxConcreteType::eSOFTBODY_MATERIAL)
PX_DEFINE_TYPEINFO(PxFEMClothMaterial, PxConcreteType::eCLOTH_MATERIAL)
PX_DEFINE_TYPEINFO(PxPBDMaterial, PxConcreteType::ePBD_MATERIAL)
PX_DEFINE_TYPEINFO(PxFLIPMaterial, PxConcreteType::eFLIP_MATERIAL)
PX_DEFINE_TYPEINFO(PxMPMMaterial, PxConcreteType::eMPM_MATERIAL)
PX_DEFINE_TYPEINFO(PxConvexMesh, PxConcreteType::eCONVEX_MESH)
PX_DEFINE_TYPEINFO(PxTriangleMesh, PxConcreteType::eUNDEFINED)
PX_DEFINE_TYPEINFO(PxBVH33TriangleMesh, PxConcreteType::eTRIANGLE_MESH_BVH33)
PX_DEFINE_TYPEINFO(PxBVH34TriangleMesh, PxConcreteType::eTRIANGLE_MESH_BVH34)
PX_DEFINE_TYPEINFO(PxTetrahedronMesh, PxConcreteType::eTETRAHEDRON_MESH)
PX_DEFINE_TYPEINFO(PxHeightField, PxConcreteType::eHEIGHTFIELD)
PX_DEFINE_TYPEINFO(PxActor, PxConcreteType::eUNDEFINED)
PX_DEFINE_TYPEINFO(PxRigidActor, PxConcreteType::eUNDEFINED)
PX_DEFINE_TYPEINFO(PxRigidBody, PxConcreteType::eUNDEFINED)
PX_DEFINE_TYPEINFO(PxRigidDynamic, PxConcreteType::eRIGID_DYNAMIC)
PX_DEFINE_TYPEINFO(PxRigidStatic, PxConcreteType::eRIGID_STATIC)
PX_DEFINE_TYPEINFO(PxArticulationLink, PxConcreteType::eARTICULATION_LINK)
PX_DEFINE_TYPEINFO(PxArticulationJointReducedCoordinate, PxConcreteType::eARTICULATION_JOINT_REDUCED_COORDINATE)
PX_DEFINE_TYPEINFO(PxArticulationReducedCoordinate, PxConcreteType::eARTICULATION_REDUCED_COORDINATE)
PX_DEFINE_TYPEINFO(PxAggregate, PxConcreteType::eAGGREGATE)
PX_DEFINE_TYPEINFO(PxConstraint, PxConcreteType::eCONSTRAINT)
PX_DEFINE_TYPEINFO(PxShape, PxConcreteType::eSHAPE)
PX_DEFINE_TYPEINFO(PxPruningStructure, PxConcreteType::ePRUNING_STRUCTURE)
PX_DEFINE_TYPEINFO(PxParticleSystem, PxConcreteType::eUNDEFINED)
PX_DEFINE_TYPEINFO(PxPBDParticleSystem, PxConcreteType::ePBD_PARTICLESYSTEM)
PX_DEFINE_TYPEINFO(PxFLIPParticleSystem, PxConcreteType::eFLIP_PARTICLESYSTEM)
PX_DEFINE_TYPEINFO(PxMPMParticleSystem, PxConcreteType::eMPM_PARTICLESYSTEM)
PX_DEFINE_TYPEINFO(PxSoftBody, PxConcreteType::eSOFT_BODY)
PX_DEFINE_TYPEINFO(PxFEMCloth, PxConcreteType::eFEM_CLOTH)
PX_DEFINE_TYPEINFO(PxHairSystem, PxConcreteType::eHAIR_SYSTEM)
PX_DEFINE_TYPEINFO(PxParticleBuffer, PxConcreteType::ePARTICLE_BUFFER)
PX_DEFINE_TYPEINFO(PxParticleAndDiffuseBuffer, PxConcreteType::ePARTICLE_DIFFUSE_BUFFER)
PX_DEFINE_TYPEINFO(PxParticleClothBuffer, PxConcreteType::ePARTICLE_CLOTH_BUFFER)
PX_DEFINE_TYPEINFO(PxParticleRigidBuffer, PxConcreteType::ePARTICLE_RIGID_BUFFER)
#if !PX_DOXYGEN
} // namespace physx
#endif
/** @} */
#endif
| 6,469 | C | 38.451219 | 141 | 0.765652 |
NVIDIA-Omniverse/PhysX/physx/include/common/PxStringTable.h | // 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-2023 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 PX_STRING_TABLE_H
#define PX_STRING_TABLE_H
#include "foundation/PxPreprocessor.h"
/** \addtogroup physics
@{
*/
#if !PX_DOXYGEN
namespace physx
{
#endif
/**
* \brief a table to manage strings. Strings allocated through this object are expected to be owned by this object.
*/
class PxStringTable
{
protected:
virtual ~PxStringTable(){}
public:
/**
* \brief Allocate a new string.
*
* \param[in] inSrc Source string, null terminated or null.
*
* \return *Always* a valid null terminated string. "" is returned if "" or null is passed in.
*/
virtual const char* allocateStr( const char* inSrc ) = 0;
/**
* Release the string table and all the strings associated with it.
*/
virtual void release() = 0;
};
#if !PX_DOXYGEN
} // namespace physx
#endif
/** @} */
#endif
| 2,503 | C | 33.777777 | 116 | 0.737515 |
NVIDIA-Omniverse/PhysX/physx/include/common/PxSerialFramework.h | // 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-2023 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 PX_SERIAL_FRAMEWORK_H
#define PX_SERIAL_FRAMEWORK_H
/** \addtogroup common
@{
*/
#include "common/PxPhysXCommonConfig.h"
#if !PX_DOXYGEN
namespace physx
{
#endif
typedef PxU16 PxType;
class PxBase;
class PxSerializationContext;
class PxRepXSerializer;
class PxSerializer;
class PxPhysics;
class PxCollection;
//! Default serialization alignment
#define PX_SERIAL_ALIGN 16
//! Serialized input data must be aligned to this value
#define PX_SERIAL_FILE_ALIGN 128
//! PxSerialObjectId value for objects that do not have an ID
#define PX_SERIAL_OBJECT_ID_INVALID 0
//! ID type for PxBase objects in a PxCollection
typedef PxU64 PxSerialObjectId;
//! Bit to mark pointer type references, @see PxDeserializationContext
#define PX_SERIAL_REF_KIND_PTR_TYPE_BIT (1u<<31)
//! Reference kind value for PxBase objects
#define PX_SERIAL_REF_KIND_PXBASE (0 | PX_SERIAL_REF_KIND_PTR_TYPE_BIT)
//! Reference kind value for material indices
#define PX_SERIAL_REF_KIND_MATERIAL_IDX (1)
//! Used to fix multi-byte characters warning from gcc for situations like: PxU32 foo = 'CCTS';
#define PX_MAKE_FOURCC(a, b, c, d) ( (a) | ((b)<<8) | ((c)<<16) | ((d)<<24) )
/**
\brief Callback class used to process PxBase objects.
@see PxSerializer::requires
*/
class PxProcessPxBaseCallback
{
public:
virtual ~PxProcessPxBaseCallback() {}
virtual void process(PxBase&) = 0;
};
/**
\brief Binary serialization context class.
This class is used to register reference values and write object
and object extra data during serialization.
It is mainly used by the serialization framework. Except for custom
serializable types, users should not have to worry about it.
@see PxDeserializationContext
*/
class PxSerializationContext
{
public:
/**
\brief Registers a reference value corresponding to a PxBase object.
This method is assumed to be called in the implementation of PxSerializer::registerReferences for serialized
references that need to be resolved on deserialization.
A reference needs to be associated with exactly one PxBase object in either the collection or the
external references collection.
Different kinds of references are supported and need to be specified. In the most common case
(PX_SERIAL_REF_KIND_PXBASE) the PxBase object matches the reference value (which is the pointer
to the PxBase object). Integer references maybe registered as well (used for internal material
indices with PX_SERIAL_REF_KIND_MATERIAL_IDX). Other kinds could be added with the restriction that
for pointer types the kind value needs to be marked with the PX_SERIAL_REF_KIND_PTR_TYPE_BIT.
\param[in] base PxBase object associated with the reference
\param[in] kind What kind of reference this is (PX_SERIAL_REF_KIND_PXBASE, PX_SERIAL_REF_KIND_MATERIAL_IDX or custom kind)
\param[in] reference Value of reference
@see PxDeserializationContext::resolveReference, PX_SERIAL_REF_KIND_PXBASE, PX_SERIAL_REF_KIND_MATERIAL_IDX, PxSerializer::registerReferences
*/
virtual void registerReference(PxBase& base, PxU32 kind, size_t reference) = 0;
/**
\brief Returns the collection that is being serialized.
*/
virtual const PxCollection& getCollection() const = 0;
/**
\brief Serializes object data and object extra data.
This function is assumed to be called within the implementation of PxSerializer::exportData and PxSerializer::exportExtraData.
@see PxSerializer::exportData, PxSerializer::exportExtraData, PxSerializer::createObject, PxDeserializationContext::readExtraData
*/
virtual void writeData(const void* data, PxU32 size) = 0;
/**
\brief Aligns the serialized data.
This function is assumed to be called within the implementation of PxSerializer::exportData and PxSerializer::exportExtraData.
@see PxSerializer::exportData, PxSerializer::exportExtraData, PxDeserializationContext::alignExtraData
*/
virtual void alignData(PxU32 alignment = PX_SERIAL_ALIGN) = 0;
/**
\brief Helper function to write a name to the extraData if serialization is configured to save names.
This function is assumed to be called within the implementation of PxSerializer::exportExtraData.
@see PxSerialization::serializeCollectionToBinary, PxDeserializationContext::readName
*/
virtual void writeName(const char* name) = 0;
protected:
PxSerializationContext() {}
virtual ~PxSerializationContext() {}
};
/**
\brief Binary deserialization context class.
This class is used to resolve references and access extra data during deserialization.
It is mainly used by the serialization framework. Except for custom
serializable types, users should not have to worry about it.
@see PxSerializationContext
*/
class PxDeserializationContext
{
public:
/**
\brief Retrieves a pointer to a deserialized PxBase object given a corresponding deserialized reference value
This method is assumed to be called in the implementation of PxSerializer::createObject in order
to update reference values on deserialization.
To update a PxBase reference the corresponding deserialized pointer value needs to be provided in order to retrieve
the location of the corresponding deserialized PxBase object. (PxDeserializationContext::translatePxBase simplifies
this common case).
For other kinds of references the reverence values need to be updated by deduction given the corresponding PxBase instance.
\param[in] kind What kind of reference this is (PX_SERIAL_REF_KIND_PXBASE, PX_SERIAL_REF_KIND_MATERIAL_IDX or custom kind)
\param[in] reference Deserialized reference value
\return PxBase object associated with the reference value
@see PxSerializationContext::registerReference, PX_SERIAL_REF_KIND_PXBASE, PX_SERIAL_REF_KIND_MATERIAL_IDX, translatePxBase
*/
virtual PxBase* resolveReference(PxU32 kind, size_t reference) const = 0;
/**
\brief Helper function to update PxBase pointer on deserialization
@see resolveReference, PX_SERIAL_REF_KIND_PXBASE
*/
template<typename T>
void translatePxBase(T*& base) { if (base) { base = static_cast<T*>(resolveReference(PX_SERIAL_REF_KIND_PXBASE, size_t(base))); } }
/**
\brief Helper function to read a name from the extra data during deserialization.
This function is assumed to be called within the implementation of PxSerializer::createObject.
@see PxSerializationContext::writeName
*/
PX_INLINE void readName(const char*& name)
{
PxU32 len = *reinterpret_cast<PxU32*>(mExtraDataAddress);
mExtraDataAddress += sizeof(len);
name = len ? reinterpret_cast<const char*>(mExtraDataAddress) : NULL;
mExtraDataAddress += len;
}
/**
\brief Function to read extra data during deserialization.
This function is assumed to be called within the implementation of PxSerializer::createObject.
@see PxSerializationContext::writeData, PxSerializer::createObject
*/
template<typename T>
PX_INLINE T* readExtraData(PxU32 count=1)
{
T* data = reinterpret_cast<T*>(mExtraDataAddress);
mExtraDataAddress += sizeof(T)*count;
return data;
}
/**
\brief Function to read extra data during deserialization optionally aligning the extra data stream before reading.
This function is assumed to be called within the implementation of PxSerializer::createObject.
@see PxSerializationContext::writeData, PxDeserializationContext::alignExtraData, PxSerializer::createObject
*/
template<typename T, PxU32 alignment>
PX_INLINE T* readExtraData(PxU32 count=1)
{
alignExtraData(alignment);
return readExtraData<T>(count);
}
/**
\brief Function to align the extra data stream to a power of 2 alignment
This function is assumed to be called within the implementation of PxSerializer::createObject.
@see PxSerializationContext::alignData, PxSerializer::createObject
*/
PX_INLINE void alignExtraData(PxU32 alignment = PX_SERIAL_ALIGN)
{
size_t addr = size_t(mExtraDataAddress);
addr = (addr+alignment-1)&~size_t(alignment-1);
mExtraDataAddress = reinterpret_cast<PxU8*>(addr);
}
protected:
PxDeserializationContext() {}
virtual ~PxDeserializationContext() {}
PxU8* mExtraDataAddress;
};
/**
\brief Callback type for exporting binary meta data for a serializable type.
\deprecated Binary conversion and binary meta data are deprecated.
@see PxSerializationRegistry::registerBinaryMetaDataCallback
\param stream Stream to store binary meta data.
*/
typedef PX_DEPRECATED void (*PxBinaryMetaDataCallback)(PxOutputStream& stream);
/**
\brief Class serving as a registry for XML (RepX) and binary serializable types.
In order to serialize and deserialize objects the application needs
to maintain an instance of this class. It can be created with
PxSerialization::createSerializationRegistry() and released with
PxSerializationRegistry::release().
@see PxSerialization::createSerializationRegistry
*/
class PxSerializationRegistry
{
public:
/************************************************************************************************/
/** @name Binary Serialization Functionality
*/
//@{
/**
\brief Register a serializer for a concrete type
\param type PxConcreteType corresponding to the serializer
\param serializer The PxSerializer to be registered
@see PxConcreteType, PxSerializer, PxSerializationRegistry::unregisterSerializer
*/
virtual void registerSerializer(PxType type, PxSerializer& serializer) = 0;
/**
\brief Unregister a serializer for a concrete type, and retrieves the corresponding serializer object.
\param type PxConcreteType for which the serializer should be unregistered
\return Unregistered serializer corresponding to type, NULL for types for which no serializer has been registered.
@see PxConcreteType, PxSerializationRegistry::registerSerializer, PxSerializationRegistry::release
*/
virtual PxSerializer* unregisterSerializer(PxType type) = 0;
/**
\brief Register binary meta data callback
\deprecated Binary conversion and binary meta data are deprecated.
The callback is executed when calling PxSerialization::dumpBinaryMetaData.
\param callback PxBinaryMetaDataCallback to be registered.
@see PxBinaryMetaDataCallback, PxSerialization::dumpBinaryMetaData
*/
PX_DEPRECATED virtual void registerBinaryMetaDataCallback(PxBinaryMetaDataCallback callback) = 0;
/**
\brief Returns PxSerializer corresponding to type
\param type PxConcreteType of the serializer requested.
\return Registered PxSerializer object corresponding to type
@see PxConcreteType
*/
virtual const PxSerializer* getSerializer(PxType type) const = 0;
//@}
/************************************************************************************************/
/** @name RepX (XML) Serialization Functionality
*/
//@{
/**
\brief Register a RepX serializer for a concrete type
\deprecated Xml serialization is deprecated. An alternative serialization system is provided through USD Physics.
\param type PxConcreteType corresponding to the RepX serializer
\param serializer The PxRepXSerializer to be registered
@see PxConcreteType, PxRepXSerializer
*/
PX_DEPRECATED virtual void registerRepXSerializer(PxType type, PxRepXSerializer& serializer) = 0;
/**
\brief Unregister a RepX serializer for a concrete type, and retrieves the corresponding serializer object.
\deprecated Xml serialization is deprecated. An alternative serialization system is provided through USD Physics.
\param type PxConcreteType for which the RepX serializer should be unregistered
\return Unregistered PxRepxSerializer corresponding to type, NULL for types for which no RepX serializer has been registered.
@see PxConcreteType, PxSerializationRegistry::registerRepXSerializer, PxSerializationRegistry::release
*/
PX_DEPRECATED virtual PxRepXSerializer* unregisterRepXSerializer(PxType type) = 0;
/**
\brief Returns RepX serializer given the corresponding type name
\deprecated Xml serialization is deprecated. An alternative serialization system is provided through USD Physics.
\param typeName Name of the type
\return Registered PxRepXSerializer object corresponding to type name
@see PxRepXSerializer, PxTypeInfo, PX_DEFINE_TYPEINFO
*/
PX_DEPRECATED virtual PxRepXSerializer* getRepXSerializer(const char* typeName) const = 0;
//@}
/************************************************************************************************/
/**
\brief Releases PxSerializationRegistry instance.
This unregisters all PhysX and PhysXExtension serializers. Make sure to unregister all custom type
serializers before releasing the PxSerializationRegistry.
@see PxSerializationRegistry::unregisterSerializer, PxSerializationRegistry::unregisterRepXSerializer
*/
virtual void release() = 0;
protected:
virtual ~PxSerializationRegistry(){}
};
#if !PX_DOXYGEN
} // namespace physx
#endif
/** @} */
#endif
| 14,566 | C | 34.616137 | 142 | 0.758204 |
NVIDIA-Omniverse/PhysX/physx/include/common/PxCoreUtilityTypes.h | // 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-2023 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 PX_CORE_UTILITY_TYPES_H
#define PX_CORE_UTILITY_TYPES_H
/** \addtogroup common
@{
*/
#include "foundation/PxAssert.h"
#include "foundation/PxMemory.h"
#if !PX_DOXYGEN
namespace physx
{
#endif
struct PxStridedData
{
/**
\brief The offset in bytes between consecutive samples in the data.
<b>Default:</b> 0
*/
PxU32 stride;
const void* data;
PxStridedData() : stride( 0 ), data( NULL ) {}
template<typename TDataType>
PX_INLINE const TDataType& at( PxU32 idx ) const
{
PxU32 theStride( stride );
if ( theStride == 0 )
theStride = sizeof( TDataType );
PxU32 offset( theStride * idx );
return *(reinterpret_cast<const TDataType*>( reinterpret_cast< const PxU8* >( data ) + offset ));
}
};
template<typename TDataType>
struct PxTypedStridedData
{
PxU32 stride;
const TDataType* data;
PxTypedStridedData()
: stride( 0 )
, data( NULL )
{
}
PxTypedStridedData(const TDataType* data_, PxU32 stride_ = 0)
: stride(stride_)
, data(data_)
{
}
PX_INLINE const TDataType& at(PxU32 idx) const
{
PxU32 theStride(stride);
if (theStride == 0)
theStride = sizeof(TDataType);
PxU32 offset(theStride * idx);
return *(reinterpret_cast<const TDataType*>(reinterpret_cast<const PxU8*>(data) + offset));
}
};
struct PxBoundedData : public PxStridedData
{
PxU32 count;
PxBoundedData() : count( 0 ) {}
};
template<PxU8 TNumBytes>
struct PxPadding
{
PxU8 mPadding[TNumBytes];
PxPadding()
{
for ( PxU8 idx =0; idx < TNumBytes; ++idx )
mPadding[idx] = 0;
}
};
template <PxU32 NB_ELEMENTS> class PxFixedSizeLookupTable
{
public:
PxFixedSizeLookupTable()
: mNbDataPairs(0)
{
}
PxFixedSizeLookupTable(const PxEMPTY) {}
PxFixedSizeLookupTable(const PxReal* dataPairs, const PxU32 numDataPairs)
{
PxMemCopy(mDataPairs,dataPairs,sizeof(PxReal)*2*numDataPairs);
mNbDataPairs=numDataPairs;
}
PxFixedSizeLookupTable(const PxFixedSizeLookupTable& src)
{
PxMemCopy(mDataPairs,src.mDataPairs,sizeof(PxReal)*2*src.mNbDataPairs);
mNbDataPairs=src.mNbDataPairs;
}
~PxFixedSizeLookupTable()
{
}
PxFixedSizeLookupTable& operator=(const PxFixedSizeLookupTable& src)
{
PxMemCopy(mDataPairs,src.mDataPairs,sizeof(PxReal)*2*src.mNbDataPairs);
mNbDataPairs=src.mNbDataPairs;
return *this;
}
PX_FORCE_INLINE void addPair(const PxReal x, const PxReal y)
{
PX_ASSERT(mNbDataPairs<NB_ELEMENTS);
mDataPairs[2*mNbDataPairs+0]=x;
mDataPairs[2*mNbDataPairs+1]=y;
mNbDataPairs++;
}
PX_FORCE_INLINE PxReal getYVal(const PxReal x) const
{
if(0==mNbDataPairs)
{
PX_ASSERT(false);
return 0;
}
if(1==mNbDataPairs || x<getX(0))
{
return getY(0);
}
PxReal x0=getX(0);
PxReal y0=getY(0);
for(PxU32 i=1;i<mNbDataPairs;i++)
{
const PxReal x1=getX(i);
const PxReal y1=getY(i);
if((x>=x0)&&(x<x1))
{
return (y0+(y1-y0)*(x-x0)/(x1-x0));
}
x0=x1;
y0=y1;
}
PX_ASSERT(x>=getX(mNbDataPairs-1));
return getY(mNbDataPairs-1);
}
PxU32 getNbDataPairs() const {return mNbDataPairs;}
void clear()
{
PxMemSet(mDataPairs, 0, NB_ELEMENTS*2*sizeof(PxReal));
mNbDataPairs = 0;
}
PX_FORCE_INLINE PxReal getX(const PxU32 i) const
{
return mDataPairs[2*i];
}
PX_FORCE_INLINE PxReal getY(const PxU32 i) const
{
return mDataPairs[2*i+1];
}
PxReal mDataPairs[2*NB_ELEMENTS];
PxU32 mNbDataPairs;
PxU32 mPad[3];
};
#if !PX_DOXYGEN
} // namespace physx
#endif
/** @} */
#endif
| 5,116 | C | 22.472477 | 99 | 0.712275 |
NVIDIA-Omniverse/PhysX/physx/include/common/windows/PxWindowsDelayLoadHook.h | // 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-2023 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 PX_WINDOWS_DELAY_LOAD_HOOK_H
#define PX_WINDOWS_DELAY_LOAD_HOOK_H
#include "foundation/PxPreprocessor.h"
#include "common/PxPhysXCommonConfig.h"
/** \addtogroup foundation
@{
*/
#if !PX_DOXYGEN
namespace physx
{
#endif
/**
\brief PxDelayLoadHook
This is a helper class for delay loading the PhysXCommon dll and PhysXFoundation dll.
If a PhysXCommon dll or PhysXFoundation dll with a non-default file name needs to be loaded,
PxDelayLoadHook can be sub-classed to provide the custom filenames.
Once the names are set, the instance must be set for use by PhysX.dll using PxSetPhysXDelayLoadHook(),
PhysXCooking.dll using PxSetPhysXCookingDelayLoadHook() or by PhysXCommon.dll using PxSetPhysXCommonDelayLoadHook().
@see PxSetPhysXDelayLoadHook(), PxSetPhysXCookingDelayLoadHook(), PxSetPhysXCommonDelayLoadHook()
*/
class PxDelayLoadHook
{
public:
PxDelayLoadHook() {}
virtual ~PxDelayLoadHook() {}
virtual const char* getPhysXFoundationDllName() const = 0;
virtual const char* getPhysXCommonDllName() const = 0;
protected:
private:
};
/**
\brief Sets delay load hook instance for PhysX dll.
\param[in] hook Delay load hook.
@see PxDelayLoadHook
*/
PX_C_EXPORT PX_PHYSX_CORE_API void PX_CALL_CONV PxSetPhysXDelayLoadHook(const physx::PxDelayLoadHook* hook);
/**
\brief Sets delay load hook instance for PhysXCooking dll.
\param[in] hook Delay load hook.
@see PxDelayLoadHook
*/
PX_C_EXPORT PX_PHYSX_CORE_API void PX_CALL_CONV PxSetPhysXCookingDelayLoadHook(const physx::PxDelayLoadHook* hook);
/**
\brief Sets delay load hook instance for PhysXCommon dll.
\param[in] hook Delay load hook.
@see PxDelayLoadHook
*/
PX_C_EXPORT PX_PHYSX_COMMON_API void PX_CALL_CONV PxSetPhysXCommonDelayLoadHook(const physx::PxDelayLoadHook* hook);
#if !PX_DOXYGEN
} // namespace physx
#endif
/** @} */
#endif
| 3,560 | C | 34.257425 | 117 | 0.76236 |
NVIDIA-Omniverse/PhysX/physx/include/characterkinematic/PxController.h | // 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-2023 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 PX_CONTROLLER_H
#define PX_CONTROLLER_H
/** \addtogroup character
@{
*/
#include "characterkinematic/PxExtended.h"
#include "characterkinematic/PxControllerObstacles.h"
#include "PxQueryFiltering.h"
#include "foundation/PxErrorCallback.h"
#if !PX_DOXYGEN
namespace physx
{
#endif
/**
\brief The type of controller, eg box, sphere or capsule.
*/
struct PxControllerShapeType
{
enum Enum
{
/**
\brief A box controller.
@see PxBoxController PxBoxControllerDesc
*/
eBOX,
/**
\brief A capsule controller
@see PxCapsuleController PxCapsuleControllerDesc
*/
eCAPSULE,
eFORCE_DWORD = 0x7fffffff
};
};
class PxShape;
class PxScene;
class PxController;
class PxRigidDynamic;
class PxMaterial;
struct PxFilterData;
class PxQueryFilterCallback;
class PxControllerBehaviorCallback;
class PxObstacleContext;
class PxObstacle;
/**
\brief specifies how a CCT interacts with non-walkable parts.
This is only used when slopeLimit is non zero. It is currently enabled for static actors only, and not supported for spheres or capsules.
*/
struct PxControllerNonWalkableMode
{
enum Enum
{
ePREVENT_CLIMBING, //!< Stops character from climbing up non-walkable slopes, but doesn't move it otherwise
ePREVENT_CLIMBING_AND_FORCE_SLIDING //!< Stops character from climbing up non-walkable slopes, and forces it to slide down those slopes
};
};
/**
\brief specifies which sides a character is colliding with.
*/
struct PxControllerCollisionFlag
{
enum Enum
{
eCOLLISION_SIDES = (1<<0), //!< Character is colliding to the sides.
eCOLLISION_UP = (1<<1), //!< Character has collision above.
eCOLLISION_DOWN = (1<<2) //!< Character has collision below.
};
};
/**
\brief Bitfield that contains a set of raised flags defined in PxControllerCollisionFlag.
@see PxControllerCollisionFlag
*/
typedef PxFlags<PxControllerCollisionFlag::Enum, PxU8> PxControllerCollisionFlags;
PX_FLAGS_OPERATORS(PxControllerCollisionFlag::Enum, PxU8)
/**
\brief Describes a controller's internal state.
*/
struct PxControllerState
{
PxVec3 deltaXP; //!< delta position vector for the object the CCT is standing/riding on. Not always match the CCT delta when variable timesteps are used.
PxShape* touchedShape; //!< Shape on which the CCT is standing
PxRigidActor* touchedActor; //!< Actor owning 'touchedShape'
PxObstacleHandle touchedObstacleHandle; // Obstacle on which the CCT is standing
PxU32 collisionFlags; //!< Last known collision flags (PxControllerCollisionFlag)
bool standOnAnotherCCT; //!< Are we standing on another CCT?
bool standOnObstacle; //!< Are we standing on a user-defined obstacle?
bool isMovingUp; //!< is CCT moving up or not? (i.e. explicit jumping)
};
/**
\brief Describes a controller's internal statistics.
*/
struct PxControllerStats
{
PxU16 nbIterations;
PxU16 nbFullUpdates;
PxU16 nbPartialUpdates;
PxU16 nbTessellation;
};
/**
\brief Describes a generic CCT hit.
*/
struct PxControllerHit
{
PxController* controller; //!< Current controller
PxExtendedVec3 worldPos; //!< Contact position in world space
PxVec3 worldNormal; //!< Contact normal in world space
PxVec3 dir; //!< Motion direction
PxF32 length; //!< Motion length
};
/**
\brief Describes a hit between a CCT and a shape. Passed to onShapeHit()
@see PxUserControllerHitReport.onShapeHit()
*/
struct PxControllerShapeHit : public PxControllerHit
{
PxShape* shape; //!< Touched shape
PxRigidActor* actor; //!< Touched actor
PxU32 triangleIndex; //!< touched triangle index (only for meshes/heightfields)
};
/**
\brief Describes a hit between a CCT and another CCT. Passed to onControllerHit().
@see PxUserControllerHitReport.onControllerHit()
*/
struct PxControllersHit : public PxControllerHit
{
PxController* other; //!< Touched controller
};
/**
\brief Describes a hit between a CCT and a user-defined obstacle. Passed to onObstacleHit().
@see PxUserControllerHitReport.onObstacleHit() PxObstacleContext
*/
struct PxControllerObstacleHit : public PxControllerHit
{
const void* userData;
};
/**
\brief User callback class for character controller events.
\note Character controller hit reports are only generated when move is called.
@see PxControllerDesc.callback
*/
class PxUserControllerHitReport
{
public:
/**
\brief Called when current controller hits a shape.
This is called when the CCT moves and hits a shape. This will not be called when a moving shape hits a non-moving CCT.
\param[in] hit Provides information about the hit.
@see PxControllerShapeHit
*/
virtual void onShapeHit(const PxControllerShapeHit& hit) = 0;
/**
\brief Called when current controller hits another controller.
\param[in] hit Provides information about the hit.
@see PxControllersHit
*/
virtual void onControllerHit(const PxControllersHit& hit) = 0;
/**
\brief Called when current controller hits a user-defined obstacle.
\param[in] hit Provides information about the hit.
@see PxControllerObstacleHit PxObstacleContext
*/
virtual void onObstacleHit(const PxControllerObstacleHit& hit) = 0;
protected:
virtual ~PxUserControllerHitReport(){}
};
/**
\brief Dedicated filtering callback for CCT vs CCT.
This controls collisions between CCTs (one CCT vs anoter CCT).
To make each CCT collide against all other CCTs, just return true - or simply avoid defining a callback.
To make each CCT freely go through all other CCTs, just return false.
Otherwise create a custom filtering logic in this callback.
@see PxControllerFilters
*/
class PxControllerFilterCallback
{
public:
virtual ~PxControllerFilterCallback(){}
/**
\brief Filtering method for CCT-vs-CCT.
\param[in] a First CCT
\param[in] b Second CCT
\return true to keep the pair, false to filter it out
*/
virtual bool filter(const PxController& a, const PxController& b) = 0;
};
/**
\brief Filtering data for "move" call.
This class contains all filtering-related parameters for the PxController::move() call.
Collisions between a CCT and the world are filtered using the mFilterData, mFilterCallback and mFilterFlags
members. These parameters are internally passed to PxScene::overlap() to find objects touched by the CCT.
Please refer to the PxScene::overlap() documentation for details.
Collisions between a CCT and another CCT are filtered using the mCCTFilterCallback member. If this filter
callback is not defined, none of the CCT-vs-CCT collisions are filtered, and each CCT will collide against
all other CCTs.
\note PxQueryFlag::eANY_HIT and PxQueryFlag::eNO_BLOCK are ignored in mFilterFlags.
@see PxController.move() PxControllerFilterCallback
*/
class PxControllerFilters
{
public:
PX_INLINE PxControllerFilters(const PxFilterData* filterData=NULL, PxQueryFilterCallback* cb=NULL, PxControllerFilterCallback* cctFilterCb=NULL) :
mFilterData (filterData),
mFilterCallback (cb),
mFilterFlags (PxQueryFlag::eSTATIC|PxQueryFlag::eDYNAMIC|PxQueryFlag::ePREFILTER),
mCCTFilterCallback (cctFilterCb)
{}
// CCT-vs-shapes:
const PxFilterData* mFilterData; //!< Data for internal PxQueryFilterData structure. Passed to PxScene::overlap() call.
//!< This can be NULL, in which case a default PxFilterData is used.
PxQueryFilterCallback* mFilterCallback; //!< Custom filter logic (can be NULL). Passed to PxScene::overlap() call.
PxQueryFlags mFilterFlags; //!< Flags for internal PxQueryFilterData structure. Passed to PxScene::overlap() call.
// CCT-vs-CCT:
PxControllerFilterCallback* mCCTFilterCallback; //!< CCT-vs-CCT filter callback. If NULL, all CCT-vs-CCT collisions are kept.
};
/**
\brief Descriptor class for a character controller.
@see PxBoxController PxCapsuleController
*/
class PxControllerDesc
{
public:
/**
\brief returns true if the current settings are valid
\return True if the descriptor is valid.
*/
PX_INLINE virtual bool isValid() const;
/**
\brief Returns the character controller type
\return The controllers type.
@see PxControllerType PxCapsuleControllerDesc PxBoxControllerDesc
*/
PX_INLINE PxControllerShapeType::Enum getType() const { return mType; }
/**
\brief The position of the character
\note The character's initial position must be such that it does not overlap the static geometry.
<b>Default:</b> Zero
*/
PxExtendedVec3 position;
/**
\brief Specifies the 'up' direction
In order to provide stepping functionality the SDK must be informed about the up direction.
<b>Default:</b> (0, 1, 0)
*/
PxVec3 upDirection;
/**
\brief The maximum slope which the character can walk up.
In general it is desirable to limit where the character can walk, in particular it is unrealistic
for the character to be able to climb arbitary slopes.
The limit is expressed as the cosine of desired limit angle. A value of 0 disables this feature.
\warning It is currently enabled for static actors only (not for dynamic/kinematic actors), and not supported for spheres or capsules.
<b>Default:</b> 0.707
@see upDirection invisibleWallHeight maxJumpHeight
*/
PxF32 slopeLimit;
/**
\brief Height of invisible walls created around non-walkable triangles
The library can automatically create invisible walls around non-walkable triangles defined
by the 'slopeLimit' parameter. This defines the height of those walls. If it is 0.0, then
no extra triangles are created.
<b>Default:</b> 0.0
@see upDirection slopeLimit maxJumpHeight
*/
PxF32 invisibleWallHeight;
/**
\brief Maximum height a jumping character can reach
This is only used if invisible walls are created ('invisibleWallHeight' is non zero).
When a character jumps, the non-walkable triangles he might fly over are not found
by the collision queries (since the character's bounding volume does not touch them).
Thus those non-walkable triangles do not create invisible walls, and it is possible
for a jumping character to land on a non-walkable triangle, while he wouldn't have
reached that place by just walking.
The 'maxJumpHeight' variable is used to extend the size of the collision volume
downward. This way, all the non-walkable triangles are properly found by the collision
queries and it becomes impossible to 'jump over' invisible walls.
If the character in your game can not jump, it is safe to use 0.0 here. Otherwise it
is best to keep this value as small as possible, since a larger collision volume
means more triangles to process.
<b>Default:</b> 0.0
@see upDirection slopeLimit invisibleWallHeight
*/
PxF32 maxJumpHeight;
/**
\brief The contact offset used by the controller.
Specifies a skin around the object within which contacts will be generated.
Use it to avoid numerical precision issues.
This is dependant on the scale of the users world, but should be a small, positive
non zero value.
<b>Default:</b> 0.1
*/
PxF32 contactOffset;
/**
\brief Defines the maximum height of an obstacle which the character can climb.
A small value will mean that the character gets stuck and cannot walk up stairs etc,
a value which is too large will mean that the character can climb over unrealistically
high obstacles.
<b>Default:</b> 0.5
@see upDirection
*/
PxF32 stepOffset;
/**
\brief Density of underlying kinematic actor
The CCT creates a PhysX's kinematic actor under the hood. This controls its density.
<b>Default:</b> 10.0
*/
PxF32 density;
/**
\brief Scale coefficient for underlying kinematic actor
The CCT creates a PhysX's kinematic actor under the hood. This controls its scale factor.
This should be a number a bit smaller than 1.0.
<b>Default:</b> 0.8
*/
PxF32 scaleCoeff;
/**
\brief Cached volume growth
Amount of space around the controller we cache to improve performance. This is a scale factor
that should be higher than 1.0f but not too big, ideally lower than 2.0f.
<b>Default:</b> 1.5
*/
PxF32 volumeGrowth;
/**
\brief Specifies a user report callback.
This report callback is called when the character collides with shapes and other characters.
Setting this to NULL disables the callback.
<b>Default:</b> NULL
@see PxUserControllerHitReport
*/
PxUserControllerHitReport* reportCallback;
/**
\brief Specifies a user behavior callback.
This behavior callback is called to customize the controller's behavior w.r.t. touched shapes.
Setting this to NULL disables the callback.
<b>Default:</b> NULL
@see PxControllerBehaviorCallback
*/
PxControllerBehaviorCallback* behaviorCallback;
/**
\brief The non-walkable mode controls if a character controller slides or not on a non-walkable part.
This is only used when slopeLimit is non zero.
<b>Default:</b> PxControllerNonWalkableMode::ePREVENT_CLIMBING
@see PxControllerNonWalkableMode
*/
PxControllerNonWalkableMode::Enum nonWalkableMode;
/**
\brief The material for the actor associated with the controller.
The controller internally creates a rigid body actor. This parameter specifies the material of the actor.
<b>Default:</b> NULL
@see PxMaterial
*/
PxMaterial* material;
/**
\brief Use a deletion listener to get informed about released objects and clear internal caches if needed.
If a character controller registers a deletion listener, it will get informed about released objects. That allows the
controller to invalidate cached data that connects to a released object. If a deletion listener is not
registered, PxController::invalidateCache has to be called manually after objects have been released.
@see PxController::invalidateCache
<b>Default:</b> true
*/
bool registerDeletionListener;
/**
\brief Client ID for associated actor.
@see PxClientID PxActor::setOwnerClient
<b>Default:</b> PX_DEFAULT_CLIENT
*/
PxClientID clientID;
/**
\brief User specified data associated with the controller.
<b>Default:</b> NULL
*/
void* userData;
protected:
const PxControllerShapeType::Enum mType; //!< The type of the controller. This gets set by the derived class' ctor, the user should not have to change it.
/**
\brief constructor sets to default.
*/
PX_INLINE PxControllerDesc(PxControllerShapeType::Enum);
PX_INLINE virtual ~PxControllerDesc();
/**
\brief copy constructor.
*/
PX_INLINE PxControllerDesc(const PxControllerDesc&);
/**
\brief assignment operator.
*/
PX_INLINE PxControllerDesc& operator=(const PxControllerDesc&);
PX_INLINE void copy(const PxControllerDesc&);
};
PX_INLINE PxControllerDesc::PxControllerDesc(PxControllerShapeType::Enum t) :
position (PxExtended(0.0), PxExtended(0.0), PxExtended(0.0)),
upDirection (0.0f, 1.0f, 0.0f),
slopeLimit (0.707f),
invisibleWallHeight (0.0f),
maxJumpHeight (0.0f),
contactOffset (0.1f),
stepOffset (0.5f),
density (10.0f),
scaleCoeff (0.8f),
volumeGrowth (1.5f),
reportCallback (NULL),
behaviorCallback (NULL),
nonWalkableMode (PxControllerNonWalkableMode::ePREVENT_CLIMBING),
material (NULL),
registerDeletionListener (true),
clientID (PX_DEFAULT_CLIENT),
userData (NULL),
mType (t)
{
}
PX_INLINE PxControllerDesc::PxControllerDesc(const PxControllerDesc& other) : mType(other.mType)
{
copy(other);
}
PX_INLINE PxControllerDesc& PxControllerDesc::operator=(const PxControllerDesc& other)
{
copy(other);
return *this;
}
PX_INLINE void PxControllerDesc::copy(const PxControllerDesc& other)
{
upDirection = other.upDirection;
slopeLimit = other.slopeLimit;
contactOffset = other.contactOffset;
stepOffset = other.stepOffset;
density = other.density;
scaleCoeff = other.scaleCoeff;
volumeGrowth = other.volumeGrowth;
reportCallback = other.reportCallback;
behaviorCallback = other.behaviorCallback;
userData = other.userData;
nonWalkableMode = other.nonWalkableMode;
position.x = other.position.x;
position.y = other.position.y;
position.z = other.position.z;
material = other.material;
invisibleWallHeight = other.invisibleWallHeight;
maxJumpHeight = other.maxJumpHeight;
registerDeletionListener = other.registerDeletionListener;
clientID = other.clientID;
}
PX_INLINE PxControllerDesc::~PxControllerDesc()
{
}
PX_INLINE bool PxControllerDesc::isValid() const
{
if( mType!=PxControllerShapeType::eBOX
&& mType!=PxControllerShapeType::eCAPSULE)
return false;
if(scaleCoeff<0.0f)
return false;
if(volumeGrowth<1.0f)
return false;
if(density<0.0f)
return false;
if(slopeLimit<0.0f)
return false;
if(stepOffset<0.0f)
return false;
if(contactOffset<=0.0f)
return false;
if(!material)
return false;
if(!toVec3(position).isFinite())
return false; //the float version needs to be finite otherwise actor creation will fail.
return true;
}
/**
\brief Base class for character controllers.
@see PxCapsuleController PxBoxController
*/
class PxController
{
public:
/**
\brief Return the type of controller
@see PxControllerType
*/
virtual PxControllerShapeType::Enum getType() const = 0;
/**
\brief Releases the controller.
*/
virtual void release() = 0;
/**
\brief Moves the character using a "collide-and-slide" algorithm.
\param[in] disp Displacement vector
\param[in] minDist The minimum travelled distance to consider. If travelled distance is smaller, the character doesn't move.
This is used to stop the recursive motion algorithm when remaining distance to travel is small.
\param[in] elapsedTime Time elapsed since last call
\param[in] filters User-defined filters for this move
\param[in] obstacles Potential additional obstacles the CCT should collide with.
\return Collision flags, collection of ::PxControllerCollisionFlags
*/
virtual PxControllerCollisionFlags move(const PxVec3& disp, PxF32 minDist, PxF32 elapsedTime, const PxControllerFilters& filters, const PxObstacleContext* obstacles=NULL) = 0;
/**
\brief Sets controller's position.
The position controlled by this function is the center of the collision shape.
\warning This is a 'teleport' function, it doesn't check for collisions.
\warning The character's position must be such that it does not overlap the static geometry.
To move the character under normal conditions use the #move() function.
\param[in] position The new (center) positon for the controller.
\return Currently always returns true.
@see PxControllerDesc.position getPosition() getFootPosition() setFootPosition() move()
*/
virtual bool setPosition(const PxExtendedVec3& position) = 0;
/**
\brief Retrieve the raw position of the controller.
The position retrieved by this function is the center of the collision shape. To retrieve the bottom position of the shape,
a.k.a. the foot position, use the getFootPosition() function.
The position is updated by calls to move(). Calling this method without calling
move() will return the last position or the initial position of the controller.
\return The controller's center position
@see PxControllerDesc.position setPosition() getFootPosition() setFootPosition() move()
*/
virtual const PxExtendedVec3& getPosition() const = 0;
/**
\brief Set controller's foot position.
The position controlled by this function is the bottom of the collision shape, a.k.a. the foot position.
\note The foot position takes the contact offset into account
\warning This is a 'teleport' function, it doesn't check for collisions.
To move the character under normal conditions use the #move() function.
\param[in] position The new (bottom) positon for the controller.
\return Currently always returns true.
@see PxControllerDesc.position setPosition() getPosition() getFootPosition() move()
*/
virtual bool setFootPosition(const PxExtendedVec3& position) = 0;
/**
\brief Retrieve the "foot" position of the controller, i.e. the position of the bottom of the CCT's shape.
\note The foot position takes the contact offset into account
\return The controller's foot position
@see PxControllerDesc.position setPosition() getPosition() setFootPosition() move()
*/
virtual PxExtendedVec3 getFootPosition() const = 0;
/**
\brief Get the rigid body actor associated with this controller (see PhysX documentation).
The behavior upon manually altering this actor is undefined, you should primarily
use it for reading const properties.
\return the actor associated with the controller.
*/
virtual PxRigidDynamic* getActor() const = 0;
/**
\brief The step height.
\param[in] offset The new step offset for the controller.
@see PxControllerDesc.stepOffset
*/
virtual void setStepOffset(const PxF32 offset) =0;
/**
\brief Retrieve the step height.
\return The step offset for the controller.
@see setStepOffset()
*/
virtual PxF32 getStepOffset() const =0;
/**
\brief Sets the non-walkable mode for the CCT.
\param[in] flag The new value of the non-walkable mode.
@see PxControllerNonWalkableMode
*/
virtual void setNonWalkableMode(PxControllerNonWalkableMode::Enum flag) = 0;
/**
\brief Retrieves the non-walkable mode for the CCT.
\return The current non-walkable mode.
@see PxControllerNonWalkableMode
*/
virtual PxControllerNonWalkableMode::Enum getNonWalkableMode() const = 0;
/**
\brief Retrieve the contact offset.
\return The contact offset for the controller.
@see PxControllerDesc.contactOffset
*/
virtual PxF32 getContactOffset() const =0;
/**
\brief Sets the contact offset.
\param[in] offset The contact offset for the controller.
@see PxControllerDesc.contactOffset
*/
virtual void setContactOffset(PxF32 offset) =0;
/**
\brief Retrieve the 'up' direction.
\return The up direction for the controller.
@see PxControllerDesc.upDirection
*/
virtual PxVec3 getUpDirection() const =0;
/**
\brief Sets the 'up' direction.
\param[in] up The up direction for the controller.
@see PxControllerDesc.upDirection
*/
virtual void setUpDirection(const PxVec3& up) =0;
/**
\brief Retrieve the slope limit.
\return The slope limit for the controller.
@see PxControllerDesc.slopeLimit
*/
virtual PxF32 getSlopeLimit() const =0;
/**
\brief Sets the slope limit.
\note This feature can not be enabled at runtime, i.e. if the slope limit is zero when creating the CCT
(which disables the feature) then changing the slope limit at runtime will not have any effect, and the call
will be ignored.
\param[in] slopeLimit The slope limit for the controller.
@see PxControllerDesc.slopeLimit
*/
virtual void setSlopeLimit(PxF32 slopeLimit) =0;
/**
\brief Flushes internal geometry cache.
The character controller uses caching in order to speed up collision testing. The cache is
automatically flushed when a change to static objects is detected in the scene. For example when a
static shape is added, updated, or removed from the scene, the cache is automatically invalidated.
However there may be situations that cannot be automatically detected, and those require manual
invalidation of the cache. Currently the user must call this when the filtering behavior changes (the
PxControllerFilters parameter of the PxController::move call). While the controller in principle
could detect a change in these parameters, it cannot detect a change in the behavior of the filtering
function.
@see PxController.move
*/
virtual void invalidateCache() = 0;
/**
\brief Retrieve the scene associated with the controller.
\return The physics scene
*/
virtual PxScene* getScene() = 0;
/**
\brief Returns the user data associated with this controller.
\return The user pointer associated with the controller.
@see PxControllerDesc.userData
*/
virtual void* getUserData() const = 0;
/**
\brief Sets the user data associated with this controller.
\param[in] userData The user pointer associated with the controller.
@see PxControllerDesc.userData
*/
virtual void setUserData(void* userData) = 0;
/**
\brief Returns information about the controller's internal state.
\param[out] state The controller's internal state
@see PxControllerState
*/
virtual void getState(PxControllerState& state) const = 0;
/**
\brief Returns the controller's internal statistics.
\param[out] stats The controller's internal statistics
@see PxControllerStats
*/
virtual void getStats(PxControllerStats& stats) const = 0;
/**
\brief Resizes the controller.
This function attempts to resize the controller to a given size, while making sure the bottom
position of the controller remains constant. In other words the function modifies both the
height and the (center) position of the controller. This is a helper function that can be used
to implement a 'crouch' functionality for example.
\param[in] height Desired controller's height
*/
virtual void resize(PxReal height) = 0;
protected:
PX_INLINE PxController() {}
virtual ~PxController() {}
};
#if !PX_DOXYGEN
} // namespace physx
#endif
/** @} */
#endif
| 26,944 | C | 28.544956 | 177 | 0.745064 |
NVIDIA-Omniverse/PhysX/physx/include/characterkinematic/PxControllerManager.h | // 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-2023 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 PX_CONTROLLER_MANAGER_H
#define PX_CONTROLLER_MANAGER_H
/** \addtogroup character
@{
*/
#include "PxPhysXConfig.h"
#include "foundation/PxFlags.h"
#include "foundation/PxErrorCallback.h"
#include "common/PxRenderBuffer.h"
#if !PX_DOXYGEN
namespace physx
{
#endif
class PxPhysics;
class PxScene;
class PxController;
class PxControllerDesc;
class PxObstacleContext;
class PxControllerFilterCallback;
/**
\brief specifies debug-rendering flags
*/
struct PxControllerDebugRenderFlag
{
enum Enum
{
eTEMPORAL_BV = (1<<0), //!< Temporal bounding volume around controllers
eCACHED_BV = (1<<1), //!< Cached bounding volume around controllers
eOBSTACLES = (1<<2), //!< User-defined obstacles
eNONE = 0,
eALL = 0xffffffff
};
};
/**
\brief Bitfield that contains a set of raised flags defined in PxControllerDebugRenderFlag.
@see PxControllerDebugRenderFlag
*/
typedef PxFlags<PxControllerDebugRenderFlag::Enum, PxU32> PxControllerDebugRenderFlags;
PX_FLAGS_OPERATORS(PxControllerDebugRenderFlag::Enum, PxU32)
/**
\brief Manages an array of character controllers.
@see PxController PxBoxController PxCapsuleController
*/
class PxControllerManager
{
public:
/**
\brief Releases the controller manager.
\note This will release all associated controllers and obstacle contexts.
\note This function is required to be called to release foundation usage.
*/
virtual void release() = 0;
/**
\brief Returns the scene the manager is adding the controllers to.
\return The associated physics scene.
*/
virtual PxScene& getScene() const = 0;
/**
\brief Returns the number of controllers that are being managed.
\return The number of controllers.
*/
virtual PxU32 getNbControllers() const = 0;
/**
\brief Retrieve one of the controllers in the manager.
\param index the index of the controller to return
\return The controller with the specified index.
*/
virtual PxController* getController(PxU32 index) = 0;
/**
\brief Creates a new character controller.
\param[in] desc The controllers descriptor
\return The new controller
@see PxController PxController.release() PxControllerDesc
*/
virtual PxController* createController(const PxControllerDesc& desc) = 0;
/**
\brief Releases all the controllers that are being managed.
*/
virtual void purgeControllers() = 0;
/**
\brief Retrieves debug data.
\return The render buffer filled with debug-render data
@see PxControllerManager.setDebugRenderingFlags()
*/
virtual PxRenderBuffer& getRenderBuffer() = 0;
/**
\brief Sets debug rendering flags
\param[in] flags The debug rendering flags (combination of PxControllerDebugRenderFlags)
@see PxControllerManager.getRenderBuffer() PxControllerDebugRenderFlags
*/
virtual void setDebugRenderingFlags(PxControllerDebugRenderFlags flags) = 0;
/**
\brief Returns the number of obstacle contexts that are being managed.
\return The number of obstacle contexts.
*/
virtual PxU32 getNbObstacleContexts() const = 0;
/**
\brief Retrieve one of the obstacle contexts in the manager.
\param index The index of the obstacle context to retrieve.
\return The obstacle context with the specified index.
*/
virtual PxObstacleContext* getObstacleContext(PxU32 index) = 0;
/**
\brief Creates an obstacle context.
\return New obstacle context
@see PxObstacleContext
*/
virtual PxObstacleContext* createObstacleContext() = 0;
/**
\brief Computes character-character interactions.
This function is an optional helper to properly resolve interactions between characters, in case they overlap (which can happen for gameplay reasons, etc).
You should call this once per frame, before your PxController::move() calls. The function will not move the characters directly, but it will
compute overlap information for each character that will be used in the next move() call.
You need to provide a proper time value here so that interactions are resolved in a way that do not depend on the framerate.
If you only have one character in the scene, or if you can guarantee your characters will never overlap, then you do not need to call this function.
\note Releasing the manager will automatically release all the associated obstacle contexts.
\param[in] elapsedTime Elapsed time since last call
\param[in] cctFilterCb Filtering callback for CCT-vs-CCT interactions
*/
virtual void computeInteractions(PxF32 elapsedTime, PxControllerFilterCallback* cctFilterCb=NULL) = 0;
/**
\brief Enables or disables runtime tessellation.
Large triangles can create accuracy issues in the sweep code, which in turn can lead to characters not sliding smoothly
against geometries, or even penetrating them. This feature allows one to reduce those issues by tessellating large
triangles at runtime, before performing sweeps against them. The amount of tessellation is controlled by the 'maxEdgeLength' parameter.
Any triangle with at least one edge length greater than the maxEdgeLength will get recursively tessellated, until resulting triangles are small enough.
This features only applies to triangle meshes, convex meshes, heightfields and boxes.
\param[in] flag True/false to enable/disable runtime tessellation.
\param[in] maxEdgeLength Max edge length allowed before tessellation kicks in.
*/
virtual void setTessellation(bool flag, float maxEdgeLength) = 0;
/**
\brief Enables or disables the overlap recovery module.
The overlap recovery module can be used to depenetrate CCTs from static objects when an overlap is detected. This can happen
in three main cases:
- when the CCT is directly spawned or teleported in another object
- when the CCT algorithm fails due to limited FPU accuracy
- when the "up vector" is modified, making the rotated CCT shape overlap surrounding objects
When activated, the CCT module will automatically try to resolve the penetration, and move the CCT to a safe place where it does
not overlap other objects anymore. This only concerns static objects, dynamic objects are ignored by the recovery module.
When the recovery module is not activated, it is possible for the CCTs to go through static objects. By default, the recovery
module is enabled.
The recovery module currently works with all geometries except heightfields.
\param[in] flag True/false to enable/disable overlap recovery module.
*/
virtual void setOverlapRecoveryModule(bool flag) = 0;
/**
\brief Enables or disables the precise sweeps.
Precise sweeps are more accurate, but also potentially slower than regular sweeps.
By default, precise sweeps are enabled.
\param[in] flag True/false to enable/disable precise sweeps.
*/
virtual void setPreciseSweeps(bool flag) = 0;
/**
\brief Enables or disables vertical sliding against ceilings.
Geometry is seen as "ceilings" when the following condition is met:
dot product(contact normal, up direction)<0.0f
This flag controls whether characters should slide vertically along the geometry in that case.
By default, sliding is allowed.
\param[in] flag True/false to enable/disable sliding.
*/
virtual void setPreventVerticalSlidingAgainstCeiling(bool flag) = 0;
/**
\brief Shift the origin of the character controllers and obstacle objects by the specified vector.
The positions of all character controllers, obstacle objects and the corresponding data structures will get adjusted to reflect the shifted origin location
(the shift vector will get subtracted from all character controller and obstacle object positions).
\note It is the user's responsibility to keep track of the summed total origin shift and adjust all input/output to/from PhysXCharacterKinematic accordingly.
\note This call will not automatically shift the PhysX scene and its objects. You need to call PxScene::shiftOrigin() seperately to keep the systems in sync.
\param[in] shift Translation vector to shift the origin by.
*/
virtual void shiftOrigin(const PxVec3& shift) = 0;
protected:
PxControllerManager() {}
virtual ~PxControllerManager() {}
};
#if !PX_DOXYGEN
} // namespace physx
#endif
/**
\brief Creates the controller manager.
\param[in] scene PhysX scene. You can only create one PxControllerManager per scene.
\param[in] lockingEnabled Enables/disables internal locking.
\return New controller manager, or NULL in case of failure (e.g. when a manager has already been created for that scene)
The character controller is informed by #PxDeletionListener::onRelease() when actors or shapes are released, and updates its internal
caches accordingly. If character controller movement or a call to #PxControllerManager::shiftOrigin() may overlap with actor/shape releases,
internal data structures must be guarded against concurrent access.
Locking guarantees thread safety in such scenarios.
\note locking may result in significant slowdown for release of actors or shapes.
By default, locking is disabled.
*/
PX_C_EXPORT physx::PxControllerManager* PX_CALL_CONV PxCreateControllerManager(physx::PxScene& scene, bool lockingEnabled = false);
/** @} */
#endif
| 10,813 | C | 34.92691 | 158 | 0.772589 |
NVIDIA-Omniverse/PhysX/physx/include/characterkinematic/PxCapsuleController.h | // 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-2023 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 PX_CAPSULE_CONTROLLER_H
#define PX_CAPSULE_CONTROLLER_H
/** \addtogroup character
@{
*/
#include "characterkinematic/PxController.h"
#if !PX_DOXYGEN
namespace physx
{
#endif
struct PxCapsuleClimbingMode
{
enum Enum
{
eEASY, //!< Standard mode, let the capsule climb over surfaces according to impact normal
eCONSTRAINED, //!< Constrained mode, try to limit climbing according to the step offset
eLAST
};
};
/**
\brief A descriptor for a capsule character controller.
@see PxCapsuleController PxControllerDesc
*/
class PxCapsuleControllerDesc : public PxControllerDesc
{
public:
/**
\brief constructor sets to default.
*/
PX_INLINE PxCapsuleControllerDesc ();
PX_INLINE virtual ~PxCapsuleControllerDesc () {}
/**
\brief copy constructor.
*/
PX_INLINE PxCapsuleControllerDesc(const PxCapsuleControllerDesc&);
/**
\brief assignment operator.
*/
PX_INLINE PxCapsuleControllerDesc& operator=(const PxCapsuleControllerDesc&);
/**
\brief (re)sets the structure to the default.
*/
PX_INLINE virtual void setToDefault();
/**
\brief returns true if the current settings are valid
\return True if the descriptor is valid.
*/
PX_INLINE virtual bool isValid() const;
/**
\brief The radius of the capsule
<b>Default:</b> 0.0
@see PxCapsuleController
*/
PxF32 radius;
/**
\brief The height of the controller
<b>Default:</b> 0.0
@see PxCapsuleController
*/
PxF32 height;
/**
\brief The climbing mode
<b>Default:</b> PxCapsuleClimbingMode::eEASY
@see PxCapsuleController
*/
PxCapsuleClimbingMode::Enum climbingMode;
protected:
PX_INLINE void copy(const PxCapsuleControllerDesc&);
};
PX_INLINE PxCapsuleControllerDesc::PxCapsuleControllerDesc () : PxControllerDesc(PxControllerShapeType::eCAPSULE)
{
radius = height = 0.0f;
climbingMode = PxCapsuleClimbingMode::eEASY;
}
PX_INLINE PxCapsuleControllerDesc::PxCapsuleControllerDesc(const PxCapsuleControllerDesc& other) : PxControllerDesc(other)
{
copy(other);
}
PX_INLINE PxCapsuleControllerDesc& PxCapsuleControllerDesc::operator=(const PxCapsuleControllerDesc& other)
{
PxControllerDesc::operator=(other);
copy(other);
return *this;
}
PX_INLINE void PxCapsuleControllerDesc::copy(const PxCapsuleControllerDesc& other)
{
radius = other.radius;
height = other.height;
climbingMode = other.climbingMode;
}
PX_INLINE void PxCapsuleControllerDesc::setToDefault()
{
*this = PxCapsuleControllerDesc();
}
PX_INLINE bool PxCapsuleControllerDesc::isValid() const
{
if(!PxControllerDesc::isValid()) return false;
if(radius<=0.0f) return false;
if(height<=0.0f) return false;
if(stepOffset>height+radius*2.0f) return false; // Prevents obvious mistakes
return true;
}
/**
\brief A capsule character controller.
The capsule is defined as a position, a vertical height, and a radius.
The height is the distance between the two sphere centers at the end of the capsule.
In other words:
p = pos (returned by controller)<br>
h = height<br>
r = radius<br>
p = center of capsule<br>
top sphere center = p.y + h*0.5<br>
bottom sphere center = p.y - h*0.5<br>
top capsule point = p.y + h*0.5 + r<br>
bottom capsule point = p.y - h*0.5 - r<br>
*/
class PxCapsuleController : public PxController
{
public:
/**
\brief Gets controller's radius.
\return The radius of the controller.
@see PxCapsuleControllerDesc.radius setRadius()
*/
virtual PxF32 getRadius() const = 0;
/**
\brief Sets controller's radius.
\warning this doesn't check for collisions.
\param[in] radius The new radius for the controller.
\return Currently always true.
@see PxCapsuleControllerDesc.radius getRadius()
*/
virtual bool setRadius(PxF32 radius) = 0;
/**
\brief Gets controller's height.
\return The height of the capsule controller.
@see PxCapsuleControllerDesc.height setHeight()
*/
virtual PxF32 getHeight() const = 0;
/**
\brief Resets controller's height.
\warning this doesn't check for collisions.
\param[in] height The new height for the controller.
\return Currently always true.
@see PxCapsuleControllerDesc.height getHeight()
*/
virtual bool setHeight(PxF32 height) = 0;
/**
\brief Gets controller's climbing mode.
\return The capsule controller's climbing mode.
@see PxCapsuleControllerDesc.climbingMode setClimbingMode()
*/
virtual PxCapsuleClimbingMode::Enum getClimbingMode() const = 0;
/**
\brief Sets controller's climbing mode.
\param[in] mode The capsule controller's climbing mode.
@see PxCapsuleControllerDesc.climbingMode getClimbingMode()
*/
virtual bool setClimbingMode(PxCapsuleClimbingMode::Enum mode) = 0;
protected:
PX_INLINE PxCapsuleController() {}
virtual ~PxCapsuleController() {}
};
#if !PX_DOXYGEN
} // namespace physx
#endif
/** @} */
#endif
| 6,517 | C | 25.176707 | 122 | 0.739144 |
NVIDIA-Omniverse/PhysX/physx/include/characterkinematic/PxControllerBehavior.h | // 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-2023 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 PX_CONTROLLER_BEHAVIOR_H
#define PX_CONTROLLER_BEHAVIOR_H
/** \addtogroup character
@{
*/
#include "PxFiltering.h"
#if !PX_DOXYGEN
namespace physx
{
#endif
class PxShape;
class PxObstacle;
class PxController;
/**
\brief specifies controller behavior
*/
struct PxControllerBehaviorFlag
{
enum Enum
{
eCCT_CAN_RIDE_ON_OBJECT = (1<<0), //!< Controller can ride on touched object (i.e. when this touched object is moving horizontally). \note The CCT vs. CCT case is not supported.
eCCT_SLIDE = (1<<1), //!< Controller should slide on touched object
eCCT_USER_DEFINED_RIDE = (1<<2) //!< Disable all code dealing with controllers riding on objects, let users define it outside of the SDK.
};
};
/**
\brief Bitfield that contains a set of raised flags defined in PxControllerBehaviorFlag.
@see PxControllerBehaviorFlag
*/
typedef PxFlags<PxControllerBehaviorFlag::Enum, PxU8> PxControllerBehaviorFlags;
PX_FLAGS_OPERATORS(PxControllerBehaviorFlag::Enum, PxU8)
/**
\brief User behavior callback.
This behavior callback is called to customize the controller's behavior w.r.t. touched shapes.
*/
class PxControllerBehaviorCallback
{
public:
/**
\brief Retrieve behavior flags for a shape.
When the CCT touches a shape, the CCT's behavior w.r.t. this shape can be customized by users.
This function retrieves the desired PxControllerBehaviorFlag flags capturing the desired behavior.
\note See comments about deprecated functions at the start of this class
\param[in] shape The shape the CCT is currently touching
\param[in] actor The actor owning the shape
\return Desired behavior flags for the given shape
@see PxControllerBehaviorFlag
*/
virtual PxControllerBehaviorFlags getBehaviorFlags(const PxShape& shape, const PxActor& actor) = 0;
/**
\brief Retrieve behavior flags for a controller.
When the CCT touches a controller, the CCT's behavior w.r.t. this controller can be customized by users.
This function retrieves the desired PxControllerBehaviorFlag flags capturing the desired behavior.
\note The flag PxControllerBehaviorFlag::eCCT_CAN_RIDE_ON_OBJECT is not supported.
\note See comments about deprecated functions at the start of this class
\param[in] controller The controller the CCT is currently touching
\return Desired behavior flags for the given controller
@see PxControllerBehaviorFlag
*/
virtual PxControllerBehaviorFlags getBehaviorFlags(const PxController& controller) = 0;
/**
\brief Retrieve behavior flags for an obstacle.
When the CCT touches an obstacle, the CCT's behavior w.r.t. this obstacle can be customized by users.
This function retrieves the desired PxControllerBehaviorFlag flags capturing the desired behavior.
\note See comments about deprecated functions at the start of this class
\param[in] obstacle The obstacle the CCT is currently touching
\return Desired behavior flags for the given obstacle
@see PxControllerBehaviorFlag
*/
virtual PxControllerBehaviorFlags getBehaviorFlags(const PxObstacle& obstacle) = 0;
protected:
virtual ~PxControllerBehaviorCallback(){}
};
#if !PX_DOXYGEN
}
#endif
/** @} */
#endif
| 4,894 | C | 35.259259 | 181 | 0.762158 |
NVIDIA-Omniverse/PhysX/physx/include/characterkinematic/PxBoxController.h | // 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-2023 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 PX_BOX_CONTROLLER_H
#define PX_BOX_CONTROLLER_H
/** \addtogroup character
@{
*/
#include "characterkinematic/PxController.h"
#if !PX_DOXYGEN
namespace physx
{
#endif
/**
\brief Descriptor for a box character controller.
@see PxBoxController PxControllerDesc
*/
class PxBoxControllerDesc : public PxControllerDesc
{
public:
/**
\brief constructor sets to default.
*/
PX_INLINE PxBoxControllerDesc();
PX_INLINE virtual ~PxBoxControllerDesc() {}
/**
\brief copy constructor.
*/
PX_INLINE PxBoxControllerDesc(const PxBoxControllerDesc&);
/**
\brief assignment operator.
*/
PX_INLINE PxBoxControllerDesc& operator=(const PxBoxControllerDesc&);
/**
\brief (re)sets the structure to the default.
*/
PX_INLINE virtual void setToDefault();
/**
\brief returns true if the current settings are valid
\return True if the descriptor is valid.
*/
PX_INLINE virtual bool isValid() const;
/**
\brief Half height
<b>Default:</b> 1.0
*/
PxF32 halfHeight; // Half-height in the "up" direction
/**
\brief Half side extent
<b>Default:</b> 0.5
*/
PxF32 halfSideExtent; // Half-extent in the "side" direction
/**
\brief Half forward extent
<b>Default:</b> 0.5
*/
PxF32 halfForwardExtent; // Half-extent in the "forward" direction
protected:
PX_INLINE void copy(const PxBoxControllerDesc&);
};
PX_INLINE PxBoxControllerDesc::PxBoxControllerDesc() :
PxControllerDesc (PxControllerShapeType::eBOX),
halfHeight (1.0f),
halfSideExtent (0.5f),
halfForwardExtent (0.5f)
{
}
PX_INLINE PxBoxControllerDesc::PxBoxControllerDesc(const PxBoxControllerDesc& other) : PxControllerDesc(other)
{
copy(other);
}
PX_INLINE PxBoxControllerDesc& PxBoxControllerDesc::operator=(const PxBoxControllerDesc& other)
{
PxControllerDesc::operator=(other);
copy(other);
return *this;
}
PX_INLINE void PxBoxControllerDesc::copy(const PxBoxControllerDesc& other)
{
halfHeight = other.halfHeight;
halfSideExtent = other.halfSideExtent;
halfForwardExtent = other.halfForwardExtent;
}
PX_INLINE void PxBoxControllerDesc::setToDefault()
{
*this = PxBoxControllerDesc();
}
PX_INLINE bool PxBoxControllerDesc::isValid() const
{
if(!PxControllerDesc::isValid()) return false;
if(halfHeight<=0.0f) return false;
if(halfSideExtent<=0.0f) return false;
if(halfForwardExtent<=0.0f) return false;
if(stepOffset>2.0f*halfHeight) return false; // Prevents obvious mistakes
return true;
}
/**
\brief Box character controller.
@see PxBoxControllerDesc PxController
*/
class PxBoxController : public PxController
{
public:
/**
\brief Gets controller's half height.
\return The half height of the controller.
@see PxBoxControllerDesc.halfHeight setHalfHeight()
*/
virtual PxF32 getHalfHeight() const = 0;
/**
\brief Gets controller's half side extent.
\return The half side extent of the controller.
@see PxBoxControllerDesc.halfSideExtent setHalfSideExtent()
*/
virtual PxF32 getHalfSideExtent() const = 0;
/**
\brief Gets controller's half forward extent.
\return The half forward extent of the controller.
@see PxBoxControllerDesc.halfForwardExtent setHalfForwardExtent()
*/
virtual PxF32 getHalfForwardExtent() const = 0;
/**
\brief Sets controller's half height.
\warning this doesn't check for collisions.
\param[in] halfHeight The new half height for the controller.
\return Currently always true.
@see PxBoxControllerDesc.halfHeight getHalfHeight()
*/
virtual bool setHalfHeight(PxF32 halfHeight) = 0;
/**
\brief Sets controller's half side extent.
\warning this doesn't check for collisions.
\param[in] halfSideExtent The new half side extent for the controller.
\return Currently always true.
@see PxBoxControllerDesc.halfSideExtent getHalfSideExtent()
*/
virtual bool setHalfSideExtent(PxF32 halfSideExtent) = 0;
/**
\brief Sets controller's half forward extent.
\warning this doesn't check for collisions.
\param[in] halfForwardExtent The new half forward extent for the controller.
\return Currently always true.
@see PxBoxControllerDesc.halfForwardExtent getHalfForwardExtent()
*/
virtual bool setHalfForwardExtent(PxF32 halfForwardExtent) = 0;
protected:
PX_INLINE PxBoxController() {}
virtual ~PxBoxController() {}
};
#if !PX_DOXYGEN
} // namespace physx
#endif
/** @} */
#endif
| 6,070 | C | 25.627193 | 110 | 0.742834 |
NVIDIA-Omniverse/PhysX/physx/include/characterkinematic/PxControllerObstacles.h | // 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-2023 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 PX_CONTROLLER_OBSTACLES_H
#define PX_CONTROLLER_OBSTACLES_H
/** \addtogroup character
@{
*/
#include "characterkinematic/PxExtended.h"
#include "geometry/PxGeometry.h"
#if !PX_DOXYGEN
namespace physx
{
#endif
class PxControllerManager;
#define PX_INVALID_OBSTACLE_HANDLE 0xffffffff
/**
\brief Base class for obstacles.
@see PxBoxObstacle PxCapsuleObstacle PxObstacleContext
*/
class PxObstacle
{
protected:
PxObstacle() :
mType (PxGeometryType::eINVALID),
mUserData (NULL),
mPos (0.0, 0.0, 0.0),
mRot (PxQuat(PxIdentity))
{}
PxGeometryType::Enum mType;
public:
PX_FORCE_INLINE PxGeometryType::Enum getType() const { return mType; }
void* mUserData;
PxExtendedVec3 mPos;
PxQuat mRot;
};
/**
\brief A box obstacle.
@see PxObstacle PxCapsuleObstacle PxObstacleContext
*/
class PxBoxObstacle : public PxObstacle
{
public:
PxBoxObstacle() :
mHalfExtents(0.0f)
{ mType = PxGeometryType::eBOX; }
PxVec3 mHalfExtents;
};
/**
\brief A capsule obstacle.
@see PxBoxObstacle PxObstacle PxObstacleContext
*/
class PxCapsuleObstacle : public PxObstacle
{
public:
PxCapsuleObstacle() :
mHalfHeight (0.0f),
mRadius (0.0f)
{ mType = PxGeometryType::eCAPSULE; }
PxReal mHalfHeight;
PxReal mRadius;
};
typedef PxU32 PxObstacleHandle;
/**
\brief Context class for obstacles.
An obstacle context class contains and manages a set of user-defined obstacles.
@see PxBoxObstacle PxCapsuleObstacle PxObstacle
*/
class PxObstacleContext
{
public:
PxObstacleContext() {}
virtual ~PxObstacleContext() {}
/**
\brief Releases the context.
*/
virtual void release() = 0;
/**
\brief Retrieves the controller manager associated with this context.
\return The associated controller manager
*/
virtual PxControllerManager& getControllerManager() const = 0;
/**
\brief Adds an obstacle to the context.
\param [in] obstacle Obstacle data for the new obstacle. The data gets copied.
\return Handle for newly-added obstacle
*/
virtual PxObstacleHandle addObstacle(const PxObstacle& obstacle) = 0;
/**
\brief Removes an obstacle from the context.
\param [in] handle Handle for the obstacle object that needs to be removed.
\return True if success
*/
virtual bool removeObstacle(PxObstacleHandle handle) = 0;
/**
\brief Updates data for an existing obstacle.
\param [in] handle Handle for the obstacle object that needs to be updated.
\param [in] obstacle New obstacle data
\return True if success
*/
virtual bool updateObstacle(PxObstacleHandle handle, const PxObstacle& obstacle) = 0;
/**
\brief Retrieves number of obstacles in the context.
\return Number of obstacles in the context
*/
virtual PxU32 getNbObstacles() const = 0;
/**
\brief Retrieves desired obstacle.
\param [in] i Obstacle index
\return Desired obstacle
*/
virtual const PxObstacle* getObstacle(PxU32 i) const = 0;
/**
\brief Retrieves desired obstacle by given handle.
\param [in] handle Obstacle handle
\return Desired obstacle
*/
virtual const PxObstacle* getObstacleByHandle(PxObstacleHandle handle) const = 0;
};
#if !PX_DOXYGEN
}
#endif
/** @} */
#endif
| 5,199 | C | 26.225131 | 90 | 0.693403 |
NVIDIA-Omniverse/PhysX/physx/include/gpu/PxPhysicsGpu.h | // 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-2023 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 PX_PHYSICS_GPU_H
#define PX_PHYSICS_GPU_H
/** \addtogroup extensions
@{
*/
#include "cudamanager/PxCudaContext.h"
#include "cudamanager/PxCudaContextManager.h"
#include "foundation/PxSimpleTypes.h"
#include "foundation/PxVec4.h"
#include "PxParticleSystem.h"
#include "foundation/PxArray.h"
#include "PxParticleGpu.h"
#if !PX_DOXYGEN
namespace physx
{
#endif
#if PX_SUPPORT_GPU_PHYSX
class PxSceneDesc;
class PxIsosurfaceExtractor;
class PxSparseGridIsosurfaceExtractor;
class PxAnisotropyGenerator;
class PxSmoothedPositionGenerator;
class PxParticleNeighborhoodProvider;
class PxArrayConverter;
class PxLineStripSkinning;
class PxSoftBodyEmbedding;
class PxSDFBuilder;
struct PxIsosurfaceParams;
struct PxSparseGridParams;
class PxPhysicsGpu
{
public:
/**
\brief Creates an isosurface extractor operating on a dense grid
\param[in] cudaContextManager A cuda context manager
\param[in] worldBounds The bounds of the internally used dense grid. The isosurface can only be generated inside those bounds.
\param[in] cellSize The size of a single grid cell
\param[in] isosurfaceParams The isosurface parameters to control the isolevel etc.
\param[in] maxNumParticles The maximal number of particles that can be processed
\param[in] maxNumVertices The maximal number of vertices the output buffer can hold
\param[in] maxNumTriangles The maximal number of triangles the output buffer can hold
*/
virtual PxIsosurfaceExtractor* createDenseGridIsosurfaceExtractor(PxCudaContextManager* cudaContextManager, const PxBounds3& worldBounds,
PxReal cellSize, const PxIsosurfaceParams& isosurfaceParams, PxU32 maxNumParticles, PxU32 maxNumVertices = 512 * 1024, PxU32 maxNumTriangles = 1024 * 1024) = 0;
/**
\brief Creates an isosurface extractor operating on a sparse grid
\param[in] cudaContextManager A cuda context manager
\param[in] sparseGridParams The sparse grid parameters defining the cell size etc.
\param[in] isosurfaceParams The isosurface parameters to control the isolevel etc.
\param[in] maxNumParticles The maximal number of particles that can be processed
\param[in] maxNumVertices The maximal number of vertices the output buffer can hold
\param[in] maxNumTriangles The maximal number of triangles the output buffer can hold
*/
virtual PxSparseGridIsosurfaceExtractor* createSparseGridIsosurfaceExtractor(PxCudaContextManager* cudaContextManager, const PxSparseGridParams& sparseGridParams,
const PxIsosurfaceParams& isosurfaceParams, PxU32 maxNumParticles, PxU32 maxNumVertices = 512 * 1024, PxU32 maxNumTriangles = 1024 * 1024) = 0;
/**
\brief Creates an anisotropy generator
\param[in] cudaContextManager A cuda context manager
\param[in] maxNumParticles The number of particles
\param[in] anisotropyScale A uniform scaling factor to increase or decrease anisotropy
\param[in] minAnisotropy The minimum scaling factor in any dimension that anisotropy can have
\param[in] maxAnisotropy The maximum scaling factor in any dimension that anisotropy can have
*/
virtual PxAnisotropyGenerator* createAnisotropyGenerator(PxCudaContextManager* cudaContextManager, PxU32 maxNumParticles,
PxReal anisotropyScale = 1.0f, PxReal minAnisotropy = 0.1f, PxReal maxAnisotropy = 2.0f) = 0;
/**
\brief Creates a smoothed position generator
\param[in] cudaContextManager A cuda context manager
\param[in] maxNumParticles The number of particles
\param[in] smoothingStrength Controls the strength of the smoothing effect
*/
virtual PxSmoothedPositionGenerator* createSmoothedPositionGenerator(PxCudaContextManager* cudaContextManager, PxU32 maxNumParticles, PxReal smoothingStrength = 0.5f) = 0;
/**
\brief Creates a neighborhood provider
\param[in] cudaContextManager A cuda context manager
\param[in] maxNumParticles The number of particles
\param[in] cellSize The grid cell size. Should be equal to 2*contactOffset for PBD particle systems.
\param[in] maxNumSparseGridCells The maximal number of cells the internally used sparse grid can provide
*/
virtual PxParticleNeighborhoodProvider* createParticleNeighborhoodProvider(PxCudaContextManager* cudaContextManager, const PxU32 maxNumParticles,
const PxReal cellSize, const PxU32 maxNumSparseGridCells = 262144) = 0;
/**
\brief Creates an array converter. If not used anymore, the caller needs to delete the returned pointer.
\param[in] cudaContextManager A cuda context manager
*/
virtual PxArrayConverter* createArrayConverter(PxCudaContextManager* cudaContextManager) = 0;
/**
\brief Creates an line strip embedding helper. If not used anymore, the caller needs to delete the returned pointer.
\param[in] cudaContextManager A cuda context manager
\return Pointer to a new instance of a PxLineStripSkinning
*/
virtual PxLineStripSkinning* createLineStripSkinning(PxCudaContextManager* cudaContextManager) = 0;
/**
\brief Creates sdf builder to construct sdfs quickly on the GPU. If not used anymore, the caller needs to delete the returned pointer.
\param[in] cudaContextManager A cuda context manager
\return Pointer to a new instance of a PxSDFBuilder
*/
virtual PxSDFBuilder* createSDFBuilder(PxCudaContextManager* cudaContextManager) = 0;
/**
\brief Estimates the amount of GPU memory needed to create a scene for the given descriptor.
\param[in] sceneDesc a valid scene desriptor
\note While this is a conservative estimate, scene allocation may still fail even though there is
enough memory - this function does not contain the potential overhead coming from the CUDA allocator.
Additionally, there may be fragmentation issues. Generally, this is not an issue for
scene allocation sizes < 500Mb, but may become problematic for larger scenes.
\return A conservative estimate for the amount of GPU memory needed to create a scene for the given descriptor.
*/
virtual PxU64 estimateSceneCreationGpuMemoryRequirements(const PxSceneDesc& sceneDesc) = 0;
virtual void release() = 0;
virtual ~PxPhysicsGpu() {}
};
#endif
#if !PX_DOXYGEN
} // namespace physx
#endif
/** @} */
#endif
| 7,853 | C | 41.454054 | 173 | 0.784414 |
Subsets and Splits