Main Page Class List Class Members

# 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

< 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