diff options
Diffstat (limited to 'sdk/lowlevel/include')
| -rwxr-xr-x[-rw-r--r--] | sdk/lowlevel/include/NvBlast.h | 1786 | ||||
| -rwxr-xr-x[-rw-r--r--] | sdk/lowlevel/include/NvBlastPreprocessor.h | 80 | ||||
| -rwxr-xr-x[-rw-r--r--] | sdk/lowlevel/include/NvBlastTypes.h | 1188 | ||||
| -rwxr-xr-x[-rw-r--r--] | sdk/lowlevel/include/NvCTypes.h | 250 | ||||
| -rwxr-xr-x[-rw-r--r--] | sdk/lowlevel/include/NvPreprocessor.h | 1080 |
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
|