nvidia::apex::ModuleDestructible Class Reference

#include <ModuleDestructible.h>

List of all members.

Public Member Functions
virtual DestructibleActorJoint *	createDestructibleActorJoint (const DestructibleActorJointDesc &desc, Scene &scene)=0
virtual bool	isDestructibleActorJointActive (const DestructibleActorJoint *candidateJoint, Scene &apexScene) const =0
virtual void	setMaxDynamicChunkIslandCount (uint32_t maxCount)=0
virtual void	setMaxChunkCount (uint32_t maxCount)=0
virtual void	setSortByBenefit (bool sortByBenefit)=0
virtual void	setValidBoundsPadding (float pad)=0
virtual void	setMaxChunkDepthOffset (uint32_t maxChunkDepthOffset)=0
virtual void	setMaxChunkSeparationLOD (float separationLOD)=0
virtual void	setChunkReport (UserChunkReport *chunkReport)=0
virtual void	setImpactDamageReportCallback (UserImpactDamageReport *impactDamageReport)=0
virtual void	setChunkReportBitMask (uint32_t chunkReportBitMask)=0
virtual void	setDestructiblePhysXActorReport (UserDestructiblePhysXActorReport *destructiblePhysXActorReport)=0
virtual void	setChunkReportMaxFractureEventDepth (uint32_t chunkReportMaxFractureEventDepth)=0
virtual void	scheduleChunkStateEventCallback (DestructibleCallbackSchedule::Enum chunkStateEventCallbackSchedule)=0
virtual void	setChunkCrumbleReport (UserChunkParticleReport *chunkCrumbleReport)=0
virtual void	setChunkDustReport (UserChunkParticleReport *chunkDustReport)=0
virtual void	setWorldSupportPhysXScene (Scene &apexScene, PxScene *physxScene)=0
virtual bool	owns (const PxRigidActor *actor) const =0
virtual bool	isRuntimeFractureShape (const PxShape &shape) const =0
virtual DestructibleActor *	getDestructibleAndChunk (const PxShape *shape, int32_t *chunkIndex=NULL) const =0
virtual void	applyRadiusDamage (Scene &scene, float damage, float momentum, const PxVec3 &position, float radius, bool falloff)=0
virtual void	setMaxActorCreatesPerFrame (uint32_t maxActorsPerFrame)=0
virtual void	setMaxFracturesProcessedPerFrame (uint32_t maxFracturesProcessedPerFrame)=0
virtual bool	setSyncParams (UserDestructibleSyncHandler< DamageEventHeader > *userDamageEventHandler, UserDestructibleSyncHandler< FractureEventHeader > *userFractureEventHandler, UserDestructibleSyncHandler< ChunkTransformHeader > *userChunkMotionHandler)=0
virtual void	setUseLegacyChunkBoundsTesting (bool useLegacyChunkBoundsTesting)=0
virtual void	setUseLegacyDamageRadiusSpread (bool useLegacyDamageRadiusSpread)=0
virtual bool	setMassScaling (float massScale, float scaledMassExponent, Scene &apexScene)=0
virtual void	invalidateBounds (const PxBounds3 *bounds, uint32_t boundsCount, Scene &apexScene)=0
virtual void	setDamageApplicationRaycastFlags (nvidia::DestructibleActorRaycastFlags::Enum flags, Scene &apexScene)=0
virtual bool	setChunkCollisionHullCookingScale (const PxVec3 &scale)=0
virtual PxVec3	getChunkCollisionHullCookingScale () const =0
virtual class FractureToolsAPI *	getFractureTools () const =0
	Get reference to FractureTools object.
Protected Member Functions
virtual	~ModuleDestructible ()

---

Detailed Description

Descriptor used to create the Destructible APEX module.

---

Constructor & Destructor Documentation

virtual nvidia::apex::ModuleDestructible::~ModuleDestructible

(

)

[inline, protected, virtual]

---

Member Function Documentation

virtual void nvidia::apex::ModuleDestructible::applyRadiusDamage	(	Scene &	scene,
		float	damage,
		float	momentum,
		const PxVec3 &	position,
		float	radius,
		bool	falloff
	)		[pure virtual]

Applies damage to all DestructibleActors within the given radius in the apex scene. damage = the amount of damage at the damage point momentum = the magnitude of the impulse to transfer to each chunk position = the damage location radius = distance from damage location at which chunks will be affected falloff = whether or not to decrease damage with distance from the damage location. If true, damage will decrease linearly from the full damage (at zero distance) to zero damage (at radius). If false, full damage is applied to all chunks within the radius.

virtual DestructibleActorJoint* nvidia::apex::ModuleDestructible::createDestructibleActorJoint	(	const DestructibleActorJointDesc &	desc,
		Scene &	scene
	)		[pure virtual]

Object creation Create an DestructibleActorJoint from the descriptor. (See DestructibleActorJoint and DestructibleActorJointDesc.) This module will own the DestructibleActorJoint, so that any DestructibleAsset created by it will be released when this module is released. You may also call the DestructibleActorJoint's release() method, as long as the DestructibleActorJoint is still valid in the scene. (See isDestructibleActorJointActive())

virtual PxVec3 nvidia::apex::ModuleDestructible::getChunkCollisionHullCookingScale

(

)

const [pure virtual]

Retrieves the cooking scale used for PhysX3 collision hulls, which can be set by setChunkCollisionHullCookingScale.

virtual DestructibleActor* nvidia::apex::ModuleDestructible::getDestructibleAndChunk	(	const PxShape *	shape,
		int32_t *	chunkIndex = NULL
	)		const [pure virtual]

PhysX SDK 3.X. Given an PxShape, returns the DestructibleActor and chunkIndex which belong to it, if the shape's PxActor is owned by the Destructible module (see the 'owns' function, above). Otherwise returns NULL. Useful when a scene query such as a raycast returns a shape.

virtual class FractureToolsAPI* nvidia::apex::ModuleDestructible::getFractureTools

(

)

const [pure virtual]

Get reference to FractureTools object.

virtual void nvidia::apex::ModuleDestructible::invalidateBounds	(	const PxBounds3 *	bounds,
		uint32_t	boundsCount,
		Scene &	apexScene
	)		[pure virtual]

If a static PhysX actor is about to be removed, or has just been added, to the scene, then world support may change. Use this function to notify the destruction module that it may need to reconsider world support in the given volumes. This may be called multiple times, and the bounds list will accumulate. This list will be processed upon the next APEX simulate call, and cleared.

virtual bool nvidia::apex::ModuleDestructible::isDestructibleActorJointActive	(	const DestructibleActorJoint *	candidateJoint,
		Scene &	apexScene
	)		const [pure virtual]

Query the module on the validity of a created DestructibleActorJoint. A DestructibleActorJoint will no longer be valid when it is destroyed in the scene, in which case the module calls the DestructibleActorJoint's release(). Therefore, this DestructibleActorJoint should no longer be referenced if it is not valid.

virtual bool nvidia::apex::ModuleDestructible::isRuntimeFractureShape

(

const PxShape &

shape

)

const [pure virtual]

PhysX SDK 3.X. Returns true iff the PxShape was created by the runtime fracture system.

virtual bool nvidia::apex::ModuleDestructible::owns

(

const PxRigidActor *

actor

)

const [pure virtual]

PhysX SDK 3.X. Returns true iff the PxRigidActor was created by the Destructible module. If true, the user must NOT destroy the actor.

virtual void nvidia::apex::ModuleDestructible::scheduleChunkStateEventCallback

(

DestructibleCallbackSchedule::Enum

chunkStateEventCallbackSchedule

)

[pure virtual]

Set whether or not the UserChunkReport::onStateChangeNotify interface will be used to deliver visibility change data to the user.

Default = DestructibleCallbackSchedule::Disabled.

virtual bool nvidia::apex::ModuleDestructible::setChunkCollisionHullCookingScale

(

const PxVec3 &

scale

)

[pure virtual]

In PhysX 3.x, scaling of collision shapes can be done in the shape, not the cooked hull data. As a consequence, each collision hull only needs to be cooked once. By default, this hull is not scaled from the original data. But if the user desires, the hull can be scaled before cooking. That scale will be removed from the DestructibleActor's scale before being applied to the shape using the hull. So ideally, this user-set cooking scale does nothing. Numerically, however, it may have an effect, so we leave it as an option.

The input scale must be positive in all components. If not, the cooking scale will not be set, and the function returns false. Otherwise, the scale is set and the function returns true.

virtual void nvidia::apex::ModuleDestructible::setChunkCrumbleReport

(

UserChunkParticleReport *

chunkCrumbleReport

)

[pure virtual]

Sets the user chunk crumble particle buffer callback. See UserChunkParticleReport. Set to NULL (the default) to disable. APEX does not take ownership of the report object.

virtual void nvidia::apex::ModuleDestructible::setChunkDustReport

(

UserChunkParticleReport *

chunkDustReport

)

[pure virtual]

Sets the user chunk dust particle buffer callback. See UserChunkParticleReport. Set to NULL (the default) to disable. APEX does not take ownership of the report object.

Note - this is a placeholder API. The dust feature is disabled in 1.2.0.

virtual void nvidia::apex::ModuleDestructible::setChunkReport

(

UserChunkReport *

chunkReport

)

[pure virtual]

General Sets the user chunk fracture/destroy callback. See UserChunkReport. Set to NULL (the default) to disable. APEX does not take ownership of the report object.

virtual void nvidia::apex::ModuleDestructible::setChunkReportBitMask

(

uint32_t

chunkReportBitMask

)

[pure virtual]

Set a bit mask of flags (see ApexChunkFlag) for the fracture/destroy callback (See setChunkReport.) Fracture events with flags that overlap this mask will contribute to the DamageEventReportData.

virtual void nvidia::apex::ModuleDestructible::setChunkReportMaxFractureEventDepth

(

uint32_t

chunkReportMaxFractureEventDepth

)

[pure virtual]

Set the maximum depth at which individual chunk fracture events will be reported in an DamageEventReportData's fractureEventList through the UserChunkReport. Fracture events deeper than this will still contribute to the DamageEventReportData's worldBounds and totalNumberOfFractureEvents.

virtual void nvidia::apex::ModuleDestructible::setDamageApplicationRaycastFlags	(	nvidia::DestructibleActorRaycastFlags::Enum	flags,
		Scene &	apexScene
	)		[pure virtual]

When applyDamage, or damage from impact, is processed, a rayCast call is used internally to find a more accurate damage position. This allows the user to specify the rayCast behavior. If no flags are set, no raycasting is done. Raycasting will be peformed against static or dynamic chunks, or both, depending on the value of flags. The flags are defined by DestructibleActorRaycastFlags::Enum.

The default flag used is DestructibleActorRaycastFlags::StaticChunks, since static-only raycasts are faster than ones that include dynamic chunks.

Note: only the flags DestructibleActorRaycastFlags::NoChunks, StaticChunks, and DynamicChunks are considered.

virtual void nvidia::apex::ModuleDestructible::setDestructiblePhysXActorReport

(

UserDestructiblePhysXActorReport *

destructiblePhysXActorReport

)

[pure virtual]

Sets the user callback to receive PhysX actor create/release notifications for destruction-associated PhysX actors. Set to NULL (the default) to disable.

virtual void nvidia::apex::ModuleDestructible::setImpactDamageReportCallback

(

UserImpactDamageReport *

impactDamageReport

)

[pure virtual]

Sets the user impact damage report callback. See UserImpactDamageReport. Set to NULL (the default) to disable. APEX does not take ownership of the report object.

virtual bool nvidia::apex::ModuleDestructible::setMassScaling	(	float	massScale,
		float	scaledMassExponent,
		Scene &	apexScene
	)		[pure virtual]

Sets mass scaling properties in a given apex scene.

massScale and scaledMassExponent are used for scaling dynamic chunk masses. The 'real' mass m of a chunk is calculated by the destructible actor's density multiplied by the total volume of the chunk's (scaled) collision shapes. The mass used in the simulation is massScale*pow(m/massScale,scaledMassExponent). Values less than 1 have the effect of reducing the ratio of different masses. The closer scaledMassExponent is to zero, the more the ratio will be 'flattened.' This helps PhysX converge when there is a very large number of interacting rigid bodies (such as a pile of destructible chunks).

massScale valid range: (0,infinity). Default = 1.0. scaledMassExponent valid range: [0,1]. Default = 0.5.

Returns true iff the parameters are valid and the apexScene is valid.

virtual void nvidia::apex::ModuleDestructible::setMaxActorCreatesPerFrame

(

uint32_t

maxActorsPerFrame

)

[pure virtual]

Lets the user throttle the number of SDK actor creates per frame (per scene) due to destruction, as this can be quite costly. The default is 0xffffffff (unlimited).

virtual void nvidia::apex::ModuleDestructible::setMaxChunkCount

(

uint32_t

maxCount

)

[pure virtual]

The maximum number of allowed visible chunks in the scene. If a fracturing event would cause more chunks to be created, then PxActors are released to make room for the created chunks. The priority for released PxActors is the same as described in setMaxDynamicChunkIslandCount.

virtual void nvidia::apex::ModuleDestructible::setMaxChunkDepthOffset

(

uint32_t

maxChunkDepthOffset

)

[pure virtual]

Effectively eliminates the deeper level (smaller) chunks from DestructibleAssets (see DestructibleAsset). If maxChunkDepthOffset = 0, all chunks can be fractured. If maxChunkDepthOffset = 1, the depest level (smallest) chunks are eliminated, etc. This prevents too many chunks from being formed. In other words, the higher maxChunkDepthOffset, the lower the "level of detail."

virtual void nvidia::apex::ModuleDestructible::setMaxChunkSeparationLOD

(

float

separationLOD

)

[pure virtual]

Every destructible asset defines a min and max lifetime, and maximum separation distance for its chunks. Chunk islands are destroyed after this time or separation from their origins. This parameter sets the lifetimes and max separations within their min-max ranges. The valid range is [0,1]. Default is 0.5.

virtual void nvidia::apex::ModuleDestructible::setMaxDynamicChunkIslandCount

(

uint32_t

maxCount

)

[pure virtual]

LOD The maximum number of allowed PxActors which represent dynamic groups of chunks. If a fracturing event would cause more PxActors to be created, then some PxActors are released and the chunks they represent destroyed. The PxActors released to make room for others depends on the priority mode. If sorting by benefit (see setSortByBenefit), then chunks with the lowest LOD benefit are released first. Otherwise, oldest chunks are released first.

virtual void nvidia::apex::ModuleDestructible::setMaxFracturesProcessedPerFrame

(

uint32_t

maxFracturesProcessedPerFrame

)

[pure virtual]

Lets the user throttle the number of fractures processed per frame (per scene) due to destruction, as this can be quite costly. The default is 0xffffffff (unlimited).

virtual void nvidia::apex::ModuleDestructible::setSortByBenefit

(

bool

sortByBenefit

)

[pure virtual]

Instead of keeping the youngest PxActors, keep the greatest benefit PxActors if sortByBenefit is true. By default, this module does not sort by benefit. That is, oldest PxActors are released first.

virtual bool nvidia::apex::ModuleDestructible::setSyncParams	(	UserDestructibleSyncHandler< DamageEventHeader > *	userDamageEventHandler,
		UserDestructibleSyncHandler< FractureEventHeader > *	userFractureEventHandler,
		UserDestructibleSyncHandler< ChunkTransformHeader > *	userChunkMotionHandler
	)		[pure virtual]

Set the callback pointers from which APEX will use to return sync-able data.

virtual void nvidia::apex::ModuleDestructible::setUseLegacyChunkBoundsTesting

(

bool

useLegacyChunkBoundsTesting

)

[pure virtual]

The following functions control the use of legacy behavior. By default, destruction damage application (either point or radius damage) now use the exact collision bounds of the chunk to determine damage application. Before, bounding spheres were used on "leaf" chunks (deepest in the fracture hierarchy) and only the bounding sphere center (effectively radius 0) was used on all chunks higher in the hierarchy. This led to inconsistent behavior when damaging destructibles at various levels of detail.

If true is passed into this function, the legacy behavior is restored.

virtual void nvidia::apex::ModuleDestructible::setUseLegacyDamageRadiusSpread

(

bool

useLegacyDamageRadiusSpread

)

[pure virtual]

By default, the BehaviorGroup fields damageSpread.minimumRadius, damageSpread.radiusMultiplier, and damageSpread.falloffExponent are used for point and radius damage. Impact damage still uses damageToRadius, but this radius does not scale with the size of the destructible.

The old, deprecated behavior was to base damage spread upon the damageToRadius field of the BehaviorGroup used by the chunk. Specifically, damage would spread throughout a damage radius calculated as radius = damageToRadius * (damage / damageThreshold) * (size of destructible).

If true is passed into this function, the legacy behavior is restored.

virtual void nvidia::apex::ModuleDestructible::setValidBoundsPadding

(

float

pad

)

[pure virtual]

Deprecated

virtual void nvidia::apex::ModuleDestructible::setWorldSupportPhysXScene	(	Scene &	apexScene,
		PxScene *	physxScene
	)		[pure virtual]

PhysX SDK 3.X. Allows the user to specify an alternative PhysX scene to use for world support calculations. If NULL (the default), the PhysX scene associated with the Scene will be used.

---

The documentation for this class was generated from the following file:

• ModuleDestructible.h