Nv::Blast Namespace Reference


Namespaces
namespace	ApexImporter
namespace	BooleanConfigurations
namespace	Serialization
namespace	VecMath
namespace	VSA
Classes
class	Actor
struct	ActorSerializationFormat
struct	ActorSerializationHeader
class	Allocator
class	AllocatorCallback
	Abstract base class for an application defined memory allocator that can be used by toolkit (Tk) or any extension (Ext). More...
struct	Array
class	Asset
struct	AuthoringResult
class	BBoxBasedAccelerator
struct	BeamPatternDesc
class	BlastBondGenerator
class	BlastBondGeneratorImpl
struct	BondGenerationConfig
struct	BooleanConf
class	BooleanEvaluator
struct	BooleanResultEdge
struct	BooleanToolOutputData
struct	BooleanToolOutputDataImpl
class	BooleanToolV2
class	ChunkDepthFirstIt
struct	ChunkGraph
struct	ChunkGraphLink
struct	ChunkInfo
struct	CmpSharedFace
struct	CmpVec
struct	CollisionHull
struct	CollisionHullImpl
struct	ConvexDecompositionParams
struct	ConvexLoop
class	ConvexMeshBuilder
struct	Cutout
struct	CutoutConfiguration
class	CutoutSet
struct	CutoutSetImpl
struct	DamagePattern
struct	DebugBuffer
struct	DebugLine
struct	DLink
class	DList
class	DListIt
class	DummyAccelerator
struct	Edge
struct	EdgeComparator
struct	EdgeFacetIntersectionData
struct	EdgeToTriangles
struct	EdgeWithParent
class	ErrorCallback
	User defined interface class. Used by the library to emit debug information. More...
struct	ErrorCode
	Error codes. More...
struct	ExporterMeshData
class	ExtAtomicCounter
class	ExtCustomProfiler
class	ExtDamageAcceleratorInternal
struct	ExtForceMode
class	ExtGroupTaskManager
class	ExtGroupTaskManagerImpl
class	ExtGroupWorkerTask
class	ExtImpactDamageManager
struct	ExtImpactSettings
class	ExtInputStream
class	ExtIStream
class	ExtKJPxInputStream
class	ExtKJPxOutputStream
class	ExtOutputStream
struct	ExtProfileData
class	ExtPxActor
struct	ExtPxActorDescTemplate
class	ExtPxAsset
struct	ExtPxAssetDesc
struct	ExtPxChunk
class	ExtPxCollisionBuilder
class	ExtPxCollisionBuilderImpl
class	ExtPxFamily
struct	ExtPxFamilyDesc
class	ExtPxListener
class	ExtPxManager
struct	ExtPxObjectTypeID
struct	ExtPxShapeDescTemplate
struct	ExtPxSpawnSettings
class	ExtPxStressSolver
struct	ExtPxSubchunk
class	ExtSerialization
class	ExtSerializationCAPN
class	ExtSerializationInternal
class	ExtSerializer
class	ExtStressSolver
struct	ExtStressSolverSettings
class	ExtSync
struct	ExtSyncEvent
struct	ExtSyncEventFamilySync
struct	ExtSyncEventFracture
struct	ExtSyncEventInstance
struct	ExtSyncEventPhysicsSync
struct	ExtSyncEventType
class	ExtTaskSync
struct	Facet
struct	FacetFacetResult
class	FamilyGraph
struct	FamilyHeader
class	FbxFileReader
class	FbxFileWriter
class	final
class	FixedArray
class	FixedBitmap
class	FixedBoolArray
class	FixedPriorityQueue
class	FixedQueue
struct	FractureDesc
class	Fracturer
class	FractureRT
class	FractureRTImpl
class	FractureRTMultithreadedImpl
class	FractureTool
class	FractureToolImpl
class	Grid
class	GridWalker
struct	HashMap
struct	HashSet
struct	HullPolygon
class	IFbxFileReader
class	IJsonCollisionExporter
class	IMeshFileReader
class	IMeshFileWriter
struct	IndexDLink
class	IndexDList
struct	InlineArray
class	IteratorBase
struct	Less
class	LListIt
struct	LlObjectTypeID
class	LocalBuffer
struct	Material
class	Mesh
class	MeshCleaner
class	MeshCleanerImpl
struct	MeshDesc
class	MeshGenerator
class	MeshImpl
class	MeshNoiser
struct	NoiseConfiguration
class	ObjFileReader
class	ObjFileWriter
struct	PatternDescriptor
class	PatternGenerator
class	PatternGeneratorImpl
class	PerlinNoise
struct	PerTriangleAdditionalData
struct	PlaneChunkIndexer
struct	POINT2D
struct	PolyVert
class	ProfilerCallback
struct	ProfilerDetail
struct	PxActorCreateInfo
class	RandomGeneratorBase
struct	RegularRadialPatternDesc
struct	SegmentToIndex
struct	Separation
class	SharedBlock
class	SharedBuffer
struct	SharedFace
class	SharedMemory
class	SimplexNoise
struct	SlicingConfiguration
class	SpatialAccelerator
struct	SupportGraph
class	SweepingAccelerator
class	Time
class	TkActor
struct	TkActorData
struct	TkActorDesc
struct	TkActorFlag
class	TkActorImpl
class	TkAsset
struct	TkAssetDesc
struct	TkAssetJointDesc
struct	TkEvent
class	TkEventListener
class	TkEventQueue
class	TkFamily
struct	TkFractureCommands
struct	TkFractureEvents
class	TkFramework
class	TkFrameworkImpl
class	TkGroup
struct	TkGroupDesc
struct	TkGroupStats
class	TkGroupWorker
class	TkIdentifiable
class	TkJoint
struct	TkJointData
struct	TkJointDesc
class	TkJointImpl
struct	TkJointLink
struct	TkJointUpdateEvent
class	TkObject
struct	TkObjectTypeID
struct	TkSplitEvent
class	TkType
class	TkTypeImpl
struct	TkTypeIndex
struct	TkWorkerJob
struct	Triangle
struct	TriangleIndexed
class	TriangleProcessor
class	Triangulator
class	TriangulatorV2
struct	TrPrcTriangle
struct	TrPrcTriangle2d
struct	UniformPatternDesc
struct	Vertex
class	VertexWelding
class	VoronoiSitesGenerator
class	VoronoiSitesGeneratorImpl
struct	VrtComp
struct	VrtPositionComparator
Typedefs
typedef uint32_t	ActorIndex
typedef bool(*	ExtImpactDamageFunction )(void data, ExtPxActor actor, physx::PxShape *shape, physx::PxVec3 worldPos, physx::PxVec3 worldForce)
typedef physx::PxJoint (	ExtPxCreateJointFunction )(ExtPxActor actor0, const physx::PxTransform &localFrame0, ExtPxActor actor1, const physx::PxTransform &localFrame1, physx::PxPhysics &physics, TkJoint &joint)
typedef NodeIndex	IslandId
typedef uint32_t	NodeIndex
typedef std::map < physx::PxVec3, std::map < uint32_t, uint32_t >, CmpVec >	PointMap
typedef float(*	RNG_CALLBACK )(void)
typedef std::map< std::pair < physx::PxVec3, physx::PxVec3 > , SharedFace, CmpSharedFace >	SharedFacesMap
Enumerations
enum	PatternFacetType { GOOD_FACET = 0, INFINITE_FACET = 0xffffff }
enum	ProjectionDirections { YZ_PLANE = 1 << 1, XY_PLANE = 1 << 2, ZX_PLANE = 1 << 3, OPPOSITE_WINDING = 1 << 4 }
Functions
template<typename T >
NV_INLINE T	align16 (T value)
NV_INLINE float	at3 (const float &rx, const float &ry, const float &rz, const PxVec3 q)
int32_t	atomicDecrement (volatile int32_t *val)
int32_t	atomicIncrement (volatile int32_t *val)
void	buildCuttingConeFaces (const CutoutConfiguration &conf, const std::vector< std::vector< physx::PxVec3 >> &points, float heightBot, float heightTop, float conicityBot, float conicityTop, int64_t &id, int32_t seed, int32_t interiorMaterialId, SharedFacesMap &sharedFacesMap)
int32_t	buildMeshConvexDecomposition (ConvexMeshBuilder &cmb, const Triangle mesh, uint32_t triangleCount, const ConvexDecompositionParams &params, CollisionHull *&convexes)
NV_INLINE float	calculateCollisionHullVolume (const CollisionHull &hull)
void	createCutoutSet (Nv::Blast::CutoutSetImpl &cutoutSet, const uint8_t *pixelBuffer, uint32_t bufferWidth, uint32_t bufferHeight, float segmentationErrorThreshold, float snapThreshold, bool periodic, bool expandGaps)
template<typename T >
void	createIndexStartLookup (T lookup, T indexBase, T indexRange, T indexSource, T indexCount, T indexByteStride)
ExtPxAsset *	deserializeExtPxAsset (ExtIStream &stream, TkFramework &framework, physx::PxPhysics &physics)
TkAsset *	deserializeTkAsset (ExtIStream &stream, TkFramework &framework)
NV_INLINE uint32_t	enumerateChunkHierarchyBreadthFirst (uint32_t chunkIndices, uint32_t chunkIndicesSize, const NvBlastChunk chunks, uint32_t chunkIndex, bool includeRoot=true, uint32_t chunkIndexLimit=invalidIndex< uint32_t >())
template<typename Factory , size_t N>
size_t	ExtSerializationLoadSet (Nv::Blast::ExtSerializationInternal &serialization, Factory(&factories)[N])
NV_INLINE float	fade (float t)
void	findCellBasePlanes (const std::vector< NvcVec3 > &sites, std::vector< std::vector< int32_t > > &neighboors)
NV_FORCE_INLINE uint32_t	findClosestNode (const float point[4], const uint32_t firstGraphNodeIndex, const uint32_t familyGraphNodeIndexLinks, const uint32_t adjacencyPartition, const uint32_t adjacentNodeIndices, const uint32_t adjacentBondIndices, const NvBlastBond bonds, const float bondHealths, const uint32_t *chunkIndices)
NV_FORCE_INLINE uint32_t	findClosestNode (const float point[4], const uint32_t firstGraphNodeIndex, const uint32_t familyGraphNodeIndexLinks, const uint32_t adjacencyPartition, const uint32_t adjacentNodeIndices, const uint32_t adjacentBondIndices, const NvBlastBond assetBonds, const float bondHealths, const NvBlastChunk assetChunks, const float supportChunkHealths, const uint32_t *chunkIndices)
NV_INLINE size_t	getActorSerializationSize (uint32_t visibleChunkCount, uint32_t lowerSupportChunkCount, uint32_t graphNodeCount, uint32_t bondCount)
Mesh *	getBigBox (const physx::PxVec3 &point, float size, int32_t interiorMaterialId)
Mesh *	getCellMesh (class BooleanEvaluator &eval, int32_t planeIndexerOffset, int32_t cellId, const std::vector< NvcVec3 > &sites, std::vector< std::vector< int32_t > > &neighboors, int32_t interiorMaterialId, NvcVec3 origin)
Mesh *	getCuttingBox (const physx::PxVec3 &point, const physx::PxVec3 &normal, float size, int64_t id, int32_t interiorMaterialId)
Mesh *	getCuttingCone (const CutoutConfiguration &conf, const std::vector< physx::PxVec3 > &points, const std::set< int32_t > &smoothingGroups, float heightBot, float heightTop, float conicityBot, float conicityTop, int64_t &id, int32_t seed, int32_t interiorMaterialId, const SharedFacesMap &sharedFacesMap, bool inverseNormals=false)
NV_INLINE const NvBlastID &	getFamilyID (const TkFamilyImpl *family)
NV_INLINE const NvBlastID &	getFamilyID (const TkActor *actor)
size_t	getFamilyMemorySize (const Asset *asset)
Mesh *	getNoisyCuttingBoxPair (const physx::PxVec3 &point, const physx::PxVec3 &normal, float size, float jaggedPlaneSize, physx::PxVec3 resolution, int64_t id, float amplitude, float frequency, int32_t octaves, int32_t seed, int32_t interiorMaterialId)
NV_INLINE bool	getPlaneSegmentIntersection (const physx::PxPlane &pl, const physx::PxVec3 &a, const physx::PxVec3 &b, physx::PxVec3 &result)
NV_FORCE_INLINE physx::PxVec2	getProjectedPoint (const NvcVec3 &point, ProjectionDirections dir)
NV_FORCE_INLINE physx::PxVec2	getProjectedPoint (const physx::PxVec3 &point, ProjectionDirections dir)
NV_FORCE_INLINE physx::PxVec2	getProjectedPointWithWinding (const physx::PxVec3 &point, ProjectionDirections dir)
NV_FORCE_INLINE ProjectionDirections	getProjectionDirection (const physx::PxVec3 &normal)
bool	importerHullsInProximityApexFree (uint32_t hull0Count, const physx::PxVec3 hull0, physx::PxBounds3 &hull0Bounds, const physx::PxTransform &localToWorldRT0In, const physx::PxVec3 &scale0In, uint32_t hull1Count, const physx::PxVec3 hull1, physx::PxBounds3 &hull1Bounds, const physx::PxTransform &localToWorldRT1In, const physx::PxVec3 &scale1In, physx::PxF32 maxDistance, Separation *separation)
NVBLAST_API Asset *	initializeAsset (void *mem, NvBlastID id, uint32_t chunkCount, uint32_t graphNodeCount, uint32_t leafChunkCount, uint32_t firstSubsupportChunkIndex, uint32_t bondCount, NvBlastLog logFn)
template<typename T >
NV_INLINE T	invalidIndex ()
void	inverseNormalAndIndices (Mesh *mesh)
template<typename T >
void	invertMap (T inverseMap, const T map, const T size)
template<typename T >
NV_INLINE bool	isInvalidIndex (T index)
NV_INLINE float	lerp (float t, float a, float b)
NV_INLINE void	logLL (int type, const char msg, const char file, int line)
NV_INLINE float	noiseSample (PxVec3 point, int p, PxVec3 g)
	NVBLASTTK_IMPL_DECLARE (Group)
	NVBLASTTK_IMPL_DECLARE (Family)
	NVBLASTTK_IMPL_DECLARE (Asset)
NV_FORCE_INLINE void	operator+= (NvBlastTimers &lhs, const NvBlastTimers &rhs)
bool	operator< (const Edge &a, const Edge &b)
template<typename T >
NV_INLINE ExtIStream &	operator>> (ExtIStream &s, T &x)
template<typename T >
NV_INLINE T	pointerOffset (const void *p, ptrdiff_t offset)
template<typename T >
NV_INLINE T	pointerOffset (void *p, ptrdiff_t offset)
NVBLAST_API void	savePatternToObj (DamagePattern *pattern)
void	setCuttingBox (const physx::PxVec3 &point, const physx::PxVec3 &normal, Mesh *mesh, float size, int64_t id)
NV_INLINE void	setup (int i, PxVec3 point, float &t, int &b0, int &b1, float &r0, float &r1)
NV_INLINE NvBlastID	TkGenerateGUID (void *ptr)
NV_INLINE bool	TkGUIDIsZero (const NvBlastID *id)
NV_INLINE void	TkGUIDReset (NvBlastID *id)
NV_INLINE bool	TkGUIDsEqual (const NvBlastID id1, const NvBlastID id2)
void	trimCollisionGeometry (ConvexMeshBuilder &cmb, uint32_t chunksCount, CollisionHull *in, const uint32_t chunkDepth)
template<class VisibilityRep >
void	updateVisibleChunksFromSupportChunk (VisibilityRep actors, IndexDLink< uint32_t > visibleChunkIndexLinks, uint32_t chunkActorIndices, uint32_t actorIndex, uint32_t supportChunkIndex, const NvBlastChunk chunks, uint32_t upperSupportChunkCount)
NV_INLINE bool	weakBoundingBoxIntersection (const physx::PxBounds3 &aBox, const physx::PxBounds3 &bBox)
Variables
const uint32_t	kMaterialInteriorId = 1000
const uint32_t	kNotValidVertexIndex = UINT32_MAX
const uint32_t	kSmoothingGroupInteriorId = 1000

Typedef Documentation

typedef uint32_t Nv::Blast::ActorIndex

typedef bool(* Nv::Blast::ExtImpactDamageFunction)(void *data, ExtPxActor *actor, physx::PxShape *shape, physx::PxVec3 worldPos, physx::PxVec3 worldForce)

Custom Damage Function

typedef physx::PxJoint*(* Nv::Blast::ExtPxCreateJointFunction)(ExtPxActor *actor0, const physx::PxTransform &localFrame0, ExtPxActor *actor1, const physx::PxTransform &localFrame1, physx::PxPhysics &physics, TkJoint &joint)

Function pointer for PxJoint creation.

It will be called when new joints are being created. It should return valid PxJoint pointer or nullptr.

typedef NodeIndex Nv::Blast::IslandId

typedef uint32_t Nv::Blast::NodeIndex

typedef std::map<physx::PxVec3, std::map<uint32_t, uint32_t>, CmpVec> Nv::Blast::PointMap

typedef float(* Nv::Blast::RNG_CALLBACK)(void)

typedef std::map<std::pair<physx::PxVec3, physx::PxVec3>, SharedFace, CmpSharedFace> Nv::Blast::SharedFacesMap

Enumeration Type Documentation

enum Nv::Blast::PatternFacetType

Enumerator:

GOOD_FACET
INFINITE_FACET

enum Nv::Blast::ProjectionDirections

Vertex projection direction flag.

Enumerator:

YZ_PLANE
XY_PLANE
ZX_PLANE
OPPOSITE_WINDING

Function Documentation

template<typename T >

NV_INLINE T Nv::Blast::align16 ( T value ) [inline]

Utility function to align the given value to the next 16-byte boundary.

Returns the aligned value.

NV_INLINE float Nv::Blast::at3	(	const float &	rx,
		const float &	ry,
		const float &	rz,
		const PxVec3	q
	)

int32_t Nv::Blast::atomicDecrement ( volatile int32_t * val )

int32_t Nv::Blast::atomicIncrement ( volatile int32_t * val )

void Nv::Blast::buildCuttingConeFaces	(	const CutoutConfiguration &	conf,
		const std::vector< std::vector< physx::PxVec3 >> &	points,
		float	heightBot,
		float	heightTop,
		float	conicityBot,
		float	conicityTop,
		int64_t &	id,
		int32_t	seed,
		int32_t	interiorMaterialId,
		SharedFacesMap &	sharedFacesMap
	)

int32_t Nv::Blast::buildMeshConvexDecomposition	(	ConvexMeshBuilder &	cmb,
		const Triangle *	mesh,
		uint32_t	triangleCount,
		const ConvexDecompositionParams &	params,
		CollisionHull **&	convexes
	)

NV_INLINE float Nv::Blast::calculateCollisionHullVolume ( const CollisionHull & hull )

void Nv::Blast::createCutoutSet	(	Nv::Blast::CutoutSetImpl &	cutoutSet,
		const uint8_t *	pixelBuffer,
		uint32_t	bufferWidth,
		uint32_t	bufferHeight,
		float	segmentationErrorThreshold,
		float	snapThreshold,
		bool	periodic,
		bool	expandGaps
	)

template<typename T >

void Nv::Blast::createIndexStartLookup	(	T *	lookup,
		T	indexBase,
		T	indexRange,
		T *	indexSource,
		T	indexCount,
		T	indexByteStride
	)			`[inline]`

Create a lookup table for data sorted by a templated index type.

Note: when using this function with unsigned integer index types invalidIndex<T>() is treated as a value less than zero.

On input:

The indices must lie in the interval [indexBase, indexBase+indexRange].

indexSource must point to the first index in the data.

indexCount must be set to the number of indices in the data.

indexByteStride must be set to the distance, in bytes, between subequent indices.

lookup must point to a T array of size indexRange+2.

On return:

lookup will be filled such that:

lookup[i] = the position of first data element with index (i + indexBase)

lookup[indexRange+1] = indexCount

The last (indexRange+1) element is used so that one may always determine the number of data elements with the given index using:

count = lookup[i+1] - lookup[i]

Note, if an index (i + indexBase) is not present in the data then, lookup[i+1] = lookup[i], so the count (above) will correctly be zero. In this case, the actual value of lookup[i] is irrelevant.

ExtPxAsset* Nv::Blast::deserializeExtPxAsset	(	ExtIStream &	stream,
		TkFramework &	framework,
		physx::PxPhysics &	physics
	)

TkAsset* Nv::Blast::deserializeTkAsset	(	ExtIStream &	stream,
		TkFramework &	framework
	)

NV_INLINE uint32_t Nv::Blast::enumerateChunkHierarchyBreadthFirst	(	uint32_t *	chunkIndices,
		uint32_t	chunkIndicesSize,
		const NvBlastChunk *	chunks,
		uint32_t	chunkIndex,
		bool	includeRoot = `true`,
		uint32_t	chunkIndexLimit = `invalidIndex<uint32_t>()`
	)

Enumerates chunk indices in a subtree with root given by chunkIndex, in breadth-first order. Will not traverse chunks with index at or beyond chunkIndexLimit. Returns the number of indices written to the chunkIndex array

template<typename Factory , size_t N>

size_t Nv::Blast::ExtSerializationLoadSet	(	Nv::Blast::ExtSerializationInternal &	serialization,
		Factory(&)	factories[N]
	)			`[inline]`

NV_INLINE float Nv::Blast::fade ( float t )

void Nv::Blast::findCellBasePlanes	(	const std::vector< NvcVec3 > &	sites,
		std::vector< std::vector< int32_t > > &	neighboors
	)

NV_FORCE_INLINE uint32_t Nv::Blast::findClosestNode	(	const float	point[4],
		const uint32_t	firstGraphNodeIndex,
		const uint32_t *	familyGraphNodeIndexLinks,
		const uint32_t *	adjacencyPartition,
		const uint32_t *	adjacentNodeIndices,
		const uint32_t *	adjacentBondIndices,
		const NvBlastBond *	bonds,
		const float *	bondHealths,
		const uint32_t *	chunkIndices
	)

Find the closest node to point in the graph. Uses primarily distance to bond centroids. Slower compared to chunk based lookup but may yield better accuracy in some cases. Bond normals are expected to be directed from the lower to higher node index. Cannot be used for graph actors with only the world chunk in the graph.

Parameters:

`[in]`	point	the point to test against
`[in]`	firstGraphNodeIndex	the entry point for familyGraphNodeIndexLinks
`[in]`	familyGraphNodeIndexLinks	the list index links of the actor's graph
`[in]`	adjacencyPartition	the actor's SupportGraph adjacency partition
`[in]`	adjacentNodeIndices	the actor's SupportGraph adjacent node indices
`[in]`	adjacentBondIndices	the actor's SupportGraph adjacent bond indices
`[in]`	assetBonds	the actor's asset bonds
`[in]`	bondHealths	the actor's bond healths
`[in]`	chunkIndices	maps node index to chunk index in SupportGraph

Returns:: the index of the node closest to point

NV_FORCE_INLINE uint32_t Nv::Blast::findClosestNode	(	const float	point[4],
		const uint32_t	firstGraphNodeIndex,
		const uint32_t *	familyGraphNodeIndexLinks,
		const uint32_t *	adjacencyPartition,
		const uint32_t *	adjacentNodeIndices,
		const uint32_t *	adjacentBondIndices,
		const NvBlastBond *	assetBonds,
		const float *	bondHealths,
		const NvBlastChunk *	assetChunks,
		const float *	supportChunkHealths,
		const uint32_t *	chunkIndices
	)

Find the closest node to point in the graph. Uses primarily distance to chunk centroids. Bond normals are expected to be directed from the lower to higher node index. Cannot be used for graph actors with only the world chunk in the graph.

Parameters:

`[in]`	point	the point to test against
`[in]`	firstGraphNodeIndex	the entry point for familyGraphNodeIndexLinks
`[in]`	familyGraphNodeIndexLinks	the list index links of the actor's graph
`[in]`	adjacencyPartition	the actor's SupportGraph adjacency partition
`[in]`	adjacentNodeIndices	the actor's SupportGraph adjacent node indices
`[in]`	adjacentBondIndices	the actor's SupportGraph adjacent bond indices
`[in]`	assetBonds	the actor's asset bonds
`[in]`	bondHealths	the actor's bond healths
`[in]`	assetChunks	the actor's asset chunks
`[in]`	supportChunkHealths	the actor's graph chunks healths
`[in]`	chunkIndices	maps node index to chunk index in SupportGraph

Returns:: the index of the node closest to point

NV_INLINE size_t Nv::Blast::getActorSerializationSize	(	uint32_t	visibleChunkCount,
		uint32_t	lowerSupportChunkCount,
		uint32_t	graphNodeCount,
		uint32_t	bondCount
	)

A buffer size sufficient to serialize an actor with a given visible chunk count, lower support chunk count, graph node count, and bond count.

Parameters:

`[in]`	visibleChunkCount	The number of visible chunks
`[in]`	lowerSupportChunkCount	The number of lower-support chunks in the asset.
`[in]`	graphNodeCount	The number of graph nodes in the asset.
`[in]`	bondCount	The number of graph bonds in the asset.

Returns:: the required buffer size in bytes.

Mesh* Nv::Blast::getBigBox	(	const physx::PxVec3 &	point,
		float	size,
		int32_t	interiorMaterialId
	)

Create box at some particular position.

Parameters:

`[in]`	point	Cutting face center
`[in]`	size	Cutting box size

Mesh* Nv::Blast::getCellMesh	(	class BooleanEvaluator &	eval,
		int32_t	planeIndexerOffset,
		int32_t	cellId,
		const std::vector< NvcVec3 > &	sites,
		std::vector< std::vector< int32_t > > &	neighboors,
		int32_t	interiorMaterialId,
		NvcVec3	origin
	)

Mesh* Nv::Blast::getCuttingBox	(	const physx::PxVec3 &	point,
		const physx::PxVec3 &	normal,
		float	size,
		int64_t	id,
		int32_t	interiorMaterialId
	)

Create cutting box at some particular position.

Parameters:

`[in]`	point	Cutting face center
`[in]`	normal	Cutting face normal
`[in]`	size	Cutting box size
`[in]`	id	Cutting box ID

Mesh* Nv::Blast::getCuttingCone	(	const CutoutConfiguration &	conf,
		const std::vector< physx::PxVec3 > &	points,
		const std::set< int32_t > &	smoothingGroups,
		float	heightBot,
		float	heightTop,
		float	conicityBot,
		float	conicityTop,
		int64_t &	id,
		int32_t	seed,
		int32_t	interiorMaterialId,
		const SharedFacesMap &	sharedFacesMap,
		bool	inverseNormals = `false`
	)

Create cutting cone at some particular position.

Parameters:

`[in]`	conf	Cutout configuration parameters and data
`[in]`	meshId	Cutout index
`[in]`	points	Array of points for loop
`[in]`	smoothingGroups	Array of point indices at which smoothing group should be toggled
`[in]`	heightBot	Cutting cone bottom height (below z = 0)
`[in]`	heightTop	Cutting cone top height (below z = 0)
`[in]`	conicityBot	Cutting cone bottom points multiplier
`[in]`	conicityTop	Cutting cone top points multiplier
`[in]`	id	Cutting cylinder ID
`[in]`	seed	Seed for RNG
`[in]`	interiorMaterialId	Interior material index
`[in]`	sharedFacesMap	Shared faces for noisy fracture

NV_INLINE const NvBlastID& Nv::Blast::getFamilyID ( const TkFamilyImpl * family )

NV_INLINE const NvBlastID& Nv::Blast::getFamilyID ( const TkActor * actor )

size_t Nv::Blast::getFamilyMemorySize ( const Asset * asset )

Returns the number of bytes of memory that a family created using the given asset will require. A pointer to a block of memory of at least this size must be passed in as the mem argument of createFamily.

Parameters:

[in] asset The asset that will be passed into NvBlastAssetCreateFamily.

Mesh* Nv::Blast::getNoisyCuttingBoxPair	(	const physx::PxVec3 &	point,
		const physx::PxVec3 &	normal,
		float	size,
		float	jaggedPlaneSize,
		physx::PxVec3	resolution,
		int64_t	id,
		float	amplitude,
		float	frequency,
		int32_t	octaves,
		int32_t	seed,
		int32_t	interiorMaterialId
	)

Create slicing box with noisy cutting surface.

Parameters:

`[in]`	point	Cutting face center
`[in]`	normal	Cutting face normal
`[in]`	size	Cutting box size
`[in]`	jaggedPlaneSize	Noisy surface size
`[in]`	resolution	Noisy surface resolution
`[in]`	id	Cutting box ID
`[in]`	amplitude	Noise amplitude
`[in]`	frequency	Noise frequency
`[in]`	octaves	Noise octaves
`[in]`	seed	Random generator seed, used for noise generation.

NV_INLINE bool Nv::Blast::getPlaneSegmentIntersection	(	const physx::PxPlane &	pl,
		const physx::PxVec3 &	a,
		const physx::PxVec3 &	b,
		physx::PxVec3 &	result
	)

Test segment vs plane intersection. If segment intersects the plane true is returned. Point of intersection is written into 'result'.

NV_FORCE_INLINE physx::PxVec2 Nv::Blast::getProjectedPoint	(	const NvcVec3 &	point,
		ProjectionDirections	dir
	)

NV_FORCE_INLINE physx::PxVec2 Nv::Blast::getProjectedPoint	(	const physx::PxVec3 &	point,
		ProjectionDirections	dir
	)

Computes point projected on given axis aligned plane.

NV_FORCE_INLINE physx::PxVec2 Nv::Blast::getProjectedPointWithWinding	(	const physx::PxVec3 &	point,
		ProjectionDirections	dir
	)

Computes point projected on given axis aligned plane, this method is polygon-winding aware.

NV_FORCE_INLINE ProjectionDirections Nv::Blast::getProjectionDirection ( const physx::PxVec3 & normal )

Computes best direction to project points.

bool Nv::Blast::importerHullsInProximityApexFree	(	uint32_t	hull0Count,
		const physx::PxVec3 *	hull0,
		physx::PxBounds3 &	hull0Bounds,
		const physx::PxTransform &	localToWorldRT0In,
		const physx::PxVec3 &	scale0In,
		uint32_t	hull1Count,
		const physx::PxVec3 *	hull1,
		physx::PxBounds3 &	hull1Bounds,
		const physx::PxTransform &	localToWorldRT1In,
		const physx::PxVec3 &	scale1In,
		physx::PxF32	maxDistance,
		Separation *	separation
	)

Function to compute midplane between two convex hulls. Is copied from APEX.

NVBLAST_API Asset* Nv::Blast::initializeAsset	(	void *	mem,
		NvBlastID	id,
		uint32_t	chunkCount,
		uint32_t	graphNodeCount,
		uint32_t	leafChunkCount,
		uint32_t	firstSubsupportChunkIndex,
		uint32_t	bondCount,
		NvBlastLog	logFn
	)

template<typename T >

NV_INLINE T Nv::Blast::invalidIndex ( ) [inline]

Set to invalid index.

void Nv::Blast::inverseNormalAndIndices ( Mesh * mesh )

Inverses normals of cutting box and sets indices.

Parameters:

[in] mesh Cutting box mesh

template<typename T >

void Nv::Blast::invertMap	(	T *	inverseMap,
		const T *	map,
		const T	size
	)			`[inline]`

Creates the inverse of a map, such that inverseMap[map[i]] = i. Unmapped indices are set to invalidIndex<T>.

Parameters:

`[out]`	inverseMap	inverse map space of given size
`[in]`	map	original map of given size, unmapped entries must contain invalidIndex<T>
`[in]`	size	size of the involved maps

template<typename T >

NV_INLINE bool Nv::Blast::isInvalidIndex ( T index ) [inline]

Test for invalid index (max representable integer).

NV_INLINE float Nv::Blast::lerp	(	float	t,
		float	a,
		float	b
	)

NV_INLINE void Nv::Blast::logLL	(	int	type,
		const char *	msg,
		const char *	file,
		int	line
	)

Logging wrapper compatible with NvBlastLog.

See also:: NvBlastLog.

Pass this function to LowLevel function calls in order to get logging into global ErrorCallback.

NV_INLINE float Nv::Blast::noiseSample	(	PxVec3	point,
		int *	p,
		PxVec3 *	g
	)

Nv::Blast::NVBLASTTK_IMPL_DECLARE ( Group )

Remove the actor from this group if the actor actually belongs to it and the group is not processing.

Parameters:

[in] actor The TkActor to remove.

Returns:: true if removing succeeded, false otherwise

Add the actor to this group's job queue. It is the caller's responsibility to add an actor only once. This condition is checked in debug builds.

Atomically check if this group is processing actors.

See also:: setProcessing()

Returns:: true between startProcess() and endProcess() calls, false otherwise

Atomically set the processing state. This function checks for the current state before changing it.

See also:: isProcessing()

Parameters:

[in] value the value of the new state

Returns:: true if the new state could be set, false otherwise

Get the group-family shared memory for the specified family. To be used when the memory is expected to already exist.

< number of actors in this group

< memory sharable by actors in the same family in this group

< chunk data for damage/fracture

< bond data for damage/fracture

< initial memory block for event data

< split scratch memory

< true while workers are processing

< this group's workers

< this group's process jobs

< accumulated group's worker stats

Nv::Blast::NVBLASTTK_IMPL_DECLARE ( Family )

< The chunk indices within the TkFamily objects joined by the joint. These chunks will be support chunks.

Nv::Blast::NVBLASTTK_IMPL_DECLARE ( Asset )

Implementation of TkAsset

Factory create method. This method creates a low-level asset and stores a reference to it.

Parameters:

[in] desc Asset descriptor set by the user.

Returns:: a pointer to a new TkAssetImpl object if successful, NULL otherwise.

Static method to create an asset from an existing low-level asset.

Parameters:

`[in]`	assetLL	A valid low-level asset passed in by the user.
`[in]`	jointDescs	Optional joint descriptors to add to the new asset.
`[in]`	jointDescCount	The number of joint descriptors in the jointDescs array. If non-zero, jointDescs cannot be NULL.
`[in]`	ownsAsset	Whether or not to let this TkAssetImpl object release the low-level NvBlastAsset memory upon its own release.

Returns:

a pointer to a new TkAssetImpl object if successful, NULL otherwise.

a pointer to the underlying low-level NvBlastAsset associated with this asset.

the number of internal joint descriptors stored with this asset.

the array of internal joint descriptors stored with this asset, with size given by getJointDescCountInternal().

Utility to add a joint descriptor between the indexed chunks. The two chunks must be support chunks, and there must exist a bond between them. The joint's attachment positions will be the bond centroid.

Parameters:

`[in]`	chunkIndex0	The first chunk index.
`[in]`	chunkIndex1	The second chunk index.

Returns:: true iff successful.

< The underlying low-level asset.

< The array of internal joint descriptors.

< Whether or not this asset should release its low-level asset upon its own release.

NV_FORCE_INLINE void Nv::Blast::operator+=	(	NvBlastTimers &	lhs,
		const NvBlastTimers &	rhs
	)

bool Nv::Blast::operator<	(	const Edge &	a,
		const Edge &	b
	)			`[inline]`

template<typename T >

NV_INLINE ExtIStream& Nv::Blast::operator>>	(	ExtIStream &	s,
		T &	x
	)			`[inline]`

template<typename T >

NV_INLINE const void * Nv::Blast::pointerOffset	(	const void *	p,
		ptrdiff_t	offset
	)			`[inline]`

template<typename T >

NV_INLINE void * Nv::Blast::pointerOffset	(	void *	p,
		ptrdiff_t	offset
	)			`[inline]`

Offset void* pointer by 'offset' bytes helper-functions

NVBLAST_API void Nv::Blast::savePatternToObj ( DamagePattern * pattern )

void Nv::Blast::setCuttingBox	(	const physx::PxVec3 &	point,
		const physx::PxVec3 &	normal,
		Mesh *	mesh,
		float	size,
		int64_t	id
	)

Helper functions Set cutting box at some particular position.

Parameters:

`[in]`	point	Cutting face center
`[in]`	normal	Cutting face normal
`[in]`	mesh	Cutting box mesh
`[in]`	size	Cutting box size
`[in]`	id	Cutting box ID

NV_INLINE void Nv::Blast::setup	(	int	i,
		PxVec3	point,
		float &	t,
		int &	b0,
		int &	b1,
		float &	r0,
		float &	r1
	)

NV_INLINE NvBlastID Nv::Blast::TkGenerateGUID ( void * ptr )

NV_INLINE bool Nv::Blast::TkGUIDIsZero ( const NvBlastID * id )

Tests an NvBlastID to determine if it's zeroed. After calling TkGUIDReset on an ID, passing it to this function will return a value of true.

Parameters:

[in] id A pointer to the ID to test.

NV_INLINE void Nv::Blast::TkGUIDReset ( NvBlastID * id )

Clears an NvBlastID (sets all of its fields to zero).

Parameters:

[out] id A pointer to the ID to clear.

NV_INLINE bool Nv::Blast::TkGUIDsEqual	(	const NvBlastID *	id1,
		const NvBlastID *	id2
	)

Compares two NvBlastIDs.

Parameters:

`[in]`	id1	A pointer to the first id to compare.
`[in]`	id2	A pointer to the second id to compare.

Returns:: true iff ids are equal.

void Nv::Blast::trimCollisionGeometry	(	ConvexMeshBuilder &	cmb,
		uint32_t	chunksCount,
		CollisionHull **	in,
		const uint32_t *	chunkDepth
	)

template<class VisibilityRep >

void Nv::Blast::updateVisibleChunksFromSupportChunk	(	VisibilityRep *	actors,
		IndexDLink< uint32_t > *	visibleChunkIndexLinks,
		uint32_t *	chunkActorIndices,
		uint32_t	actorIndex,
		uint32_t	supportChunkIndex,
		const NvBlastChunk *	chunks,
		uint32_t	upperSupportChunkCount
	)			`[inline]`

VisibilityRep must have m_firstVisibleChunkIndex and m_visibleChunkCount fields

NV_INLINE bool Nv::Blast::weakBoundingBoxIntersection	(	const physx::PxBounds3 &	aBox,
		const physx::PxBounds3 &	bBox
	)

Test fattened bounding box intersetion.

Variable Documentation

const uint32_t Nv::Blast::kMaterialInteriorId = 1000

Default material id assigned to interior faces (faces which created between 2 fractured chunks)

const uint32_t Nv::Blast::kNotValidVertexIndex = UINT32_MAX

Vertex index which considired by NvBlast as not valid.

const uint32_t Nv::Blast::kSmoothingGroupInteriorId = 1000

Default smoothing group id assigned to interior faces

Nv::Blast Namespace Reference

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation