Blast 1.1.3. See docs/release_notes.txt.v1.1.3_rc1

5 files changed, 2192 insertions, 2192 deletions

diff --git a/sdk/lowlevel/include/NvBlast.h b/sdk/lowlevel/include/NvBlast.h
index 8987059..4b777cb 100644..100755
--- a/sdk/lowlevel/include/NvBlast.h
+++ b/sdk/lowlevel/include/NvBlast.h
@@ -1,893 +1,893 @@
-// This code contains NVIDIA Confidential Information and is disclosed to you
-// under a form of NVIDIA software license agreement provided separately to you.
-//
-// Notice
-// NVIDIA Corporation and its licensors retain all intellectual property and
-// proprietary rights in and to this software and related documentation and
-// any modifications thereto. Any use, reproduction, disclosure, or
-// distribution of this software and related documentation without an express
-// license agreement from NVIDIA Corporation is strictly prohibited.
-//
-// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
-// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
-// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
-// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
-//
-// Information and code furnished is believed to be accurate and reliable.
-// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
-// information or for any infringement of patents or other rights of third parties that may
-// result from its use. No license is granted by implication or otherwise under any patent
-// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
-// This code supersedes and replaces all information previously supplied.
-// NVIDIA Corporation products are not authorized for use as critical
-// components in life support devices or systems without express written approval of
-// NVIDIA Corporation.
-//
-// Copyright (c) 2016-2018 NVIDIA Corporation. All rights reserved.
-
-
-#ifndef NVBLAST_H
-#define NVBLAST_H
-
-
-#include "NvBlastTypes.h"
-
-
-///////////////////////////////////////////////////////////////////////////////
-//	NvBlastAsset functions
-///////////////////////////////////////////////////////////////////////////////
-///@{
-
-/**
-Calculates the memory requirements for an asset based upon its descriptor.  Use this function
-when building an asset with NvBlastCreateAsset.
-
-\param[in] desc		Asset descriptor (see NvBlastAssetDesc).
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return the memory size (in bytes) required for the asset, or zero if desc is invalid.
-*/
-NVBLAST_API size_t NvBlastGetAssetMemorySize(const NvBlastAssetDesc* desc, NvBlastLog logFn);
-
-
-/**
-Returns the number of bytes of scratch memory that the user must supply to NvBlastCreateAsset,
-based upon the descriptor that will be passed into that function.
-
-\param[in] desc		The asset descriptor that will be passed into NvBlastCreateAsset.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return	the number of bytes of scratch memory required for a call to NvBlastCreateAsset with that descriptor.
-*/
-NVBLAST_API size_t NvBlastGetRequiredScratchForCreateAsset(const NvBlastAssetDesc* desc, NvBlastLog logFn);
-
-
-/**
-Asset-building function.
-
-Constructs an NvBlastAsset in-place at the address given by the user.  The address must point to a block
-of memory of at least the size given by NvBlastGetAssetMemorySize(desc, logFn), and must be 16-byte aligned.
-
-Support chunks (marked in the NvBlastChunkDesc struct) must provide full coverage over the asset.
-This means that from any leaf chunk to the root node, exactly one chunk must be support.  If this condition
-is not met the function fails to create an asset.
-
-Any bonds described by NvBlastBondDesc descriptors that reference non-support chunks will be removed.  
-Duplicate bonds will be removed as well (bonds that are between the same chunk pairs).
-
-Chunks in the asset should be arranged such that sibling chunks (chunks with the same parent) are contiguous.
-Chunks are also should be arranged such that leaf chunks (chunks with no children) are at the end of the chunk list.
-If chunks aren't arranged properly the function fails to create an asset.
-
-\param[in] mem		Pointer to block of memory of at least the size given by NvBlastGetAssetMemorySize(desc, logFn).  Must be 16-byte aligned.
-\param[in] desc		Asset descriptor (see NvBlastAssetDesc).
-\param[in] scratch	User-supplied scratch memory of size NvBlastGetRequiredScratchForCreateAsset(desc) bytes.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return pointer to new NvBlastAsset (will be the same address as mem), or NULL if unsuccessful.
-*/
-NVBLAST_API NvBlastAsset* NvBlastCreateAsset(void* mem, const NvBlastAssetDesc* desc, void* scratch, NvBlastLog logFn);
-
-
-/**
-Calculates the memory requirements for a family based upon an asset.  Use this function
-when building a family with NvBlastAssetCreateFamily.
-
-\param[in] asset	Asset used to build the family (see NvBlastAsset).
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return the memory size (in bytes) required for the family, or zero if asset is invalid.
-*/
-NVBLAST_API size_t NvBlastAssetGetFamilyMemorySize(const NvBlastAsset* asset, NvBlastLog logFn);
-
-
-/**
-Family-building function.
-
-Constructs an NvBlastFamily in-place at the address given by the user.  The address must point to a block
-of memory of at least the size given by NvBlastAssetGetFamilyMemorySize(asset, logFn), and must be 16-byte aligned.
-
-\param[in] mem		Pointer to block of memory of at least the size given by NvBlastAssetGetFamilyMemorySize(asset, logFn).  Must be 16-byte aligned.
-\param[in] asset	Asset to instance.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return the family.
-*/
-NVBLAST_API NvBlastFamily* NvBlastAssetCreateFamily(void* mem, const NvBlastAsset* asset, NvBlastLog logFn);
-
-
-/**
-Retrieve the asset ID.
-
-\param[in] asset	The given asset.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return the ID of the asset.
-*/
-NVBLAST_API NvBlastID NvBlastAssetGetID(const NvBlastAsset* asset, NvBlastLog logFn);
-
-
-/**
-Set an asset's ID
-
-\param[in] asset	The given asset.
-\param[in] id		A pointer to the id to copy into the asset.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return	true iff the id is successfully set.
-*/
-NVBLAST_API bool NvBlastAssetSetID(NvBlastAsset* asset, const NvBlastID* id, NvBlastLog logFn);
-
-
-/**
-Retrieve the data format version for the given asset
-
-\param[in] asset	The asset.  Cannot be NULL.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return	the data format version (NvBlastAssetDataFormat).
-*/
-NVBLAST_API uint32_t NvBlastAssetGetFormatVersion(const NvBlastAsset* asset, NvBlastLog logFn);
-
-
-/**
-Retrieve the memory size (in bytes) of the given data asset
-
-\param[in] asset	The asset.  Cannot be NULL.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return	the memory size of the asset (in bytes).
-*/
-NVBLAST_API uint32_t NvBlastAssetGetSize(const NvBlastAsset* asset, NvBlastLog logFn);
-
-
-/**
-Get the number of chunks in the given asset.
-
-\param[in] asset	The asset.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return	the number of chunks in the asset.
-*/
-NVBLAST_API uint32_t NvBlastAssetGetChunkCount(const NvBlastAsset* asset, NvBlastLog logFn);
-
-
-/**
-Get the number of support chunks in the given asset.  This will equal the number of
-graph nodes in NvBlastSupportGraph::nodeCount returned by NvBlastAssetGetSupportGraph only
-if no extra "world" node was created due to bonds defined between support chunks and the world.
-If such bonds were created, then there is an extra graph node representing the world, and this
-function will return NvBlastSupportGraph::nodeCount - 1.
-
-\param[in] asset	The asset.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return	the number of chunks in the asset.
-*/
-NVBLAST_API uint32_t NvBlastAssetGetSupportChunkCount(const NvBlastAsset* asset, NvBlastLog logFn);
-
-
-/**
-Get the number of leaf chunks in the given asset.
-
-\param[in] asset	The asset.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return	the number of leaf chunks in the asset.
-*/
-NVBLAST_API uint32_t NvBlastAssetGetLeafChunkCount(const NvBlastAsset* asset, NvBlastLog logFn);
-
-
-/**
-Get the first subsupport chunk index in the given asset.  Chunks are sorted such that subsupport chunks
-come last.  This is the first subsupport chunk index.  Equals to total chunk count if there are no subsupport
-chunks.
-
-\param[in] asset	The asset.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return	the first subsupport chunk index in the asset.
-*/
-NVBLAST_API uint32_t NvBlastAssetGetFirstSubsupportChunkIndex(const NvBlastAsset* asset, NvBlastLog logFn);
-
-
-/**
-Get the number of bonds in the given asset.
-
-\param[in] asset	The asset.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return	the number of bonds in the asset.
-*/
-NVBLAST_API uint32_t NvBlastAssetGetBondCount(const NvBlastAsset* asset, NvBlastLog logFn);
-
-
-/**
-Access the support graph for the given asset.
-
-\param[in] asset	The asset.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return	a struct of support graph for the given asset.
-*/
-NVBLAST_API const NvBlastSupportGraph NvBlastAssetGetSupportGraph(const NvBlastAsset* asset, NvBlastLog logFn);
-
-
-/**
-Access a map from chunk index to graph node index.
-Returned map is valid in the domain [0, NvBlastAssetGetChunkCount(asset, logFn)).
-Non-support chunks are mapped to the invalid index 0xFFFFFFFF.
-
-\param[in] asset	The asset.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return	an array of uint32_t values defining the map, of size NvBlastAssetGetChunkCount(asset, logFn).
-*/
-NVBLAST_API const uint32_t* NvBlastAssetGetChunkToGraphNodeMap(const NvBlastAsset* asset, NvBlastLog logFn);
-
-
-/**
-Access an array of chunks of the given asset.
-
-\param[in] asset	The asset.
-\param[in] logFn	User - supplied message function(see NvBlastLog definition).May be NULL.
-
-\return	a pointer to an array of chunks of the asset.
-*/
-NVBLAST_API const NvBlastChunk* NvBlastAssetGetChunks(const NvBlastAsset* asset, NvBlastLog logFn);
-
-
-/**
-Access an array of bonds of the given asset.
-
-\param[in] asset	The asset.
-\param[in] logFn	User - supplied message function(see NvBlastLog definition).May be NULL.
-
-\return	a pointer to an array of bonds of the asset.
-*/
-NVBLAST_API const NvBlastBond* NvBlastAssetGetBonds(const NvBlastAsset* asset, NvBlastLog logFn);
-
-
-/**
-A buffer size sufficient to serialize an actor instanced from a given asset.
-This function is faster than NvBlastActorGetSerializationSize, and can be used to create a reusable buffer
-for actor serialization.
-
-\param[in] asset	The asset.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return the required buffer size in bytes.
-*/
-NVBLAST_API uint32_t NvBlastAssetGetActorSerializationSizeUpperBound(const NvBlastAsset* asset, NvBlastLog logFn);
-
-///@} End NvBlastAsset functions
-
-
-///////////////////////////////////////////////////////////////////////////////
-//	NvBlastAsset helper functions
-///////////////////////////////////////////////////////////////////////////////
-///@{
-
-/**
-Function to ensure (check and update) support coverage of chunks.
-
-Support chunks (marked in the NvBlastChunkDesc struct) must provide full coverage over the asset.
-This means that from any leaf chunk to the root node, exactly one chunk must be support.  If this condition
-is not met, the actual support chunks will be adjusted accordingly.
-
-Chunk order depends on support coverage, so this function should be called before chunk reordering.
-
-\param[in]  chunkDescs			Array of chunk descriptors of size chunkCount. It will be updated accordingly.
-\param[in]  chunkCount			The number of chunk descriptors.
-\param[in]	scratch				User-supplied scratch storage, must point to chunkCount valid bytes of memory.
-\param[in]  logFn				User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return	true iff coverage was already exact.
-*/
-NVBLAST_API bool NvBlastEnsureAssetExactSupportCoverage(NvBlastChunkDesc* chunkDescs, uint32_t chunkCount, void* scratch, NvBlastLog logFn);
-
-
-/**
-Build chunk reorder map. 
-
-NvBlastCreateAsset function requires NvBlastChunkDesc array to be in correct oder:
-
-1. Root chunks (chunks with invalid parent index) must be first in the asset's chunk list.
-2. Chunks in the asset must be arranged such that sibling chunks (chunks with the same parent) are contiguous.
-3. Chunks must be arranged such that upper-support chunks (support chunks and their parent chunks) go first in 
-chunk list.
-
-This function builds chunk reorder map which can be used to order chunk descs. Reordering chunk's descriptors 
-according to generated map places them in correct order for NvBlastCreateAsset to succeed.
-
-Iff chunks are already ordered correctly, function returns 'true' and identity chunk reorder map. Otherwise 'false' is returned.
-
-\param[out] chunkReorderMap	User-supplied map of size chunkCount to fill. For every chunk index this array will contain new chunk position (index).
-\param[in]  chunkDescs		Array of chunk descriptors of size chunkCount.
-\param[in]  chunkCount		The number of chunk descriptors.
-\param[in]	scratch			User-supplied scratch storage, must point to 2 * chunkCount * sizeof(uint32_t) valid bytes of memory.
-\param[in]  logFn			User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return	true iff the chunks did not require reordering (chunkReorderMap is the identity map).
-*/
-NVBLAST_API bool NvBlastBuildAssetDescChunkReorderMap(uint32_t* chunkReorderMap, const NvBlastChunkDesc* chunkDescs, uint32_t chunkCount, void* scratch, NvBlastLog logFn);
-
-
-/**
-Apply chunk reorder map.
-
-Function applies reorder map on NvBlastChunkDesc and NvBlastBondDesc arrays. It reorders chunks, replaces their 'parentChunkIndex' field
-with new indices. Bonds are kept in the same order, but their 'chunkIndices' field is updated with proper indices.
-
-@see NvBlastBuildAssetDescChunkReorderMap
-
-\param[out] reorderedChunkDescs			User-supplied array of size chunkCount to fill with new reordered NvBlastChunkDesc's.
-\param[in]  chunkDescs					Array of chunk descriptors of size chunkCount.
-\param[in]  chunkCount					The number of chunk descriptors.
-\param[in]  bondDescs					Array of bond descriptors of size chunkCount. It will be updated accordingly.
-\param[in]  bondCount					The number of bond descriptors.
-\param[in]  chunkReorderMap				Chunk reorder map to use, must be of size chunkCount.
-\param[in]	keepBondNormalChunkOrder	If true, bond normals will be flipped if their chunk index order was reveresed by the reorder map.
-\param[in]	logFn						User-supplied message function (see NvBlastLog definition).  May be NULL.
-*/
-NVBLAST_API void NvBlastApplyAssetDescChunkReorderMap
-(
-	NvBlastChunkDesc* reorderedChunkDescs,
-	const NvBlastChunkDesc* chunkDescs,
-	uint32_t chunkCount,
-	NvBlastBondDesc* bondDescs,
-	uint32_t bondCount,
-	const uint32_t* chunkReorderMap,
-	bool keepBondNormalChunkOrder,
-	NvBlastLog logFn
-);
-
-
-/**
-Apply chunk reorder map.
-
-Function applies reorder map on NvBlastChunkDesc and NvBlastBondDesc arrays. It reorders chunks, replaces their 'parentChunkIndex' field
-with new indices. Bonds are kept in the same order, but their 'chunkIndices' field is updated with proper indices.
-
-This overload of function reorders chunks in place.
-
-@see NvBlastBuildAssetDescChunkReorderMap
-
-\param[in]  chunkDescs					Array of chunk descriptors of size chunkCount. It will be updated accordingly.
-\param[in]  chunkCount					The number of chunk descriptors.
-\param[in]  bondDescs					Array of bond descriptors of size chunkCount. It will be updated accordingly.
-\param[in]  bondCount					The number of bond descriptors.
-\param[in]  chunkReorderMap				Chunk reorder map to use, must be of size chunkCount.
-\param[in]	keepBondNormalChunkOrder	If true, bond normals will be flipped if their chunk index order was reveresed by the reorder map.
-\param[in]	scratch						User-supplied scratch storage, must point to chunkCount * sizeof(NvBlastChunkDesc) valid bytes of memory.
-\param[in]	logFn						User-supplied message function (see NvBlastLog definition).  May be NULL.
-*/
-NVBLAST_API void NvBlastApplyAssetDescChunkReorderMapInPlace
-(
-	NvBlastChunkDesc* chunkDescs,
-	uint32_t chunkCount,
-	NvBlastBondDesc* bondDescs,
-	uint32_t bondCount,
-	const uint32_t* chunkReorderMap,
-	bool keepBondNormalChunkOrder,
-	void* scratch,
-	NvBlastLog logFn
-);
-
-
-/**
-Build and apply chunk reorder map. 
-
-Function basically calls NvBlastBuildAssetDescChunkReorderMap and NvBlastApplyAssetDescChunkReorderMap. Used for Convenience.
-
-\param[in]  chunkDescs					Array of chunk descriptors of size chunkCount. It will be updated accordingly.
-\param[in]  chunkCount					The number of chunk descriptors.
-\param[in]  bondDescs					Array of bond descriptors of size chunkCount. It will be updated accordingly.
-\param[in]  bondCount					The number of bond descriptors.
-\param[in]  chunkReorderMap				Chunk reorder map to fill, must be of size chunkCount.
-\param[in]	keepBondNormalChunkOrder	If true, bond normals will be flipped if their chunk index order was reveresed by the reorder map.
-\param[in]	scratch						User-supplied scratch storage, must point to chunkCount * sizeof(NvBlastChunkDesc) valid bytes of memory.
-\param[in]  logFn						User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return	true iff the chunks did not require reordering (chunkReorderMap is the identity map).
-*/
-NVBLAST_API bool NvBlastReorderAssetDescChunks
-(
-	NvBlastChunkDesc* chunkDescs,
-	uint32_t chunkCount,
-	NvBlastBondDesc* bondDescs,
-	uint32_t bondCount,
-	uint32_t* chunkReorderMap,
-	bool keepBondNormalChunkOrder,
-	void* scratch,
-	NvBlastLog logFn
-);
-
-///@} End NvBlastAsset helper functions
-
-
-///////////////////////////////////////////////////////////////////////////////
-//	NvBlastFamily functions
-///////////////////////////////////////////////////////////////////////////////
-///@{
-
-/**
-Retrieve the data format version for the given family.
-
-\param[in] family	The family.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return the family format version.
-*/
-NVBLAST_API uint32_t NvBlastFamilyGetFormatVersion(const NvBlastFamily* family, NvBlastLog logFn);
-
-
-/**
-Retrieve the asset of the given family.
-
-\param[in] family	The family.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return pointer to the asset associated with the family.
-*/
-NVBLAST_API const NvBlastAsset* NvBlastFamilyGetAsset(const NvBlastFamily* family, NvBlastLog logFn);
-
-
-/**
-Set asset to the family. It should be the same asset as the one family was created from (same ID).
-
-\param[in] family	The family.
-\param[in] asset	Asset to instance.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-*/
-NVBLAST_API void NvBlastFamilySetAsset(NvBlastFamily* family, const NvBlastAsset* asset, NvBlastLog logFn);
-
-
-/**
-Retrieve the size (in bytes) of the given family.
-
-\param[in] family	The family.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return the size of the family (in bytes).
-*/
-NVBLAST_API uint32_t NvBlastFamilyGetSize(const NvBlastFamily* family, NvBlastLog logFn);
-
-
-/**
-Retrieve the asset ID of the given family.
-
-\param[in] family	The family.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return the ID of the asset associated with the family.
-*/
-NVBLAST_API NvBlastID NvBlastFamilyGetAssetID(const NvBlastFamily* family, NvBlastLog logFn);
-
-
-/**
-Returns the number of bytes of scratch memory that the user must supply to NvBlastFamilyCreateFirstActor.
-
-\param[in] family	The family from which the first actor will be instanced.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return	the number of bytes of scratch memory required for a call to NvBlastFamilyCreateFirstActor.
-*/
-NVBLAST_API size_t NvBlastFamilyGetRequiredScratchForCreateFirstActor(const NvBlastFamily* family, NvBlastLog logFn);
-
-
-/**
-Instance the family's asset into a new, unfractured actor.
-
-\param[in] family	Family in which to create a new actor.  The family must have no other actors in it.  (See NvBlastAssetCreateFamily.)
-\param[in] desc		Actor descriptor (see NvBlastActorDesc).
-\param[in] scratch	User-supplied scratch memory of size NvBlastFamilyGetRequiredScratchForCreateFirstActor(asset) bytes, where 'asset' is the NvBlastAsset from which the family was created.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return pointer to new NvBlastActor if successful (the actor was successfully inserted into the family), or NULL if unsuccessful.
-*/
-NVBLAST_API NvBlastActor* NvBlastFamilyCreateFirstActor(NvBlastFamily* family, const NvBlastActorDesc* desc, void* scratch, NvBlastLog logFn);
-
-
-/**
-Retrieve the number of active actors associated with the given family.
-
-\param[in] family	The family.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return the number of active actors in the family.
-*/
-NVBLAST_API uint32_t NvBlastFamilyGetActorCount(const NvBlastFamily* family, NvBlastLog logFn);
-
-
-/**
-Deserialize a single Actor from a buffer into the given family.  The actor will be inserted if it
-is compatible with the current family state.  That is, it must not share any chunks or internal
-IDs with the actors already present in the family.
-
-\param[in] family	Family in which to deserialize the actor.
-\param[in] buffer	User-supplied buffer containing the actor to deserialize.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return the deserialized actor if successful, NULL otherwise.
-*/
-NVBLAST_API NvBlastActor* NvBlastFamilyDeserializeActor(NvBlastFamily* family, const void* buffer, NvBlastLog logFn);
-
-
-/**
-Retrieve the active actors associated with the given family.
-
-\param[out] actors		User-supplied array to be filled with the returned actor pointers.
-\param[out] actorsSize	The size of the actors array.  To receive all actor pointers, the size must be at least that given by NvBlastFamilyGetActorCount(family).
-\param[in] family		The family.
-\param[in] logFn		User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return	the number of actor pointers written to actors.  This will not exceed actorsSize.
-*/
-NVBLAST_API uint32_t NvBlastFamilyGetActors(NvBlastActor** actors, uint32_t actorsSize, const NvBlastFamily* family, NvBlastLog logFn);
-
-
-/**
-Retrieve the actor associated with the given chunk.
-
-\param[in] family		The family.
-\param[in] chunkIndex	The index of chunk.
-\param[in] logFn		User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return	pointer to actor associated with given chunk.  NULL if there is no such actor.
-*/
-NVBLAST_API NvBlastActor* NvBlastFamilyGetChunkActor(const NvBlastFamily* family, uint32_t chunkIndex, NvBlastLog logFn);
-
-
-/**
-Retrieve the max active actor count family could have.
-
-\param[in] family		The family.
-\param[in] logFn		User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return	the max number of active actors family could have.
-*/
-NVBLAST_API uint32_t NvBlastFamilyGetMaxActorCount(const NvBlastFamily* family, NvBlastLog logFn);
-
-///@} End NvBlastFamily functions
-
-
-///////////////////////////////////////////////////////////////////////////////////////
-//	NvBlastActor accessor, serialization, and deactivation functions
-///////////////////////////////////////////////////////////////////////////////////////
-///@{
-
-/**
-Get the number of visible chunks for this actor.  May be used in conjunction with NvBlastActorGetVisibleChunkIndices.
-
-\param[in] actor	The actor.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return	the number of visible chunk indices for the actor.
-*/
-NVBLAST_API uint32_t NvBlastActorGetVisibleChunkCount(const NvBlastActor* actor, NvBlastLog logFn);
-
-
-/**
-Retrieve a list of visible chunk indices for the actor into the given array.
-
-\param[in] visibleChunkIndices		User-supplied array to be filled in with indices of visible chunks for this actor.
-\param[in] visibleChunkIndicesSize	The size of the visibleChunkIndices array.  To receive all visible chunk indices, the size must be at least that given by NvBlastActorGetVisibleChunkCount(actor).
-\param[in] actor					The actor.
-\param[in] logFn					User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return	the number of indices written to visibleChunkIndices.  This will not exceed visibleChunkIndicesSize.
-*/
-NVBLAST_API uint32_t NvBlastActorGetVisibleChunkIndices(uint32_t* visibleChunkIndices, uint32_t visibleChunkIndicesSize, const NvBlastActor* actor, NvBlastLog logFn);
-
-
-/**
-Get the number of graph nodes for this actor.  May be used in conjunction with NvBlastActorGetGraphNodeIndices.
-
-\param[in] actor	The actor.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return	the number of graph node indices for the actor.
-*/
-NVBLAST_API uint32_t NvBlastActorGetGraphNodeCount(const NvBlastActor* actor, NvBlastLog logFn);
-
-
-/**
-Retrieve a list of graph node indices for the actor into the given array.
-
-\param[in] graphNodeIndices		User-supplied array to be filled in with indices of graph nodes for this actor.
-\param[in] graphNodeIndicesSize	The size of the graphNodeIndices array.  To receive all graph node indices, the size must be at least that given by NvBlastActorGetGraphNodeCount(actor).
-\param[in] actor				The actor.
-\param[in] logFn				User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return	the number of indices written to graphNodeIndices.  This will not exceed graphNodeIndicesSize.
-*/
-NVBLAST_API uint32_t NvBlastActorGetGraphNodeIndices(uint32_t* graphNodeIndices, uint32_t graphNodeIndicesSize, const NvBlastActor* actor, NvBlastLog logFn);
-
-
-/**
-Access the bond health data for an actor.
-
-This function returns a pointer to the head of an array of bond healths (floats).  This array is the same for any actor that
-has been created from repeated fracturing of the same original instance of an asset (in the same instance family).
-
-The indices obtained from NvBlastSupportGraph::adjacentBondIndices in the asset may be used to access this array.
-
-The size of the array returned is NvBlastAssetGetBondCount(asset, logFn), where 'asset' is the NvBlastAsset
-that was used to create the actor.
-
-This array is valid as long as any actor in the instance family for the input actor exists.
-
-If the input actor is invalid, NULL will be returned.
-
-\param[in] actor	The actor.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return	the array of bond healths for the actor's instance family, or NULL if the actor is invalid.
-*/
-NVBLAST_API const float* NvBlastActorGetBondHealths(const NvBlastActor* actor, NvBlastLog logFn);
-
-
-/**
-The buffer size needed to serialize a single actor.  This will give the exact size needed.  For an upper bound
-on the buffer size needed for any actor instanced from an NvBlastAsset, use NvBlastAssetGetActorSerializationSizeUpperBound.
-
-\param[in] actor	The actor.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return the required buffer size in bytes.
-*/
-NVBLAST_API uint32_t NvBlastActorGetSerializationSize(const NvBlastActor* actor, NvBlastLog logFn);
-
-
-/**
-Serialize a single actor to a buffer.
-
-\param[out] buffer		User-supplied buffer, must be at least of size given by NvBlastActorGetSerializationSize(actor).
-\param[in] bufferSize	The size of the user-supplied buffer.
-\param[in] actor		The actor.
-\param[in] logFn		User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return the number of bytes written to the buffer, or 0 if there is an error (such as an under-sized buffer).
-*/
-NVBLAST_API uint32_t NvBlastActorSerialize(void* buffer, uint32_t bufferSize, const NvBlastActor* actor, NvBlastLog logFn);
-
-
-/**
-Access to an actor's family.
-
-\param[in] actor	The actor.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return the family with which the actor is associated.
-*/
-NVBLAST_API NvBlastFamily* NvBlastActorGetFamily(const NvBlastActor* actor, NvBlastLog logFn);
-
-
-/**
-Access to an actor's internal index.
-
-\param[in] actor	The actor.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return actor's internal index in family.
-*/
-NVBLAST_API uint32_t NvBlastActorGetIndex(const NvBlastActor* actor, NvBlastLog logFn);
-
-
-/**
-Deactivate an actor within its family.  Conceptually this is "destroying" the actor, however memory will not be released until the family is released.
-
-\param[in] actor	Points to a user-supplied actor struct.  May be NULL, in which case this function no-ops.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return true iff successful (actor was active).
-*/
-NVBLAST_API bool NvBlastActorDeactivate(NvBlastActor* actor, NvBlastLog logFn);
-
-///@} End NvBlastActor accessor, serialization, and deactivation functions
-
-
-///////////////////////////////////////////////////////////////////////////////
-//	NvBlastActor damage and fracturing functions
-///////////////////////////////////////////////////////////////////////////////
-///@{
-
-/**
-Creates fracture commands for the actor using a damage program and program parameters (material and damage descriptions).
-
-\param[in,out]	commandBuffers		Target buffers to hold generated commands.
-									To avoid data loss, provide an entry for every support chunk and every bond in the original actor.
-\param[in]		actor				The NvBlastActor to create fracture commands for.
-\param[in]		program				A NvBlastDamageProgram containing damage shaders.
-\param[in]		programParams		Parameters for the NvBlastDamageProgram.
-\param[in]		logFn				User-supplied message function (see NvBlastLog definition).  May be NULL.
-\param[in,out]	timers				If non-NULL this struct will be filled out with profiling information for the step, in profile build configurations.
-
-Interpretation of NvBlastFractureBuffers:
-As input:
-	Counters denote available entries for FractureData.
-	Chunk and Bond userdata are not used.
-	Health values are not used.
-
-As output:
-	Counters denote valid entires in FractureData arrays.
-	Chunks and Bond userdata reflect the respective userdata set during asset initialization, where implemented by the material function.
-	Health values denote how much damage is to be applied.
-*/
-NVBLAST_API void NvBlastActorGenerateFracture
-(
-	NvBlastFractureBuffers* commandBuffers,
-	const NvBlastActor* actor,
-	const NvBlastDamageProgram program, 
-	const void* programParams,
-	NvBlastLog logFn, 
-	NvBlastTimers* timers
-);
-
-
-/**
-Applies the direct fracture and breaks graph bonds/edges as necessary.
-Chunks damaged beyond their respective health fracture their children recursively, creating a NvBlastChunkFractureData for each.
-
-\param[in,out]	eventBuffers		Target buffers to hold applied fracture events. May be NULL, in which case events are not reported.
-									To avoid data loss, provide an entry for every lower-support chunk and every bond in the original actor.
-\param[in,out]	actor				The NvBlastActor to apply fracture to.
-\param[in]		commands			The fracture commands to process.
-\param[in]		logFn				User-supplied message function (see NvBlastLog definition).  May be NULL.
-\param[in,out]	timers				If non-NULL this struct will be filled out with profiling information for the step, in profile build configurations.
-
-Interpretation of NvBlastFractureBuffers:
-commands:
-	Counters denote the number of command entries to process.
-	Chunk and Bond userdata are not used.
-	Health values denote the amount of damage to apply, as a positive value.
-
-eventBuffers as input:
-	Counters denote available entries for FractureData.
-	Chunk and Bond userdata are not used.
-	Health values are not used.
-
-eventBuffers as output:
-	Counters denote valid entires in FractureData arrays.
-	Chunks and Bond userdata reflect the respective userdata set during asset initialization.
-	Health values denote how much health is remaining for the damaged element. 
-	Broken elements report a negative value corresponding to the superfluous health damage.
-
-commands and eventBuffers may point to the same memory.
-*/
-NVBLAST_API void NvBlastActorApplyFracture
-(
-	NvBlastFractureBuffers* eventBuffers,
-	NvBlastActor* actor,
-	const NvBlastFractureBuffers* commands,
-	NvBlastLog logFn,
-	NvBlastTimers* timers
-);
-
-
-/**
-Releases the oldActor and creates its children newActors if necessary.
-
-\param[out]		result				The list of deleted and created NvBlastActor objects.
-\param[in]		actor				The actor to split.
-\param[in]		newActorsMaxCount	Number of available NvBlastActor slots. In the worst case, one NvBlastActor may be created for every chunk in the asset.
-\param[in]		scratch				Scratch Memory used during processing. NvBlastActorGetRequiredScratchForSplit provides the necessary size.
-\param[in]		logFn				User-supplied message function (see NvBlastLog definition).  May be NULL.
-\param[in,out]	timers				If non-NULL this struct will be filled out with profiling information for the step, in profile build configurations
-
-\return	1..n:	new actors were created
-\return	0:		oldActor is unchanged
-*/
-NVBLAST_API uint32_t NvBlastActorSplit
-(
-	NvBlastActorSplitEvent* result, 
-	NvBlastActor* actor,
-	uint32_t newActorsMaxCount,
-	void* scratch,
-	NvBlastLog logFn,
-	NvBlastTimers* timers
-);
-
-
-/**
-Returns the number of bytes of scratch memory that the user must supply to NvBlastActorSplit,
-based upon the actor that will be passed into that function.
-
-\param[in] actor	The actor that will be passed into NvBlastActorSplit.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return	the number of bytes of scratch memory required for a call to NvBlastActorSplit with that actor.
-*/
-NVBLAST_API size_t NvBlastActorGetRequiredScratchForSplit(const NvBlastActor* actor, NvBlastLog logFn);
-
-
-/**
-Returns the upper-bound number of actors which can be created by calling NvBlastActorSplit with that actor, this
-value can't exceed chunk count.
-
-\param[in] actor	The actor.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return	the upper-bound number of actors which can be created by calling NvBlastActorSplit with that actor.
-*/
-NVBLAST_API uint32_t NvBlastActorGetMaxActorCountForSplit(const NvBlastActor* actor, NvBlastLog logFn);
-
-
-/**
-Determines if the actor can fracture further.
-
-\param[in] actor	The actor potentially being fractured.
-\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.
-
-\return true if any result can be expected from fracturing the actor. false if no further change to the actor is possible.
-*/
-NVBLAST_API bool NvBlastActorCanFracture(const NvBlastActor* actor, NvBlastLog logFn);
-
-
-/**
-Determines if the actor is damaged (was fractured) and split call is required.
-
-The actor could be damaged by calling NvBlastActorApplyFracture or NvBlastFamilyApplyFracture and NvBlastActorSplit is expected after.
-This function gives a hint that NvBlastActorSplit will have some work to be done and actor could potentially be split.
-If actor is not damaged calling NvBlastActorSplit will make no effect.
-
-\return true iff split call is required for this actor.
-*/
-NVBLAST_API bool NvBlastActorIsSplitRequired(const NvBlastActor* actor, NvBlastLog logFn);
-
-
-/**
-\return true iff this actor contains the "world" support graph node, created when a bond contains the UINT32_MAX value for one of their chunkIndices.
-*/
-NVBLAST_API bool NvBlastActorIsBoundToWorld(const NvBlastActor* actor, NvBlastLog logFn);
-
-///@} End NvBlastActor damage and fracturing functions
-
-
-///////////////////////////////////////////////////////////////////////////////
-//	NvBlastTimers functions and helpers
-///////////////////////////////////////////////////////////////////////////////
-///@{
-
-/**
-Resets all values in the given NvBlastTimers struct to zero.
-
-\param[in]	timers	The NvBlastTimers to set to zero.
-*/
-NVBLAST_API void NvBlastTimersReset(NvBlastTimers* timers);
-
-
-/**
-Convert a tick value from NvBlastTimers to seconds.
-
-\param[in]	ticks	The tick value.
-
-\return the seconds correposnding to the input tick value.
-*/
-NVBLAST_API double NvBlastTicksToSeconds(int64_t ticks);
-
-///@} End NvBlastTimers functions and helpers
-
-
-#endif // ifndef NVBLAST_H
+// This code contains NVIDIA Confidential Information and is disclosed to you

+// under a form of NVIDIA software license agreement provided separately to you.

+//

+// Notice

+// NVIDIA Corporation and its licensors retain all intellectual property and

+// proprietary rights in and to this software and related documentation and

+// any modifications thereto. Any use, reproduction, disclosure, or

+// distribution of this software and related documentation without an express

+// license agreement from NVIDIA Corporation is strictly prohibited.

+//

+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES

+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO

+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,

+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.

+//

+// Information and code furnished is believed to be accurate and reliable.

+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such

+// information or for any infringement of patents or other rights of third parties that may

+// result from its use. No license is granted by implication or otherwise under any patent

+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.

+// This code supersedes and replaces all information previously supplied.

+// NVIDIA Corporation products are not authorized for use as critical

+// components in life support devices or systems without express written approval of

+// NVIDIA Corporation.

+//

+// Copyright (c) 2016-2018 NVIDIA Corporation. All rights reserved.

+

+

+#ifndef NVBLAST_H

+#define NVBLAST_H

+

+

+#include "NvBlastTypes.h"

+

+

+///////////////////////////////////////////////////////////////////////////////

+//	NvBlastAsset functions

+///////////////////////////////////////////////////////////////////////////////

+///@{

+

+/**

+Calculates the memory requirements for an asset based upon its descriptor.  Use this function

+when building an asset with NvBlastCreateAsset.

+

+\param[in] desc		Asset descriptor (see NvBlastAssetDesc).

+\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.

+

+\return the memory size (in bytes) required for the asset, or zero if desc is invalid.

+*/

+NVBLAST_API size_t NvBlastGetAssetMemorySize(const NvBlastAssetDesc* desc, NvBlastLog logFn);

+

+

+/**

+Returns the number of bytes of scratch memory that the user must supply to NvBlastCreateAsset,

+based upon the descriptor that will be passed into that function.

+

+\param[in] desc		The asset descriptor that will be passed into NvBlastCreateAsset.

+\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.

+

+\return	the number of bytes of scratch memory required for a call to NvBlastCreateAsset with that descriptor.

+*/

+NVBLAST_API size_t NvBlastGetRequiredScratchForCreateAsset(const NvBlastAssetDesc* desc, NvBlastLog logFn);

+

+

+/**

+Asset-building function.

+

+Constructs an NvBlastAsset in-place at the address given by the user.  The address must point to a block

+of memory of at least the size given by NvBlastGetAssetMemorySize(desc, logFn), and must be 16-byte aligned.

+

+Support chunks (marked in the NvBlastChunkDesc struct) must provide full coverage over the asset.

+This means that from any leaf chunk to the root node, exactly one chunk must be support.  If this condition

+is not met the function fails to create an asset.

+

+Any bonds described by NvBlastBondDesc descriptors that reference non-support chunks will be removed.  

+Duplicate bonds will be removed as well (bonds that are between the same chunk pairs).

+

+Chunks in the asset should be arranged such that sibling chunks (chunks with the same parent) are contiguous.

+Chunks are also should be arranged such that leaf chunks (chunks with no children) are at the end of the chunk list.

+If chunks aren't arranged properly the function fails to create an asset.

+

+\param[in] mem		Pointer to block of memory of at least the size given by NvBlastGetAssetMemorySize(desc, logFn).  Must be 16-byte aligned.

+\param[in] desc		Asset descriptor (see NvBlastAssetDesc).

+\param[in] scratch	User-supplied scratch memory of size NvBlastGetRequiredScratchForCreateAsset(desc) bytes.

+\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.

+

+\return pointer to new NvBlastAsset (will be the same address as mem), or NULL if unsuccessful.

+*/

+NVBLAST_API NvBlastAsset* NvBlastCreateAsset(void* mem, const NvBlastAssetDesc* desc, void* scratch, NvBlastLog logFn);

+

+

+/**

+Calculates the memory requirements for a family based upon an asset.  Use this function

+when building a family with NvBlastAssetCreateFamily.

+

+\param[in] asset	Asset used to build the family (see NvBlastAsset).

+\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.

+

+\return the memory size (in bytes) required for the family, or zero if asset is invalid.

+*/

+NVBLAST_API size_t NvBlastAssetGetFamilyMemorySize(const NvBlastAsset* asset, NvBlastLog logFn);

+

+

+/**

+Family-building function.

+

+Constructs an NvBlastFamily in-place at the address given by the user.  The address must point to a block

+of memory of at least the size given by NvBlastAssetGetFamilyMemorySize(asset, logFn), and must be 16-byte aligned.

+

+\param[in] mem		Pointer to block of memory of at least the size given by NvBlastAssetGetFamilyMemorySize(asset, logFn).  Must be 16-byte aligned.

+\param[in] asset	Asset to instance.

+\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.

+

+\return the family.

+*/

+NVBLAST_API NvBlastFamily* NvBlastAssetCreateFamily(void* mem, const NvBlastAsset* asset, NvBlastLog logFn);

+

+

+/**

+Retrieve the asset ID.

+

+\param[in] asset	The given asset.

+\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.

+

+\return the ID of the asset.

+*/

+NVBLAST_API NvBlastID NvBlastAssetGetID(const NvBlastAsset* asset, NvBlastLog logFn);

+

+

+/**

+Set an asset's ID

+

+\param[in] asset	The given asset.

+\param[in] id		A pointer to the id to copy into the asset.

+\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.

+

+\return	true iff the id is successfully set.

+*/

+NVBLAST_API bool NvBlastAssetSetID(NvBlastAsset* asset, const NvBlastID* id, NvBlastLog logFn);

+

+

+/**

+Retrieve the data format version for the given asset

+

+\param[in] asset	The asset.  Cannot be NULL.

+\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.

+

+\return	the data format version (NvBlastAssetDataFormat).

+*/

+NVBLAST_API uint32_t NvBlastAssetGetFormatVersion(const NvBlastAsset* asset, NvBlastLog logFn);

+

+

+/**

+Retrieve the memory size (in bytes) of the given data asset

+

+\param[in] asset	The asset.  Cannot be NULL.

+\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.

+

+\return	the memory size of the asset (in bytes).

+*/

+NVBLAST_API uint32_t NvBlastAssetGetSize(const NvBlastAsset* asset, NvBlastLog logFn);

+

+

+/**

+Get the number of chunks in the given asset.

+

+\param[in] asset	The asset.

+\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.

+

+\return	the number of chunks in the asset.

+*/

+NVBLAST_API uint32_t NvBlastAssetGetChunkCount(const NvBlastAsset* asset, NvBlastLog logFn);

+

+

+/**

+Get the number of support chunks in the given asset.  This will equal the number of

+graph nodes in NvBlastSupportGraph::nodeCount returned by NvBlastAssetGetSupportGraph only

+if no extra "world" node was created due to bonds defined between support chunks and the world.

+If such bonds were created, then there is an extra graph node representing the world, and this

+function will return NvBlastSupportGraph::nodeCount - 1.

+

+\param[in] asset	The asset.

+\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.

+

+\return	the number of chunks in the asset.

+*/

+NVBLAST_API uint32_t NvBlastAssetGetSupportChunkCount(const NvBlastAsset* asset, NvBlastLog logFn);

+

+

+/**

+Get the number of leaf chunks in the given asset.

+

+\param[in] asset	The asset.

+\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.

+

+\return	the number of leaf chunks in the asset.

+*/

+NVBLAST_API uint32_t NvBlastAssetGetLeafChunkCount(const NvBlastAsset* asset, NvBlastLog logFn);

+

+

+/**

+Get the first subsupport chunk index in the given asset.  Chunks are sorted such that subsupport chunks

+come last.  This is the first subsupport chunk index.  Equals to total chunk count if there are no subsupport

+chunks.

+

+\param[in] asset	The asset.

+\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.

+

+\return	the first subsupport chunk index in the asset.

+*/

+NVBLAST_API uint32_t NvBlastAssetGetFirstSubsupportChunkIndex(const NvBlastAsset* asset, NvBlastLog logFn);

+

+

+/**

+Get the number of bonds in the given asset.

+

+\param[in] asset	The asset.

+\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.

+

+\return	the number of bonds in the asset.

+*/

+NVBLAST_API uint32_t NvBlastAssetGetBondCount(const NvBlastAsset* asset, NvBlastLog logFn);

+

+

+/**

+Access the support graph for the given asset.

+

+\param[in] asset	The asset.

+\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.

+

+\return	a struct of support graph for the given asset.

+*/

+NVBLAST_API const NvBlastSupportGraph NvBlastAssetGetSupportGraph(const NvBlastAsset* asset, NvBlastLog logFn);

+

+

+/**

+Access a map from chunk index to graph node index.

+Returned map is valid in the domain [0, NvBlastAssetGetChunkCount(asset, logFn)).

+Non-support chunks are mapped to the invalid index 0xFFFFFFFF.

+

+\param[in] asset	The asset.

+\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.

+

+\return	an array of uint32_t values defining the map, of size NvBlastAssetGetChunkCount(asset, logFn).

+*/

+NVBLAST_API const uint32_t* NvBlastAssetGetChunkToGraphNodeMap(const NvBlastAsset* asset, NvBlastLog logFn);

+

+

+/**

+Access an array of chunks of the given asset.

+

+\param[in] asset	The asset.

+\param[in] logFn	User - supplied message function(see NvBlastLog definition).May be NULL.

+

+\return	a pointer to an array of chunks of the asset.

+*/

+NVBLAST_API const NvBlastChunk* NvBlastAssetGetChunks(const NvBlastAsset* asset, NvBlastLog logFn);

+

+

+/**

+Access an array of bonds of the given asset.

+

+\param[in] asset	The asset.

+\param[in] logFn	User - supplied message function(see NvBlastLog definition).May be NULL.

+

+\return	a pointer to an array of bonds of the asset.

+*/

+NVBLAST_API const NvBlastBond* NvBlastAssetGetBonds(const NvBlastAsset* asset, NvBlastLog logFn);

+

+

+/**

+A buffer size sufficient to serialize an actor instanced from a given asset.

+This function is faster than NvBlastActorGetSerializationSize, and can be used to create a reusable buffer

+for actor serialization.

+

+\param[in] asset	The asset.

+\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.

+

+\return the required buffer size in bytes.

+*/

+NVBLAST_API uint32_t NvBlastAssetGetActorSerializationSizeUpperBound(const NvBlastAsset* asset, NvBlastLog logFn);

+

+///@} End NvBlastAsset functions

+

+

+///////////////////////////////////////////////////////////////////////////////

+//	NvBlastAsset helper functions

+///////////////////////////////////////////////////////////////////////////////

+///@{

+

+/**

+Function to ensure (check and update) support coverage of chunks.

+

+Support chunks (marked in the NvBlastChunkDesc struct) must provide full coverage over the asset.

+This means that from any leaf chunk to the root node, exactly one chunk must be support.  If this condition

+is not met, the actual support chunks will be adjusted accordingly.

+

+Chunk order depends on support coverage, so this function should be called before chunk reordering.

+

+\param[in]  chunkDescs			Array of chunk descriptors of size chunkCount. It will be updated accordingly.

+\param[in]  chunkCount			The number of chunk descriptors.

+\param[in]	scratch				User-supplied scratch storage, must point to chunkCount valid bytes of memory.

+\param[in]  logFn				User-supplied message function (see NvBlastLog definition).  May be NULL.

+

+\return	true iff coverage was already exact.

+*/

+NVBLAST_API bool NvBlastEnsureAssetExactSupportCoverage(NvBlastChunkDesc* chunkDescs, uint32_t chunkCount, void* scratch, NvBlastLog logFn);

+

+

+/**

+Build chunk reorder map. 

+

+NvBlastCreateAsset function requires NvBlastChunkDesc array to be in correct oder:

+

+1. Root chunks (chunks with invalid parent index) must be first in the asset's chunk list.

+2. Chunks in the asset must be arranged such that sibling chunks (chunks with the same parent) are contiguous.

+3. Chunks must be arranged such that upper-support chunks (support chunks and their parent chunks) go first in 

+chunk list.

+

+This function builds chunk reorder map which can be used to order chunk descs. Reordering chunk's descriptors 

+according to generated map places them in correct order for NvBlastCreateAsset to succeed.

+

+Iff chunks are already ordered correctly, function returns 'true' and identity chunk reorder map. Otherwise 'false' is returned.

+

+\param[out] chunkReorderMap	User-supplied map of size chunkCount to fill. For every chunk index this array will contain new chunk position (index).

+\param[in]  chunkDescs		Array of chunk descriptors of size chunkCount.

+\param[in]  chunkCount		The number of chunk descriptors.

+\param[in]	scratch			User-supplied scratch storage, must point to 2 * chunkCount * sizeof(uint32_t) valid bytes of memory.

+\param[in]  logFn			User-supplied message function (see NvBlastLog definition).  May be NULL.

+

+\return	true iff the chunks did not require reordering (chunkReorderMap is the identity map).

+*/

+NVBLAST_API bool NvBlastBuildAssetDescChunkReorderMap(uint32_t* chunkReorderMap, const NvBlastChunkDesc* chunkDescs, uint32_t chunkCount, void* scratch, NvBlastLog logFn);

+

+

+/**

+Apply chunk reorder map.

+

+Function applies reorder map on NvBlastChunkDesc and NvBlastBondDesc arrays. It reorders chunks, replaces their 'parentChunkIndex' field

+with new indices. Bonds are kept in the same order, but their 'chunkIndices' field is updated with proper indices.

+

+@see NvBlastBuildAssetDescChunkReorderMap

+

+\param[out] reorderedChunkDescs			User-supplied array of size chunkCount to fill with new reordered NvBlastChunkDesc's.

+\param[in]  chunkDescs					Array of chunk descriptors of size chunkCount.

+\param[in]  chunkCount					The number of chunk descriptors.

+\param[in]  bondDescs					Array of bond descriptors of size chunkCount. It will be updated accordingly.

+\param[in]  bondCount					The number of bond descriptors.

+\param[in]  chunkReorderMap				Chunk reorder map to use, must be of size chunkCount.

+\param[in]	keepBondNormalChunkOrder	If true, bond normals will be flipped if their chunk index order was reveresed by the reorder map.

+\param[in]	logFn						User-supplied message function (see NvBlastLog definition).  May be NULL.

+*/

+NVBLAST_API void NvBlastApplyAssetDescChunkReorderMap

+(

+	NvBlastChunkDesc* reorderedChunkDescs,

+	const NvBlastChunkDesc* chunkDescs,

+	uint32_t chunkCount,

+	NvBlastBondDesc* bondDescs,

+	uint32_t bondCount,

+	const uint32_t* chunkReorderMap,

+	bool keepBondNormalChunkOrder,

+	NvBlastLog logFn

+);

+

+

+/**

+Apply chunk reorder map.

+

+Function applies reorder map on NvBlastChunkDesc and NvBlastBondDesc arrays. It reorders chunks, replaces their 'parentChunkIndex' field

+with new indices. Bonds are kept in the same order, but their 'chunkIndices' field is updated with proper indices.

+

+This overload of function reorders chunks in place.

+

+@see NvBlastBuildAssetDescChunkReorderMap

+

+\param[in]  chunkDescs					Array of chunk descriptors of size chunkCount. It will be updated accordingly.

+\param[in]  chunkCount					The number of chunk descriptors.

+\param[in]  bondDescs					Array of bond descriptors of size chunkCount. It will be updated accordingly.

+\param[in]  bondCount					The number of bond descriptors.

+\param[in]  chunkReorderMap				Chunk reorder map to use, must be of size chunkCount.

+\param[in]	keepBondNormalChunkOrder	If true, bond normals will be flipped if their chunk index order was reveresed by the reorder map.

+\param[in]	scratch						User-supplied scratch storage, must point to chunkCount * sizeof(NvBlastChunkDesc) valid bytes of memory.

+\param[in]	logFn						User-supplied message function (see NvBlastLog definition).  May be NULL.

+*/

+NVBLAST_API void NvBlastApplyAssetDescChunkReorderMapInPlace

+(

+	NvBlastChunkDesc* chunkDescs,

+	uint32_t chunkCount,

+	NvBlastBondDesc* bondDescs,

+	uint32_t bondCount,

+	const uint32_t* chunkReorderMap,

+	bool keepBondNormalChunkOrder,

+	void* scratch,

+	NvBlastLog logFn

+);

+

+

+/**

+Build and apply chunk reorder map. 

+

+Function basically calls NvBlastBuildAssetDescChunkReorderMap and NvBlastApplyAssetDescChunkReorderMap. Used for Convenience.

+

+\param[in]  chunkDescs					Array of chunk descriptors of size chunkCount. It will be updated accordingly.

+\param[in]  chunkCount					The number of chunk descriptors.

+\param[in]  bondDescs					Array of bond descriptors of size chunkCount. It will be updated accordingly.

+\param[in]  bondCount					The number of bond descriptors.

+\param[in]  chunkReorderMap				Chunk reorder map to fill, must be of size chunkCount.

+\param[in]	keepBondNormalChunkOrder	If true, bond normals will be flipped if their chunk index order was reveresed by the reorder map.

+\param[in]	scratch						User-supplied scratch storage, must point to chunkCount * sizeof(NvBlastChunkDesc) valid bytes of memory.

+\param[in]  logFn						User-supplied message function (see NvBlastLog definition).  May be NULL.

+

+\return	true iff the chunks did not require reordering (chunkReorderMap is the identity map).

+*/

+NVBLAST_API bool NvBlastReorderAssetDescChunks

+(

+	NvBlastChunkDesc* chunkDescs,

+	uint32_t chunkCount,

+	NvBlastBondDesc* bondDescs,

+	uint32_t bondCount,

+	uint32_t* chunkReorderMap,

+	bool keepBondNormalChunkOrder,

+	void* scratch,

+	NvBlastLog logFn

+);

+

+///@} End NvBlastAsset helper functions

+

+

+///////////////////////////////////////////////////////////////////////////////

+//	NvBlastFamily functions

+///////////////////////////////////////////////////////////////////////////////

+///@{

+

+/**

+Retrieve the data format version for the given family.

+

+\param[in] family	The family.

+\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.

+

+\return the family format version.

+*/

+NVBLAST_API uint32_t NvBlastFamilyGetFormatVersion(const NvBlastFamily* family, NvBlastLog logFn);

+

+

+/**

+Retrieve the asset of the given family.

+

+\param[in] family	The family.

+\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.

+

+\return pointer to the asset associated with the family.

+*/

+NVBLAST_API const NvBlastAsset* NvBlastFamilyGetAsset(const NvBlastFamily* family, NvBlastLog logFn);

+

+

+/**

+Set asset to the family. It should be the same asset as the one family was created from (same ID).

+

+\param[in] family	The family.

+\param[in] asset	Asset to instance.

+\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.

+*/

+NVBLAST_API void NvBlastFamilySetAsset(NvBlastFamily* family, const NvBlastAsset* asset, NvBlastLog logFn);

+

+

+/**

+Retrieve the size (in bytes) of the given family.

+

+\param[in] family	The family.

+\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.

+

+\return the size of the family (in bytes).

+*/

+NVBLAST_API uint32_t NvBlastFamilyGetSize(const NvBlastFamily* family, NvBlastLog logFn);

+

+

+/**

+Retrieve the asset ID of the given family.

+

+\param[in] family	The family.

+\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.

+

+\return the ID of the asset associated with the family.

+*/

+NVBLAST_API NvBlastID NvBlastFamilyGetAssetID(const NvBlastFamily* family, NvBlastLog logFn);

+

+

+/**

+Returns the number of bytes of scratch memory that the user must supply to NvBlastFamilyCreateFirstActor.

+

+\param[in] family	The family from which the first actor will be instanced.

+\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.

+

+\return	the number of bytes of scratch memory required for a call to NvBlastFamilyCreateFirstActor.

+*/

+NVBLAST_API size_t NvBlastFamilyGetRequiredScratchForCreateFirstActor(const NvBlastFamily* family, NvBlastLog logFn);

+

+

+/**

+Instance the family's asset into a new, unfractured actor.

+

+\param[in] family	Family in which to create a new actor.  The family must have no other actors in it.  (See NvBlastAssetCreateFamily.)

+\param[in] desc		Actor descriptor (see NvBlastActorDesc).

+\param[in] scratch	User-supplied scratch memory of size NvBlastFamilyGetRequiredScratchForCreateFirstActor(asset) bytes, where 'asset' is the NvBlastAsset from which the family was created.

+\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.

+

+\return pointer to new NvBlastActor if successful (the actor was successfully inserted into the family), or NULL if unsuccessful.

+*/

+NVBLAST_API NvBlastActor* NvBlastFamilyCreateFirstActor(NvBlastFamily* family, const NvBlastActorDesc* desc, void* scratch, NvBlastLog logFn);

+

+

+/**

+Retrieve the number of active actors associated with the given family.

+

+\param[in] family	The family.

+\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.

+

+\return the number of active actors in the family.

+*/

+NVBLAST_API uint32_t NvBlastFamilyGetActorCount(const NvBlastFamily* family, NvBlastLog logFn);

+

+

+/**

+Deserialize a single Actor from a buffer into the given family.  The actor will be inserted if it

+is compatible with the current family state.  That is, it must not share any chunks or internal

+IDs with the actors already present in the family.

+

+\param[in] family	Family in which to deserialize the actor.

+\param[in] buffer	User-supplied buffer containing the actor to deserialize.

+\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.

+

+\return the deserialized actor if successful, NULL otherwise.

+*/

+NVBLAST_API NvBlastActor* NvBlastFamilyDeserializeActor(NvBlastFamily* family, const void* buffer, NvBlastLog logFn);

+

+

+/**

+Retrieve the active actors associated with the given family.

+

+\param[out] actors		User-supplied array to be filled with the returned actor pointers.

+\param[out] actorsSize	The size of the actors array.  To receive all actor pointers, the size must be at least that given by NvBlastFamilyGetActorCount(family).

+\param[in] family		The family.

+\param[in] logFn		User-supplied message function (see NvBlastLog definition).  May be NULL.

+

+\return	the number of actor pointers written to actors.  This will not exceed actorsSize.

+*/

+NVBLAST_API uint32_t NvBlastFamilyGetActors(NvBlastActor** actors, uint32_t actorsSize, const NvBlastFamily* family, NvBlastLog logFn);

+

+

+/**

+Retrieve the actor associated with the given chunk.

+

+\param[in] family		The family.

+\param[in] chunkIndex	The index of chunk.

+\param[in] logFn		User-supplied message function (see NvBlastLog definition).  May be NULL.

+

+\return	pointer to actor associated with given chunk.  NULL if there is no such actor.

+*/

+NVBLAST_API NvBlastActor* NvBlastFamilyGetChunkActor(const NvBlastFamily* family, uint32_t chunkIndex, NvBlastLog logFn);

+

+

+/**

+Retrieve the max active actor count family could have.

+

+\param[in] family		The family.

+\param[in] logFn		User-supplied message function (see NvBlastLog definition).  May be NULL.

+

+\return	the max number of active actors family could have.

+*/

+NVBLAST_API uint32_t NvBlastFamilyGetMaxActorCount(const NvBlastFamily* family, NvBlastLog logFn);

+

+///@} End NvBlastFamily functions

+

+

+///////////////////////////////////////////////////////////////////////////////////////

+//	NvBlastActor accessor, serialization, and deactivation functions

+///////////////////////////////////////////////////////////////////////////////////////

+///@{

+

+/**

+Get the number of visible chunks for this actor.  May be used in conjunction with NvBlastActorGetVisibleChunkIndices.

+

+\param[in] actor	The actor.

+\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.

+

+\return	the number of visible chunk indices for the actor.

+*/

+NVBLAST_API uint32_t NvBlastActorGetVisibleChunkCount(const NvBlastActor* actor, NvBlastLog logFn);

+

+

+/**

+Retrieve a list of visible chunk indices for the actor into the given array.

+

+\param[in] visibleChunkIndices		User-supplied array to be filled in with indices of visible chunks for this actor.

+\param[in] visibleChunkIndicesSize	The size of the visibleChunkIndices array.  To receive all visible chunk indices, the size must be at least that given by NvBlastActorGetVisibleChunkCount(actor).

+\param[in] actor					The actor.

+\param[in] logFn					User-supplied message function (see NvBlastLog definition).  May be NULL.

+

+\return	the number of indices written to visibleChunkIndices.  This will not exceed visibleChunkIndicesSize.

+*/

+NVBLAST_API uint32_t NvBlastActorGetVisibleChunkIndices(uint32_t* visibleChunkIndices, uint32_t visibleChunkIndicesSize, const NvBlastActor* actor, NvBlastLog logFn);

+

+

+/**

+Get the number of graph nodes for this actor.  May be used in conjunction with NvBlastActorGetGraphNodeIndices.

+

+\param[in] actor	The actor.

+\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.

+

+\return	the number of graph node indices for the actor.

+*/

+NVBLAST_API uint32_t NvBlastActorGetGraphNodeCount(const NvBlastActor* actor, NvBlastLog logFn);

+

+

+/**

+Retrieve a list of graph node indices for the actor into the given array.

+

+\param[in] graphNodeIndices		User-supplied array to be filled in with indices of graph nodes for this actor.

+\param[in] graphNodeIndicesSize	The size of the graphNodeIndices array.  To receive all graph node indices, the size must be at least that given by NvBlastActorGetGraphNodeCount(actor).

+\param[in] actor				The actor.

+\param[in] logFn				User-supplied message function (see NvBlastLog definition).  May be NULL.

+

+\return	the number of indices written to graphNodeIndices.  This will not exceed graphNodeIndicesSize.

+*/

+NVBLAST_API uint32_t NvBlastActorGetGraphNodeIndices(uint32_t* graphNodeIndices, uint32_t graphNodeIndicesSize, const NvBlastActor* actor, NvBlastLog logFn);

+

+

+/**

+Access the bond health data for an actor.

+

+This function returns a pointer to the head of an array of bond healths (floats).  This array is the same for any actor that

+has been created from repeated fracturing of the same original instance of an asset (in the same instance family).

+

+The indices obtained from NvBlastSupportGraph::adjacentBondIndices in the asset may be used to access this array.

+

+The size of the array returned is NvBlastAssetGetBondCount(asset, logFn), where 'asset' is the NvBlastAsset

+that was used to create the actor.

+

+This array is valid as long as any actor in the instance family for the input actor exists.

+

+If the input actor is invalid, NULL will be returned.

+

+\param[in] actor	The actor.

+\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.

+

+\return	the array of bond healths for the actor's instance family, or NULL if the actor is invalid.

+*/

+NVBLAST_API const float* NvBlastActorGetBondHealths(const NvBlastActor* actor, NvBlastLog logFn);

+

+

+/**

+The buffer size needed to serialize a single actor.  This will give the exact size needed.  For an upper bound

+on the buffer size needed for any actor instanced from an NvBlastAsset, use NvBlastAssetGetActorSerializationSizeUpperBound.

+

+\param[in] actor	The actor.

+\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.

+

+\return the required buffer size in bytes.

+*/

+NVBLAST_API uint32_t NvBlastActorGetSerializationSize(const NvBlastActor* actor, NvBlastLog logFn);

+

+

+/**

+Serialize a single actor to a buffer.

+

+\param[out] buffer		User-supplied buffer, must be at least of size given by NvBlastActorGetSerializationSize(actor).

+\param[in] bufferSize	The size of the user-supplied buffer.

+\param[in] actor		The actor.

+\param[in] logFn		User-supplied message function (see NvBlastLog definition).  May be NULL.

+

+\return the number of bytes written to the buffer, or 0 if there is an error (such as an under-sized buffer).

+*/

+NVBLAST_API uint32_t NvBlastActorSerialize(void* buffer, uint32_t bufferSize, const NvBlastActor* actor, NvBlastLog logFn);

+

+

+/**

+Access to an actor's family.

+

+\param[in] actor	The actor.

+\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.

+

+\return the family with which the actor is associated.

+*/

+NVBLAST_API NvBlastFamily* NvBlastActorGetFamily(const NvBlastActor* actor, NvBlastLog logFn);

+

+

+/**

+Access to an actor's internal index.

+

+\param[in] actor	The actor.

+\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.

+

+\return actor's internal index in family.

+*/

+NVBLAST_API uint32_t NvBlastActorGetIndex(const NvBlastActor* actor, NvBlastLog logFn);

+

+

+/**

+Deactivate an actor within its family.  Conceptually this is "destroying" the actor, however memory will not be released until the family is released.

+

+\param[in] actor	Points to a user-supplied actor struct.  May be NULL, in which case this function no-ops.

+\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.

+

+\return true iff successful (actor was active).

+*/

+NVBLAST_API bool NvBlastActorDeactivate(NvBlastActor* actor, NvBlastLog logFn);

+

+///@} End NvBlastActor accessor, serialization, and deactivation functions

+

+

+///////////////////////////////////////////////////////////////////////////////

+//	NvBlastActor damage and fracturing functions

+///////////////////////////////////////////////////////////////////////////////

+///@{

+

+/**

+Creates fracture commands for the actor using a damage program and program parameters (material and damage descriptions).

+

+\param[in,out]	commandBuffers		Target buffers to hold generated commands.

+									To avoid data loss, provide an entry for every support chunk and every bond in the original actor.

+\param[in]		actor				The NvBlastActor to create fracture commands for.

+\param[in]		program				A NvBlastDamageProgram containing damage shaders.

+\param[in]		programParams		Parameters for the NvBlastDamageProgram.

+\param[in]		logFn				User-supplied message function (see NvBlastLog definition).  May be NULL.

+\param[in,out]	timers				If non-NULL this struct will be filled out with profiling information for the step, in profile build configurations.

+

+Interpretation of NvBlastFractureBuffers:

+As input:

+	Counters denote available entries for FractureData.

+	Chunk and Bond userdata are not used.

+	Health values are not used.

+

+As output:

+	Counters denote valid entires in FractureData arrays.

+	Chunks and Bond userdata reflect the respective userdata set during asset initialization, where implemented by the material function.

+	Health values denote how much damage is to be applied.

+*/

+NVBLAST_API void NvBlastActorGenerateFracture

+(

+	NvBlastFractureBuffers* commandBuffers,

+	const NvBlastActor* actor,

+	const NvBlastDamageProgram program, 

+	const void* programParams,

+	NvBlastLog logFn, 

+	NvBlastTimers* timers

+);

+

+

+/**

+Applies the direct fracture and breaks graph bonds/edges as necessary.

+Chunks damaged beyond their respective health fracture their children recursively, creating a NvBlastChunkFractureData for each.

+

+\param[in,out]	eventBuffers		Target buffers to hold applied fracture events. May be NULL, in which case events are not reported.

+									To avoid data loss, provide an entry for every lower-support chunk and every bond in the original actor.

+\param[in,out]	actor				The NvBlastActor to apply fracture to.

+\param[in]		commands			The fracture commands to process.

+\param[in]		logFn				User-supplied message function (see NvBlastLog definition).  May be NULL.

+\param[in,out]	timers				If non-NULL this struct will be filled out with profiling information for the step, in profile build configurations.

+

+Interpretation of NvBlastFractureBuffers:

+commands:

+	Counters denote the number of command entries to process.

+	Chunk and Bond userdata are not used.

+	Health values denote the amount of damage to apply, as a positive value.

+

+eventBuffers as input:

+	Counters denote available entries for FractureData.

+	Chunk and Bond userdata are not used.

+	Health values are not used.

+

+eventBuffers as output:

+	Counters denote valid entires in FractureData arrays.

+	Chunks and Bond userdata reflect the respective userdata set during asset initialization.

+	Health values denote how much health is remaining for the damaged element. 

+	Broken elements report a negative value corresponding to the superfluous health damage.

+

+commands and eventBuffers may point to the same memory.

+*/

+NVBLAST_API void NvBlastActorApplyFracture

+(

+	NvBlastFractureBuffers* eventBuffers,

+	NvBlastActor* actor,

+	const NvBlastFractureBuffers* commands,

+	NvBlastLog logFn,

+	NvBlastTimers* timers

+);

+

+

+/**

+Releases the oldActor and creates its children newActors if necessary.

+

+\param[out]		result				The list of deleted and created NvBlastActor objects.

+\param[in]		actor				The actor to split.

+\param[in]		newActorsMaxCount	Number of available NvBlastActor slots. In the worst case, one NvBlastActor may be created for every chunk in the asset.

+\param[in]		scratch				Scratch Memory used during processing. NvBlastActorGetRequiredScratchForSplit provides the necessary size.

+\param[in]		logFn				User-supplied message function (see NvBlastLog definition).  May be NULL.

+\param[in,out]	timers				If non-NULL this struct will be filled out with profiling information for the step, in profile build configurations

+

+\return	1..n:	new actors were created

+\return	0:		oldActor is unchanged

+*/

+NVBLAST_API uint32_t NvBlastActorSplit

+(

+	NvBlastActorSplitEvent* result, 

+	NvBlastActor* actor,

+	uint32_t newActorsMaxCount,

+	void* scratch,

+	NvBlastLog logFn,

+	NvBlastTimers* timers

+);

+

+

+/**

+Returns the number of bytes of scratch memory that the user must supply to NvBlastActorSplit,

+based upon the actor that will be passed into that function.

+

+\param[in] actor	The actor that will be passed into NvBlastActorSplit.

+\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.

+

+\return	the number of bytes of scratch memory required for a call to NvBlastActorSplit with that actor.

+*/

+NVBLAST_API size_t NvBlastActorGetRequiredScratchForSplit(const NvBlastActor* actor, NvBlastLog logFn);

+

+

+/**

+Returns the upper-bound number of actors which can be created by calling NvBlastActorSplit with that actor, this

+value can't exceed chunk count.

+

+\param[in] actor	The actor.

+\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.

+

+\return	the upper-bound number of actors which can be created by calling NvBlastActorSplit with that actor.

+*/

+NVBLAST_API uint32_t NvBlastActorGetMaxActorCountForSplit(const NvBlastActor* actor, NvBlastLog logFn);

+

+

+/**

+Determines if the actor can fracture further.

+

+\param[in] actor	The actor potentially being fractured.

+\param[in] logFn	User-supplied message function (see NvBlastLog definition).  May be NULL.

+

+\return true if any result can be expected from fracturing the actor. false if no further change to the actor is possible.

+*/

+NVBLAST_API bool NvBlastActorCanFracture(const NvBlastActor* actor, NvBlastLog logFn);

+

+

+/**

+Determines if the actor is damaged (was fractured) and split call is required.

+

+The actor could be damaged by calling NvBlastActorApplyFracture or NvBlastFamilyApplyFracture and NvBlastActorSplit is expected after.

+This function gives a hint that NvBlastActorSplit will have some work to be done and actor could potentially be split.

+If actor is not damaged calling NvBlastActorSplit will make no effect.

+

+\return true iff split call is required for this actor.

+*/

+NVBLAST_API bool NvBlastActorIsSplitRequired(const NvBlastActor* actor, NvBlastLog logFn);

+

+

+/**

+\return true iff this actor contains the "world" support graph node, created when a bond contains the UINT32_MAX value for one of their chunkIndices.

+*/

+NVBLAST_API bool NvBlastActorIsBoundToWorld(const NvBlastActor* actor, NvBlastLog logFn);

+

+///@} End NvBlastActor damage and fracturing functions

+

+

+///////////////////////////////////////////////////////////////////////////////

+//	NvBlastTimers functions and helpers

+///////////////////////////////////////////////////////////////////////////////

+///@{

+

+/**

+Resets all values in the given NvBlastTimers struct to zero.

+

+\param[in]	timers	The NvBlastTimers to set to zero.

+*/

+NVBLAST_API void NvBlastTimersReset(NvBlastTimers* timers);

+

+

+/**

+Convert a tick value from NvBlastTimers to seconds.

+

+\param[in]	ticks	The tick value.

+

+\return the seconds correposnding to the input tick value.

+*/

+NVBLAST_API double NvBlastTicksToSeconds(int64_t ticks);

+

+///@} End NvBlastTimers functions and helpers

+

+

+#endif // ifndef NVBLAST_H

diff --git a/sdk/lowlevel/include/NvBlastPreprocessor.h b/sdk/lowlevel/include/NvBlastPreprocessor.h
index 8cf7f55..e23f1c6 100644..100755
--- a/sdk/lowlevel/include/NvBlastPreprocessor.h
+++ b/sdk/lowlevel/include/NvBlastPreprocessor.h
@@ -1,40 +1,40 @@
-// This code contains NVIDIA Confidential Information and is disclosed to you
-// under a form of NVIDIA software license agreement provided separately to you.
-//
-// Notice
-// NVIDIA Corporation and its licensors retain all intellectual property and
-// proprietary rights in and to this software and related documentation and
-// any modifications thereto. Any use, reproduction, disclosure, or
-// distribution of this software and related documentation without an express
-// license agreement from NVIDIA Corporation is strictly prohibited.
-//
-// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
-// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
-// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
-// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
-//
-// Information and code furnished is believed to be accurate and reliable.
-// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
-// information or for any infringement of patents or other rights of third parties that may
-// result from its use. No license is granted by implication or otherwise under any patent
-// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
-// This code supersedes and replaces all information previously supplied.
-// NVIDIA Corporation products are not authorized for use as critical
-// components in life support devices or systems without express written approval of
-// NVIDIA Corporation.
-//
-// Copyright (c) 2016-2018 NVIDIA Corporation. All rights reserved.
-
-
-#ifndef NVBLASTPREPROCESSOR_H
-#define NVBLASTPREPROCESSOR_H
-
-
-#include "NvPreprocessor.h"
-
-
-/** Blast API declaration */
-#define NVBLAST_API NV_C_EXPORT NV_DLL_EXPORT
-
-
-#endif // ifndef NVBLASTPREPROCESSOR_H
+// This code contains NVIDIA Confidential Information and is disclosed to you

+// under a form of NVIDIA software license agreement provided separately to you.

+//

+// Notice

+// NVIDIA Corporation and its licensors retain all intellectual property and

+// proprietary rights in and to this software and related documentation and

+// any modifications thereto. Any use, reproduction, disclosure, or

+// distribution of this software and related documentation without an express

+// license agreement from NVIDIA Corporation is strictly prohibited.

+//

+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES

+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO

+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,

+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.

+//

+// Information and code furnished is believed to be accurate and reliable.

+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such

+// information or for any infringement of patents or other rights of third parties that may

+// result from its use. No license is granted by implication or otherwise under any patent

+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.

+// This code supersedes and replaces all information previously supplied.

+// NVIDIA Corporation products are not authorized for use as critical

+// components in life support devices or systems without express written approval of

+// NVIDIA Corporation.

+//

+// Copyright (c) 2016-2018 NVIDIA Corporation. All rights reserved.

+

+

+#ifndef NVBLASTPREPROCESSOR_H

+#define NVBLASTPREPROCESSOR_H

+

+

+#include "NvPreprocessor.h"

+

+

+/** Blast API declaration */

+#define NVBLAST_API NV_C_EXPORT NV_DLL_EXPORT

+

+

+#endif // ifndef NVBLASTPREPROCESSOR_H

diff --git a/sdk/lowlevel/include/NvBlastTypes.h b/sdk/lowlevel/include/NvBlastTypes.h
index dbd58d8..1c083eb 100644..100755
--- a/sdk/lowlevel/include/NvBlastTypes.h
+++ b/sdk/lowlevel/include/NvBlastTypes.h
@@ -1,594 +1,594 @@
-// This code contains NVIDIA Confidential Information and is disclosed to you
-// under a form of NVIDIA software license agreement provided separately to you.
-//
-// Notice
-// NVIDIA Corporation and its licensors retain all intellectual property and
-// proprietary rights in and to this software and related documentation and
-// any modifications thereto. Any use, reproduction, disclosure, or
-// distribution of this software and related documentation without an express
-// license agreement from NVIDIA Corporation is strictly prohibited.
-//
-// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
-// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
-// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
-// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
-//
-// Information and code furnished is believed to be accurate and reliable.
-// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
-// information or for any infringement of patents or other rights of third parties that may
-// result from its use. No license is granted by implication or otherwise under any patent
-// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
-// This code supersedes and replaces all information previously supplied.
-// NVIDIA Corporation products are not authorized for use as critical
-// components in life support devices or systems without express written approval of
-// NVIDIA Corporation.
-//
-// Copyright (c) 2016-2018 NVIDIA Corporation. All rights reserved.
-
-
-#ifndef NVBLASTTYPES_H
-#define NVBLASTTYPES_H
-
-
-#include "NvBlastPreprocessor.h"
-#include <stdint.h>
-
-
-///////////////////////////////////////////////////////////////////////////////
-//	NvBlast common types
-///////////////////////////////////////////////////////////////////////////////
-///@{
-
-/**
-Types of log messages.
-*/
-struct NvBlastMessage
-{
-	enum Type
-	{
-		Error,		//!< Error messages
-		Warning,	//!< Warning messages
-		Info,		//!< Information messages
-		Debug		//!< Used only in debug version of dll
-	};
-};
-
-
-/**
-Function pointer type for logging.
-
-When a function with this signature is passed into Blast functions with an NvBlastLog argument,
-Blast will use it to report errors, warnings, and other information.
-*/
-typedef void(*NvBlastLog)(int type, const char* msg, const char* file, int line);
-
-
-/**
-ID used to identify assets.
-*/
-struct NvBlastID
-{
-	char data[16];
-};
-
-
-/**
-Time spent (in ticks) in various parts of Blast.
-These values may be filled in during the execution of various API functions.
-To convert to seconds, use NvBlastTicksToSeconds(ticks).
-
-In profile build configurations, if a pointer to an instance of this struct is passed into
-Blast functions with an NvBlastTimers argument, then Blast will add to appropriate fields
-the time measured in corresponding sections of code.  The user must clear the timer fields
-with NvBlastTimersReset to initialize or reset.
-*/
-struct NvBlastTimers
-{
-	int64_t  material;		//!< Time spent in material function
-	int64_t  fracture;		//!< Time spent applying damage
-	int64_t  island;		//!< Time spent discovering islands
-	int64_t  partition;		//!< Time spent partitioning the graph
-	int64_t  visibility;	//!< Time spent updating visibility
-};
-
-
-/**
-Generic data block header for all data blocks.
-*/
-struct NvBlastDataBlock
-{
-	/**
-	Enum of data block types
-	*/
-	enum Type
-	{
-		AssetDataBlock,
-		FamilyDataBlock,
-
-		Count
-	};
-
-
-	/**
-	A data type keeps value from Type enum
-	*/
-	uint32_t	dataType;
-
-	/**
-	A number which is incremented every time the data layout changes. Depending on dataType corresponding	data 
-	format is kept. See NvBlastAssetDataFormat, NvBlastFamilyDataFormat enum.
-	*/
-	uint32_t	formatVersion;
-
-	/**
-	The size of the family, including this header.
-
-	Memory sizes are restricted to 32-bit representable values.
-	*/
-	uint32_t	size;
-
-	/**
-	Reserved to be possibly used in future versions
-	*/
-	uint32_t	reserved;
-};
-
-///@} End NvBlast common types
-
-
-///////////////////////////////////////////////////////////////////////////////
-//	NvBlastAsset related types
-///////////////////////////////////////////////////////////////////////////////
-///@{
-
-/**
-Represents a piece of a destructible asset which may be realized as an entity with a physical and graphical component.
-
-Chunks may form a hierarchical decomposition of the asset.  They contain parent and child chunk index information which
-defines the hierarchy.  The parent and child chunk indices are their positions with the NvBlastAsset::chunks array.
-
-Child chunk indices are contiguous, starting at firstChildIndex and ending with childIndexStop - 1.
-*/
-struct NvBlastChunk
-{
-	/**
-	Central position for the chunk's volume
-	*/
-	float		centroid[3];
-
-	/**
-	Volume of the chunk
-	*/
-	float		volume;
-
-	/**
-	Index of parent (UINT32_MAX denotes no parent)
-	*/
-	uint32_t	parentChunkIndex;
-
-	/**
-	Index of first child
-	*/
-	uint32_t	firstChildIndex;
-
-	/**
-	Stop for child indices
-	*/
-	uint32_t	childIndexStop;
-
-	/**
-	Field for user to associate with external data
-	*/
-	uint32_t	userData;
-};
-
-
-/**
-Represents the interface between two chunks.  At most one bond is created for a chunk pair.
-*/
-struct NvBlastBond
-{
-	/**
-	Interface average normal
-	*/
-	float		normal[3];
-
-	/**
-	Area of interface
-	*/
-	float		area;
-
-	/**
-	Central position on the interface between chunks
-	*/
-	float		centroid[3];
-
-	/**
-	Extra data associated with bond, e.g. whether or not to create a joint
-	*/
-	uint32_t	userData;
-};
-
-
-/**
-Describes the connectivity between support chunks via bonds.
-
-Vertices in the support graph are termed "nodes," and represent particular chunks (NvBlastChunk) in an NvBlastAsset.
-The indexing for nodes is not the same as that for chunks.  Only some chunks are represented by nodes in the graph,
-and these chunks are called "support chunks."
-
-Adjacent node indices and adjacent bond indices are stored for each node, and therefore each bond is represented twice in this graph,
-going from node[i] -> node[j] and from node[j] -> node[i].  Therefore the size of the adjacentNodeIndices and adjacentBondIndices
-arrays are twice the number of bonds stored in the corresponding NvBlastAsset. 
-
-The graph is used as follows.  Given a NvBlastSupportGraph "graph" and node index i, (0 <= i < graph.nodeCount), one may find all
-adjacent bonds and nodes using:
-
-	// adj is the lookup value in graph.adjacentNodeIndices and graph.adjacentBondIndices
-	for (uint32_t adj = graph.adjacencyPartition[i]; adj < graph.adjacencyPartition[i+1]; ++adj)
-	{
-		// An adjacent node:
-		uint32_t adjacentNodeIndex = graph.adjacentNodeIndices[adj];
-	
-		// The corresponding bond (that connects node index i with node indexed adjacentNodeIndex:
-		uint32_t adjacentBondIndex = graph.adjacentBondIndices[adj];
-	}
-
-For a graph node with index i, the corresponding asset chunk index is found using graph.chunkIndices[i].  The reverse mapping
-(obtaining a graph node index from an asset chunk index) can be done using the
-
-	NvBlastAssetGetChunkToGraphNodeMap(asset, logFn)
-
-function.  See the documentation for its use.  The returned "node index" for a non-support chunk is the invalid value 0xFFFFFFFF.
-*/
-struct NvBlastSupportGraph
-{
-	/**
-	Total number of nodes in the support graph.
-	*/
-	uint32_t	nodeCount;
-
-	/**
-	Indices of chunks represented by the nodes, an array of size nodeCount.
-	*/
-	uint32_t*	chunkIndices;
-
-	/**
-	Partitions both the adjacentNodeIndices and the adjacentBondIndices arrays into subsets corresponding to each node.
-	The size of this array is nodeCount+1.
-	For 0 <= i < nodeCount, adjacencyPartition[i] is the index of the first element in adjacentNodeIndices (or adjacentBondIndices) for nodes adjacent to the node with index i.
-	adjacencyPartition[nodeCount] is the size of the adjacentNodeIndices and adjacentBondIndices arrays.
-	This allows one to easily count the number of nodes adjacent to a node with index i, using adjacencyPartition[i+1] - adjacencyPartition[i].
-	*/
-	uint32_t*	adjacencyPartition;
-
-	/**
-	Array composed of subarrays holding the indices of nodes adjacent to a given node.  The subarrays may be accessed through the adjacencyPartition array.
-	*/
-	uint32_t*	adjacentNodeIndices;
-
-	/**
-	Array composed of subarrays holding the indices of bonds (NvBlastBond) for a given node.  The subarrays may be accessed through the adjacencyPartition array.
-	*/
-	uint32_t*	adjacentBondIndices;
-};
-
-
-/**
-Asset (opaque)
-
-Static destructible data, used to create actor families.
-
-Pointer to this struct can be created with NvBlastCreateAsset.
-
-The NvBlastAsset includes a ID which may be used to match it with physics and graphics data.
-*/
-struct NvBlastAsset {};
-
-
-/**
-Chunk descriptor used to build an asset.  See NvBlastAssetDesc.
-*/
-struct NvBlastChunkDesc
-{
-	enum Flags
-	{
-		NoFlags = 0,
-
-		/** If this flag is set then the chunk will become a support chunk, unless an ancestor chunk is also marked as support. */
-		SupportFlag = (1 << 0)
-	};
-
-	/** Central position in chunk. */
-	float		centroid[3];
-
-	/** Volume of chunk. */
-	float		volume;
-
-	/** Index of this chunk's parent.  If this is a root chunk, then this value must be UINT32_MAX. */
-	uint32_t	parentChunkIndex;
-
-	/** See Flags enum for possible flags. */
-	uint32_t	flags;
-
-	/** User-supplied data which will be accessible to the user in chunk fracture events. */
-	uint32_t	userData;
-};
-
-
-/**
-Chunk bond descriptor used to build an asset.  See NvBlastAssetDesc.
-*/
-struct NvBlastBondDesc
-{
-	/** Bond data (see NvBlastBond). */
-	NvBlastBond	bond;
-
-	/**
-	The indices of the chunks linked by this bond.  They must be different support chunk indices.
-	If one of the chunk indices is the invalid index (UINT32_MAX), then this will create a bond between
-	the chunk indexed by the other index (which must be valid) and "the world."  Any actor containing
-	this bond will cause the function NvBlastActorIsBoundToWorld to return true.
-	*/
-	uint32_t	chunkIndices[2];
-};
-
-
-/**
-Asset descriptor, used to build an asset with NvBlastCreateAsset
-
-A valid asset descriptor must have a non-zero chunkCount and valid chunkDescs.
-
-The user may create an asset with no bonds (e.g. a single-chunk asset).  In this case bondCount should be
-zero and bondDescs is ignored.
-*/
-struct NvBlastAssetDesc
-{
-	/** The number of chunk descriptors. */
-	uint32_t				chunkCount;
-
-	/** Array of chunk descriptors of size chunkCount. */
-	const NvBlastChunkDesc*	chunkDescs;
-
-	/** The number of bond descriptors. */
-	uint32_t				bondCount;
-
-	/** Array of bond descriptors of size bondCount. */
-	const NvBlastBondDesc*	bondDescs;
-};
-
-///@} End NvBlastAsset related types
-
-
-///////////////////////////////////////////////////////////////////////////////
-//	NvBlastActor related types
-///////////////////////////////////////////////////////////////////////////////
-///@{
-
-/**
-Family (opaque)
-
-a family can be created by the NvBlastAssetCreateFamily function and released 
-by the NvBlastFamilyRelease.  Family is needed to create first actor.  All the following
-actors which can be created with NvBlastActorSplit function (as a result of fracture) will share the same family
-block.  NvBlastFamilyGetActorCount can be used to know if family can be safely released.
-*/
-struct NvBlastFamily {};
-
-
-/**
-Actor (opaque)
-
-Actors can be generated by the NvBlastFamilyCreateFirstActor
-and NvBlastActorSplit functions.  Opaque NvBlastActor pointers reference data within the family
-generated during NvBlastFamilyCreateFirstActor, and represent the actor in all actor-related API
-functions.
-*/
-struct NvBlastActor {};
-
-
-/**
-Actor descriptor, used to create an instance of an NvBlastAsset with NvBlastFamilyCreateFirstActor
-
-See NvBlastFamilyCreateFirstActor.
-*/
-struct NvBlastActorDesc
-{
-	/**
-	Initial health of all bonds, if initialBondHealths is NULL (see initialBondHealths).
-	*/
-	float			uniformInitialBondHealth;
-
-	/**
-	Initial bond healths.  If not NULL, this array must be of length NvBlastAssetGetChunkCount(asset, logFn).
-	If NULL, uniformInitialBondHealth must be set.
-	*/
-	const float*	initialBondHealths;
-
-	/**
-	Initial health of all lower-support chunks, if initialSupportChunkHealths is NULL (see initialSupportChunkHealths).
-	*/
-	float			uniformInitialLowerSupportChunkHealth;
-
-	/**
-	Initial health of all support chunks.  If not NULL, this must be of length
-	NvBlastAssetGetSupportChunkCount(asset, logFn).nodeCount. The elements in the initialSupportChunkHealth
-	array will correspond to the chunk indices in the NvBlastAssetGetSupportGraph(asset, logFn).chunkIndices
-	array.  Every descendent of a support chunk will have its health initialized to its ancestor support
-	chunk's health, so this initializes all lower-support chunk healths.
-	If NULL, uniformInitialLowerSupportChunkHealth must be set.
-	*/
-	const float*	initialSupportChunkHealths;
-};
-
-///@} End NvBlastActor related types
-
-
-///////////////////////////////////////////////////////////////////////////////
-//	Types used for damage and fracturing
-///////////////////////////////////////////////////////////////////////////////
-///@{
-
-
-/**
-Fracture Data for Chunks
-
-Data interpretation varies depending on the function used. 
-@see NvBlastActorGenerateFracture NvBlastActorApplyFracture NvBlastFractureBuffers
-*/
-struct NvBlastChunkFractureData
-{
-	uint32_t	userdata;	//!<	chunk's user data
-	uint32_t	chunkIndex;	//!<	asset chunk index
-	float		health;		//!<	health value (damage or remains)
-};
-
-
-/**
-Fracture Data for Bonds
-
-Data interpretation varies depending on the function used.
-@see NvBlastActorGenerateFracture NvBlastActorApplyFracture NvBlastFractureBuffers
-*/
-struct NvBlastBondFractureData
-{
-	uint32_t	userdata;	//!<	bond's user data
-	uint32_t	nodeIndex0;	//!<	graph node index of bond
-	uint32_t	nodeIndex1;	//!<	pair graph node index of bond
-	float		health;		//!<	health value (damage or remains)
-};
-
-
-/**
-Memory to be used by fracture functions.
-
-Used as input and output target.
-@see NvBlastActorGenerateFracture NvBlastActorApplyFracture
-*/
-struct NvBlastFractureBuffers
-{
-	uint32_t					bondFractureCount;		//!<	available elements in bondFractures
-	uint32_t					chunkFractureCount;		//!<	available elements in chunkFractures
-	NvBlastBondFractureData*	bondFractures;			//!<	memory to be filled by fracture functions
-	NvBlastChunkFractureData*	chunkFractures;			//!<	memory to be filled by fracture functions
-};
-
-
-/**
-Description of a NvBlastActorSplit result.
-This tells the user about changes in the actor, or creation of children.
-*/
-struct NvBlastActorSplitEvent
-{
-	NvBlastActor*	deletedActor;	//!<	deleted actor or nullptr if actor has not changed
-	NvBlastActor**	newActors;		//!<	list of created actors
-};
-
-
-/**
-A single actor's representation used by NvBlastGraphShaderFunction.
-*/
-struct NvBlastGraphShaderActor
-{
-	uint32_t			actorIndex;				//!<	Actor's index.
-	uint32_t			graphNodeCount;			//!<	Actor's graph node count.
-	uint32_t			assetNodeCount;			//!<	Asset node count.
-	uint32_t			firstGraphNodeIndex;	//!<	Entry index for graphNodeIndexLinks
-	const uint32_t*		graphNodeIndexLinks;	//!<	Linked index list of connected nodes.  Traversable with nextIndex = graphNodeIndexLinks[currentIndex], terminates with 0xFFFFFFFF.
-	const uint32_t*		chunkIndices;			//!<	Graph's map from node index to support chunk index.
-	const uint32_t*		adjacencyPartition;		//!<	See NvBlastSupportGraph::adjacencyPartition.
-	const uint32_t*		adjacentNodeIndices;	//!<	See NvBlastSupportGraph::adjacentNodeIndices.
-	const uint32_t*		adjacentBondIndices;	//!<	See NvBlastSupportGraph::adjacentBondIndices.
-	const NvBlastBond*	assetBonds;				//!<	NvBlastBonds geometry in the NvBlastAsset.
-	const NvBlastChunk*	assetChunks;			//!<	NvBlastChunks geometry in the NvBlastAsset.
-	const float*		familyBondHealths;		//!<	Actual bond health values for broken bond detection.
-	const float*		supportChunkHealths;	//!<	Actual chunk health values for dead chunk detection.
-	const uint32_t*		nodeActorIndices;		//!<	Family's map from node index to actor index.
-};
-
-
-/**
-A single actor's representation used by NvBlastSubgraphShaderFunction.
-*/
-struct NvBlastSubgraphShaderActor
-{
-	uint32_t			chunkIndex;		//!<	Index of chunk represented by this actor.
-	const NvBlastChunk*	assetChunks;	//!<	NvBlastChunks geometry in the NvBlastAsset.
-};
-
-
-/**
-Damage shader for actors with more then one node in support graph.
-
-From a an input actor data (NvBlastGraphShaderActor) and user custom data (params),
-creates a list of NvBlastFractureCommand to be applied to the respective NvBlastActor.
-
-\param[in,out]	commandBuffers			The resulting health damage to apply.
-										Typically requires an array of size (number of support chunks) + (number of bonds) of the processed asset
-										but may depend on the actual implementation.
-\param[in]		actor					The actor representation used for creating commands.
-\param[in]		programParams			A set of parameters defined by the damage shader implementer.
-
-Interpretation of NvBlastFractureBuffers:
-As input:
-Counters denote available entries for FractureData.
-Chunk and Bond userdata are not used.
-Health values are not used.
-
-As output:
-Counters denote valid entires in FractureData arrays.
-Chunks and Bond userdata reflect the respective userdata set during asset initialization.
-Health values denote how much damage is to be applied.
-
-@see NvBlastFractureBuffers NvBlastGraphShaderActor
-*/
-typedef void(*NvBlastGraphShaderFunction)(NvBlastFractureBuffers* commandBuffers, const NvBlastGraphShaderActor* actor, const void* programParams);
-
-
-/**
-Damage shader for actors with single chunk.
-
-From a an input actor data (NvBlastSubgraphShaderActor) and user custom data (params),
-creates a list of NvBlastFractureCommand to be applied to the respective NvBlastActor.
-
-\param[in,out]	commandBuffers			The resulting health damage to apply.
-										Typically requires an array of size (number of support chunks) + (number of bonds) of the processed asset
-										but may depend on the actual implementation.
-\param[in]		actor					The actor representation used for creating commands.
-\param[in]		programParams			A set of parameters defined by the damage shader implementer.
-
-Interpretation of NvBlastFractureBuffers:
-As input:
-Counters denote available entries for FractureData.
-Chunk and Bond userdata are not used.
-Health values are not used.
-
-As output:
-Counters denote valid entires in FractureData arrays.
-Chunks and Bond userdata reflect the respective userdata set during asset initialization.
-Health values denote how much damage is to be applied.
-
-@see NvBlastFractureBuffers NvBlastSubgraphShaderActor
-*/
-typedef void(*NvBlastSubgraphShaderFunction)(NvBlastFractureBuffers* commandBuffers, const NvBlastSubgraphShaderActor* actor, const void* programParams);
-
-
-/**
-Damage Program. 
-
-Contains both graph and subgraph shader. When used on actor appropriate shader will be called.
-Any shader can be nullptr to be skipped.
-
-@see NvBlastGraphShaderFunction NvBlastSubgraphShaderFunction
-*/
-struct NvBlastDamageProgram
-{
-	NvBlastGraphShaderFunction		graphShaderFunction;
-	NvBlastSubgraphShaderFunction	subgraphShaderFunction;
-};
-
-
-///@} End of types used for damage and fracturing
-
-
-#endif // ifndef NVBLASTTYPES_H
+// This code contains NVIDIA Confidential Information and is disclosed to you

+// under a form of NVIDIA software license agreement provided separately to you.

+//

+// Notice

+// NVIDIA Corporation and its licensors retain all intellectual property and

+// proprietary rights in and to this software and related documentation and

+// any modifications thereto. Any use, reproduction, disclosure, or

+// distribution of this software and related documentation without an express

+// license agreement from NVIDIA Corporation is strictly prohibited.

+//

+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES

+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO

+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,

+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.

+//

+// Information and code furnished is believed to be accurate and reliable.

+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such

+// information or for any infringement of patents or other rights of third parties that may

+// result from its use. No license is granted by implication or otherwise under any patent

+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.

+// This code supersedes and replaces all information previously supplied.

+// NVIDIA Corporation products are not authorized for use as critical

+// components in life support devices or systems without express written approval of

+// NVIDIA Corporation.

+//

+// Copyright (c) 2016-2018 NVIDIA Corporation. All rights reserved.

+

+

+#ifndef NVBLASTTYPES_H

+#define NVBLASTTYPES_H

+

+

+#include "NvBlastPreprocessor.h"

+#include <stdint.h>

+

+

+///////////////////////////////////////////////////////////////////////////////

+//	NvBlast common types

+///////////////////////////////////////////////////////////////////////////////

+///@{

+

+/**

+Types of log messages.

+*/

+struct NvBlastMessage

+{

+	enum Type

+	{

+		Error,		//!< Error messages

+		Warning,	//!< Warning messages

+		Info,		//!< Information messages

+		Debug		//!< Used only in debug version of dll

+	};

+};

+

+

+/**

+Function pointer type for logging.

+

+When a function with this signature is passed into Blast functions with an NvBlastLog argument,

+Blast will use it to report errors, warnings, and other information.

+*/

+typedef void(*NvBlastLog)(int type, const char* msg, const char* file, int line);

+

+

+/**

+ID used to identify assets.

+*/

+struct NvBlastID

+{

+	char data[16];

+};

+

+

+/**

+Time spent (in ticks) in various parts of Blast.

+These values may be filled in during the execution of various API functions.

+To convert to seconds, use NvBlastTicksToSeconds(ticks).

+

+In profile build configurations, if a pointer to an instance of this struct is passed into

+Blast functions with an NvBlastTimers argument, then Blast will add to appropriate fields

+the time measured in corresponding sections of code.  The user must clear the timer fields

+with NvBlastTimersReset to initialize or reset.

+*/

+struct NvBlastTimers

+{

+	int64_t  material;		//!< Time spent in material function

+	int64_t  fracture;		//!< Time spent applying damage

+	int64_t  island;		//!< Time spent discovering islands

+	int64_t  partition;		//!< Time spent partitioning the graph

+	int64_t  visibility;	//!< Time spent updating visibility

+};

+

+

+/**

+Generic data block header for all data blocks.

+*/

+struct NvBlastDataBlock

+{

+	/**

+	Enum of data block types

+	*/

+	enum Type

+	{

+		AssetDataBlock,

+		FamilyDataBlock,

+

+		Count

+	};

+

+

+	/**

+	A data type keeps value from Type enum

+	*/

+	uint32_t	dataType;

+

+	/**

+	A number which is incremented every time the data layout changes. Depending on dataType corresponding	data 

+	format is kept. See NvBlastAssetDataFormat, NvBlastFamilyDataFormat enum.

+	*/

+	uint32_t	formatVersion;

+

+	/**

+	The size of the family, including this header.

+

+	Memory sizes are restricted to 32-bit representable values.

+	*/

+	uint32_t	size;

+

+	/**

+	Reserved to be possibly used in future versions

+	*/

+	uint32_t	reserved;

+};

+

+///@} End NvBlast common types

+

+

+///////////////////////////////////////////////////////////////////////////////

+//	NvBlastAsset related types

+///////////////////////////////////////////////////////////////////////////////

+///@{

+

+/**

+Represents a piece of a destructible asset which may be realized as an entity with a physical and graphical component.

+

+Chunks may form a hierarchical decomposition of the asset.  They contain parent and child chunk index information which

+defines the hierarchy.  The parent and child chunk indices are their positions with the NvBlastAsset::chunks array.

+

+Child chunk indices are contiguous, starting at firstChildIndex and ending with childIndexStop - 1.

+*/

+struct NvBlastChunk

+{

+	/**

+	Central position for the chunk's volume

+	*/

+	float		centroid[3];

+

+	/**

+	Volume of the chunk

+	*/

+	float		volume;

+

+	/**

+	Index of parent (UINT32_MAX denotes no parent)

+	*/

+	uint32_t	parentChunkIndex;

+

+	/**

+	Index of first child

+	*/

+	uint32_t	firstChildIndex;

+

+	/**

+	Stop for child indices

+	*/

+	uint32_t	childIndexStop;

+

+	/**

+	Field for user to associate with external data

+	*/

+	uint32_t	userData;

+};

+

+

+/**

+Represents the interface between two chunks.  At most one bond is created for a chunk pair.

+*/

+struct NvBlastBond

+{

+	/**

+	Interface average normal

+	*/

+	float		normal[3];

+

+	/**

+	Area of interface

+	*/

+	float		area;

+

+	/**

+	Central position on the interface between chunks

+	*/

+	float		centroid[3];

+

+	/**

+	Extra data associated with bond, e.g. whether or not to create a joint

+	*/

+	uint32_t	userData;

+};

+

+

+/**

+Describes the connectivity between support chunks via bonds.

+

+Vertices in the support graph are termed "nodes," and represent particular chunks (NvBlastChunk) in an NvBlastAsset.

+The indexing for nodes is not the same as that for chunks.  Only some chunks are represented by nodes in the graph,

+and these chunks are called "support chunks."

+

+Adjacent node indices and adjacent bond indices are stored for each node, and therefore each bond is represented twice in this graph,

+going from node[i] -> node[j] and from node[j] -> node[i].  Therefore the size of the adjacentNodeIndices and adjacentBondIndices

+arrays are twice the number of bonds stored in the corresponding NvBlastAsset. 

+

+The graph is used as follows.  Given a NvBlastSupportGraph "graph" and node index i, (0 <= i < graph.nodeCount), one may find all

+adjacent bonds and nodes using:

+

+	// adj is the lookup value in graph.adjacentNodeIndices and graph.adjacentBondIndices

+	for (uint32_t adj = graph.adjacencyPartition[i]; adj < graph.adjacencyPartition[i+1]; ++adj)

+	{

+		// An adjacent node:

+		uint32_t adjacentNodeIndex = graph.adjacentNodeIndices[adj];

+	

+		// The corresponding bond (that connects node index i with node indexed adjacentNodeIndex:

+		uint32_t adjacentBondIndex = graph.adjacentBondIndices[adj];

+	}

+

+For a graph node with index i, the corresponding asset chunk index is found using graph.chunkIndices[i].  The reverse mapping

+(obtaining a graph node index from an asset chunk index) can be done using the

+

+	NvBlastAssetGetChunkToGraphNodeMap(asset, logFn)

+

+function.  See the documentation for its use.  The returned "node index" for a non-support chunk is the invalid value 0xFFFFFFFF.

+*/

+struct NvBlastSupportGraph

+{

+	/**

+	Total number of nodes in the support graph.

+	*/

+	uint32_t	nodeCount;

+

+	/**

+	Indices of chunks represented by the nodes, an array of size nodeCount.

+	*/

+	uint32_t*	chunkIndices;

+

+	/**

+	Partitions both the adjacentNodeIndices and the adjacentBondIndices arrays into subsets corresponding to each node.

+	The size of this array is nodeCount+1.

+	For 0 <= i < nodeCount, adjacencyPartition[i] is the index of the first element in adjacentNodeIndices (or adjacentBondIndices) for nodes adjacent to the node with index i.

+	adjacencyPartition[nodeCount] is the size of the adjacentNodeIndices and adjacentBondIndices arrays.

+	This allows one to easily count the number of nodes adjacent to a node with index i, using adjacencyPartition[i+1] - adjacencyPartition[i].

+	*/

+	uint32_t*	adjacencyPartition;

+

+	/**

+	Array composed of subarrays holding the indices of nodes adjacent to a given node.  The subarrays may be accessed through the adjacencyPartition array.

+	*/

+	uint32_t*	adjacentNodeIndices;

+

+	/**

+	Array composed of subarrays holding the indices of bonds (NvBlastBond) for a given node.  The subarrays may be accessed through the adjacencyPartition array.

+	*/

+	uint32_t*	adjacentBondIndices;

+};

+

+

+/**

+Asset (opaque)

+

+Static destructible data, used to create actor families.

+

+Pointer to this struct can be created with NvBlastCreateAsset.

+

+The NvBlastAsset includes a ID which may be used to match it with physics and graphics data.

+*/

+struct NvBlastAsset {};

+

+

+/**

+Chunk descriptor used to build an asset.  See NvBlastAssetDesc.

+*/

+struct NvBlastChunkDesc

+{

+	enum Flags

+	{

+		NoFlags = 0,

+

+		/** If this flag is set then the chunk will become a support chunk, unless an ancestor chunk is also marked as support. */

+		SupportFlag = (1 << 0)

+	};

+

+	/** Central position in chunk. */

+	float		centroid[3];

+

+	/** Volume of chunk. */

+	float		volume;

+

+	/** Index of this chunk's parent.  If this is a root chunk, then this value must be UINT32_MAX. */

+	uint32_t	parentChunkIndex;

+

+	/** See Flags enum for possible flags. */

+	uint32_t	flags;

+

+	/** User-supplied data which will be accessible to the user in chunk fracture events. */

+	uint32_t	userData;

+};

+

+

+/**

+Chunk bond descriptor used to build an asset.  See NvBlastAssetDesc.

+*/

+struct NvBlastBondDesc

+{

+	/** Bond data (see NvBlastBond). */

+	NvBlastBond	bond;

+

+	/**

+	The indices of the chunks linked by this bond.  They must be different support chunk indices.

+	If one of the chunk indices is the invalid index (UINT32_MAX), then this will create a bond between

+	the chunk indexed by the other index (which must be valid) and "the world."  Any actor containing

+	this bond will cause the function NvBlastActorIsBoundToWorld to return true.

+	*/

+	uint32_t	chunkIndices[2];

+};

+

+

+/**

+Asset descriptor, used to build an asset with NvBlastCreateAsset

+

+A valid asset descriptor must have a non-zero chunkCount and valid chunkDescs.

+

+The user may create an asset with no bonds (e.g. a single-chunk asset).  In this case bondCount should be

+zero and bondDescs is ignored.

+*/

+struct NvBlastAssetDesc

+{

+	/** The number of chunk descriptors. */

+	uint32_t				chunkCount;

+

+	/** Array of chunk descriptors of size chunkCount. */

+	const NvBlastChunkDesc*	chunkDescs;

+

+	/** The number of bond descriptors. */

+	uint32_t				bondCount;

+

+	/** Array of bond descriptors of size bondCount. */

+	const NvBlastBondDesc*	bondDescs;

+};

+

+///@} End NvBlastAsset related types

+

+

+///////////////////////////////////////////////////////////////////////////////

+//	NvBlastActor related types

+///////////////////////////////////////////////////////////////////////////////

+///@{

+

+/**

+Family (opaque)

+

+a family can be created by the NvBlastAssetCreateFamily function and released 

+by the NvBlastFamilyRelease.  Family is needed to create first actor.  All the following

+actors which can be created with NvBlastActorSplit function (as a result of fracture) will share the same family

+block.  NvBlastFamilyGetActorCount can be used to know if family can be safely released.

+*/

+struct NvBlastFamily {};

+

+

+/**

+Actor (opaque)

+

+Actors can be generated by the NvBlastFamilyCreateFirstActor

+and NvBlastActorSplit functions.  Opaque NvBlastActor pointers reference data within the family

+generated during NvBlastFamilyCreateFirstActor, and represent the actor in all actor-related API

+functions.

+*/

+struct NvBlastActor {};

+

+

+/**

+Actor descriptor, used to create an instance of an NvBlastAsset with NvBlastFamilyCreateFirstActor

+

+See NvBlastFamilyCreateFirstActor.

+*/

+struct NvBlastActorDesc

+{

+	/**

+	Initial health of all bonds, if initialBondHealths is NULL (see initialBondHealths).

+	*/

+	float			uniformInitialBondHealth;

+

+	/**

+	Initial bond healths.  If not NULL, this array must be of length NvBlastAssetGetChunkCount(asset, logFn).

+	If NULL, uniformInitialBondHealth must be set.

+	*/

+	const float*	initialBondHealths;

+

+	/**

+	Initial health of all lower-support chunks, if initialSupportChunkHealths is NULL (see initialSupportChunkHealths).

+	*/

+	float			uniformInitialLowerSupportChunkHealth;

+

+	/**

+	Initial health of all support chunks.  If not NULL, this must be of length

+	NvBlastAssetGetSupportChunkCount(asset, logFn).nodeCount. The elements in the initialSupportChunkHealth

+	array will correspond to the chunk indices in the NvBlastAssetGetSupportGraph(asset, logFn).chunkIndices

+	array.  Every descendent of a support chunk will have its health initialized to its ancestor support

+	chunk's health, so this initializes all lower-support chunk healths.

+	If NULL, uniformInitialLowerSupportChunkHealth must be set.

+	*/

+	const float*	initialSupportChunkHealths;

+};

+

+///@} End NvBlastActor related types

+

+

+///////////////////////////////////////////////////////////////////////////////

+//	Types used for damage and fracturing

+///////////////////////////////////////////////////////////////////////////////

+///@{

+

+

+/**

+Fracture Data for Chunks

+

+Data interpretation varies depending on the function used. 

+@see NvBlastActorGenerateFracture NvBlastActorApplyFracture NvBlastFractureBuffers

+*/

+struct NvBlastChunkFractureData

+{

+	uint32_t	userdata;	//!<	chunk's user data

+	uint32_t	chunkIndex;	//!<	asset chunk index

+	float		health;		//!<	health value (damage or remains)

+};

+

+

+/**

+Fracture Data for Bonds

+

+Data interpretation varies depending on the function used.

+@see NvBlastActorGenerateFracture NvBlastActorApplyFracture NvBlastFractureBuffers

+*/

+struct NvBlastBondFractureData

+{

+	uint32_t	userdata;	//!<	bond's user data

+	uint32_t	nodeIndex0;	//!<	graph node index of bond

+	uint32_t	nodeIndex1;	//!<	pair graph node index of bond

+	float		health;		//!<	health value (damage or remains)

+};

+

+

+/**

+Memory to be used by fracture functions.

+

+Used as input and output target.

+@see NvBlastActorGenerateFracture NvBlastActorApplyFracture

+*/

+struct NvBlastFractureBuffers

+{

+	uint32_t					bondFractureCount;		//!<	available elements in bondFractures

+	uint32_t					chunkFractureCount;		//!<	available elements in chunkFractures

+	NvBlastBondFractureData*	bondFractures;			//!<	memory to be filled by fracture functions

+	NvBlastChunkFractureData*	chunkFractures;			//!<	memory to be filled by fracture functions

+};

+

+

+/**

+Description of a NvBlastActorSplit result.

+This tells the user about changes in the actor, or creation of children.

+*/

+struct NvBlastActorSplitEvent

+{

+	NvBlastActor*	deletedActor;	//!<	deleted actor or nullptr if actor has not changed

+	NvBlastActor**	newActors;		//!<	list of created actors

+};

+

+

+/**

+A single actor's representation used by NvBlastGraphShaderFunction.

+*/

+struct NvBlastGraphShaderActor

+{

+	uint32_t			actorIndex;				//!<	Actor's index.

+	uint32_t			graphNodeCount;			//!<	Actor's graph node count.

+	uint32_t			assetNodeCount;			//!<	Asset node count.

+	uint32_t			firstGraphNodeIndex;	//!<	Entry index for graphNodeIndexLinks

+	const uint32_t*		graphNodeIndexLinks;	//!<	Linked index list of connected nodes.  Traversable with nextIndex = graphNodeIndexLinks[currentIndex], terminates with 0xFFFFFFFF.

+	const uint32_t*		chunkIndices;			//!<	Graph's map from node index to support chunk index.

+	const uint32_t*		adjacencyPartition;		//!<	See NvBlastSupportGraph::adjacencyPartition.

+	const uint32_t*		adjacentNodeIndices;	//!<	See NvBlastSupportGraph::adjacentNodeIndices.

+	const uint32_t*		adjacentBondIndices;	//!<	See NvBlastSupportGraph::adjacentBondIndices.

+	const NvBlastBond*	assetBonds;				//!<	NvBlastBonds geometry in the NvBlastAsset.

+	const NvBlastChunk*	assetChunks;			//!<	NvBlastChunks geometry in the NvBlastAsset.

+	const float*		familyBondHealths;		//!<	Actual bond health values for broken bond detection.

+	const float*		supportChunkHealths;	//!<	Actual chunk health values for dead chunk detection.

+	const uint32_t*		nodeActorIndices;		//!<	Family's map from node index to actor index.

+};

+

+

+/**

+A single actor's representation used by NvBlastSubgraphShaderFunction.

+*/

+struct NvBlastSubgraphShaderActor

+{

+	uint32_t			chunkIndex;		//!<	Index of chunk represented by this actor.

+	const NvBlastChunk*	assetChunks;	//!<	NvBlastChunks geometry in the NvBlastAsset.

+};

+

+

+/**

+Damage shader for actors with more then one node in support graph.

+

+From a an input actor data (NvBlastGraphShaderActor) and user custom data (params),

+creates a list of NvBlastFractureCommand to be applied to the respective NvBlastActor.

+

+\param[in,out]	commandBuffers			The resulting health damage to apply.

+										Typically requires an array of size (number of support chunks) + (number of bonds) of the processed asset

+										but may depend on the actual implementation.

+\param[in]		actor					The actor representation used for creating commands.

+\param[in]		programParams			A set of parameters defined by the damage shader implementer.

+

+Interpretation of NvBlastFractureBuffers:

+As input:

+Counters denote available entries for FractureData.

+Chunk and Bond userdata are not used.

+Health values are not used.

+

+As output:

+Counters denote valid entires in FractureData arrays.

+Chunks and Bond userdata reflect the respective userdata set during asset initialization.

+Health values denote how much damage is to be applied.

+

+@see NvBlastFractureBuffers NvBlastGraphShaderActor

+*/

+typedef void(*NvBlastGraphShaderFunction)(NvBlastFractureBuffers* commandBuffers, const NvBlastGraphShaderActor* actor, const void* programParams);

+

+

+/**

+Damage shader for actors with single chunk.

+

+From a an input actor data (NvBlastSubgraphShaderActor) and user custom data (params),

+creates a list of NvBlastFractureCommand to be applied to the respective NvBlastActor.

+

+\param[in,out]	commandBuffers			The resulting health damage to apply.

+										Typically requires an array of size (number of support chunks) + (number of bonds) of the processed asset

+										but may depend on the actual implementation.

+\param[in]		actor					The actor representation used for creating commands.

+\param[in]		programParams			A set of parameters defined by the damage shader implementer.

+

+Interpretation of NvBlastFractureBuffers:

+As input:

+Counters denote available entries for FractureData.

+Chunk and Bond userdata are not used.

+Health values are not used.

+

+As output:

+Counters denote valid entires in FractureData arrays.

+Chunks and Bond userdata reflect the respective userdata set during asset initialization.

+Health values denote how much damage is to be applied.

+

+@see NvBlastFractureBuffers NvBlastSubgraphShaderActor

+*/

+typedef void(*NvBlastSubgraphShaderFunction)(NvBlastFractureBuffers* commandBuffers, const NvBlastSubgraphShaderActor* actor, const void* programParams);

+

+

+/**

+Damage Program. 

+

+Contains both graph and subgraph shader. When used on actor appropriate shader will be called.

+Any shader can be nullptr to be skipped.

+

+@see NvBlastGraphShaderFunction NvBlastSubgraphShaderFunction

+*/

+struct NvBlastDamageProgram

+{

+	NvBlastGraphShaderFunction		graphShaderFunction;

+	NvBlastSubgraphShaderFunction	subgraphShaderFunction;

+};

+

+

+///@} End of types used for damage and fracturing

+

+

+#endif // ifndef NVBLASTTYPES_H

diff --git a/sdk/lowlevel/include/NvCTypes.h b/sdk/lowlevel/include/NvCTypes.h
index 563e832..8ac2fde 100644..100755
--- a/sdk/lowlevel/include/NvCTypes.h
+++ b/sdk/lowlevel/include/NvCTypes.h
@@ -1,125 +1,125 @@
-// This code contains NVIDIA Confidential Information and is disclosed to you
-// under a form of NVIDIA software license agreement provided separately to you.
-//
-// Notice
-// NVIDIA Corporation and its licensors retain all intellectual property and
-// proprietary rights in and to this software and related documentation and
-// any modifications thereto. Any use, reproduction, disclosure, or
-// distribution of this software and related documentation without an express
-// license agreement from NVIDIA Corporation is strictly prohibited.
-//
-// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
-// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
-// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
-// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
-//
-// Information and code furnished is believed to be accurate and reliable.
-// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
-// information or for any infringement of patents or other rights of third parties that may
-// result from its use. No license is granted by implication or otherwise under any patent
-// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
-// This code supersedes and replaces all information previously supplied.
-// NVIDIA Corporation products are not authorized for use as critical
-// components in life support devices or systems without express written approval of
-// NVIDIA Corporation.
-//
-// Copyright (c) 2008-2018 NVIDIA Corporation. All rights reserved.
-// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
-// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
-
-
-#ifndef NV_C_TYPES_H
-#define NV_C_TYPES_H
-
-#include "NvPreprocessor.h"
-#ifdef _MSC_VER
-#ifndef _INTPTR
-#define _INTPTR 0
-#endif
-#endif
-#include <stdint.h>
-
-/**  C type for 2-float vectors */
-typedef struct
-{
-	float x, y;
-} NvcVec2;
-
-/**  C type for 3-float vectors */
-typedef struct
-{
-	float x, y, z;
-} NvcVec3;
-
-/**  C type for 4-float vectors */
-typedef struct
-{
-	float x, y, z, w;
-} NvcVec4;
-
-/**  C type for quaternions */
-typedef struct
-{
-	float x, y, z, w;
-} NvcQuat;
-
-/**  C type for transforms */
-typedef struct
-{
-	NvcQuat q;
-	NvcVec3 p;
-} NvcTransform;
-
-/**  C type for 3x3 matrices */
-typedef struct
-{
-	NvcVec3 column0, column1, column2, column3;
-} NvcMat34;
-
-/**  C type for 3x3 matrices */
-typedef struct
-{
-	NvcVec3 column0, column1, column2;
-} NvcMat33;
-
-/**  C type for 4x4 matrices */
-typedef struct
-{
-	NvcVec4 column0, column1, column2, column3;
-} NvcMat44;
-
-/** C type for 3d bounding box */
-typedef struct
-{
-	NvcVec3 minimum;
-	NvcVec3 maximum;
-} NvcBounds3;
-
-/** C type for a plane */
-typedef struct
-{
-	NvcVec3 n;
-	float d;
-} NvcPlane;
-
-/**  C type for 2-integer vectors */
-typedef struct
-{
-	int32_t x, y;
-} NvcVec2i;
-
-/**  C type for 3-integer vectors */
-typedef struct
-{
-	int32_t x, y, z;
-} NvcVec3i;
-
-/**  C type for 4-integer vectors */
-typedef struct
-{
-	int32_t x, y, z, w;
-} NvcVec4i;
-
-/** @} */
-
-#endif // NV_C_TYPES_H
+// This code contains NVIDIA Confidential Information and is disclosed to you

+// under a form of NVIDIA software license agreement provided separately to you.

+//

+// Notice

+// NVIDIA Corporation and its licensors retain all intellectual property and

+// proprietary rights in and to this software and related documentation and

+// any modifications thereto. Any use, reproduction, disclosure, or

+// distribution of this software and related documentation without an express

+// license agreement from NVIDIA Corporation is strictly prohibited.

+//

+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES

+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO

+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,

+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.

+//

+// Information and code furnished is believed to be accurate and reliable.

+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such

+// information or for any infringement of patents or other rights of third parties that may

+// result from its use. No license is granted by implication or otherwise under any patent

+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.

+// This code supersedes and replaces all information previously supplied.

+// NVIDIA Corporation products are not authorized for use as critical

+// components in life support devices or systems without express written approval of

+// NVIDIA Corporation.

+//

+// Copyright (c) 2008-2018 NVIDIA Corporation. All rights reserved.

+// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.

+// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.

+

+

+#ifndef NV_C_TYPES_H

+#define NV_C_TYPES_H

+

+#include "NvPreprocessor.h"

+#ifdef _MSC_VER

+#ifndef _INTPTR

+#define _INTPTR 0

+#endif

+#endif

+#include <stdint.h>

+

+/**  C type for 2-float vectors */

+typedef struct

+{

+	float x, y;

+} NvcVec2;

+

+/**  C type for 3-float vectors */

+typedef struct

+{

+	float x, y, z;

+} NvcVec3;

+

+/**  C type for 4-float vectors */

+typedef struct

+{

+	float x, y, z, w;

+} NvcVec4;

+

+/**  C type for quaternions */

+typedef struct

+{

+	float x, y, z, w;

+} NvcQuat;

+

+/**  C type for transforms */

+typedef struct

+{

+	NvcQuat q;

+	NvcVec3 p;

+} NvcTransform;

+

+/**  C type for 3x3 matrices */

+typedef struct

+{

+	NvcVec3 column0, column1, column2, column3;

+} NvcMat34;

+

+/**  C type for 3x3 matrices */

+typedef struct

+{

+	NvcVec3 column0, column1, column2;

+} NvcMat33;

+

+/**  C type for 4x4 matrices */

+typedef struct

+{

+	NvcVec4 column0, column1, column2, column3;

+} NvcMat44;

+

+/** C type for 3d bounding box */

+typedef struct

+{

+	NvcVec3 minimum;

+	NvcVec3 maximum;

+} NvcBounds3;

+

+/** C type for a plane */

+typedef struct

+{

+	NvcVec3 n;

+	float d;

+} NvcPlane;

+

+/**  C type for 2-integer vectors */

+typedef struct

+{

+	int32_t x, y;

+} NvcVec2i;

+

+/**  C type for 3-integer vectors */

+typedef struct

+{

+	int32_t x, y, z;

+} NvcVec3i;

+

+/**  C type for 4-integer vectors */

+typedef struct

+{

+	int32_t x, y, z, w;

+} NvcVec4i;

+

+/** @} */

+

+#endif // NV_C_TYPES_H

diff --git a/sdk/lowlevel/include/NvPreprocessor.h b/sdk/lowlevel/include/NvPreprocessor.h
index e17673f..2cc0fa2 100644..100755
--- a/sdk/lowlevel/include/NvPreprocessor.h
+++ b/sdk/lowlevel/include/NvPreprocessor.h
@@ -1,540 +1,540 @@
-// This code contains NVIDIA Confidential Information and is disclosed to you
-// under a form of NVIDIA software license agreement provided separately to you.
-//
-// Notice
-// NVIDIA Corporation and its licensors retain all intellectual property and
-// proprietary rights in and to this software and related documentation and
-// any modifications thereto. Any use, reproduction, disclosure, or
-// distribution of this software and related documentation without an express
-// license agreement from NVIDIA Corporation is strictly prohibited.
-//
-// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
-// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
-// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
-// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
-//
-// Information and code furnished is believed to be accurate and reliable.
-// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
-// information or for any infringement of patents or other rights of third parties that may
-// result from its use. No license is granted by implication or otherwise under any patent
-// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
-// This code supersedes and replaces all information previously supplied.
-// NVIDIA Corporation products are not authorized for use as critical
-// components in life support devices or systems without express written approval of
-// NVIDIA Corporation.
-//
-// Copyright (c) 2008-2018 NVIDIA Corporation. All rights reserved.
-// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
-// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
-
-#ifndef NV_NVFOUNDATION_NVPREPROCESSOR_H
-#define NV_NVFOUNDATION_NVPREPROCESSOR_H
-
-#include <stddef.h>
-
-/** \addtogroup foundation
-  @{
-*/
-
-/*
-The following preprocessor identifiers specify compiler, OS, and architecture.
-All definitions have a value of 1 or 0, use '#if' instead of '#ifdef'.
-*/
-
-/**
-Compiler defines, see http://sourceforge.net/p/predef/wiki/Compilers/
-*/
-#if defined(_MSC_VER)
-#if _MSC_VER >= 1900
-#define NV_VC 14
-#elif _MSC_VER >= 1800
-#define NV_VC 12
-#elif _MSC_VER >= 1700
-#define NV_VC 11
-#elif _MSC_VER >= 1600
-#define NV_VC 10
-#elif _MSC_VER >= 1500
-#define NV_VC 9
-#else
-#error "Unknown VC version"
-#endif
-#elif defined(__clang__)
-#define NV_CLANG 1
-#elif defined(__SNC__)
-#define NV_SNC 1
-#elif defined(__ghs__)
-#define NV_GHS 1
-#elif defined(__GNUC__) // note: __clang__, __SNC__, or __ghs__ imply __GNUC__
-#define NV_GCC 1
-#else
-#error "Unknown compiler"
-#endif
-
-/**
-Operating system defines, see http://sourceforge.net/p/predef/wiki/OperatingSystems/
-*/
-#if defined(WINAPI_FAMILY) && WINAPI_FAMILY == WINAPI_PARTITION_APP
-#define NV_WINRT 1 // Windows Runtime, either on Windows RT or Windows 8
-#elif defined(XBOXONE) || defined(_XBOX_ONE)
-#define NV_XBOXONE 1
-#elif defined(_WIN64) // note: XBOXONE implies _WIN64
-#define NV_WIN64 1
-#elif defined(_M_PPC)
-#define NV_X360 1
-#elif defined(_WIN32) // note: _M_PPC implies _WIN32
-#define NV_WIN32 1
-#elif defined(__ANDROID__)
-#define NV_ANDROID 1
-#elif defined(__linux__) // note: __ANDROID__ implies __linux__
-#define NV_LINUX 1
-#elif defined(__APPLE__) && (defined(__arm__) || defined(__arm64__))
-#define NV_IOS 1
-#elif defined(__APPLE__)
-#define NV_OSX 1
-#elif defined(__CELLOS_LV2__)
-#define NV_PS3 1
-#elif defined(__ORBIS__)
-#define NV_PS4 1
-#elif defined(__SNC__) && defined(__arm__)
-#define NV_PSP2 1
-#elif defined(__ghs__)
-#define NV_WIIU 1
-#else
-#error "Unknown operating system"
-#endif
-
-/**
-Architecture defines, see http://sourceforge.net/p/predef/wiki/Architectures/
-*/
-#if defined(__x86_64__) || defined(_M_X64) // ps4 compiler defines _M_X64 without value
-#define NV_X64 1
-#elif defined(__i386__) || defined(_M_IX86)
-#define NV_X86 1
-#elif defined(__arm64__) || defined(__aarch64__)
-#define NV_A64 1
-#elif defined(__arm__) || defined(_M_ARM)
-#define NV_ARM 1
-#elif defined(__SPU__)
-#define NV_SPU 1
-#elif defined(__ppc__) || defined(_M_PPC) || defined(__CELLOS_LV2__)
-#define NV_PPC 1
-#else
-#error "Unknown architecture"
-#endif
-
-/**
-SIMD defines
-*/
-#if defined(__i386__) || defined(_M_IX86) || defined(__x86_64__) || defined(_M_X64)
-#define NV_SSE2 1
-#endif
-#if defined(_M_ARM) || defined(__ARM_NEON__)
-#define NV_NEON 1
-#endif
-#if defined(_M_PPC) || defined(__CELLOS_LV2__)
-#define NV_VMX 1
-#endif
-
-/**
-define anything not defined on this platform to 0
-*/
-#ifndef NV_VC
-#define NV_VC 0
-#endif
-#ifndef NV_CLANG
-#define NV_CLANG 0
-#endif
-#ifndef NV_SNC
-#define NV_SNC 0
-#endif
-#ifndef NV_GHS
-#define NV_GHS 0
-#endif
-#ifndef NV_GCC
-#define NV_GCC 0
-#endif
-#ifndef NV_WINRT
-#define NV_WINRT 0
-#endif
-#ifndef NV_XBOXONE
-#define NV_XBOXONE 0
-#endif
-#ifndef NV_WIN64
-#define NV_WIN64 0
-#endif
-#ifndef NV_X360
-#define NV_X360 0
-#endif
-#ifndef NV_WIN32
-#define NV_WIN32 0
-#endif
-#ifndef NV_ANDROID
-#define NV_ANDROID 0
-#endif
-#ifndef NV_LINUX
-#define NV_LINUX 0
-#endif
-#ifndef NV_IOS
-#define NV_IOS 0
-#endif
-#ifndef NV_OSX
-#define NV_OSX 0
-#endif
-#ifndef NV_PS3
-#define NV_PS3 0
-#endif
-#ifndef NV_PS4
-#define NV_PS4 0
-#endif
-#ifndef NV_PSP2
-#define NV_PSP2 0
-#endif
-#ifndef NV_WIIU
-#define NV_WIIU 0
-#endif
-#ifndef NV_X64
-#define NV_X64 0
-#endif
-#ifndef NV_X86
-#define NV_X86 0
-#endif
-#ifndef NV_A64
-#define NV_A64 0
-#endif
-#ifndef NV_ARM
-#define NV_ARM 0
-#endif
-#ifndef NV_SPU
-#define NV_SPU 0
-#endif
-#ifndef NV_PPC
-#define NV_PPC 0
-#endif
-#ifndef NV_SSE2
-#define NV_SSE2 0
-#endif
-#ifndef NV_NEON
-#define NV_NEON 0
-#endif
-#ifndef NV_VMX
-#define NV_VMX 0
-#endif
-
-/*
-define anything not defined through the command line to 0
-*/
-#ifndef NV_DEBUG
-#define NV_DEBUG 0
-#endif
-#ifndef NV_CHECKED
-#define NV_CHECKED 0
-#endif
-#ifndef NV_PROFILE
-#define NV_PROFILE 0
-#endif
-#ifndef NV_NVTX
-#define NV_NVTX 0
-#endif
-#ifndef NV_DOXYGEN
-#define NV_DOXYGEN 0
-#endif
-
-/**
-family shortcuts
-*/
-// compiler
-#define NV_GCC_FAMILY (NV_CLANG || NV_SNC || NV_GHS || NV_GCC)
-// os
-#define NV_WINDOWS_FAMILY (NV_WINRT || NV_WIN32 || NV_WIN64)
-#define NV_MICROSOFT_FAMILY (NV_XBOXONE || NV_X360 || NV_WINDOWS_FAMILY)
-#define NV_LINUX_FAMILY (NV_LINUX || NV_ANDROID)
-#define NV_APPLE_FAMILY (NV_IOS || NV_OSX)                  // equivalent to #if __APPLE__
-#define NV_UNIX_FAMILY (NV_LINUX_FAMILY || NV_APPLE_FAMILY) // shortcut for unix/posix platforms
-// architecture
-#define NV_INTEL_FAMILY (NV_X64 || NV_X86)
-#define NV_ARM_FAMILY (NV_ARM || NV_A64)
-#define NV_P64_FAMILY (NV_X64 || NV_A64) // shortcut for 64-bit architectures
-
-// shortcut for PS3 PPU
-#define NV_PPU (NV_PS3&& NV_PPC)
-
-/**
-Assert macro
-*/
-#ifndef NV_ENABLE_ASSERTS
-#if NV_DEBUG && !defined(__CUDACC__)
-#define NV_ENABLE_ASSERTS 1
-#else
-#define NV_ENABLE_ASSERTS 0
-#endif
-#endif
-
-/**
-DLL export macros
-*/
-#ifndef NV_C_EXPORT
-#if NV_WINDOWS_FAMILY || NV_LINUX || NV_PS4 || NV_XBOXONE
-#define NV_C_EXPORT extern "C"
-#else
-#define NV_C_EXPORT
-#endif
-#endif
-
-#if NV_UNIX_FAMILY && __GNUC__ >= 4
-#define NV_UNIX_EXPORT __attribute__((visibility("default")))
-#else
-#define NV_UNIX_EXPORT
-#endif
-
-#if NV_WINDOWS_FAMILY
-#define NV_DLL_EXPORT __declspec(dllexport)
-#define NV_DLL_IMPORT __declspec(dllimport)
-#else
-#define NV_DLL_EXPORT NV_UNIX_EXPORT
-#define NV_DLL_IMPORT
-#endif
-
-/**
-Define API function declaration
-
-NV_FOUNDATION_DLL=1 - used by the DLL library (PhysXCommon) to export the API
-NV_FOUNDATION_DLL=0 - for windows configurations where the NV_FOUNDATION_API is linked through standard static linking
-no definition       - this will allow DLLs and libraries to use the exported API from PhysXCommon
-
-*/
-
-#if NV_WINDOWS_FAMILY && !NV_ARM_FAMILY || NV_WINRT
-#ifndef NV_FOUNDATION_DLL
-#define NV_FOUNDATION_API NV_DLL_IMPORT
-#elif NV_FOUNDATION_DLL
-#define NV_FOUNDATION_API NV_DLL_EXPORT
-#endif
-#elif NV_UNIX_FAMILY
-#ifdef NV_FOUNDATION_DLL
-#define NV_FOUNDATION_API NV_UNIX_EXPORT
-#endif
-#endif
-
-#ifndef NV_FOUNDATION_API
-#define NV_FOUNDATION_API
-#endif
-
-/**
-Calling convention
-*/
-#ifndef NV_CALL_CONV
-#if NV_MICROSOFT_FAMILY
-#define NV_CALL_CONV __cdecl
-#else
-#define NV_CALL_CONV
-#endif
-#endif
-
-/**
-Pack macros - disabled on SPU because they are not supported
-*/
-#if NV_VC
-#define NV_PUSH_PACK_DEFAULT __pragma(pack(push, 8))
-#define NV_POP_PACK __pragma(pack(pop))
-#elif NV_GCC_FAMILY && !NV_SPU
-#define NV_PUSH_PACK_DEFAULT _Pragma("pack(push, 8)")
-#define NV_POP_PACK _Pragma("pack(pop)")
-#else
-#define NV_PUSH_PACK_DEFAULT
-#define NV_POP_PACK
-#endif
-
-/**
-Inline macro
-*/
-#define NV_INLINE inline
-#if NV_MICROSOFT_FAMILY
-#pragma inline_depth(255)
-#endif
-
-/**
-Force inline macro
-*/
-#if NV_VC
-#define NV_FORCE_INLINE __forceinline
-#elif NV_LINUX // Workaround; Fedora Core 3 do not agree with force inline and NvcPool
-#define NV_FORCE_INLINE inline
-#elif NV_GCC_FAMILY
-#define NV_FORCE_INLINE inline __attribute__((always_inline))
-#else
-#define NV_FORCE_INLINE inline
-#endif
-
-/**
-Noinline macro
-*/
-#if NV_MICROSOFT_FAMILY
-#define NV_NOINLINE __declspec(noinline)
-#elif NV_GCC_FAMILY
-#define NV_NOINLINE __attribute__((noinline))
-#else
-#define NV_NOINLINE
-#endif
-
-/**
-Restrict macro
-*/
-#if defined(__CUDACC__)
-#define NV_RESTRICT __restrict__
-#else
-#define NV_RESTRICT __restrict
-#endif
-
-/**
-Noalias macro
-*/
-#if NV_MICROSOFT_FAMILY
-#define NV_NOALIAS __declspec(noalias)
-#else
-#define NV_NOALIAS
-#endif
-
-/**
-Alignment macros
-
-NV_ALIGN_PREFIX and NV_ALIGN_SUFFIX can be used for type alignment instead of aligning individual variables as follows:
-NV_ALIGN_PREFIX(16)
-struct A {
-...
-} NV_ALIGN_SUFFIX(16);
-This declaration style is parsed correctly by Visual Assist.
-
-*/
-#ifndef NV_ALIGN
-#if NV_MICROSOFT_FAMILY
-#define NV_ALIGN(alignment, decl) __declspec(align(alignment)) decl
-#define NV_ALIGN_PREFIX(alignment) __declspec(align(alignment))
-#define NV_ALIGN_SUFFIX(alignment)
-#elif NV_GCC_FAMILY
-#define NV_ALIGN(alignment, decl) decl __attribute__((aligned(alignment)))
-#define NV_ALIGN_PREFIX(alignment)
-#define NV_ALIGN_SUFFIX(alignment) __attribute__((aligned(alignment)))
-#else
-#define NV_ALIGN(alignment, decl)
-#define NV_ALIGN_PREFIX(alignment)
-#define NV_ALIGN_SUFFIX(alignment)
-#endif
-#endif
-
-/**
-Deprecated macro
-- To deprecate a function: Place NV_DEPRECATED at the start of the function header (leftmost word).
-- To deprecate a 'typedef', a 'struct' or a 'class': Place NV_DEPRECATED directly after the keywords ('typdef',
-'struct', 'class').
-
-Use these macro definitions to create warnings for deprecated functions
-#define NV_DEPRECATED __declspec(deprecated) // Microsoft
-#define NV_DEPRECATED __attribute__((deprecated())) // GCC
-*/
-#define NV_DEPRECATED
-
-/**
-General defines
-*/
-
-// static assert
-#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) || defined(__ORBIS__)
-#define NV_COMPILE_TIME_ASSERT(exp) typedef char NvCompileTimeAssert_Dummy[(exp) ? 1 : -1] __attribute__((unused))
-#else
-#define NV_COMPILE_TIME_ASSERT(exp) typedef char NvCompileTimeAssert_Dummy[(exp) ? 1 : -1]
-#endif
-
-#if NV_GCC_FAMILY && !NV_SNC && !NV_GHS
-#define NV_OFFSET_OF(X, Y) __builtin_offsetof(X, Y)
-#else
-#define NV_OFFSET_OF(X, Y) offsetof(X, Y)
-#endif
-
-#define NV_OFFSETOF_BASE 0x100 // casting the null ptr takes a special-case code path, which we don't want
-#define NV_OFFSET_OF_RT(Class, Member)                                                                                 \
-	(reinterpret_cast<size_t>(&reinterpret_cast<Class*>(NV_OFFSETOF_BASE)->Member) - size_t(NV_OFFSETOF_BASE))
-
-// check that exactly one of NDEBUG and _DEBUG is defined
-#if !defined(NDEBUG) ^ defined(_DEBUG)
-#error Exactly one of NDEBUG and _DEBUG needs to be defined!
-#endif
-
-// make sure NV_CHECKED is defined in all _DEBUG configurations as well
-#if !defined(NV_CHECKED) && defined(NV_DEBUG)
-#error NV_CHECKED must be defined when NV_DEBUG is defined
-#endif
-
-#ifdef __CUDACC__
-#define NV_CUDA_CALLABLE __host__ __device__
-#else
-#define NV_CUDA_CALLABLE
-#endif
-
-// avoid unreferenced parameter warning
-// preferred solution: omit the parameter's name from the declaration
-template <class T>
-NV_CUDA_CALLABLE NV_INLINE void NV_UNUSED(T const&)
-{
-}
-
-// Ensure that the application hasn't tweaked the pack value to less than 8, which would break
-// matching between the API headers and the binaries
-// This assert works on win32/win64/360/ps3, but may need further specialization on other platforms.
-// Some GCC compilers need the compiler flag -malign-double to be set.
-// Apparently the apple-clang-llvm compiler doesn't support malign-double.
-#if NV_PS4 || NV_APPLE_FAMILY
-struct NvPackValidation
-{
-	char _;
-	long a;
-};
-#elif NV_ANDROID
-struct NvPackValidation
-{
-	char _;
-	double a;
-};
-#else
-struct NvPackValidation
-{
-	char _;
-	long long a;
-};
-#endif
-#if !NV_APPLE_FAMILY
-NV_COMPILE_TIME_ASSERT(NV_OFFSET_OF(NvPackValidation, a) == 8);
-#endif
-
-// use in a cpp file to suppress LNK4221
-#if NV_VC
-#define NV_DUMMY_SYMBOL                                                                                                \
-	namespace                                                                                                          \
-	{                                                                                                                  \
-	char NvDummySymbol;                                                                                                \
-	}
-#else
-#define NV_DUMMY_SYMBOL
-#endif
-
-#if NV_GCC_FAMILY && !NV_GHS
-#define NV_WEAK_SYMBOL __attribute__((weak)) // this is to support SIMD constant merging in template specialization
-#else
-#define NV_WEAK_SYMBOL
-#endif
-
-// Macro for avoiding default assignment and copy, because doing this by inheritance can increase class size on some
-// platforms.
-#define NV_NOCOPY(Class)                                                                                               \
-	\
-protected:                                                                                                             \
-	Class(const Class&);                                                                                               \
-	Class& operator=(const Class&);
-
-#define NV_STRINGIZE_HELPER(X) #X
-#define NV_STRINGIZE(X) NV_STRINGIZE_HELPER(X)
-
-#define NV_CONCAT_HELPER(X, Y) X##Y
-#define NV_CONCAT(X, Y) NV_CONCAT_HELPER(X, Y)
-
-/** @} */
-#endif // #ifndef NV_NVFOUNDATION_NVPREPROCESSOR_H
+// This code contains NVIDIA Confidential Information and is disclosed to you

+// under a form of NVIDIA software license agreement provided separately to you.

+//

+// Notice

+// NVIDIA Corporation and its licensors retain all intellectual property and

+// proprietary rights in and to this software and related documentation and

+// any modifications thereto. Any use, reproduction, disclosure, or

+// distribution of this software and related documentation without an express

+// license agreement from NVIDIA Corporation is strictly prohibited.

+//

+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES

+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO

+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,

+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.

+//

+// Information and code furnished is believed to be accurate and reliable.

+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such

+// information or for any infringement of patents or other rights of third parties that may

+// result from its use. No license is granted by implication or otherwise under any patent

+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.

+// This code supersedes and replaces all information previously supplied.

+// NVIDIA Corporation products are not authorized for use as critical

+// components in life support devices or systems without express written approval of

+// NVIDIA Corporation.

+//

+// Copyright (c) 2008-2018 NVIDIA Corporation. All rights reserved.

+// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.

+// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.

+

+#ifndef NV_NVFOUNDATION_NVPREPROCESSOR_H

+#define NV_NVFOUNDATION_NVPREPROCESSOR_H

+

+#include <stddef.h>

+

+/** \addtogroup foundation

+  @{

+*/

+

+/*

+The following preprocessor identifiers specify compiler, OS, and architecture.

+All definitions have a value of 1 or 0, use '#if' instead of '#ifdef'.

+*/

+

+/**

+Compiler defines, see http://sourceforge.net/p/predef/wiki/Compilers/

+*/

+#if defined(_MSC_VER)

+#if _MSC_VER >= 1900

+#define NV_VC 14

+#elif _MSC_VER >= 1800

+#define NV_VC 12

+#elif _MSC_VER >= 1700

+#define NV_VC 11

+#elif _MSC_VER >= 1600

+#define NV_VC 10

+#elif _MSC_VER >= 1500

+#define NV_VC 9

+#else

+#error "Unknown VC version"

+#endif

+#elif defined(__clang__)

+#define NV_CLANG 1

+#elif defined(__SNC__)

+#define NV_SNC 1

+#elif defined(__ghs__)

+#define NV_GHS 1

+#elif defined(__GNUC__) // note: __clang__, __SNC__, or __ghs__ imply __GNUC__

+#define NV_GCC 1

+#else

+#error "Unknown compiler"

+#endif

+

+/**

+Operating system defines, see http://sourceforge.net/p/predef/wiki/OperatingSystems/

+*/

+#if defined(WINAPI_FAMILY) && WINAPI_FAMILY == WINAPI_PARTITION_APP

+#define NV_WINRT 1 // Windows Runtime, either on Windows RT or Windows 8

+#elif defined(XBOXONE) || defined(_XBOX_ONE)

+#define NV_XBOXONE 1

+#elif defined(_WIN64) // note: XBOXONE implies _WIN64

+#define NV_WIN64 1

+#elif defined(_M_PPC)

+#define NV_X360 1

+#elif defined(_WIN32) // note: _M_PPC implies _WIN32

+#define NV_WIN32 1

+#elif defined(__ANDROID__)

+#define NV_ANDROID 1

+#elif defined(__linux__) // note: __ANDROID__ implies __linux__

+#define NV_LINUX 1

+#elif defined(__APPLE__) && (defined(__arm__) || defined(__arm64__))

+#define NV_IOS 1

+#elif defined(__APPLE__)

+#define NV_OSX 1

+#elif defined(__CELLOS_LV2__)

+#define NV_PS3 1

+#elif defined(__ORBIS__)

+#define NV_PS4 1

+#elif defined(__SNC__) && defined(__arm__)

+#define NV_PSP2 1

+#elif defined(__ghs__)

+#define NV_WIIU 1

+#else

+#error "Unknown operating system"

+#endif

+

+/**

+Architecture defines, see http://sourceforge.net/p/predef/wiki/Architectures/

+*/

+#if defined(__x86_64__) || defined(_M_X64) // ps4 compiler defines _M_X64 without value

+#define NV_X64 1

+#elif defined(__i386__) || defined(_M_IX86)

+#define NV_X86 1

+#elif defined(__arm64__) || defined(__aarch64__)

+#define NV_A64 1

+#elif defined(__arm__) || defined(_M_ARM)

+#define NV_ARM 1

+#elif defined(__SPU__)

+#define NV_SPU 1

+#elif defined(__ppc__) || defined(_M_PPC) || defined(__CELLOS_LV2__)

+#define NV_PPC 1

+#else

+#error "Unknown architecture"

+#endif

+

+/**

+SIMD defines

+*/

+#if defined(__i386__) || defined(_M_IX86) || defined(__x86_64__) || defined(_M_X64)

+#define NV_SSE2 1

+#endif

+#if defined(_M_ARM) || defined(__ARM_NEON__)

+#define NV_NEON 1

+#endif

+#if defined(_M_PPC) || defined(__CELLOS_LV2__)

+#define NV_VMX 1

+#endif

+

+/**

+define anything not defined on this platform to 0

+*/

+#ifndef NV_VC

+#define NV_VC 0

+#endif

+#ifndef NV_CLANG

+#define NV_CLANG 0

+#endif

+#ifndef NV_SNC

+#define NV_SNC 0

+#endif

+#ifndef NV_GHS

+#define NV_GHS 0

+#endif

+#ifndef NV_GCC

+#define NV_GCC 0

+#endif

+#ifndef NV_WINRT

+#define NV_WINRT 0

+#endif

+#ifndef NV_XBOXONE

+#define NV_XBOXONE 0

+#endif

+#ifndef NV_WIN64

+#define NV_WIN64 0

+#endif

+#ifndef NV_X360

+#define NV_X360 0

+#endif

+#ifndef NV_WIN32

+#define NV_WIN32 0

+#endif

+#ifndef NV_ANDROID

+#define NV_ANDROID 0

+#endif

+#ifndef NV_LINUX

+#define NV_LINUX 0

+#endif

+#ifndef NV_IOS

+#define NV_IOS 0

+#endif

+#ifndef NV_OSX

+#define NV_OSX 0

+#endif

+#ifndef NV_PS3

+#define NV_PS3 0

+#endif

+#ifndef NV_PS4

+#define NV_PS4 0

+#endif

+#ifndef NV_PSP2

+#define NV_PSP2 0

+#endif

+#ifndef NV_WIIU

+#define NV_WIIU 0

+#endif

+#ifndef NV_X64

+#define NV_X64 0

+#endif

+#ifndef NV_X86

+#define NV_X86 0

+#endif

+#ifndef NV_A64

+#define NV_A64 0

+#endif

+#ifndef NV_ARM

+#define NV_ARM 0

+#endif

+#ifndef NV_SPU

+#define NV_SPU 0

+#endif

+#ifndef NV_PPC

+#define NV_PPC 0

+#endif

+#ifndef NV_SSE2

+#define NV_SSE2 0

+#endif

+#ifndef NV_NEON

+#define NV_NEON 0

+#endif

+#ifndef NV_VMX

+#define NV_VMX 0

+#endif

+

+/*

+define anything not defined through the command line to 0

+*/

+#ifndef NV_DEBUG

+#define NV_DEBUG 0

+#endif

+#ifndef NV_CHECKED

+#define NV_CHECKED 0

+#endif

+#ifndef NV_PROFILE

+#define NV_PROFILE 0

+#endif

+#ifndef NV_NVTX

+#define NV_NVTX 0

+#endif

+#ifndef NV_DOXYGEN

+#define NV_DOXYGEN 0

+#endif

+

+/**

+family shortcuts

+*/

+// compiler

+#define NV_GCC_FAMILY (NV_CLANG || NV_SNC || NV_GHS || NV_GCC)

+// os

+#define NV_WINDOWS_FAMILY (NV_WINRT || NV_WIN32 || NV_WIN64)

+#define NV_MICROSOFT_FAMILY (NV_XBOXONE || NV_X360 || NV_WINDOWS_FAMILY)

+#define NV_LINUX_FAMILY (NV_LINUX || NV_ANDROID)

+#define NV_APPLE_FAMILY (NV_IOS || NV_OSX)                  // equivalent to #if __APPLE__

+#define NV_UNIX_FAMILY (NV_LINUX_FAMILY || NV_APPLE_FAMILY) // shortcut for unix/posix platforms

+// architecture

+#define NV_INTEL_FAMILY (NV_X64 || NV_X86)

+#define NV_ARM_FAMILY (NV_ARM || NV_A64)

+#define NV_P64_FAMILY (NV_X64 || NV_A64) // shortcut for 64-bit architectures

+

+// shortcut for PS3 PPU

+#define NV_PPU (NV_PS3&& NV_PPC)

+

+/**

+Assert macro

+*/

+#ifndef NV_ENABLE_ASSERTS

+#if NV_DEBUG && !defined(__CUDACC__)

+#define NV_ENABLE_ASSERTS 1

+#else

+#define NV_ENABLE_ASSERTS 0

+#endif

+#endif

+

+/**

+DLL export macros

+*/

+#ifndef NV_C_EXPORT

+#if NV_WINDOWS_FAMILY || NV_LINUX || NV_PS4 || NV_XBOXONE

+#define NV_C_EXPORT extern "C"

+#else

+#define NV_C_EXPORT

+#endif

+#endif

+

+#if NV_UNIX_FAMILY && __GNUC__ >= 4

+#define NV_UNIX_EXPORT __attribute__((visibility("default")))

+#else

+#define NV_UNIX_EXPORT

+#endif

+

+#if NV_WINDOWS_FAMILY

+#define NV_DLL_EXPORT __declspec(dllexport)

+#define NV_DLL_IMPORT __declspec(dllimport)

+#else

+#define NV_DLL_EXPORT NV_UNIX_EXPORT

+#define NV_DLL_IMPORT

+#endif

+

+/**

+Define API function declaration

+

+NV_FOUNDATION_DLL=1 - used by the DLL library (PhysXCommon) to export the API

+NV_FOUNDATION_DLL=0 - for windows configurations where the NV_FOUNDATION_API is linked through standard static linking

+no definition       - this will allow DLLs and libraries to use the exported API from PhysXCommon

+

+*/

+

+#if NV_WINDOWS_FAMILY && !NV_ARM_FAMILY || NV_WINRT

+#ifndef NV_FOUNDATION_DLL

+#define NV_FOUNDATION_API NV_DLL_IMPORT

+#elif NV_FOUNDATION_DLL

+#define NV_FOUNDATION_API NV_DLL_EXPORT

+#endif

+#elif NV_UNIX_FAMILY

+#ifdef NV_FOUNDATION_DLL

+#define NV_FOUNDATION_API NV_UNIX_EXPORT

+#endif

+#endif

+

+#ifndef NV_FOUNDATION_API

+#define NV_FOUNDATION_API

+#endif

+

+/**

+Calling convention

+*/

+#ifndef NV_CALL_CONV

+#if NV_MICROSOFT_FAMILY

+#define NV_CALL_CONV __cdecl

+#else

+#define NV_CALL_CONV

+#endif

+#endif

+

+/**

+Pack macros - disabled on SPU because they are not supported

+*/

+#if NV_VC

+#define NV_PUSH_PACK_DEFAULT __pragma(pack(push, 8))

+#define NV_POP_PACK __pragma(pack(pop))

+#elif NV_GCC_FAMILY && !NV_SPU

+#define NV_PUSH_PACK_DEFAULT _Pragma("pack(push, 8)")

+#define NV_POP_PACK _Pragma("pack(pop)")

+#else

+#define NV_PUSH_PACK_DEFAULT

+#define NV_POP_PACK

+#endif

+

+/**

+Inline macro

+*/

+#define NV_INLINE inline

+#if NV_MICROSOFT_FAMILY

+#pragma inline_depth(255)

+#endif

+

+/**

+Force inline macro

+*/

+#if NV_VC

+#define NV_FORCE_INLINE __forceinline

+#elif NV_LINUX // Workaround; Fedora Core 3 do not agree with force inline and NvcPool

+#define NV_FORCE_INLINE inline

+#elif NV_GCC_FAMILY

+#define NV_FORCE_INLINE inline __attribute__((always_inline))

+#else

+#define NV_FORCE_INLINE inline

+#endif

+

+/**

+Noinline macro

+*/

+#if NV_MICROSOFT_FAMILY

+#define NV_NOINLINE __declspec(noinline)

+#elif NV_GCC_FAMILY

+#define NV_NOINLINE __attribute__((noinline))

+#else

+#define NV_NOINLINE

+#endif

+

+/**

+Restrict macro

+*/

+#if defined(__CUDACC__)

+#define NV_RESTRICT __restrict__

+#else

+#define NV_RESTRICT __restrict

+#endif

+

+/**

+Noalias macro

+*/

+#if NV_MICROSOFT_FAMILY

+#define NV_NOALIAS __declspec(noalias)

+#else

+#define NV_NOALIAS

+#endif

+

+/**

+Alignment macros

+

+NV_ALIGN_PREFIX and NV_ALIGN_SUFFIX can be used for type alignment instead of aligning individual variables as follows:

+NV_ALIGN_PREFIX(16)

+struct A {

+...

+} NV_ALIGN_SUFFIX(16);

+This declaration style is parsed correctly by Visual Assist.

+

+*/

+#ifndef NV_ALIGN

+#if NV_MICROSOFT_FAMILY

+#define NV_ALIGN(alignment, decl) __declspec(align(alignment)) decl

+#define NV_ALIGN_PREFIX(alignment) __declspec(align(alignment))

+#define NV_ALIGN_SUFFIX(alignment)

+#elif NV_GCC_FAMILY

+#define NV_ALIGN(alignment, decl) decl __attribute__((aligned(alignment)))

+#define NV_ALIGN_PREFIX(alignment)

+#define NV_ALIGN_SUFFIX(alignment) __attribute__((aligned(alignment)))

+#else

+#define NV_ALIGN(alignment, decl)

+#define NV_ALIGN_PREFIX(alignment)

+#define NV_ALIGN_SUFFIX(alignment)

+#endif

+#endif

+

+/**

+Deprecated macro

+- To deprecate a function: Place NV_DEPRECATED at the start of the function header (leftmost word).

+- To deprecate a 'typedef', a 'struct' or a 'class': Place NV_DEPRECATED directly after the keywords ('typdef',

+'struct', 'class').

+

+Use these macro definitions to create warnings for deprecated functions

+#define NV_DEPRECATED __declspec(deprecated) // Microsoft

+#define NV_DEPRECATED __attribute__((deprecated())) // GCC

+*/

+#define NV_DEPRECATED

+

+/**

+General defines

+*/

+

+// static assert

+#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) || defined(__ORBIS__)

+#define NV_COMPILE_TIME_ASSERT(exp) typedef char NvCompileTimeAssert_Dummy[(exp) ? 1 : -1] __attribute__((unused))

+#else

+#define NV_COMPILE_TIME_ASSERT(exp) typedef char NvCompileTimeAssert_Dummy[(exp) ? 1 : -1]

+#endif

+

+#if NV_GCC_FAMILY && !NV_SNC && !NV_GHS

+#define NV_OFFSET_OF(X, Y) __builtin_offsetof(X, Y)

+#else

+#define NV_OFFSET_OF(X, Y) offsetof(X, Y)

+#endif

+

+#define NV_OFFSETOF_BASE 0x100 // casting the null ptr takes a special-case code path, which we don't want

+#define NV_OFFSET_OF_RT(Class, Member)                                                                                 \

+	(reinterpret_cast<size_t>(&reinterpret_cast<Class*>(NV_OFFSETOF_BASE)->Member) - size_t(NV_OFFSETOF_BASE))

+

+// check that exactly one of NDEBUG and _DEBUG is defined

+#if !defined(NDEBUG) ^ defined(_DEBUG)

+#error Exactly one of NDEBUG and _DEBUG needs to be defined!

+#endif

+

+// make sure NV_CHECKED is defined in all _DEBUG configurations as well

+#if !defined(NV_CHECKED) && defined(NV_DEBUG)

+#error NV_CHECKED must be defined when NV_DEBUG is defined

+#endif

+

+#ifdef __CUDACC__

+#define NV_CUDA_CALLABLE __host__ __device__

+#else

+#define NV_CUDA_CALLABLE

+#endif

+

+// avoid unreferenced parameter warning

+// preferred solution: omit the parameter's name from the declaration

+template <class T>

+NV_CUDA_CALLABLE NV_INLINE void NV_UNUSED(T const&)

+{

+}

+

+// Ensure that the application hasn't tweaked the pack value to less than 8, which would break

+// matching between the API headers and the binaries

+// This assert works on win32/win64/360/ps3, but may need further specialization on other platforms.

+// Some GCC compilers need the compiler flag -malign-double to be set.

+// Apparently the apple-clang-llvm compiler doesn't support malign-double.

+#if NV_PS4 || NV_APPLE_FAMILY

+struct NvPackValidation

+{

+	char _;

+	long a;

+};

+#elif NV_ANDROID

+struct NvPackValidation

+{

+	char _;

+	double a;

+};

+#else

+struct NvPackValidation

+{

+	char _;

+	long long a;

+};

+#endif

+#if !NV_APPLE_FAMILY

+NV_COMPILE_TIME_ASSERT(NV_OFFSET_OF(NvPackValidation, a) == 8);

+#endif

+

+// use in a cpp file to suppress LNK4221

+#if NV_VC

+#define NV_DUMMY_SYMBOL                                                                                                \

+	namespace                                                                                                          \

+	{                                                                                                                  \

+	char NvDummySymbol;                                                                                                \

+	}

+#else

+#define NV_DUMMY_SYMBOL

+#endif

+

+#if NV_GCC_FAMILY && !NV_GHS

+#define NV_WEAK_SYMBOL __attribute__((weak)) // this is to support SIMD constant merging in template specialization

+#else

+#define NV_WEAK_SYMBOL

+#endif

+

+// Macro for avoiding default assignment and copy, because doing this by inheritance can increase class size on some

+// platforms.

+#define NV_NOCOPY(Class)                                                                                               \

+	\

+protected:                                                                                                             \

+	Class(const Class&);                                                                                               \

+	Class& operator=(const Class&);

+

+#define NV_STRINGIZE_HELPER(X) #X

+#define NV_STRINGIZE(X) NV_STRINGIZE_HELPER(X)

+

+#define NV_CONCAT_HELPER(X, Y) X##Y

+#define NV_CONCAT(X, Y) NV_CONCAT_HELPER(X, Y)

+

+/** @} */

+#endif // #ifndef NV_NVFOUNDATION_NVPREPROCESSOR_H