1737 lines
71 KiB
TypeScript
1737 lines
71 KiB
TypeScript
interface Vec3 {
|
|
x: number, y: number, z: number
|
|
}
|
|
|
|
interface Quat {
|
|
x: number, y: number, z: number, w: number
|
|
}
|
|
|
|
interface FilterData {
|
|
word0: number
|
|
word1: number
|
|
word2: number
|
|
word3: number
|
|
}
|
|
|
|
declare namespace phy {
|
|
/// Base ///
|
|
|
|
const physics: Physics;
|
|
abstract class Physics {
|
|
private constructor ()
|
|
createCooking (cp: CookingParams): Cooking
|
|
createSceneDesc (): SceneDesc
|
|
createScene (desc: SceneDesc): Scene
|
|
createRigidDynamic (pose: Transform): RigidDynamic
|
|
createRigidStatic (pose: Transform): RigidStatic
|
|
createMaterial (staticFriction: number, dynamicFriction: number, restitution: number): Material
|
|
createShape (geometry: Geometry, material: Material, isExclusive?: boolean | false, shapeFlags?: number): Shape
|
|
}
|
|
|
|
interface Base {
|
|
release (): void
|
|
}
|
|
|
|
class CookingParams { }
|
|
|
|
abstract class Cooking {
|
|
createHeightField (desc: HeightFieldDesc): HeightField
|
|
createTriangleMesh (desc: TriangleMeshDesc): TriangleMesh
|
|
validateTriangleMesh (desc: TriangleMeshDesc): boolean
|
|
validateConvexMesh (desc: ConvexMeshDesc): boolean
|
|
createConvexMesh (desc: ConvexMeshDesc): ConvexMesh
|
|
setParams (params: CookingParams): void
|
|
getParams (): CookingParams
|
|
}
|
|
|
|
interface ContactPairHeader {
|
|
shapes: Shape[]
|
|
pairBuffer: ArrayBuffer
|
|
contactBuffer: ArrayBuffer
|
|
}
|
|
|
|
type onContact = (header: ContactPairHeader) => {}
|
|
type onTrigger = (pairs: any[], pairsBuffer: ArrayBuffer) => {}
|
|
class SimulationEventCallback {
|
|
constructor ()
|
|
setOnContact (method: onContact): void
|
|
setOnTrigger (method: onTrigger): void
|
|
}
|
|
|
|
class SceneDesc {
|
|
setFlags (flag: SceneFlag, val: boolean): void //PhysX 中为 setFlag
|
|
setGravity (gravity: Vec3): void
|
|
setSubThreadCount (val: number): void
|
|
getMaxSubThreadCount (): number
|
|
setSimulationEventCallback (callback: SimulationEventCallback): void
|
|
}
|
|
|
|
abstract class Scene {
|
|
getGravity (): Vec3
|
|
setGravity (val: Vec3): void
|
|
addActor (actor: Actor): void
|
|
removeActor (actor: Actor, wakeOnLostTouch?: boolean | true): void
|
|
simulate (elapsedTime: number): void
|
|
fetchResults (block?: boolean | true): void
|
|
setFlag (flag: SceneFlag, value: boolean): void
|
|
getFlags (): number
|
|
getPhysics (): Physics
|
|
getTimestamp (): number
|
|
}
|
|
|
|
class Bounds3 {
|
|
getExtents (): Vec3
|
|
getCenter (): Vec3
|
|
}
|
|
|
|
class Transform {
|
|
constructor ()
|
|
isValid (): boolean
|
|
setPosition (pos: Vec3): void
|
|
getPosition (): Vec3
|
|
setQuaternion (quat: Quat): void
|
|
getQuaternion (): Quat
|
|
}
|
|
|
|
abstract class Material implements Base {
|
|
private constructor ()
|
|
release (): void
|
|
setFlag (flag: MaterialFlag, val: boolean): void
|
|
setFlags (flags: number): void
|
|
setRestitution (val: number): void
|
|
setStaticFriction (val: number): void
|
|
setDynamicFriction (val: number): void
|
|
setFrictionCombineMode (mode: CombineMode): void
|
|
setRestitutionCombineMode (mode: CombineMode): void
|
|
}
|
|
|
|
abstract class Shape implements Base {
|
|
private constructor ()
|
|
release (): void
|
|
isExclusive (): boolean
|
|
setFlag (flag: ShapeFlag, val: boolean): void
|
|
getFlags (): number
|
|
setFlags (flags: number): void
|
|
setLocalPose (pose: Transform): void
|
|
setQueryFilterData (data: FilterData): void
|
|
setSimulationFilterData (data: FilterData): void
|
|
setMaterials (materials: Array<Material>): void
|
|
setRestOffset (val: number): void
|
|
setContactOffset (offset: number): void
|
|
setGeometry (geometry: Geometry): void
|
|
}
|
|
|
|
/// Actor ///
|
|
|
|
abstract class Actor implements Base {
|
|
release (): void
|
|
getType (): number
|
|
setUserData (data: number): void
|
|
getUserData (): number
|
|
setActorFlag (flag: ActorFlag, val: boolean): void
|
|
setActorFlags (flags: number): void
|
|
getActorFlags (): number
|
|
getWorldBounds (inflation?: number | 1.01): Bounds3
|
|
setDominanceGroup (val: number): number
|
|
getDominanceGroup (): number
|
|
}
|
|
|
|
abstract class RigidActor extends Actor {
|
|
setGlobalPose (pose: Transform, autowake?: boolean | true): void
|
|
getGlobalPose (): Transform
|
|
attachShape (shape: Shape): boolean
|
|
getNbShapes (): number
|
|
}
|
|
|
|
class RigidStatic extends RigidActor { }
|
|
|
|
abstract class RigidBody extends RigidActor {
|
|
setMass (val: number): void
|
|
getMass (val: number): void
|
|
getInvMass (val: number): void
|
|
setCMassLocalPose (pose: Transform): void
|
|
getCMassLocalPose (): Transform
|
|
setLinearDamping (val: number): void
|
|
setAngularDamping (val: number): void
|
|
setLinearVelocity (val: Vec3, autowake?: boolean | true): void
|
|
setAngularVelocity (val: Vec3, autowake?: boolean | true): void
|
|
addTorque (torque: Vec3, mode: number, autowake?: boolean | true): void
|
|
setRigidBodyFlag (flag: RigidBodyFlag, val: boolean): void
|
|
setRigidBodyFlags (flags: number): void
|
|
getRigidBodyFlags (flags: number): void
|
|
clearForce (mode: number): void
|
|
clearTorque (mode: number): void
|
|
}
|
|
|
|
abstract class RigidDynamic extends RigidBody {
|
|
wakeUp (): void
|
|
isSleeping (): boolean
|
|
putToSleep (): void
|
|
setKinematicTarget (transform: Transform): void
|
|
setWakeCounter (val: number): void
|
|
getWakeCounter (): number
|
|
setSleepThreshold (val: number): void
|
|
getSleepThreshold (): void
|
|
setContactReportThreshold (val: number): void
|
|
getContactReportThreshold (): number
|
|
setStabilizationThreshold (val: number): void
|
|
getStabilizationThreshold (): number
|
|
setRigidDynamicLockFlag (flag: RigidDynamicLockFlag, val: boolean): void
|
|
setRigidDynamicLockFlags (flags: number): void
|
|
getRigidDynamicLockFlags (): number
|
|
}
|
|
|
|
/// Character Controller ///
|
|
|
|
interface ControllerShapeHit {
|
|
}
|
|
|
|
interface ControllersHit {
|
|
}
|
|
|
|
abstract class Controller {
|
|
release (): void
|
|
move (disp: Vec3, minDist: number, elapsedTime: number,
|
|
filterData: FilterData, cb: number): number
|
|
setPosition (pos: any): void
|
|
getPosition (): any
|
|
setStepOffset (val: number): void
|
|
getStepOffset (): number
|
|
setContactOffset (val: number): void
|
|
getContactOffset (): number
|
|
setSlopeLimit (val: number): void
|
|
getSlopeLimit (): number
|
|
setCollision (val: boolean): void
|
|
setSimulationFilterData (val: FilterData): void
|
|
setQueryFilterData (val: FilterData): void
|
|
}
|
|
|
|
class CapsuleController extends Controller {
|
|
constructor ()
|
|
setRadius (val: number): void
|
|
getRadius (): number
|
|
setHeight (val: number): void
|
|
getHeight (): number
|
|
setClimbingMode (val: number): void
|
|
getClimbingMode (): number
|
|
}
|
|
|
|
class BoxController extends Controller {
|
|
constructor ()
|
|
setHalfHeight (val: number): void
|
|
getHalfHeight (): number
|
|
setHalfSideExtent(val: number): void
|
|
getHalfSideExtent (): number
|
|
setHalfForwardExtent (val: number): void
|
|
getHalfForwardExtent (): number
|
|
}
|
|
|
|
/// Geometry ///
|
|
|
|
interface Geometry {
|
|
isVaild (): boolean
|
|
}
|
|
|
|
/** Primitive */
|
|
|
|
class BoxGeometry implements Geometry {
|
|
constructor (halfSize: Vec3)
|
|
isVaild (): boolean
|
|
setHalfExtents (halfSize: Vec3): void
|
|
}
|
|
|
|
class SphereGeometry implements Geometry {
|
|
constructor (radius: number)
|
|
isVaild (): boolean
|
|
setRadius (radius: number): void
|
|
}
|
|
|
|
class PlaneGeometry implements Geometry {
|
|
constructor ()
|
|
isVaild (): boolean
|
|
}
|
|
|
|
class CapsuleGeometry implements Geometry {
|
|
constructor (radius: number, halfHeight: number)
|
|
isVaild (): boolean
|
|
setRadius (radius: number): void
|
|
setHalfHeight (halfHeight: number): void
|
|
}
|
|
|
|
class MeshScale {
|
|
constructor (scale: Vec3, rotation: Quat)
|
|
isValidForConvexMesh (): boolean
|
|
isValidForTriangleMesh (): boolean
|
|
hasNegativeDeterminant (): boolean
|
|
setScale (scale: Vec3): void
|
|
setRotation (rotation: Quat): void
|
|
}
|
|
|
|
/** Triangle Mesh */
|
|
|
|
class TriangleMeshDesc {
|
|
constructor ()
|
|
isValid (): boolean
|
|
setPointsData (data: Float32Array): void
|
|
setPointsCount (count: number): void
|
|
setPointsStride (stride: number): void
|
|
setTrianglesData (data: Uint32Array | Uint16Array): void
|
|
setTrianglesCount (count: number): void
|
|
setTrianglesStride (stride: number): void
|
|
getMaterialsData (): Uint16Array
|
|
setMaterialsData (data: Uint16Array): void
|
|
getMaterialsStride (): number
|
|
setMaterialsStride (stride: number): void
|
|
}
|
|
|
|
class TriangleMesh implements Base {
|
|
private constructor ()
|
|
release (): void
|
|
getLocalBounds (): Bounds3
|
|
}
|
|
|
|
class TriangleMeshGeometry implements Geometry {
|
|
constructor (mesh: TriangleMesh, scale: MeshScale, flags: number)
|
|
isVaild (): boolean
|
|
setScale (scale: MeshScale): void
|
|
setFlags (flags: number): void
|
|
setTriangleMesh (mesh: TriangleMesh): void
|
|
}
|
|
|
|
/** Convex Hull */
|
|
|
|
class ConvexMeshDesc {
|
|
isValid (): boolean
|
|
setPointsData (data: Float32Array): void
|
|
setPointsCount (count: number): void
|
|
setPointsStride (stride: number): void
|
|
setConvexFlags (flags: number): void
|
|
}
|
|
|
|
class ConvexMesh implements Base {
|
|
private constructor ()
|
|
release (): void
|
|
getLocalBounds (): Bounds3
|
|
}
|
|
|
|
class ConvexMeshGeometry implements Geometry {
|
|
constructor (mesh: ConvexMesh, scale: MeshScale, flags: number)
|
|
isVaild (): boolean
|
|
setScale (scale: MeshScale): void
|
|
setFlags (flags: number): void
|
|
setTriangleMesh (mesh: TriangleMesh): void
|
|
}
|
|
|
|
/** Height Field */
|
|
|
|
class HeightFieldDesc {
|
|
isValid (): boolean
|
|
setNbRows (rows: number): void
|
|
setNbColumns (cols: number): void
|
|
setSamples (samples: HeightFieldSamples): void
|
|
setHeightFieldFlags (flags: number): void
|
|
setConvexEdgeThreshold (threshold: number): void
|
|
}
|
|
|
|
class HeightFieldSamples {
|
|
setHeightAtIndex (index: number, height: number): void
|
|
}
|
|
|
|
class HeightField implements Base {
|
|
private constructor ()
|
|
release (): void
|
|
}
|
|
|
|
class HeightFieldGeometry implements Geometry {
|
|
constructor (hf: HeightField, heightScale: number, rowScale: number, colScale: number)
|
|
isVaild (): boolean
|
|
}
|
|
|
|
/// Joints ///
|
|
|
|
/// Extensions ///
|
|
|
|
interface Spring {
|
|
stiffness: number
|
|
damping: number
|
|
}
|
|
|
|
interface Bounce {
|
|
restitution: number
|
|
velocityThreshold: number
|
|
}
|
|
|
|
class JointLimitParameters {
|
|
protected constructor ()
|
|
getRestitution (): number
|
|
setRestitution (val: number): void
|
|
setBounceThreshold (val: number): void
|
|
getBounceThreshold (): number
|
|
getStiffness (): number
|
|
setStiffness (val: number): void
|
|
getDamping (): number
|
|
setDamping (val: number): void
|
|
getContactDistance (): number
|
|
setContactDistance (val: number): void
|
|
isValid (): boolean
|
|
isSoft (): boolean
|
|
}
|
|
|
|
class JointLinearLimit extends JointLimitParameters {
|
|
constructor (extent: number, contactDist?: number | -1)
|
|
constructor (extent: number, spring: Spring)
|
|
getValue (): number
|
|
setValue (val: number): void
|
|
}
|
|
|
|
class JointLinearLimitPair extends JointLimitParameters {
|
|
constructor (lowerLimit: number, upperLimit: number, contactDist?: number | -1)
|
|
constructor (lowerLimit: number, upperLimit: number, spring: Spring)
|
|
getUpper (): number
|
|
setUpper (val: number): void
|
|
getLower (): number
|
|
setLower (val: number): void
|
|
}
|
|
|
|
class JointAngularLimitPair extends JointLimitParameters {
|
|
constructor (lowerLimit: number, upperLimit: number, contactDist?: number | -1)
|
|
constructor (lowerLimit: number, upperLimit: number, spring: Spring)
|
|
getUpper (): number
|
|
setUpper (val: number): void
|
|
getLower (): number
|
|
setLower (val: number): void
|
|
}
|
|
|
|
class JointLimitCone extends JointLimitParameters {
|
|
constructor (lowerLimit: number, upperLimit: number, contactDist?: number | -1)
|
|
constructor (lowerLimit: number, upperLimit: number, spring: Spring)
|
|
getYAngle (): number
|
|
setYAngle (val: number): void
|
|
getZAngle (): number
|
|
setZAngle (val: number): void
|
|
}
|
|
|
|
class JointLimitPyramid extends JointLimitParameters {
|
|
constructor (yLimitAngleMin: number, yLimitAngleMax: number, LimitAngleMin: number, zLimitAngleMax: number, contactDist?: number | -1)
|
|
constructor (yLimitAngleMin: number, yLimitAngleMax: number, LimitAngleMin: number, zLimitAngleMax: number, spring: Spring)
|
|
getYAngleMin (): number
|
|
setYAngleMin (val: number): void
|
|
getYAngleMax (): number
|
|
setYAngleMax (val: number): void
|
|
getZAngleMin (): number
|
|
setZAngleMin (val: number): void
|
|
getZAngleMax (): number
|
|
setZAngleMax (val: number): void
|
|
}
|
|
|
|
interface JointBreakForce {
|
|
force: number
|
|
torque: number
|
|
}
|
|
|
|
class Joint implements Base {
|
|
protected constructor ()
|
|
release (): void
|
|
setActors (actor0: RigidActor, actor1?: RigidActor): void
|
|
setLocalPose (index: JointActorIndex, pose: Transform): void
|
|
setBreakForce (force: number, torque: number): void
|
|
getBreakForce (): JointBreakForce
|
|
setConstraintFlag (flag: ConstraintFlag, val: boolean): void
|
|
setConstraintFlags (flags: number): void
|
|
getConstraintFlags (): number
|
|
setInvMassScale0 (val: number): void
|
|
setInvInertiaScale0 (val: number): void
|
|
setInvMassScale1 (val: number): void
|
|
setInvInertiaScale1 (val: number): void
|
|
getInvMassScale0 (): number
|
|
getInvMassScale1 (): number
|
|
getInvInertiaScale0 (): number
|
|
getInvInertiaScale1 (): number
|
|
getLocalPose (index: JointActorIndex): Transform
|
|
getRelativeTransform (): Transform
|
|
getRelativeLinearVelocity (): Vec3
|
|
getRelativeAngularVelocity (): Vec3
|
|
getScene (): Scene | null
|
|
}
|
|
|
|
class RevoluteJoint extends Joint {
|
|
private constructor ()
|
|
getAngle (): number
|
|
getVelocity (): number
|
|
getLimit (): JointAngularLimitPair
|
|
getDriveVelocity (): number
|
|
getDriveForceLimit (): number
|
|
getDriveGearRatio (): number
|
|
getRevoluteJointFlags (): number
|
|
getProjectionLinearTolerance (): number
|
|
getProjectionAngularTolerance (): number
|
|
setLimit (limit: JointAngularLimitPair): void
|
|
setProjectionAngularTolerance (val: number): void
|
|
setProjectionLinearTolerance (val: number): void
|
|
setRevoluteJointFlags (flags: number): void
|
|
setRevoluteJointFlag (flag: RevoluteJointFlag, val: boolean): void
|
|
setDriveGearRatio (val: number): void
|
|
setDriveForceLimit (val: number): void
|
|
setDriveVelocity (val: number, autowake?: boolean | true): void
|
|
}
|
|
|
|
class DistanceJoint extends Joint {
|
|
private constructor ()
|
|
getDistance (): number
|
|
getMinDistance (): number
|
|
getMaxDistance (): number
|
|
getTolerance (): number
|
|
getStiffness (): number
|
|
getDamping (): number
|
|
getDistanceJointFlags (): number
|
|
setDamping (): number
|
|
setDistanceJointFlag (flag: DistanceJointFlag, val: boolean): void
|
|
setDistanceJointFlags (flags: number): void
|
|
setStiffness (val: number): void
|
|
setTolerance (val: number): void
|
|
setMaxDistance (val: number): void
|
|
setMinDistance (val: number): void
|
|
}
|
|
|
|
class FixedJoint extends Joint {
|
|
private constructor ()
|
|
setProjectionLinearTolerance (val: number): void
|
|
setProjectionAngularTolerance (val: number): void
|
|
getProjectionAngularTolerance (): number
|
|
getProjectionLinearTolerance (): number
|
|
}
|
|
|
|
class PrismaticJoint extends Joint {
|
|
private constructor ()
|
|
setLimit (limit: JointLinearLimitPair): void
|
|
setPrismaticJointFlag (flag: PrismaticJointFlag, val: boolean): void
|
|
setPrismaticJointFlags (flags: number): void
|
|
setProjectionLinearTolerance (val: number): void
|
|
setProjectionAngularTolerance (val: number): void
|
|
getPosition (): number
|
|
getVelocity (): number
|
|
getLimit (): JointLinearLimitPair
|
|
getPrismaticJointFlags (): number
|
|
getProjectionLinearTolerance (): number
|
|
getProjectionAngularTolerance (): number
|
|
}
|
|
|
|
class SphericalJoint extends Joint {
|
|
private constructor ()
|
|
getLimitCone (): JointLimitCone
|
|
setSphericalJointFlag (flag: PrismaticJointFlag, val: boolean): void
|
|
getSphericalJointFlags (): number
|
|
getProjectionLinearTolerance (): number
|
|
setLimitCone (limit: JointLimitCone): void
|
|
setSphericalJointFlags (flags: number): void
|
|
setProjectionLinearTolerance (val: number): void
|
|
}
|
|
|
|
class ContactJoint extends Joint {
|
|
private constructor ()
|
|
setContact (val: Vec3): void
|
|
setContactNormal (val: Vec3): void
|
|
setPenetration (val: number): void
|
|
setResititution (val: number): void
|
|
setBounceThreshold (val: number): void
|
|
getContact (): Vec3
|
|
getContactNormal (): Vec3
|
|
getPenetration (): number
|
|
getResititution (): number
|
|
getBounceThreshold (): number
|
|
}
|
|
|
|
class D6JointDrive {
|
|
constructor ()
|
|
constructor (driveStiffness: number, driveDamping: number, driveForceLimit: number, isAcceleration?: boolean | false)
|
|
setForceLimit (val: number): void
|
|
getForceLimit (): number
|
|
setFlags (flags: number): void
|
|
getFlags (): number
|
|
setStiffness (val: number): void
|
|
getStiffness (): number
|
|
setDamping (val: number): void
|
|
getDamping (): number
|
|
}
|
|
|
|
interface DriveVelocity {
|
|
linear: Vec3
|
|
angular: Vec3
|
|
}
|
|
|
|
class D6Joint extends Joint {
|
|
private constructor ()
|
|
getMotion (axis: D6Axis): D6Motion
|
|
getTwistAngle (): number
|
|
getSwingYAngle (): number
|
|
getSwingZAngle (): number
|
|
getDistanceLimit (): JointLinearLimit
|
|
getLinearLimit (axis: D6Axis): JointLinearLimitPair
|
|
getTwistLimit (): JointAngularLimitPair
|
|
getSwingLimit (): JointLimitCone
|
|
getPyramidSwingLimit (): JointLimitPyramid
|
|
getDrive (index: D6Drive): D6JointDrive
|
|
getDrivePosition (): Transform
|
|
getDriveVelocity (): DriveVelocity
|
|
getProjectionLinearTolerance (): number
|
|
getProjectionAngularTolerance (): number
|
|
setDriveVelocity (linear: Vec3, angular: Vec3, autowake?: boolean | true): void
|
|
setProjectionLinearTolerance (val: number): void
|
|
setProjectionAngularTolerance (val: number): void
|
|
setLinearLimit (axis: D6Axis, limit: JointLinearLimit): void
|
|
setDrive (index: D6Drive, drive: D6JointDrive): void
|
|
setDrivePosition (pose: Transform, autowake?: boolean | true): void
|
|
setSwingLimit (limit: JointLimitCone): void
|
|
setTwistLimit (limit: JointAngularLimitPair): void
|
|
setMotion (index: D6Axis, motion: D6Motion): void
|
|
setDistanceLimit (limit: JointLinearLimit): void
|
|
setPyramidSwingLimit (limit: JointLimitPyramid): void
|
|
}
|
|
|
|
function createRevoluteJoint (actor0: RigidActor, localframe0: Transform, actor1: RigidActor | null, localframe1: Transform): RevoluteJoint
|
|
function createContactJoint (actor0: RigidActor, localframe0: Transform, actor1: RigidActor | null, localframe1: Transform): ContactJoint
|
|
function createDistanceJoint (actor0: RigidActor, localframe0: Transform, actor1: RigidActor | null, localframe1: Transform): DistanceJoint
|
|
function createD6Joint (actor0: RigidActor, localframe0: Transform, actor1: RigidActor | null, localframe1: Transform): D6Joint
|
|
function createPrismaticJoint (actor0: RigidActor, localframe0: Transform, actor1: RigidActor | null, localframe1: Transform): PrismaticJoint
|
|
function createFixedJoint (actor0: RigidActor, localframe0: Transform, actor1: RigidActor | null, localframe1: Transform): FixedJoint
|
|
function createSphericalJoint (actor0: RigidActor, localframe0: Transform, actor1: RigidActor | null, localframe1: Transform): SphericalJoint
|
|
|
|
/// Extensions ///
|
|
|
|
namespace ShapeExt {
|
|
function getWorldBounds (shape: Shape, actor: RigidActor, inflation?: number | 1.01): Bounds3
|
|
}
|
|
|
|
namespace RigidBodyExt {
|
|
function setMassAndUpdateInertia (body: RigidBody, shapeDensities: number | Array<number>, massLoclPose?: Vec3, includeNonSimShapes?: boolean): boolean
|
|
function applyImpulse (body: RigidBody, impulse: Vec3, relativePoint: Vec3): void
|
|
function applyLocalImpulse (body: RigidBody, localImpulse: Vec3, relativePoint: Vec3): void
|
|
function applyForce (body: RigidBody, force: Vec3, relativePoint: Vec3): void
|
|
function applyLocalForce (body: RigidBody, localForce: Vec3, relativePoint: Vec3): void
|
|
}
|
|
|
|
class SceneQueryHit {
|
|
private constructor ()
|
|
actor: RigidActor;
|
|
shape: Shape;
|
|
faceIndex: number;
|
|
}
|
|
|
|
class RayCastHit {
|
|
private constructor ()
|
|
actor: RigidActor;
|
|
shape: Shape;
|
|
faceIndex: number;
|
|
u: number;
|
|
v: number;
|
|
normal: Vec3;
|
|
position: Vec3;
|
|
distance: number;
|
|
flags: number;
|
|
}
|
|
|
|
type preFilter = (filterData: FilterData, shape: Shape, actor: RigidActor, hitFlags: number) => QueryHitType
|
|
class QueryFilterCallback {
|
|
constructor ()
|
|
setPreFilter (cb: preFilter): void
|
|
getPreFilter (): preFilter | null
|
|
}
|
|
|
|
namespace SceneQueryExt {
|
|
|
|
interface SceneQueryFilterData {
|
|
data: FilterData
|
|
flags: number
|
|
}
|
|
|
|
function raycastSingle (scene: Scene, origin: Vec3, unitDir: Vec3, distacne: number, flags: number, filterData: SceneQueryFilterData, cb: QueryFilterCallback): RayCastHit | null
|
|
function raycastAny (scene: Scene, origin: Vec3, unitDir: Vec3, distacne: number, filterData: SceneQueryFilterData, cb: QueryFilterCallback): SceneQueryHit | null
|
|
function raycastMultiple (scene: Scene, origin: Vec3, unitDir: Vec3, distacne: number, maxRayCast: number, flags: number, filterData: SceneQueryFilterData, cb: QueryFilterCallback): Array<RayCastHit> | null
|
|
}
|
|
|
|
/// Enum ///
|
|
|
|
enum Axis {
|
|
x,
|
|
y,
|
|
z
|
|
}
|
|
|
|
enum ContactPairHeaderFlag {
|
|
eREMOVED_ACTOR_0 = (1 << 0), //!< The actor with index 0 has been removed from the scene.
|
|
eREMOVED_ACTOR_1 = (1 << 1) //!< The actor with index 1 has been removed from the scene.
|
|
}
|
|
|
|
enum ContactPairFlag {
|
|
/**
|
|
\brief The shape with index 0 has been removed from the actor/scene.
|
|
*/
|
|
eREMOVED_SHAPE_0 = (1 << 0),
|
|
|
|
/**
|
|
\brief The shape with index 1 has been removed from the actor/scene.
|
|
*/
|
|
eREMOVED_SHAPE_1 = (1 << 1),
|
|
|
|
/**
|
|
\brief First actor pair contact.
|
|
|
|
The provided shape pair marks the first contact between the two actors, no other shape pair has been touching prior to the current simulation frame.
|
|
|
|
\note: This info is only available if #PxPairFlag::eNOTIFY_TOUCH_FOUND has been declared for the pair.
|
|
*/
|
|
eACTOR_PAIR_HAS_FIRST_TOUCH = (1 << 2),
|
|
|
|
/**
|
|
\brief All contact between the actor pair was lost.
|
|
|
|
All contact between the two actors has been lost, no shape pairs remain touching after the current simulation frame.
|
|
*/
|
|
eACTOR_PAIR_LOST_TOUCH = (1 << 3),
|
|
|
|
/**
|
|
\brief Internal flag, used by #PxContactPair.extractContacts()
|
|
|
|
The applied contact impulses are provided for every contact point.
|
|
This is the case if #PxPairFlag::eSOLVE_CONTACT has been set for the pair.
|
|
*/
|
|
eINTERNAL_HAS_IMPULSES = (1 << 4),
|
|
|
|
/**
|
|
\brief Internal flag, used by #PxContactPair.extractContacts()
|
|
|
|
The provided contact point information is flipped with regards to the shapes of the contact pair. This mainly concerns the order of the internal triangle indices.
|
|
*/
|
|
eINTERNAL_CONTACTS_ARE_FLIPPED = (1 << 5)
|
|
}
|
|
|
|
enum PairFlag {
|
|
/**
|
|
\brief Process the contacts of this collision pair in the dynamics solver.
|
|
|
|
\note Only takes effect if the colliding actors are rigid bodies.
|
|
*/
|
|
eSOLVE_CONTACT = (1 << 0),
|
|
|
|
/**
|
|
\brief Call contact modification callback for this collision pair
|
|
|
|
\note Only takes effect if the colliding actors are rigid bodies.
|
|
|
|
@see PxContactModifyCallback
|
|
*/
|
|
eMODIFY_CONTACTS = (1 << 1),
|
|
|
|
/**
|
|
\brief Call contact report callback or trigger callback when this collision pair starts to be in contact.
|
|
|
|
If one of the two collision objects is a trigger shape (see #PxShapeFlag::eTRIGGER_SHAPE)
|
|
then the trigger callback will get called as soon as the other object enters the trigger volume.
|
|
If none of the two collision objects is a trigger shape then the contact report callback will get
|
|
called when the actors of this collision pair start to be in contact.
|
|
|
|
\note Only takes effect if the colliding actors are rigid bodies.
|
|
|
|
\note Only takes effect if eDETECT_DISCRETE_CONTACT or eDETECT_CCD_CONTACT is raised
|
|
|
|
@see PxSimulationEventCallback.onContact() PxSimulationEventCallback.onTrigger()
|
|
*/
|
|
eNOTIFY_TOUCH_FOUND = (1 << 2),
|
|
|
|
/**
|
|
\brief Call contact report callback while this collision pair is in contact
|
|
|
|
If none of the two collision objects is a trigger shape then the contact report callback will get
|
|
called while the actors of this collision pair are in contact.
|
|
|
|
\note Triggers do not support this event. Persistent trigger contacts need to be tracked separately by observing eNOTIFY_TOUCH_FOUND/eNOTIFY_TOUCH_LOST events.
|
|
|
|
\note Only takes effect if the colliding actors are rigid bodies.
|
|
|
|
\note No report will get sent if the objects in contact are sleeping.
|
|
|
|
\note Only takes effect if eDETECT_DISCRETE_CONTACT or eDETECT_CCD_CONTACT is raised
|
|
|
|
\note If this flag gets enabled while a pair is in touch already, there will be no eNOTIFY_TOUCH_PERSISTS events until the pair loses and regains touch.
|
|
|
|
@see PxSimulationEventCallback.onContact() PxSimulationEventCallback.onTrigger()
|
|
*/
|
|
eNOTIFY_TOUCH_PERSISTS = (1 << 3),
|
|
|
|
/**
|
|
\brief Call contact report callback or trigger callback when this collision pair stops to be in contact
|
|
|
|
If one of the two collision objects is a trigger shape (see #PxShapeFlag::eTRIGGER_SHAPE)
|
|
then the trigger callback will get called as soon as the other object leaves the trigger volume.
|
|
If none of the two collision objects is a trigger shape then the contact report callback will get
|
|
called when the actors of this collision pair stop to be in contact.
|
|
|
|
\note Only takes effect if the colliding actors are rigid bodies.
|
|
|
|
\note This event will also get triggered if one of the colliding objects gets deleted.
|
|
|
|
\note Only takes effect if eDETECT_DISCRETE_CONTACT or eDETECT_CCD_CONTACT is raised
|
|
|
|
@see PxSimulationEventCallback.onContact() PxSimulationEventCallback.onTrigger()
|
|
*/
|
|
eNOTIFY_TOUCH_LOST = (1 << 4),
|
|
|
|
/**
|
|
\brief Call contact report callback when this collision pair is in contact during CCD passes.
|
|
|
|
If CCD with multiple passes is enabled, then a fast moving object might bounce on and off the same
|
|
object multiple times. Hence, the same pair might be in contact multiple times during a simulation step.
|
|
This flag will make sure that all the detected collision during CCD will get reported. For performance
|
|
reasons, the system can not always tell whether the contact pair lost touch in one of the previous CCD
|
|
passes and thus can also not always tell whether the contact is new or has persisted. eNOTIFY_TOUCH_CCD
|
|
just reports when the two collision objects were detected as being in contact during a CCD pass.
|
|
|
|
\note Only takes effect if the colliding actors are rigid bodies.
|
|
|
|
\note Trigger shapes are not supported.
|
|
|
|
\note Only takes effect if eDETECT_CCD_CONTACT is raised
|
|
|
|
@see PxSimulationEventCallback.onContact() PxSimulationEventCallback.onTrigger()
|
|
*/
|
|
eNOTIFY_TOUCH_CCD = (1 << 5),
|
|
|
|
/**
|
|
\brief Call contact report callback when the contact force between the actors of this collision pair exceeds one of the actor-defined force thresholds.
|
|
|
|
\note Only takes effect if the colliding actors are rigid bodies.
|
|
|
|
\note Only takes effect if eDETECT_DISCRETE_CONTACT or eDETECT_CCD_CONTACT is raised
|
|
|
|
@see PxSimulationEventCallback.onContact()
|
|
*/
|
|
eNOTIFY_THRESHOLD_FORCE_FOUND = (1 << 6),
|
|
|
|
/**
|
|
\brief Call contact report callback when the contact force between the actors of this collision pair continues to exceed one of the actor-defined force thresholds.
|
|
|
|
\note Only takes effect if the colliding actors are rigid bodies.
|
|
|
|
\note If a pair gets re-filtered and this flag has previously been disabled, then the report will not get fired in the same frame even if the force threshold has been reached in the
|
|
previous one (unless #eNOTIFY_THRESHOLD_FORCE_FOUND has been set in the previous frame).
|
|
|
|
\note Only takes effect if eDETECT_DISCRETE_CONTACT or eDETECT_CCD_CONTACT is raised
|
|
|
|
@see PxSimulationEventCallback.onContact()
|
|
*/
|
|
eNOTIFY_THRESHOLD_FORCE_PERSISTS = (1 << 7),
|
|
|
|
/**
|
|
\brief Call contact report callback when the contact force between the actors of this collision pair falls below one of the actor-defined force thresholds (includes the case where this collision pair stops being in contact).
|
|
|
|
\note Only takes effect if the colliding actors are rigid bodies.
|
|
|
|
\note If a pair gets re-filtered and this flag has previously been disabled, then the report will not get fired in the same frame even if the force threshold has been reached in the
|
|
previous one (unless #eNOTIFY_THRESHOLD_FORCE_FOUND or #eNOTIFY_THRESHOLD_FORCE_PERSISTS has been set in the previous frame).
|
|
|
|
\note Only takes effect if eDETECT_DISCRETE_CONTACT or eDETECT_CCD_CONTACT is raised
|
|
|
|
@see PxSimulationEventCallback.onContact()
|
|
*/
|
|
eNOTIFY_THRESHOLD_FORCE_LOST = (1 << 8),
|
|
|
|
/**
|
|
\brief Provide contact points in contact reports for this collision pair.
|
|
|
|
\note Only takes effect if the colliding actors are rigid bodies and if used in combination with the flags eNOTIFY_TOUCH_... or eNOTIFY_THRESHOLD_FORCE_...
|
|
|
|
\note Only takes effect if eDETECT_DISCRETE_CONTACT or eDETECT_CCD_CONTACT is raised
|
|
|
|
@see PxSimulationEventCallback.onContact() PxContactPair PxContactPair.extractContacts()
|
|
*/
|
|
eNOTIFY_CONTACT_POINTS = (1 << 9),
|
|
|
|
/**
|
|
\brief This flag is used to indicate whether this pair generates discrete collision detection contacts.
|
|
|
|
\note Contacts are only responded to if eSOLVE_CONTACT is enabled.
|
|
*/
|
|
eDETECT_DISCRETE_CONTACT = (1 << 10),
|
|
|
|
/**
|
|
\brief This flag is used to indicate whether this pair generates CCD contacts.
|
|
|
|
\note The contacts will only be responded to if eSOLVE_CONTACT is enabled on this pair.
|
|
\note The scene must have PxSceneFlag::eENABLE_CCD enabled to use this feature.
|
|
\note Non-static bodies of the pair should have PxRigidBodyFlag::eENABLE_CCD specified for this feature to work correctly.
|
|
\note This flag is not supported with trigger shapes. However, CCD trigger events can be emulated using non-trigger shapes
|
|
and requesting eNOTIFY_TOUCH_FOUND and eNOTIFY_TOUCH_LOST and not raising eSOLVE_CONTACT on the pair.
|
|
|
|
@see PxRigidBodyFlag::eENABLE_CCD
|
|
@see PxSceneFlag::eENABLE_CCD
|
|
*/
|
|
eDETECT_CCD_CONTACT = (1 << 11),
|
|
|
|
/**
|
|
\brief Provide pre solver velocities in contact reports for this collision pair.
|
|
|
|
If the collision pair has contact reports enabled, the velocities of the rigid bodies before contacts have been solved
|
|
will be provided in the contact report callback unless the pair lost touch in which case no data will be provided.
|
|
|
|
\note Usually it is not necessary to request these velocities as they will be available by querying the velocity from the provided
|
|
PxRigidActor object directly. However, it might be the case that the velocity of a rigid body gets set while the simulation is running
|
|
in which case the PxRigidActor would return this new velocity in the contact report callback and not the velocity the simulation used.
|
|
|
|
@see PxSimulationEventCallback.onContact(), PxContactPairVelocity, PxContactPairHeader.extraDataStream
|
|
*/
|
|
ePRE_SOLVER_VELOCITY = (1 << 12),
|
|
|
|
/**
|
|
\brief Provide post solver velocities in contact reports for this collision pair.
|
|
|
|
If the collision pair has contact reports enabled, the velocities of the rigid bodies after contacts have been solved
|
|
will be provided in the contact report callback unless the pair lost touch in which case no data will be provided.
|
|
|
|
@see PxSimulationEventCallback.onContact(), PxContactPairVelocity, PxContactPairHeader.extraDataStream
|
|
*/
|
|
ePOST_SOLVER_VELOCITY = (1 << 13),
|
|
|
|
/**
|
|
\brief Provide rigid body poses in contact reports for this collision pair.
|
|
|
|
If the collision pair has contact reports enabled, the rigid body poses at the contact event will be provided
|
|
in the contact report callback unless the pair lost touch in which case no data will be provided.
|
|
|
|
\note Usually it is not necessary to request these poses as they will be available by querying the pose from the provided
|
|
PxRigidActor object directly. However, it might be the case that the pose of a rigid body gets set while the simulation is running
|
|
in which case the PxRigidActor would return this new pose in the contact report callback and not the pose the simulation used.
|
|
Another use case is related to CCD with multiple passes enabled, A fast moving object might bounce on and off the same
|
|
object multiple times. This flag can be used to request the rigid body poses at the time of impact for each such collision event.
|
|
|
|
@see PxSimulationEventCallback.onContact(), PxContactPairPose, PxContactPairHeader.extraDataStream
|
|
*/
|
|
eCONTACT_EVENT_POSE = (1 << 14),
|
|
|
|
eNEXT_FREE = (1 << 15), //!< For internal use only.
|
|
|
|
/**
|
|
\brief Provided default flag to do simple contact processing for this collision pair.
|
|
*/
|
|
eCONTACT_DEFAULT = eSOLVE_CONTACT | eDETECT_DISCRETE_CONTACT,
|
|
|
|
/**
|
|
\brief Provided default flag to get commonly used trigger behavior for this collision pair.
|
|
*/
|
|
eTRIGGER_DEFAULT = eNOTIFY_TOUCH_FOUND | eNOTIFY_TOUCH_LOST | eDETECT_DISCRETE_CONTACT
|
|
}
|
|
|
|
enum TriggerPairFlag {
|
|
eREMOVED_SHAPE_TRIGGER = (1 << 0), //!< The trigger shape has been removed from the actor/scene.
|
|
eREMOVED_SHAPE_OTHER = (1 << 1), //!< The shape causing the trigger event has been removed from the actor/scene.
|
|
eNEXT_FREE = (1 << 2) //!< For internal use only.
|
|
}
|
|
|
|
enum ActorType {
|
|
/**
|
|
\brief A static rigid body
|
|
@see RigidStatic
|
|
*/
|
|
eRIGID_STATIC,
|
|
|
|
/**
|
|
\brief A dynamic rigid body
|
|
@see RigidDynamic
|
|
*/
|
|
eRIGID_DYNAMIC,
|
|
|
|
eARTICULATION_LINK
|
|
}
|
|
|
|
enum ActorFlag {
|
|
/**
|
|
\brief Enable debug renderer for this actor
|
|
@see PxScene.getRenderBuffer() PxRenderBuffer PxVisualizationParameter
|
|
*/
|
|
eVISUALIZATION = (1 << 0),
|
|
|
|
/**
|
|
\brief Disables scene gravity for this actor
|
|
*/
|
|
eDISABLE_GRAVITY = (1 << 1),
|
|
|
|
/**
|
|
\brief Enables the sending of SimulationEventCallback::onWake() and SimulationEventCallback::onSleep() notify events
|
|
|
|
@see SimulationEventCallback::onWake() SimulationEventCallback::onSleep()
|
|
*/
|
|
eSEND_SLEEP_NOTIFIES = (1 << 2),
|
|
|
|
/**
|
|
\brief Disables simulation for the actor.
|
|
|
|
\note This is only supported by RigidStatic and RigidDynamic actors and can be used to reduce the memory footprint when rigid actors are
|
|
used for scene queries only.
|
|
|
|
\note Setting this flag will remove all constraints attached to the actor from the scene.
|
|
|
|
\note If this flag is set, the following calls are forbidden:
|
|
\li RigidBody: setLinearVelocity(), setAngularVelocity(), addForce(), addTorque(), clearForce(), clearTorque()
|
|
\li RigidDynamic: setKinematicTarget(), setWakeCounter(), wakeUp(), putToSleep()
|
|
|
|
\par <b>Sleeping:</b>
|
|
Raising this flag will set all velocities and the wake counter to 0, clear all forces, clear the kinematic target, put the actor
|
|
to sleep and wake up all touching actors from the previous frame.
|
|
*/
|
|
eDISABLE_SIMULATION = (1 << 3)
|
|
}
|
|
|
|
enum RigidBodyFlag {
|
|
|
|
/**
|
|
\brief Enables kinematic mode for the actor.
|
|
|
|
Kinematic actors are special dynamic actors that are not
|
|
influenced by forces (such as gravity), and have no momentum. They are considered to have infinite
|
|
mass and can be moved around the world using the setKinematicTarget() method. They will push
|
|
regular dynamic actors out of the way. Kinematics will not collide with static or other kinematic objects.
|
|
|
|
Kinematic actors are great for moving platforms or characters, where direct motion control is desired.
|
|
|
|
You can not connect Reduced joints to kinematic actors. Lagrange joints work ok if the platform
|
|
is moving with a relatively low, uniform velocity.
|
|
|
|
<b>Sleeping:</b>
|
|
\li Setting this flag on a dynamic actor will put the actor to sleep and set the velocities to 0.
|
|
\li If this flag gets cleared, the current sleep state of the actor will be kept.
|
|
|
|
\note kinematic actors are incompatible with CCD so raising this flag will automatically clear eENABLE_CCD
|
|
|
|
@see RigidDynamic.setKinematicTarget()
|
|
*/
|
|
eKINEMATIC = (1 << 0), //!< Enable kinematic mode for the body.
|
|
|
|
/**
|
|
\brief Use the kinematic target transform for scene queries.
|
|
|
|
If this flag is raised, then scene queries will treat the kinematic target transform as the current pose
|
|
of the body (instead of using the actual pose). Without this flag, the kinematic target will only take
|
|
effect with respect to scene queries after a simulation step.
|
|
|
|
@see RigidDynamic.setKinematicTarget()
|
|
*/
|
|
eUSE_KINEMATIC_TARGET_FOR_SCENE_QUERIES = (1 << 1),
|
|
|
|
/**
|
|
\brief Enables swept integration for the actor.
|
|
|
|
If this flag is raised and CCD is enabled on the scene, then this body will be simulated by the CCD system to ensure that collisions are not missed due to
|
|
high-speed motion. Note individual shape pairs still need to enable PairFlag::eDETECT_CCD_CONTACT in the collision filtering to enable the CCD to respond to
|
|
individual interactions.
|
|
|
|
\note kinematic actors are incompatible with CCD so this flag will be cleared automatically when raised on a kinematic actor
|
|
|
|
*/
|
|
eENABLE_CCD = (1 << 2), //!< Enable CCD for the body.
|
|
|
|
/**
|
|
\brief Enabled CCD in swept integration for the actor.
|
|
|
|
If this flag is raised and CCD is enabled, CCD interactions will simulate friction. By default, friction is disabled in CCD interactions because
|
|
CCD friction has been observed to introduce some simulation artifacts. CCD friction was enabled in previous versions of the SDK. Raising this flag will result in behavior
|
|
that is a closer match for previous versions of the SDK.
|
|
|
|
\note This flag requires RigidBodyFlag::eENABLE_CCD to be raised to have any effect.
|
|
*/
|
|
eENABLE_CCD_FRICTION = (1 << 3),
|
|
|
|
/**
|
|
\brief Register a rigid body for reporting pose changes by the simulation at an early stage.
|
|
|
|
Sometimes it might be advantageous to get access to the new pose of a rigid body as early as possible and
|
|
not wait until the call to fetchResults() returns. Setting this flag will schedule the rigid body to get reported
|
|
in #SimulationEventCallback::onAdvance(). Please refer to the documentation of that callback to understand
|
|
the behavior and limitations of this functionality.
|
|
|
|
@see SimulationEventCallback::onAdvance()
|
|
*/
|
|
eENABLE_POSE_INTEGRATION_PREVIEW = (1 << 4),
|
|
|
|
/**
|
|
\brief Register a rigid body to dynamicly adjust contact offset based on velocity. This can be used to achieve a CCD effect.
|
|
*/
|
|
eENABLE_SPECULATIVE_CCD = (1 << 5),
|
|
|
|
/**
|
|
\brief Permit CCD to limit maxContactImpulse. This is useful for use-cases like a destruction system but can cause visual artefacts so is not enabled by default.
|
|
*/
|
|
eENABLE_CCD_MAX_CONTACT_IMPULSE = (1 << 6)
|
|
}
|
|
|
|
enum ForceMode {
|
|
eFORCE, //!< parameter has unit of mass * distance/ time^2, i.e. a force
|
|
eIMPULSE, //!< parameter has unit of mass * distance /time
|
|
eVELOCITY_CHANGE, //!< parameter has unit of distance / time, i.e. the effect is mass independent: a velocity change.
|
|
eACCELERATION //!< parameter has unit of distance/ time^2, i.e. an acceleration. It gets treated just like a force except the mass is not divided out before integration.
|
|
}
|
|
|
|
enum RigidDynamicLockFlag {
|
|
eLOCK_LINEAR_X = (1 << 0),
|
|
eLOCK_LINEAR_Y = (1 << 1),
|
|
eLOCK_LINEAR_Z = (1 << 2),
|
|
eLOCK_ANGULAR_X = (1 << 3),
|
|
eLOCK_ANGULAR_Y = (1 << 4),
|
|
eLOCK_ANGULAR_Z = (1 << 5)
|
|
}
|
|
|
|
// Px1DConstraintFlag
|
|
enum Constraint1DFlag {
|
|
eSPRING = 1 << 0, //!< whether the constraint is a spring. Mutually exclusive with eRESTITUTION. If set, eKEEPBIAS is ignored.
|
|
eACCELERATION_SPRING = 1 << 1, //!< whether the constraint is a force or acceleration spring. Only valid if eSPRING is set.
|
|
eRESTITUTION = 1 << 2, //!< whether the restitution model should be applied to generate the target velocity. Mutually exclusive with eSPRING. If restitution causes a bounces, eKEEPBIAS is ignored
|
|
eKEEPBIAS = 1 << 3, //!< whether to keep the error term when solving for velocity. Ignored if restitution generates bounce, or eSPRING is set.
|
|
eOUTPUT_FORCE = 1 << 4, //!< whether to accumulate the force value from this constraint in the force total that is reported for the constraint and tested for breakage
|
|
eHAS_DRIVE_LIMIT = 1 << 5 //!< whether the constraint has a drive force limit (which will be scaled by dt unless PxConstraintFlag::eLIMITS_ARE_FORCES is set)
|
|
}
|
|
|
|
enum ConstraintFlag {
|
|
eBROKEN = 1 << 0, //!< whether the constraint is broken
|
|
ePROJECT_TO_ACTOR0 = 1 << 1, //!< whether actor1 should get projected to actor0 for this constraint (note: projection of a static/kinematic actor to a dynamic actor will be ignored)
|
|
ePROJECT_TO_ACTOR1 = 1 << 2, //!< whether actor0 should get projected to actor1 for this constraint (note: projection of a static/kinematic actor to a dynamic actor will be ignored)
|
|
ePROJECTION = ePROJECT_TO_ACTOR0 | ePROJECT_TO_ACTOR1, //!< whether the actors should get projected for this constraint (the direction will be chosen by PhysX)
|
|
eCOLLISION_ENABLED = 1 << 3, //!< whether contacts should be generated between the objects this constraint constrains
|
|
eVISUALIZATION = 1 << 4, //!< whether this constraint should be visualized, if constraint visualization is turned on
|
|
eDRIVE_LIMITS_ARE_FORCES = 1 << 5, //!< limits for drive strength are forces rather than impulses
|
|
eIMPROVED_SLERP = 1 << 7, //!< perform preprocessing for improved accuracy on D6 Slerp Drive (this flag will be removed in a future release when preprocessing is no longer required)
|
|
eDISABLE_PREPROCESSING = 1 << 8, //!< suppress constraint preprocessing, intended for use with rowResponseThreshold. May result in worse solver accuracy for ill-conditioned constraints.
|
|
eGPU_COMPATIBLE = 1 << 9 //!< the constraint type is supported by gpu dynamic
|
|
}
|
|
|
|
enum ConstraintSolveHint {
|
|
eNONE = 0, //!< no special properties
|
|
eACCELERATION1 = 256, //!< a group of acceleration drive constraints with the same stiffness and drive parameters
|
|
eSLERP_SPRING = 258, //!< temporary special value to identify SLERP drive rows
|
|
eACCELERATION2 = 512, //!< a group of acceleration drive constraints with the same stiffness and drive parameters
|
|
eACCELERATION3 = 768, //!< a group of acceleration drive constraints with the same stiffness and drive parameters
|
|
eROTATIONAL_EQUALITY = 1024, //!< rotational equality constraints with no force limit and no velocity target
|
|
eROTATIONAL_INEQUALITY = 1025, //!< rotational inequality constraints with (0, PX_MAX_FLT) force limits
|
|
eEQUALITY = 2048, //!< equality constraints with no force limit and no velocity target
|
|
eINEQUALITY = 2049 //!< inequality constraints with (0, PX_MAX_FLT) force limits
|
|
}
|
|
|
|
enum ConvexFlag {
|
|
/**
|
|
Denotes the use of 16-bit vertex indices in PxConvexMeshDesc::triangles or PxConvexMeshDesc::polygons.
|
|
(otherwise, 32-bit indices are assumed)
|
|
@see #PxConvexMeshDesc.indices
|
|
*/
|
|
e16_BIT_INDICES = (1 << 0),
|
|
|
|
/**
|
|
Automatically recomputes the hull from the vertices. If this flag is not set, you must provide the entire geometry manually.
|
|
|
|
\note There are two different algorithms for hull computation, please see PxConvexMeshCookingType.
|
|
|
|
@see PxConvexMeshCookingType
|
|
*/
|
|
eCOMPUTE_CONVEX = (1 << 1),
|
|
|
|
/**
|
|
\brief Checks and removes almost zero-area triangles during convex hull computation.
|
|
The rejected area size is specified in PxCookingParams::areaTestEpsilon
|
|
|
|
\note This flag is only used in combination with eCOMPUTE_CONVEX.
|
|
|
|
\note If this flag is used in combination with eINFLATE_CONVEX, the newly added triangles
|
|
by the inflation algorithm are not checked (size of the triangles depends on PxCooking::skinWidth).
|
|
|
|
@see PxCookingParams PxCookingParams::areaTestEpsilon
|
|
*/
|
|
eCHECK_ZERO_AREA_TRIANGLES = (1 << 2),
|
|
|
|
/**
|
|
\brief Inflates the convex points according to skin width.
|
|
|
|
\note eINFLATE_CONVEX flag has been deprecated. The flag is automatically used when
|
|
PxConvexMeshCookingType::eINFLATION_INCREMENTAL_HULL is set. The default algorithm
|
|
PxConvexMeshCookingType::eQUICK_HULL ignores this flag, inflation is not used.
|
|
|
|
/**
|
|
\brief Quantizes the input vertices using the k-means clustering
|
|
|
|
\note The input vertices are quantized to PxConvexMeshDesc::quantizedCount
|
|
see http://en.wikipedia.org/wiki/K-means_clustering
|
|
|
|
*/
|
|
eQUANTIZE_INPUT = (1 << 4),
|
|
|
|
/**
|
|
\brief Disables the convex mesh validation to speed-up hull creation. Please use separate validation
|
|
function in checked/debug builds. Creating a convex mesh with invalid input data without prior validation
|
|
may result in undefined behavior.
|
|
|
|
@see PxCooking::validateConvexMesh
|
|
*/
|
|
eDISABLE_MESH_VALIDATION = (1 << 5),
|
|
|
|
/**
|
|
\brief Enables plane shifting vertex limit algorithm.
|
|
|
|
Plane shifting is an alternative algorithm for the case when the computed hull has more vertices
|
|
than the specified vertex limit.
|
|
|
|
The default algorithm computes the full hull, and an OBB around the input vertices. This OBB is then sliced
|
|
with the hull planes until the vertex limit is reached.The default algorithm requires the vertex limit
|
|
to be set to at least 8, and typically produces results that are much better quality than are produced
|
|
by plane shifting.
|
|
|
|
When plane shifting is enabled, the hull computation stops when vertex limit is reached. The hull planes
|
|
are then shifted to contain all input vertices, and the new plane intersection points are then used to
|
|
generate the final hull with the given vertex limit.Plane shifting may produce sharp edges to vertices
|
|
very far away from the input cloud, and does not guarantee that all input vertices are inside the resulting
|
|
hull.However, it can be used with a vertex limit as low as 4.
|
|
*/
|
|
ePLANE_SHIFTING = (1 << 6),
|
|
|
|
/**
|
|
\brief Inertia tensor computation is faster using SIMD code, but the precision is lower, which may result
|
|
in incorrect inertia for very thin hulls.
|
|
*/
|
|
eFAST_INERTIA_COMPUTATION = (1 << 7),
|
|
|
|
/**
|
|
\brief Convex hull input vertices are shifted to be around origin to provide better computation stability.
|
|
It is recommended to provide input vertices around the origin, otherwise use this flag to improve
|
|
numerical stability.
|
|
\note Is used only with eCOMPUTE_CONVEX flag.
|
|
*/
|
|
eSHIFT_VERTICES = (1 << 9)
|
|
}
|
|
|
|
enum ConvexMeshCookingType {
|
|
eQUICKHULL
|
|
}
|
|
|
|
enum MeshCookingHint {
|
|
eSIM_PERFORMANCE = 0, //!< Default value. Favors higher quality hierarchy with higher runtime performance over cooking speed.
|
|
eCOOKING_PERFORMANCE = 1 //!< Enables fast cooking path at the expense of somewhat lower quality hierarchy construction.
|
|
}
|
|
|
|
enum MeshPreprocessingFlag {
|
|
/**
|
|
\brief When set, mesh welding is performed. See CookingParams::meshWeldTolerance. Clean mesh must be enabled.
|
|
*/
|
|
eWELD_VERTICES = 1 << 0,
|
|
|
|
/**
|
|
\brief When set, mesh cleaning is disabled. This makes cooking faster.
|
|
|
|
When clean mesh is not performed, mesh welding is also not performed.
|
|
|
|
It is recommended to use only meshes that passed during validateTriangleMesh.
|
|
|
|
*/
|
|
eDISABLE_CLEAN_MESH = 1 << 1,
|
|
|
|
/**
|
|
\brief When set, active edges are set for each triangle edge. This makes cooking faster but slow up contact generation.
|
|
*/
|
|
eDISABLE_ACTIVE_EDGES_PRECOMPUTE = 1 << 2,
|
|
|
|
/**
|
|
\brief When set, 32-bit indices will always be created regardless of triangle count.
|
|
|
|
\note By default mesh will be created with 16-bit indices for triangle count <= 0xFFFF and 32-bit otherwise.
|
|
*/
|
|
eFORCE_32BIT_INDICES = 1 << 3
|
|
}
|
|
|
|
enum QueryHitType {
|
|
eNONE = 0, //!< the query should ignore this shape
|
|
eTOUCH = 1, //!< a hit on the shape touches the intersection geometry of the query but does not block it
|
|
eBLOCK = 2 //!< a hit on the shape blocks the query (does not block overlap queries)
|
|
}
|
|
|
|
enum HitFlag {
|
|
ePOSITION = (1 << 0), //!< "position" member of #PxQueryHit is valid
|
|
eNORMAL = (1 << 1), //!< "normal" member of #PxQueryHit is valid
|
|
eUV = (1 << 3), //!< "u" and "v" barycentric coordinates of #PxQueryHit are valid. Not applicable to sweep queries.
|
|
eASSUME_NO_INITIAL_OVERLAP = (1 << 4), //!< Performance hint flag for sweeps when it is known upfront there's no initial overlap.
|
|
//!< NOTE: using this flag may cause undefined results if shapes are initially overlapping.
|
|
eMESH_MULTIPLE = (1 << 5), //!< Report all hits for meshes rather than just the first. Not applicable to sweep queries.
|
|
eMESH_ANY = (1 << 6), //!< Report any first hit for meshes. If neither eMESH_MULTIPLE nor eMESH_ANY is specified,
|
|
//!< a single closest hit will be reported for meshes.
|
|
eMESH_BOTH_SIDES = (1 << 7), //!< Report hits with back faces of mesh triangles. Also report hits for raycast
|
|
//!< originating on mesh surface and facing away from the surface normal. Not applicable to sweep queries.
|
|
//!< Please refer to the user guide for heightfield-specific differences.
|
|
ePRECISE_SWEEP = (1 << 8), //!< Use more accurate but slower narrow phase sweep tests.
|
|
//!< May provide better compatibility with PhysX 3.2 sweep behavior.
|
|
eMTD = (1 << 9), //!< Report the minimum translation depth, normal and contact point.
|
|
eFACE_INDEX = (1 << 10), //!< "face index" member of #PxQueryHit is valid
|
|
|
|
eDEFAULT = ePOSITION | eNORMAL | eFACE_INDEX,
|
|
|
|
/** \brief Only this subset of flags can be modified by pre-filter. Other modifications will be discarded. */
|
|
eMODIFIABLE_FLAGS = eMESH_MULTIPLE | eMESH_BOTH_SIDES | eASSUME_NO_INITIAL_OVERLAP | ePRECISE_SWEEP
|
|
}
|
|
|
|
enum FilterFlag {
|
|
/**
|
|
\brief Ignore the collision pair as long as the bounding volumes of the pair objects overlap.
|
|
|
|
Killed pairs will be ignored by the simulation and won't run through the filter again until one
|
|
of the following occurs:
|
|
|
|
\li The bounding volumes of the two objects overlap again (after being separated)
|
|
\li The user enforces a re-filtering (see #PxScene::resetFiltering())
|
|
|
|
@see PxScene::resetFiltering()
|
|
*/
|
|
eKILL = (1 << 0),
|
|
|
|
/**
|
|
\brief Ignore the collision pair as long as the bounding volumes of the pair objects overlap or until filtering relevant data changes for one of the collision objects.
|
|
|
|
Suppressed pairs will be ignored by the simulation and won't make another filter request until one
|
|
of the following occurs:
|
|
|
|
\li Same conditions as for killed pairs (see #eKILL)
|
|
\li The filter data or the filter object attributes change for one of the collision objects
|
|
|
|
\note For PxCloth objects, eSUPPRESS will be treated as eKILL.
|
|
|
|
@see PxFilterData PxFilterObjectAttributes
|
|
*/
|
|
eSUPPRESS = (1 << 1),
|
|
|
|
/**
|
|
\brief Invoke the filter callback (#PxSimulationFilterCallback::pairFound()) for this collision pair.
|
|
|
|
@see PxSimulationFilterCallback
|
|
*/
|
|
eCALLBACK = (1 << 2),
|
|
|
|
/**
|
|
\brief Track this collision pair with the filter callback mechanism.
|
|
|
|
When the bounding volumes of the collision pair lose contact, the filter callback #PxSimulationFilterCallback::pairLost()
|
|
will be invoked. Furthermore, the filter status of the collision pair can be adjusted through #PxSimulationFilterCallback::statusChange()
|
|
once per frame (until a pairLost() notification occurs).
|
|
|
|
@see PxSimulationFilterCallback
|
|
*/
|
|
eNOTIFY = (1 << 3) | eCALLBACK,
|
|
|
|
/**
|
|
\brief Provided default to get standard behavior:
|
|
|
|
The application configure the pair's collision properties once when bounding volume overlap is found and
|
|
doesn't get asked again about that pair until overlap status or filter properties changes, or re-filtering is requested.
|
|
|
|
No notification is provided when bounding volume overlap is lost
|
|
|
|
The pair will not be killed or suppressed, so collision detection will be processed
|
|
*/
|
|
|
|
eDEFAULT = 0
|
|
}
|
|
|
|
enum FilterObjectType {
|
|
/**
|
|
\brief A static rigid body
|
|
@see RigidStatic
|
|
*/
|
|
eRIGID_STATIC,
|
|
|
|
/**
|
|
\brief A dynamic rigid body
|
|
@see RigidDynamic
|
|
*/
|
|
eRIGID_DYNAMIC,
|
|
|
|
/**
|
|
\brief An articulation
|
|
@see Articulation
|
|
*/
|
|
eARTICULATION = 4,
|
|
|
|
}
|
|
|
|
enum FilterObjectFlag {
|
|
eKINEMATIC = (1 << 4),
|
|
eTRIGGER = (1 << 5)
|
|
}
|
|
|
|
enum GeometryType {
|
|
eSPHERE,
|
|
ePLANE,
|
|
eCAPSULE,
|
|
eBOX,
|
|
eCONVEXMESH,
|
|
eTRIANGLEMESH,
|
|
eHEIGHTFIELD
|
|
}
|
|
|
|
enum ConvexMeshGeometryFlag {
|
|
eTIGHT_BOUNDS = (1 << 0) //!< Use tighter (but more expensive to compute) bounds around the convex geometry.
|
|
}
|
|
|
|
enum HeightFieldFormat {
|
|
/**
|
|
\brief Height field height data is 16 bit signed integers, followed by triangle materials.
|
|
|
|
Each sample is 32 bits wide arranged as follows:
|
|
|
|
\image html heightFieldFormat_S16_TM.png
|
|
|
|
1) First there is a 16 bit height value.
|
|
2) Next, two one byte material indices, with the high bit of each byte reserved for special use.
|
|
(so the material index is only 7 bits).
|
|
The high bit of material0 is the tess-flag.
|
|
The high bit of material1 is reserved for future use.
|
|
|
|
There are zero or more unused bytes before the next sample depending on HeightFieldDesc.sampleStride,
|
|
where the application may eventually keep its own data.
|
|
|
|
This is the only format supported at the moment.
|
|
|
|
@see HeightFieldDesc.format HeightFieldDesc.samples
|
|
*/
|
|
eS16_TM = (1 << 0)
|
|
}
|
|
|
|
enum HeightFieldFlag {
|
|
/**
|
|
\brief Disable collisions with height field with boundary edges.
|
|
|
|
Raise this flag if several terrain patches are going to be placed adjacent to each other,
|
|
to avoid a bump when sliding across.
|
|
|
|
This flag is ignored in contact generation with sphere and capsule shapes.
|
|
|
|
@see PxHeightFieldDesc.flags
|
|
*/
|
|
eNO_BOUNDARY_EDGES = (1 << 0)
|
|
}
|
|
|
|
enum D6Axis {
|
|
eX = 0, //!< motion along the X axix
|
|
eY = 1, //!< motion along the Y axis
|
|
eZ = 2, //!< motion along the Z axis
|
|
eTWIST = 3, //!< motion around the X axis
|
|
eSWING1 = 4, //!< motion around the Y axis
|
|
eSWING2 = 5, //!< motion around the Z axis
|
|
}
|
|
|
|
enum D6Motion {
|
|
eLOCKED, //!< The DOF is locked, it does not allow relative motion.
|
|
eLIMITED, //!< The DOF is limited, it only allows motion within a specific range.
|
|
eFREE //!< The DOF is free and has its full range of motion.
|
|
}
|
|
|
|
enum D6Drive {
|
|
eX = 0, //!< drive along the X-axis
|
|
eY = 1, //!< drive along the Y-axis
|
|
eZ = 2, //!< drive along the Z-axis
|
|
eSWING = 3, //!< drive of displacement from the X-axis
|
|
eTWIST = 4, //!< drive of the displacement around the X-axis
|
|
eSLERP = 5, //!< drive of all three angular degrees along a SLERP-path
|
|
}
|
|
|
|
enum D6JointDriveFlag {
|
|
eACCELERATION = 1 //!< drive spring is for the acceleration at the joint (rather than the force)
|
|
}
|
|
|
|
enum JointActorIndex {
|
|
eACTOR0,
|
|
eACTOR1,
|
|
}
|
|
|
|
enum DistanceJointFlag {
|
|
eMAX_DISTANCE_ENABLED = 1 << 1,
|
|
eMIN_DISTANCE_ENABLED = 1 << 2,
|
|
eSPRING_ENABLED = 1 << 3
|
|
}
|
|
|
|
enum PrismaticJointFlag {
|
|
eLIMIT_ENABLED = 1 << 1
|
|
}
|
|
|
|
enum RevoluteJointFlag {
|
|
eLIMIT_ENABLED = 1 << 0, //!< enable the limit
|
|
eDRIVE_ENABLED = 1 << 1, //!< enable the drive
|
|
eDRIVE_FREESPIN = 1 << 2 //!< if the existing velocity is beyond the drive velocity, do not add force
|
|
}
|
|
|
|
enum MaterialFlag {
|
|
/**
|
|
If this flag is set, friction computations are always skipped between shapes with this material and any other shape.
|
|
*/
|
|
eDISABLE_FRICTION = 1 << 0,
|
|
|
|
/**
|
|
The difference between "normal" and "strong" friction is that the strong friction feature
|
|
remembers the "friction error" between simulation steps. The friction is a force trying to
|
|
hold objects in place (or slow them down) and this is handled in the solver. But since the
|
|
solver is only an approximation, the result of the friction calculation can include a small
|
|
"error" - e.g. a box resting on a slope should not move at all if the static friction is in
|
|
action, but could slowly glide down the slope because of a small friction error in each
|
|
simulation step. The strong friction counter-acts this by remembering the small error and
|
|
taking it to account during the next simulation step.
|
|
|
|
However, in some cases the strong friction could cause problems, and this is why it is
|
|
possible to disable the strong friction feature by setting this flag. One example is
|
|
raycast vehicles, that are sliding fast across the surface, but still need a precise
|
|
steering behavior. It may be a good idea to reenable the strong friction when objects
|
|
are coming to a rest, to prevent them from slowly creeping down inclines.
|
|
|
|
Note: This flag only has an effect if the MaterialFlag::eDISABLE_FRICTION bit is 0.
|
|
*/
|
|
eDISABLE_STRONG_FRICTION = 1 << 1
|
|
}
|
|
|
|
enum CombineMode {
|
|
eAVERAGE = 0, //!< Average: (a + b)/2
|
|
eMIN = 1, //!< Minimum: minimum(a,b)
|
|
eMULTIPLY = 2, //!< Multiply: a*b
|
|
eMAX = 3, //!< Maximum: maximum(a,b)
|
|
}
|
|
|
|
enum SceneFlag {
|
|
/**
|
|
\brief Enable Active Actors Notification.
|
|
|
|
This flag enables the Active Actor Notification feature for a scene. This
|
|
feature defaults to disabled. When disabled, the function
|
|
Scene::getActiveActors() will always return a NULL list.
|
|
|
|
\note There may be a performance penalty for enabling the Active Actor Notification, hence this flag should
|
|
only be enabled if the application intends to use the feature.
|
|
|
|
<b>Default:</b> False
|
|
*/
|
|
eENABLE_ACTIVE_ACTORS = (1 << 0),
|
|
|
|
/**
|
|
\brief Enables a second broad phase check after integration that makes it possible to prevent objects from tunneling through eachother.
|
|
|
|
PairFlag::eDETECT_CCD_CONTACT requires this flag to be specified.
|
|
|
|
\note For this feature to be effective for bodies that can move at a significant velocity, the user should raise the flag RigidBodyFlag::eENABLE_CCD for them.
|
|
\note This flag is not mutable, and must be set in SceneDesc at scene creation.
|
|
|
|
<b>Default:</b> False
|
|
|
|
@see RigidBodyFlag::eENABLE_CCD, PairFlag::eDETECT_CCD_CONTACT, eDISABLE_CCD_RESWEEP
|
|
*/
|
|
eENABLE_CCD = (1 << 2),
|
|
|
|
/**
|
|
\brief Enables a simplified swept integration strategy, which sacrifices some accuracy for improved performance.
|
|
|
|
This simplified swept integration approach makes certain assumptions about the motion of objects that are not made when using a full swept integration.
|
|
These assumptions usually hold but there are cases where they could result in incorrect behavior between a set of fast-moving rigid bodies. A key issue is that
|
|
fast-moving dynamic objects may tunnel through each-other after a rebound. This will not happen if this mode is disabled. However, this approach will be potentially
|
|
faster than a full swept integration because it will perform significantly fewer sweeps in non-trivial scenes involving many fast-moving objects. This approach
|
|
should successfully resist objects passing through the static environment.
|
|
|
|
PairFlag::eDETECT_CCD_CONTACT requires this flag to be specified.
|
|
|
|
\note This scene flag requires eENABLE_CCD to be enabled as well. If it is not, this scene flag will do nothing.
|
|
\note For this feature to be effective for bodies that can move at a significant velocity, the user should raise the flag RigidBodyFlag::eENABLE_CCD for them.
|
|
\note This flag is not mutable, and must be set in SceneDesc at scene creation.
|
|
|
|
<b>Default:</b> False
|
|
|
|
@see RigidBodyFlag::eENABLE_CCD, PairFlag::eDETECT_CCD_CONTACT, eENABLE_CCD
|
|
*/
|
|
eDISABLE_CCD_RESWEEP = (1 << 3),
|
|
|
|
/**
|
|
\brief Enable adaptive forces to accelerate convergence of the solver.
|
|
|
|
\note This flag is not mutable, and must be set in SceneDesc at scene creation.
|
|
|
|
<b>Default:</b> false
|
|
*/
|
|
eADAPTIVE_FORCE = (1 << 4),
|
|
|
|
/**
|
|
\brief Enable GJK-based distance collision detection system.
|
|
|
|
\note This flag is not mutable, and must be set in SceneDesc at scene creation.
|
|
|
|
<b>Default:</b> true
|
|
*/
|
|
eENABLE_PCM = (1 << 9),
|
|
|
|
/**
|
|
\brief Disable contact report buffer resize. Once the contact buffer is full, the rest of the contact reports will
|
|
not be buffered and sent.
|
|
|
|
\note This flag is not mutable, and must be set in SceneDesc at scene creation.
|
|
|
|
<b>Default:</b> false
|
|
*/
|
|
eDISABLE_CONTACT_REPORT_BUFFER_RESIZE = (1 << 10),
|
|
|
|
/**
|
|
\brief Disable contact cache.
|
|
|
|
Contact caches are used internally to provide faster contact generation. You can disable all contact caches
|
|
if memory usage for this feature becomes too high.
|
|
|
|
\note This flag is not mutable, and must be set in SceneDesc at scene creation.
|
|
|
|
<b>Default:</b> false
|
|
*/
|
|
eDISABLE_CONTACT_CACHE = (1 << 11),
|
|
|
|
/**
|
|
\brief Require scene-level locking
|
|
|
|
When set to true this requires that threads accessing the Scene use the
|
|
multi-threaded lock methods.
|
|
|
|
\note This flag is not mutable, and must be set in SceneDesc at scene creation.
|
|
|
|
@see Scene::lockRead
|
|
@see Scene::unlockRead
|
|
@see Scene::lockWrite
|
|
@see Scene::unlockWrite
|
|
|
|
<b>Default:</b> false
|
|
*/
|
|
eREQUIRE_RW_LOCK = (1 << 12),
|
|
|
|
/**
|
|
\brief Enables additional stabilization pass in solver
|
|
|
|
When set to true, this enables additional stabilization processing to improve that stability of complex interactions between large numbers of bodies.
|
|
|
|
Note that this flag is not mutable and must be set in SceneDesc at scene creation. Also, this is an experimental feature which does result in some loss of momentum.
|
|
*/
|
|
eENABLE_STABILIZATION = (1 << 14),
|
|
|
|
/**
|
|
\brief Enables average points in contact manifolds
|
|
|
|
When set to true, this enables additional contacts to be generated per manifold to represent the average point in a manifold. This can stabilize stacking when only a small
|
|
number of solver iterations is used.
|
|
|
|
Note that this flag is not mutable and must be set in SceneDesc at scene creation.
|
|
*/
|
|
eENABLE_AVERAGE_POINT = (1 << 15),
|
|
|
|
/**
|
|
\brief Do not report kinematics in list of active actors/transforms.
|
|
|
|
Since the target pose for kinematics is set by the user, an application can track the activity state directly and use
|
|
this flag to avoid that kinematics get added to the list of active actors/transforms.
|
|
|
|
\note This flag has only an effect in combination with eENABLE_ACTIVE_ACTORS or eENABLE_ACTIVETRANSFORMS.
|
|
|
|
@see eENABLE_ACTIVE_ACTORS eENABLE_ACTIVETRANSFORMS
|
|
|
|
<b>Default:</b> false
|
|
*/
|
|
eEXCLUDE_KINEMATICS_FROM_ACTIVE_ACTORS = (1 << 17),
|
|
|
|
/**
|
|
\brief Provides improved determinism at the expense of performance.
|
|
|
|
By default, we provides limited determinism guarantees. Specifically, we guarantees that the exact scene (same actors created in the same order) and simulated using the same
|
|
time-stepping scheme should provide the exact same behaviour.
|
|
|
|
However, if additional actors are added to the simulation, this can affect the behaviour of the existing actors in the simulation, even if the set of new actors do not interact with
|
|
the existing actors.
|
|
|
|
This flag provides an additional level of determinism that guarantees that the simulation will not change if additional actors are added to the simulation, provided those actors do not interfere
|
|
with the existing actors in the scene. Determinism is only guaranteed if the actors are inserted in a consistent order each run in a newly-created scene and simulated using a consistent time-stepping
|
|
scheme.
|
|
|
|
Note that this flag is not mutable and must be set at scene creation.
|
|
|
|
Note that enabling this flag can have a negative impact on performance.
|
|
|
|
Note that this feature is not currently supported on GPU.
|
|
|
|
<b>Default</b> false
|
|
*/
|
|
eENABLE_ENHANCED_DETERMINISM = (1 << 20),
|
|
}
|
|
|
|
enum ActorTypeFlag {
|
|
/**
|
|
\brief A static rigid body
|
|
@see RigidStatic
|
|
*/
|
|
eRIGID_STATIC = (1 << 0),
|
|
|
|
/**
|
|
\brief A dynamic rigid body
|
|
@see RigidDynamic
|
|
*/
|
|
eRIGID_DYNAMIC = (1 << 1),
|
|
}
|
|
|
|
enum ShapeFlag {
|
|
/**
|
|
\brief The shape will partake in collision in the physical simulation.
|
|
|
|
\note It is illegal to raise the eSIMULATION_SHAPE and eTRIGGER_SHAPE flags.
|
|
In the event that one of these flags is already raised the sdk will reject any
|
|
attempt to raise the other. To raise the eSIMULATION_SHAPE first ensure that
|
|
eTRIGGER_SHAPE is already lowered.
|
|
|
|
\note This flag has no effect if simulation is disabled for the corresponding actor (see #ActorFlag::eDISABLE_SIMULATION).
|
|
|
|
@see SimulationEventCallback.onContact() Scene.setSimulationEventCallback() Shape.setFlag(), Shape.setFlags()
|
|
*/
|
|
eSIMULATION_SHAPE = (1 << 0),
|
|
|
|
/**
|
|
\brief The shape will partake in scene queries (ray casts, overlap tests, sweeps, ...).
|
|
*/
|
|
eSCENE_QUERY_SHAPE = (1 << 1),
|
|
|
|
/**
|
|
\brief The shape is a trigger which can send reports whenever other shapes enter/leave its volume.
|
|
|
|
\note Triangle meshes and heightfields can not be triggers. Shape creation will fail in these cases.
|
|
|
|
\note Shapes marked as triggers do not collide with other objects. If an object should act both
|
|
as a trigger shape and a collision shape then create a rigid body with two shapes, one being a
|
|
trigger shape and the other a collision shape. It is illegal to raise the eTRIGGER_SHAPE and
|
|
eSIMULATION_SHAPE flags on a single Shape instance. In the event that one of these flags is already
|
|
raised the sdk will reject any attempt to raise the other. To raise the eTRIGGER_SHAPE flag first
|
|
ensure that eSIMULATION_SHAPE flag is already lowered.
|
|
|
|
\note Shapes marked as triggers are allowed to participate in scene queries, provided the eSCENE_QUERY_SHAPE flag is set.
|
|
|
|
\note This flag has no effect if simulation is disabled for the corresponding actor (see #ActorFlag::eDISABLE_SIMULATION).
|
|
|
|
@see SimulationEventCallback.onTrigger() Scene.setSimulationEventCallback() Shape.setFlag(), Shape.setFlags()
|
|
*/
|
|
eTRIGGER_SHAPE = (1 << 2),
|
|
}
|
|
|
|
enum MeshGeometryFlag {
|
|
eDOUBLE_SIDED = (1 << 1)
|
|
}
|
|
|
|
enum MeshFlag {
|
|
/**
|
|
\brief Specifies if the SDK should flip normals.
|
|
|
|
The PhysX libraries assume that the face normal of a triangle with vertices [a,b,c] can be computed as:
|
|
edge1 = b-a
|
|
edge2 = c-a
|
|
face_normal = edge1 x edge2.
|
|
|
|
Note: This is the same as a counterclockwise winding in a right handed coordinate system or
|
|
alternatively a clockwise winding order in a left handed coordinate system.
|
|
|
|
If this does not match the winding order for your triangles, raise the below flag.
|
|
*/
|
|
|
|
eFLIPNORMALS = (1 << 0),
|
|
e16_BIT_INDICES = (1 << 1) //!< Denotes the use of 16-bit vertex indices
|
|
}
|
|
|
|
}
|