diff options
| author | git perforce import user <a@b> | 2016-10-25 12:29:14 -0600 |
|---|---|---|
| committer | Sheikh Dawood Abdul Ajees <Sheikh Dawood Abdul Ajees> | 2016-10-25 18:56:37 -0500 |
| commit | 3dfe2108cfab31ba3ee5527e217d0d8e99a51162 (patch) | |
| tree | fa6485c169e50d7415a651bf838f5bcd0fd3bfbd /APEX_1.4/module/destructible/src/autogen | |
| download | physx-3.4-3dfe2108cfab31ba3ee5527e217d0d8e99a51162.tar.xz physx-3.4-3dfe2108cfab31ba3ee5527e217d0d8e99a51162.zip | |
Initial commit:
PhysX 3.4.0 Update @ 21294896
APEX 1.4.0 Update @ 21275617
[CL 21300167]
Diffstat (limited to 'APEX_1.4/module/destructible/src/autogen')
13 files changed, 19955 insertions, 0 deletions
diff --git a/APEX_1.4/module/destructible/src/autogen/CachedOverlaps.cpp b/APEX_1.4/module/destructible/src/autogen/CachedOverlaps.cpp new file mode 100644 index 00000000..3ce2e737 --- /dev/null +++ b/APEX_1.4/module/destructible/src/autogen/CachedOverlaps.cpp @@ -0,0 +1,429 @@ +// 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-2015 NVIDIA Corporation. All rights reserved. + +// This file was generated by NvParameterized/scripts/GenParameterized.pl + + +#include "CachedOverlaps.h" +#include <string.h> +#include <stdlib.h> + +using namespace NvParameterized; + +namespace nvidia +{ +namespace destructible +{ + +using namespace CachedOverlapsNS; + +const char* const CachedOverlapsFactory::vptr = + NvParameterized::getVptr<CachedOverlaps, CachedOverlaps::ClassAlignment>(); + +const uint32_t NumParamDefs = 6; +static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs]; + + +static const size_t ParamLookupChildrenTable[] = +{ + 1, 2, 3, 4, 5, +}; + +#define TENUM(type) nvidia::##type +#define CHILDREN(index) &ParamLookupChildrenTable[index] +static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] = +{ + { TYPE_STRUCT, false, 0, CHILDREN(0), 2 }, + { TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->isCached), NULL, 0 }, // isCached + { TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->overlaps), CHILDREN(2), 1 }, // overlaps + { TYPE_STRUCT, false, 1 * sizeof(IntPair_Type), CHILDREN(3), 2 }, // overlaps[] + { TYPE_I32, false, (size_t)(&((IntPair_Type*)0)->i0), NULL, 0 }, // overlaps[].i0 + { TYPE_I32, false, (size_t)(&((IntPair_Type*)0)->i1), NULL, 0 }, // overlaps[].i1 +}; + + +bool CachedOverlaps::mBuiltFlag = false; +NvParameterized::MutexType CachedOverlaps::mBuiltFlagMutex; + +CachedOverlaps::CachedOverlaps(NvParameterized::Traits* traits, void* buf, int32_t* refCount) : + NvParameters(traits, buf, refCount) +{ + //mParameterizedTraits->registerFactory(className(), &CachedOverlapsFactoryInst); + + if (!buf) //Do not init data if it is inplace-deserialized + { + initDynamicArrays(); + initStrings(); + initReferences(); + initDefaults(); + } +} + +CachedOverlaps::~CachedOverlaps() +{ + freeStrings(); + freeReferences(); + freeDynamicArrays(); +} + +void CachedOverlaps::destroy() +{ + // We cache these fields here to avoid overwrite in destructor + bool doDeallocateSelf = mDoDeallocateSelf; + NvParameterized::Traits* traits = mParameterizedTraits; + int32_t* refCount = mRefCount; + void* buf = mBuffer; + + this->~CachedOverlaps(); + + NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf); +} + +const NvParameterized::DefinitionImpl* CachedOverlaps::getParameterDefinitionTree(void) +{ + if (!mBuiltFlag) // Double-checked lock + { + NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex); + if (!mBuiltFlag) + { + buildTree(); + } + } + + return(&ParamDefTable[0]); +} + +const NvParameterized::DefinitionImpl* CachedOverlaps::getParameterDefinitionTree(void) const +{ + CachedOverlaps* tmpParam = const_cast<CachedOverlaps*>(this); + + if (!mBuiltFlag) // Double-checked lock + { + NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex); + if (!mBuiltFlag) + { + tmpParam->buildTree(); + } + } + + return(&ParamDefTable[0]); +} + +NvParameterized::ErrorType CachedOverlaps::getParameterHandle(const char* long_name, Handle& handle) const +{ + ErrorType Ret = NvParameters::getParameterHandle(long_name, handle); + if (Ret != ERROR_NONE) + { + return(Ret); + } + + size_t offset; + void* ptr; + + getVarPtr(handle, ptr, offset); + + if (ptr == NULL) + { + return(ERROR_INDEX_OUT_OF_RANGE); + } + + return(ERROR_NONE); +} + +NvParameterized::ErrorType CachedOverlaps::getParameterHandle(const char* long_name, Handle& handle) +{ + ErrorType Ret = NvParameters::getParameterHandle(long_name, handle); + if (Ret != ERROR_NONE) + { + return(Ret); + } + + size_t offset; + void* ptr; + + getVarPtr(handle, ptr, offset); + + if (ptr == NULL) + { + return(ERROR_INDEX_OUT_OF_RANGE); + } + + return(ERROR_NONE); +} + +void CachedOverlaps::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const +{ + ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<CachedOverlaps::ParametersStruct*>(¶meters()), handle, offset); +} + + +/* Dynamic Handle Indices */ + +void CachedOverlaps::freeParameterDefinitionTable(NvParameterized::Traits* traits) +{ + if (!traits) + { + return; + } + + if (!mBuiltFlag) // Double-checked lock + { + return; + } + + NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex); + + if (!mBuiltFlag) + { + return; + } + + for (uint32_t i = 0; i < NumParamDefs; ++i) + { + ParamDefTable[i].~DefinitionImpl(); + } + + traits->free(ParamDefTable); + + mBuiltFlag = false; +} + +#define PDEF_PTR(index) (&ParamDefTable[index]) + +void CachedOverlaps::buildTree(void) +{ + + uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs; + ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize)); + memset(ParamDefTable, 0, allocSize); + + for (uint32_t i = 0; i < NumParamDefs; ++i) + { + NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits); + } + + // Initialize DefinitionImpl node: nodeIndex=0, longName="" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0]; + ParamDef->init("", TYPE_STRUCT, "STRUCT", true); + + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=1, longName="isCached" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1]; + ParamDef->init("isCached", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Whether or not chunk overlaps are cached at a particular hierarchy depth. In this\n case, overlap really means adjacency.", true); + HintTable[1].init("shortDescription", "Whether or not chunk overlaps are cached at a particular hierarchy depth", true); + ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=2, longName="overlaps" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2]; + ParamDef->init("overlaps", TYPE_ARRAY, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The overlaps at a particular hierarchy depth. This is the set of adjacencies,\n stored as pairs of chunk indices, for chunks at a the given hierarchy depth.", true); + HintTable[1].init("shortDescription", "The overlaps at a particular hierarchy depth", true); + ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + ParamDef->setArraySize(-1); + } + + // Initialize DefinitionImpl node: nodeIndex=3, longName="overlaps[]" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3]; + ParamDef->init("overlaps", TYPE_STRUCT, "IntPair", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The overlaps at a particular hierarchy depth. This is the set of adjacencies,\n stored as pairs of chunk indices, for chunks at a the given hierarchy depth.", true); + HintTable[1].init("shortDescription", "The overlaps at a particular hierarchy depth", true); + ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=4, longName="overlaps[].i0" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4]; + ParamDef->init("i0", TYPE_I32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("shortDescription", "First element", true); + ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=5, longName="overlaps[].i1" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5]; + ParamDef->init("i1", TYPE_I32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("shortDescription", "Second element", true); + ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // SetChildren for: nodeIndex=0, longName="" + { + static Definition* Children[2]; + Children[0] = PDEF_PTR(1); + Children[1] = PDEF_PTR(2); + + ParamDefTable[0].setChildren(Children, 2); + } + + // SetChildren for: nodeIndex=2, longName="overlaps" + { + static Definition* Children[1]; + Children[0] = PDEF_PTR(3); + + ParamDefTable[2].setChildren(Children, 1); + } + + // SetChildren for: nodeIndex=3, longName="overlaps[]" + { + static Definition* Children[2]; + Children[0] = PDEF_PTR(4); + Children[1] = PDEF_PTR(5); + + ParamDefTable[3].setChildren(Children, 2); + } + + mBuiltFlag = true; + +} +void CachedOverlaps::initStrings(void) +{ +} + +void CachedOverlaps::initDynamicArrays(void) +{ + overlaps.buf = NULL; + overlaps.isAllocated = true; + overlaps.elementSize = sizeof(IntPair_Type); + overlaps.arraySizes[0] = 0; +} + +void CachedOverlaps::initDefaults(void) +{ + + freeStrings(); + freeReferences(); + freeDynamicArrays(); + isCached = bool(false); + + initDynamicArrays(); + initStrings(); + initReferences(); +} + +void CachedOverlaps::initReferences(void) +{ +} + +void CachedOverlaps::freeDynamicArrays(void) +{ + if (overlaps.isAllocated && overlaps.buf) + { + mParameterizedTraits->free(overlaps.buf); + } +} + +void CachedOverlaps::freeStrings(void) +{ +} + +void CachedOverlaps::freeReferences(void) +{ +} + +} // namespace destructible +} // namespace nvidia diff --git a/APEX_1.4/module/destructible/src/autogen/DestructibleActorChunks.cpp b/APEX_1.4/module/destructible/src/autogen/DestructibleActorChunks.cpp new file mode 100644 index 00000000..ca557972 --- /dev/null +++ b/APEX_1.4/module/destructible/src/autogen/DestructibleActorChunks.cpp @@ -0,0 +1,642 @@ +// 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-2015 NVIDIA Corporation. All rights reserved. + +// This file was generated by NvParameterized/scripts/GenParameterized.pl + + +#include "DestructibleActorChunks.h" +#include <string.h> +#include <stdlib.h> + +using namespace NvParameterized; + +namespace nvidia +{ +namespace destructible +{ + +using namespace DestructibleActorChunksNS; + +const char* const DestructibleActorChunksFactory::vptr = + NvParameterized::getVptr<DestructibleActorChunks, DestructibleActorChunks::ClassAlignment>(); + +const uint32_t NumParamDefs = 14; +static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs]; + + +static const size_t ParamLookupChildrenTable[] = +{ + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, +}; + +#define TENUM(type) nvidia::##type +#define CHILDREN(index) &ParamLookupChildrenTable[index] +static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] = +{ + { TYPE_STRUCT, false, 0, CHILDREN(0), 1 }, + { TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->data), CHILDREN(1), 1 }, // data + { TYPE_STRUCT, false, 1 * sizeof(Chunk_Type), CHILDREN(2), 11 }, // data[] + { TYPE_U8, false, (size_t)(&((Chunk_Type*)0)->state), NULL, 0 }, // data[].state + { TYPE_U8, false, (size_t)(&((Chunk_Type*)0)->flags), NULL, 0 }, // data[].flags + { TYPE_U32, false, (size_t)(&((Chunk_Type*)0)->islandID), NULL, 0 }, // data[].islandID + { TYPE_F32, false, (size_t)(&((Chunk_Type*)0)->damage), NULL, 0 }, // data[].damage + { TYPE_VEC4, false, (size_t)(&((Chunk_Type*)0)->localSphere), NULL, 0 }, // data[].localSphere + { TYPE_VEC3, false, (size_t)(&((Chunk_Type*)0)->localOffset), NULL, 0 }, // data[].localOffset + { TYPE_I32, false, (size_t)(&((Chunk_Type*)0)->visibleAncestorIndex), NULL, 0 }, // data[].visibleAncestorIndex + { TYPE_U32, false, (size_t)(&((Chunk_Type*)0)->shapesCount), NULL, 0 }, // data[].shapesCount + { TYPE_TRANSFORM, false, (size_t)(&((Chunk_Type*)0)->globalPose), NULL, 0 }, // data[].globalPose + { TYPE_VEC3, false, (size_t)(&((Chunk_Type*)0)->linearVelocity), NULL, 0 }, // data[].linearVelocity + { TYPE_VEC3, false, (size_t)(&((Chunk_Type*)0)->angularVelocity), NULL, 0 }, // data[].angularVelocity +}; + + +bool DestructibleActorChunks::mBuiltFlag = false; +NvParameterized::MutexType DestructibleActorChunks::mBuiltFlagMutex; + +DestructibleActorChunks::DestructibleActorChunks(NvParameterized::Traits* traits, void* buf, int32_t* refCount) : + NvParameters(traits, buf, refCount) +{ + //mParameterizedTraits->registerFactory(className(), &DestructibleActorChunksFactoryInst); + + if (!buf) //Do not init data if it is inplace-deserialized + { + initDynamicArrays(); + initStrings(); + initReferences(); + initDefaults(); + } +} + +DestructibleActorChunks::~DestructibleActorChunks() +{ + freeStrings(); + freeReferences(); + freeDynamicArrays(); +} + +void DestructibleActorChunks::destroy() +{ + // We cache these fields here to avoid overwrite in destructor + bool doDeallocateSelf = mDoDeallocateSelf; + NvParameterized::Traits* traits = mParameterizedTraits; + int32_t* refCount = mRefCount; + void* buf = mBuffer; + + this->~DestructibleActorChunks(); + + NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf); +} + +const NvParameterized::DefinitionImpl* DestructibleActorChunks::getParameterDefinitionTree(void) +{ + if (!mBuiltFlag) // Double-checked lock + { + NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex); + if (!mBuiltFlag) + { + buildTree(); + } + } + + return(&ParamDefTable[0]); +} + +const NvParameterized::DefinitionImpl* DestructibleActorChunks::getParameterDefinitionTree(void) const +{ + DestructibleActorChunks* tmpParam = const_cast<DestructibleActorChunks*>(this); + + if (!mBuiltFlag) // Double-checked lock + { + NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex); + if (!mBuiltFlag) + { + tmpParam->buildTree(); + } + } + + return(&ParamDefTable[0]); +} + +NvParameterized::ErrorType DestructibleActorChunks::getParameterHandle(const char* long_name, Handle& handle) const +{ + ErrorType Ret = NvParameters::getParameterHandle(long_name, handle); + if (Ret != ERROR_NONE) + { + return(Ret); + } + + size_t offset; + void* ptr; + + getVarPtr(handle, ptr, offset); + + if (ptr == NULL) + { + return(ERROR_INDEX_OUT_OF_RANGE); + } + + return(ERROR_NONE); +} + +NvParameterized::ErrorType DestructibleActorChunks::getParameterHandle(const char* long_name, Handle& handle) +{ + ErrorType Ret = NvParameters::getParameterHandle(long_name, handle); + if (Ret != ERROR_NONE) + { + return(Ret); + } + + size_t offset; + void* ptr; + + getVarPtr(handle, ptr, offset); + + if (ptr == NULL) + { + return(ERROR_INDEX_OUT_OF_RANGE); + } + + return(ERROR_NONE); +} + +void DestructibleActorChunks::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const +{ + ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<DestructibleActorChunks::ParametersStruct*>(¶meters()), handle, offset); +} + + +/* Dynamic Handle Indices */ + +void DestructibleActorChunks::freeParameterDefinitionTable(NvParameterized::Traits* traits) +{ + if (!traits) + { + return; + } + + if (!mBuiltFlag) // Double-checked lock + { + return; + } + + NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex); + + if (!mBuiltFlag) + { + return; + } + + for (uint32_t i = 0; i < NumParamDefs; ++i) + { + ParamDefTable[i].~DefinitionImpl(); + } + + traits->free(ParamDefTable); + + mBuiltFlag = false; +} + +#define PDEF_PTR(index) (&ParamDefTable[index]) + +void DestructibleActorChunks::buildTree(void) +{ + + uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs; + ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize)); + memset(ParamDefTable, 0, allocSize); + + for (uint32_t i = 0; i < NumParamDefs; ++i) + { + NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits); + } + + // Initialize DefinitionImpl node: nodeIndex=0, longName="" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0]; + ParamDef->init("", TYPE_STRUCT, "STRUCT", true); + + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=1, longName="data" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1]; + ParamDef->init("data", TYPE_ARRAY, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("INCLUDED", uint64_t(1), true); + ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("INCLUDED", uint64_t(1), true); + HintTable[1].init("longDescription", "The actor's chunk data.", true); + HintTable[2].init("shortDescription", "The actor's chunk data", true); + ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + ParamDef->setArraySize(-1); + } + + // Initialize DefinitionImpl node: nodeIndex=2, longName="data[]" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2]; + ParamDef->init("data", TYPE_STRUCT, "Chunk", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("INCLUDED", uint64_t(1), true); + ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("INCLUDED", uint64_t(1), true); + HintTable[1].init("longDescription", "The actor's chunk data.", true); + HintTable[2].init("shortDescription", "The actor's chunk data", true); + ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=3, longName="data[].state" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3]; + ParamDef->init("state", TYPE_U8, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Bit flags indicating the state of the chunk.", true); + HintTable[1].init("shortDescription", "Bit flags indicating the state of the chunk", true); + ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=4, longName="data[].flags" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4]; + ParamDef->init("flags", TYPE_U8, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Overall chunk flags.", true); + HintTable[1].init("shortDescription", "Overall chunk flags", true); + ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=5, longName="data[].islandID" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5]; + ParamDef->init("islandID", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Island ID (if any) to which the chunk is attached.", true); + HintTable[1].init("shortDescription", "Island ID (if any) to which the chunk is attached", true); + ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=6, longName="data[].damage" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[6]; + ParamDef->init("damage", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "How damaged the chunk is.", true); + HintTable[1].init("shortDescription", "How damaged the chunk is", true); + ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=7, longName="data[].localSphere" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[7]; + ParamDef->init("localSphere", TYPE_VEC4, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "A local bounding sphere for the chunk.", true); + HintTable[1].init("shortDescription", "A local bounding sphere for the chunk", true); + ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=8, longName="data[].localOffset" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[8]; + ParamDef->init("localOffset", TYPE_VEC3, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "A local bounding sphere for the chunk.", true); + HintTable[1].init("shortDescription", "A local bounding sphere for the chunk", true); + ParamDefTable[8].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=9, longName="data[].visibleAncestorIndex" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[9]; + ParamDef->init("visibleAncestorIndex", TYPE_I32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Index (in structure) of this chunks' visible ancestor, if any. If none exists, it's InvalidChunkIndex.", true); + HintTable[1].init("shortDescription", "Index (in structure) of this chunks' visible ancestor, if any", true); + ParamDefTable[9].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=10, longName="data[].shapesCount" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[10]; + ParamDef->init("shapesCount", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Number of shapes for this chunk.", true); + HintTable[1].init("shortDescription", "Number of shapes for this chunk", true); + ParamDefTable[10].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=11, longName="data[].globalPose" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[11]; + ParamDef->init("globalPose", TYPE_TRANSFORM, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Chunk global transform.", true); + HintTable[1].init("shortDescription", "Chunk global transform", true); + ParamDefTable[11].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=12, longName="data[].linearVelocity" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[12]; + ParamDef->init("linearVelocity", TYPE_VEC3, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Chunk linear velocity.", true); + HintTable[1].init("shortDescription", "Chunk linear velocity", true); + ParamDefTable[12].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=13, longName="data[].angularVelocity" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[13]; + ParamDef->init("angularVelocity", TYPE_VEC3, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Chunk angular velocity.", true); + HintTable[1].init("shortDescription", "Chunk angular velocity", true); + ParamDefTable[13].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // SetChildren for: nodeIndex=0, longName="" + { + static Definition* Children[1]; + Children[0] = PDEF_PTR(1); + + ParamDefTable[0].setChildren(Children, 1); + } + + // SetChildren for: nodeIndex=1, longName="data" + { + static Definition* Children[1]; + Children[0] = PDEF_PTR(2); + + ParamDefTable[1].setChildren(Children, 1); + } + + // SetChildren for: nodeIndex=2, longName="data[]" + { + static Definition* Children[11]; + Children[0] = PDEF_PTR(3); + Children[1] = PDEF_PTR(4); + Children[2] = PDEF_PTR(5); + Children[3] = PDEF_PTR(6); + Children[4] = PDEF_PTR(7); + Children[5] = PDEF_PTR(8); + Children[6] = PDEF_PTR(9); + Children[7] = PDEF_PTR(10); + Children[8] = PDEF_PTR(11); + Children[9] = PDEF_PTR(12); + Children[10] = PDEF_PTR(13); + + ParamDefTable[2].setChildren(Children, 11); + } + + mBuiltFlag = true; + +} +void DestructibleActorChunks::initStrings(void) +{ +} + +void DestructibleActorChunks::initDynamicArrays(void) +{ + data.buf = NULL; + data.isAllocated = true; + data.elementSize = sizeof(Chunk_Type); + data.arraySizes[0] = 0; +} + +void DestructibleActorChunks::initDefaults(void) +{ + + freeStrings(); + freeReferences(); + freeDynamicArrays(); + + initDynamicArrays(); + initStrings(); + initReferences(); +} + +void DestructibleActorChunks::initReferences(void) +{ +} + +void DestructibleActorChunks::freeDynamicArrays(void) +{ + if (data.isAllocated && data.buf) + { + mParameterizedTraits->free(data.buf); + } +} + +void DestructibleActorChunks::freeStrings(void) +{ +} + +void DestructibleActorChunks::freeReferences(void) +{ +} + +} // namespace destructible +} // namespace nvidia diff --git a/APEX_1.4/module/destructible/src/autogen/DestructibleActorParam.cpp b/APEX_1.4/module/destructible/src/autogen/DestructibleActorParam.cpp new file mode 100644 index 00000000..2036ba2b --- /dev/null +++ b/APEX_1.4/module/destructible/src/autogen/DestructibleActorParam.cpp @@ -0,0 +1,8244 @@ +// 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-2015 NVIDIA Corporation. All rights reserved. + +// This file was generated by NvParameterized/scripts/GenParameterized.pl + + +#include "DestructibleActorParam.h" +#include <string.h> +#include <stdlib.h> + +using namespace NvParameterized; + +namespace nvidia +{ +namespace destructible +{ + +using namespace DestructibleActorParamNS; + +const char* const DestructibleActorParamFactory::vptr = + NvParameterized::getVptr<DestructibleActorParam, DestructibleActorParam::ClassAlignment>(); + +const uint32_t NumParamDefs = 294; +static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs]; + + +static const size_t ParamLookupChildrenTable[] = +{ + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 20, 22, 23, 24, 85, + 96, 130, 159, 176, 199, 225, 239, 243, 267, 292, 293, 19, 21, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 47, 48, 49, 50, 56, 81, 82, 83, 84, 40, 41, + 42, 43, 44, 45, 46, 51, 52, 53, 54, 55, 57, 58, 59, 60, 61, 62, 63, 69, 74, 64, 65, + 66, 67, 68, 70, 71, 72, 73, 75, 76, 77, 78, 79, 80, 86, 87, 88, 89, 90, 91, 92, 93, + 94, 95, 97, 118, 119, 125, 126, 127, 128, 129, 98, 99, 100, 101, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 120, 121, 122, 123, 124, + 131, 139, 140, 141, 142, 155, 156, 157, 158, 132, 133, 134, 135, 136, 137, 138, 143, + 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 160, 165, 166, 167, 168, 169, + 170, 171, 172, 173, 174, 175, 161, 162, 163, 164, 177, 184, 189, 194, 195, 196, 197, + 198, 178, 179, 180, 181, 182, 183, 185, 186, 187, 188, 190, 191, 192, 193, 200, 204, + 205, 206, 207, 223, 224, 201, 202, 203, 208, 209, 210, 211, 212, 213, 214, 215, 216, + 217, 218, 219, 220, 221, 222, 226, 227, 230, 231, 232, 233, 234, 235, 236, 237, 238, + 228, 229, 240, 241, 242, 244, 245, 246, 247, 251, 255, 256, 257, 258, 259, 260, 266, + 248, 249, 250, 252, 253, 254, 261, 262, 263, 264, 265, 268, 269, 270, 271, 272, 276, + 280, 281, 282, 283, 284, 285, 291, 273, 274, 275, 277, 278, 279, 286, 287, 288, 289, + 290, +}; + +#define TENUM(type) nvidia::##type +#define CHILDREN(index) &ParamLookupChildrenTable[index] +static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] = +{ + { TYPE_STRUCT, false, 0, CHILDREN(0), 34 }, + { TYPE_STRING, false, (size_t)(&((ParametersStruct*)0)->crumbleEmitterName), NULL, 0 }, // crumbleEmitterName + { TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->crumbleParticleSpacing), NULL, 0 }, // crumbleParticleSpacing + { TYPE_STRING, false, (size_t)(&((ParametersStruct*)0)->dustEmitterName), NULL, 0 }, // dustEmitterName + { TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->dustParticleSpacing), NULL, 0 }, // dustParticleSpacing + { TYPE_TRANSFORM, false, (size_t)(&((ParametersStruct*)0)->globalPose), NULL, 0 }, // globalPose + { TYPE_VEC3, false, (size_t)(&((ParametersStruct*)0)->scale), NULL, 0 }, // scale + { TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->dynamic), NULL, 0 }, // dynamic + { TYPE_U32, false, (size_t)(&((ParametersStruct*)0)->supportDepth), NULL, 0 }, // supportDepth + { TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->formExtendedStructures), NULL, 0 }, // formExtendedStructures + { TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->performDetailedOverlapTestForExtendedStructures), NULL, 0 }, // performDetailedOverlapTestForExtendedStructures + { TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->keepPreviousFrameBoneBuffer), NULL, 0 }, // keepPreviousFrameBoneBuffer + { TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->doNotCreateRenderable), NULL, 0 }, // doNotCreateRenderable + { TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->useAssetDefinedSupport), NULL, 0 }, // useAssetDefinedSupport + { TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->useWorldSupport), NULL, 0 }, // useWorldSupport + { TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->renderStaticChunksSeparately), NULL, 0 }, // renderStaticChunksSeparately + { TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->keepVisibleBonesPacked), NULL, 0 }, // keepVisibleBonesPacked + { TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->createChunkEvents), NULL, 0 }, // createChunkEvents + { TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->overrideSkinnedMaterialNames), CHILDREN(34), 1 }, // overrideSkinnedMaterialNames + { TYPE_STRING, false, 1 * sizeof(NvParameterized::DummyStringStruct), NULL, 0 }, // overrideSkinnedMaterialNames[] + { TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->overrideStaticMaterialNames), CHILDREN(35), 1 }, // overrideStaticMaterialNames + { TYPE_STRING, false, 1 * sizeof(NvParameterized::DummyStringStruct), NULL, 0 }, // overrideStaticMaterialNames[] + { TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->sleepVelocityFrameDecayConstant), NULL, 0 }, // sleepVelocityFrameDecayConstant + { TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->useHardSleeping), NULL, 0 }, // useHardSleeping + { TYPE_STRUCT, false, (size_t)(&((ParametersStruct*)0)->destructibleParameters), CHILDREN(36), 24 }, // destructibleParameters + { TYPE_F32, false, (size_t)(&((DestructibleParameters_Type*)0)->damageCap), NULL, 0 }, // destructibleParameters.damageCap + { TYPE_F32, false, (size_t)(&((DestructibleParameters_Type*)0)->forceToDamage), NULL, 0 }, // destructibleParameters.forceToDamage + { TYPE_F32, false, (size_t)(&((DestructibleParameters_Type*)0)->impactVelocityThreshold), NULL, 0 }, // destructibleParameters.impactVelocityThreshold + { TYPE_U32, false, (size_t)(&((DestructibleParameters_Type*)0)->minimumFractureDepth), NULL, 0 }, // destructibleParameters.minimumFractureDepth + { TYPE_I32, false, (size_t)(&((DestructibleParameters_Type*)0)->impactDamageDefaultDepth), NULL, 0 }, // destructibleParameters.impactDamageDefaultDepth + { TYPE_I32, false, (size_t)(&((DestructibleParameters_Type*)0)->debrisDepth), NULL, 0 }, // destructibleParameters.debrisDepth + { TYPE_U32, false, (size_t)(&((DestructibleParameters_Type*)0)->essentialDepth), NULL, 0 }, // destructibleParameters.essentialDepth + { TYPE_F32, false, (size_t)(&((DestructibleParameters_Type*)0)->debrisLifetimeMin), NULL, 0 }, // destructibleParameters.debrisLifetimeMin + { TYPE_F32, false, (size_t)(&((DestructibleParameters_Type*)0)->debrisLifetimeMax), NULL, 0 }, // destructibleParameters.debrisLifetimeMax + { TYPE_F32, false, (size_t)(&((DestructibleParameters_Type*)0)->debrisMaxSeparationMin), NULL, 0 }, // destructibleParameters.debrisMaxSeparationMin + { TYPE_F32, false, (size_t)(&((DestructibleParameters_Type*)0)->debrisMaxSeparationMax), NULL, 0 }, // destructibleParameters.debrisMaxSeparationMax + { TYPE_F32, false, (size_t)(&((DestructibleParameters_Type*)0)->debrisDestructionProbability), NULL, 0 }, // destructibleParameters.debrisDestructionProbability + { TYPE_BOUNDS3, false, (size_t)(&((DestructibleParameters_Type*)0)->validBounds), NULL, 0 }, // destructibleParameters.validBounds + { TYPE_F32, false, (size_t)(&((DestructibleParameters_Type*)0)->maxChunkSpeed), NULL, 0 }, // destructibleParameters.maxChunkSpeed + { TYPE_STRUCT, false, (size_t)(&((DestructibleParameters_Type*)0)->flags), CHILDREN(60), 7 }, // destructibleParameters.flags + { TYPE_BOOL, false, (size_t)(&((DestructibleParametersFlag_Type*)0)->ACCUMULATE_DAMAGE), NULL, 0 }, // destructibleParameters.flags.ACCUMULATE_DAMAGE + { TYPE_BOOL, false, (size_t)(&((DestructibleParametersFlag_Type*)0)->DEBRIS_TIMEOUT), NULL, 0 }, // destructibleParameters.flags.DEBRIS_TIMEOUT + { TYPE_BOOL, false, (size_t)(&((DestructibleParametersFlag_Type*)0)->DEBRIS_MAX_SEPARATION), NULL, 0 }, // destructibleParameters.flags.DEBRIS_MAX_SEPARATION + { TYPE_BOOL, false, (size_t)(&((DestructibleParametersFlag_Type*)0)->CRUMBLE_SMALLEST_CHUNKS), NULL, 0 }, // destructibleParameters.flags.CRUMBLE_SMALLEST_CHUNKS + { TYPE_BOOL, false, (size_t)(&((DestructibleParametersFlag_Type*)0)->ACCURATE_RAYCASTS), NULL, 0 }, // destructibleParameters.flags.ACCURATE_RAYCASTS + { TYPE_BOOL, false, (size_t)(&((DestructibleParametersFlag_Type*)0)->USE_VALID_BOUNDS), NULL, 0 }, // destructibleParameters.flags.USE_VALID_BOUNDS + { TYPE_BOOL, false, (size_t)(&((DestructibleParametersFlag_Type*)0)->CRUMBLE_VIA_RUNTIME_FRACTURE), NULL, 0 }, // destructibleParameters.flags.CRUMBLE_VIA_RUNTIME_FRACTURE + { TYPE_F32, false, (size_t)(&((DestructibleParameters_Type*)0)->fractureImpulseScale), NULL, 0 }, // destructibleParameters.fractureImpulseScale + { TYPE_U16, false, (size_t)(&((DestructibleParameters_Type*)0)->damageDepthLimit), NULL, 0 }, // destructibleParameters.damageDepthLimit + { TYPE_U16, false, (size_t)(&((DestructibleParameters_Type*)0)->dynamicChunkDominanceGroup), NULL, 0 }, // destructibleParameters.dynamicChunkDominanceGroup + { TYPE_STRUCT, false, (size_t)(&((DestructibleParameters_Type*)0)->dynamicChunksGroupsMask), CHILDREN(67), 5 }, // destructibleParameters.dynamicChunksGroupsMask + { TYPE_BOOL, false, (size_t)(&((GroupsMask_Type*)0)->useGroupsMask), NULL, 0 }, // destructibleParameters.dynamicChunksGroupsMask.useGroupsMask + { TYPE_U32, false, (size_t)(&((GroupsMask_Type*)0)->bits0), NULL, 0 }, // destructibleParameters.dynamicChunksGroupsMask.bits0 + { TYPE_U32, false, (size_t)(&((GroupsMask_Type*)0)->bits1), NULL, 0 }, // destructibleParameters.dynamicChunksGroupsMask.bits1 + { TYPE_U32, false, (size_t)(&((GroupsMask_Type*)0)->bits2), NULL, 0 }, // destructibleParameters.dynamicChunksGroupsMask.bits2 + { TYPE_U32, false, (size_t)(&((GroupsMask_Type*)0)->bits3), NULL, 0 }, // destructibleParameters.dynamicChunksGroupsMask.bits3 + { TYPE_STRUCT, false, (size_t)(&((DestructibleParameters_Type*)0)->runtimeFracture), CHILDREN(72), 9 }, // destructibleParameters.runtimeFracture + { TYPE_ENUM, false, (size_t)(&((RuntimeFracture_Type*)0)->RuntimeFractureType), NULL, 0 }, // destructibleParameters.runtimeFracture.RuntimeFractureType + { TYPE_BOOL, false, (size_t)(&((RuntimeFracture_Type*)0)->sheetFracture), NULL, 0 }, // destructibleParameters.runtimeFracture.sheetFracture + { TYPE_U32, false, (size_t)(&((RuntimeFracture_Type*)0)->depthLimit), NULL, 0 }, // destructibleParameters.runtimeFracture.depthLimit + { TYPE_BOOL, false, (size_t)(&((RuntimeFracture_Type*)0)->destroyIfAtDepthLimit), NULL, 0 }, // destructibleParameters.runtimeFracture.destroyIfAtDepthLimit + { TYPE_F32, false, (size_t)(&((RuntimeFracture_Type*)0)->minConvexSize), NULL, 0 }, // destructibleParameters.runtimeFracture.minConvexSize + { TYPE_F32, false, (size_t)(&((RuntimeFracture_Type*)0)->impulseScale), NULL, 0 }, // destructibleParameters.runtimeFracture.impulseScale + { TYPE_STRUCT, false, (size_t)(&((RuntimeFracture_Type*)0)->glass), CHILDREN(81), 5 }, // destructibleParameters.runtimeFracture.glass + { TYPE_U32, false, (size_t)(&((FractureGlass_Type*)0)->numSectors), NULL, 0 }, // destructibleParameters.runtimeFracture.glass.numSectors + { TYPE_F32, false, (size_t)(&((FractureGlass_Type*)0)->sectorRand), NULL, 0 }, // destructibleParameters.runtimeFracture.glass.sectorRand + { TYPE_F32, false, (size_t)(&((FractureGlass_Type*)0)->firstSegmentSize), NULL, 0 }, // destructibleParameters.runtimeFracture.glass.firstSegmentSize + { TYPE_F32, false, (size_t)(&((FractureGlass_Type*)0)->segmentScale), NULL, 0 }, // destructibleParameters.runtimeFracture.glass.segmentScale + { TYPE_F32, false, (size_t)(&((FractureGlass_Type*)0)->segmentRand), NULL, 0 }, // destructibleParameters.runtimeFracture.glass.segmentRand + { TYPE_STRUCT, false, (size_t)(&((RuntimeFracture_Type*)0)->voronoi), CHILDREN(86), 4 }, // destructibleParameters.runtimeFracture.voronoi + { TYPE_VEC3, false, (size_t)(&((FractureVoronoi_Type*)0)->dimensions), NULL, 0 }, // destructibleParameters.runtimeFracture.voronoi.dimensions + { TYPE_U32, false, (size_t)(&((FractureVoronoi_Type*)0)->numCells), NULL, 0 }, // destructibleParameters.runtimeFracture.voronoi.numCells + { TYPE_F32, false, (size_t)(&((FractureVoronoi_Type*)0)->biasExp), NULL, 0 }, // destructibleParameters.runtimeFracture.voronoi.biasExp + { TYPE_F32, false, (size_t)(&((FractureVoronoi_Type*)0)->maxDist), NULL, 0 }, // destructibleParameters.runtimeFracture.voronoi.maxDist + { TYPE_STRUCT, false, (size_t)(&((RuntimeFracture_Type*)0)->attachment), CHILDREN(90), 6 }, // destructibleParameters.runtimeFracture.attachment + { TYPE_BOOL, false, (size_t)(&((FractureAttachment_Type*)0)->posX), NULL, 0 }, // destructibleParameters.runtimeFracture.attachment.posX + { TYPE_BOOL, false, (size_t)(&((FractureAttachment_Type*)0)->negX), NULL, 0 }, // destructibleParameters.runtimeFracture.attachment.negX + { TYPE_BOOL, false, (size_t)(&((FractureAttachment_Type*)0)->posY), NULL, 0 }, // destructibleParameters.runtimeFracture.attachment.posY + { TYPE_BOOL, false, (size_t)(&((FractureAttachment_Type*)0)->negY), NULL, 0 }, // destructibleParameters.runtimeFracture.attachment.negY + { TYPE_BOOL, false, (size_t)(&((FractureAttachment_Type*)0)->posZ), NULL, 0 }, // destructibleParameters.runtimeFracture.attachment.posZ + { TYPE_BOOL, false, (size_t)(&((FractureAttachment_Type*)0)->negZ), NULL, 0 }, // destructibleParameters.runtimeFracture.attachment.negZ + { TYPE_F32, false, (size_t)(&((DestructibleParameters_Type*)0)->supportStrength), NULL, 0 }, // destructibleParameters.supportStrength + { TYPE_I8, false, (size_t)(&((DestructibleParameters_Type*)0)->legacyChunkBoundsTestSetting), NULL, 0 }, // destructibleParameters.legacyChunkBoundsTestSetting + { TYPE_I8, false, (size_t)(&((DestructibleParameters_Type*)0)->legacyDamageRadiusSpreadSetting), NULL, 0 }, // destructibleParameters.legacyDamageRadiusSpreadSetting + { TYPE_BOOL, false, (size_t)(&((DestructibleParameters_Type*)0)->alwaysDrawScatterMesh), NULL, 0 }, // destructibleParameters.alwaysDrawScatterMesh + { TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->depthParameters), CHILDREN(96), 1 }, // depthParameters + { TYPE_STRUCT, false, 1 * sizeof(DestructibleDepthParameters_Type), CHILDREN(97), 9 }, // depthParameters[] + { TYPE_BOOL, false, (size_t)(&((DestructibleDepthParameters_Type*)0)->OVERRIDE_IMPACT_DAMAGE), NULL, 0 }, // depthParameters[].OVERRIDE_IMPACT_DAMAGE + { TYPE_BOOL, false, (size_t)(&((DestructibleDepthParameters_Type*)0)->OVERRIDE_IMPACT_DAMAGE_VALUE), NULL, 0 }, // depthParameters[].OVERRIDE_IMPACT_DAMAGE_VALUE + { TYPE_BOOL, false, (size_t)(&((DestructibleDepthParameters_Type*)0)->IGNORE_POSE_UPDATES), NULL, 0 }, // depthParameters[].IGNORE_POSE_UPDATES + { TYPE_BOOL, false, (size_t)(&((DestructibleDepthParameters_Type*)0)->IGNORE_RAYCAST_CALLBACKS), NULL, 0 }, // depthParameters[].IGNORE_RAYCAST_CALLBACKS + { TYPE_BOOL, false, (size_t)(&((DestructibleDepthParameters_Type*)0)->IGNORE_CONTACT_CALLBACKS), NULL, 0 }, // depthParameters[].IGNORE_CONTACT_CALLBACKS + { TYPE_BOOL, false, (size_t)(&((DestructibleDepthParameters_Type*)0)->USER_FLAG_0), NULL, 0 }, // depthParameters[].USER_FLAG_0 + { TYPE_BOOL, false, (size_t)(&((DestructibleDepthParameters_Type*)0)->USER_FLAG_1), NULL, 0 }, // depthParameters[].USER_FLAG_1 + { TYPE_BOOL, false, (size_t)(&((DestructibleDepthParameters_Type*)0)->USER_FLAG_2), NULL, 0 }, // depthParameters[].USER_FLAG_2 + { TYPE_BOOL, false, (size_t)(&((DestructibleDepthParameters_Type*)0)->USER_FLAG_3), NULL, 0 }, // depthParameters[].USER_FLAG_3 + { TYPE_STRUCT, false, (size_t)(&((ParametersStruct*)0)->shapeDescTemplate), CHILDREN(106), 8 }, // shapeDescTemplate + { TYPE_STRUCT, false, (size_t)(&((ShapeDescTemplate_Type*)0)->flags), CHILDREN(114), 20 }, // shapeDescTemplate.flags + { TYPE_BOOL, false, (size_t)(&((ShapeDescFlags_Type*)0)->NX_TRIGGER_ON_ENTER), NULL, 0 }, // shapeDescTemplate.flags.NX_TRIGGER_ON_ENTER + { TYPE_BOOL, false, (size_t)(&((ShapeDescFlags_Type*)0)->NX_TRIGGER_ON_LEAVE), NULL, 0 }, // shapeDescTemplate.flags.NX_TRIGGER_ON_LEAVE + { TYPE_BOOL, false, (size_t)(&((ShapeDescFlags_Type*)0)->NX_TRIGGER_ON_STAY), NULL, 0 }, // shapeDescTemplate.flags.NX_TRIGGER_ON_STAY + { TYPE_BOOL, false, (size_t)(&((ShapeDescFlags_Type*)0)->NX_SF_VISUALIZATION), NULL, 0 }, // shapeDescTemplate.flags.NX_SF_VISUALIZATION + { TYPE_BOOL, false, (size_t)(&((ShapeDescFlags_Type*)0)->NX_SF_DISABLE_COLLISION), NULL, 0 }, // shapeDescTemplate.flags.NX_SF_DISABLE_COLLISION + { TYPE_BOOL, false, (size_t)(&((ShapeDescFlags_Type*)0)->NX_SF_FEATURE_INDICES), NULL, 0 }, // shapeDescTemplate.flags.NX_SF_FEATURE_INDICES + { TYPE_BOOL, false, (size_t)(&((ShapeDescFlags_Type*)0)->NX_SF_DISABLE_RAYCASTING), NULL, 0 }, // shapeDescTemplate.flags.NX_SF_DISABLE_RAYCASTING + { TYPE_BOOL, false, (size_t)(&((ShapeDescFlags_Type*)0)->NX_SF_POINT_CONTACT_FORCE), NULL, 0 }, // shapeDescTemplate.flags.NX_SF_POINT_CONTACT_FORCE + { TYPE_BOOL, false, (size_t)(&((ShapeDescFlags_Type*)0)->NX_SF_FLUID_DRAIN), NULL, 0 }, // shapeDescTemplate.flags.NX_SF_FLUID_DRAIN + { TYPE_BOOL, false, (size_t)(&((ShapeDescFlags_Type*)0)->NX_SF_FLUID_DISABLE_COLLISION), NULL, 0 }, // shapeDescTemplate.flags.NX_SF_FLUID_DISABLE_COLLISION + { TYPE_BOOL, false, (size_t)(&((ShapeDescFlags_Type*)0)->NX_SF_FLUID_TWOWAY), NULL, 0 }, // shapeDescTemplate.flags.NX_SF_FLUID_TWOWAY + { TYPE_BOOL, false, (size_t)(&((ShapeDescFlags_Type*)0)->NX_SF_DISABLE_RESPONSE), NULL, 0 }, // shapeDescTemplate.flags.NX_SF_DISABLE_RESPONSE + { TYPE_BOOL, false, (size_t)(&((ShapeDescFlags_Type*)0)->NX_SF_DYNAMIC_DYNAMIC_CCD), NULL, 0 }, // shapeDescTemplate.flags.NX_SF_DYNAMIC_DYNAMIC_CCD + { TYPE_BOOL, false, (size_t)(&((ShapeDescFlags_Type*)0)->NX_SF_DISABLE_SCENE_QUERIES), NULL, 0 }, // shapeDescTemplate.flags.NX_SF_DISABLE_SCENE_QUERIES + { TYPE_BOOL, false, (size_t)(&((ShapeDescFlags_Type*)0)->NX_SF_CLOTH_DRAIN), NULL, 0 }, // shapeDescTemplate.flags.NX_SF_CLOTH_DRAIN + { TYPE_BOOL, false, (size_t)(&((ShapeDescFlags_Type*)0)->NX_SF_CLOTH_DISABLE_COLLISION), NULL, 0 }, // shapeDescTemplate.flags.NX_SF_CLOTH_DISABLE_COLLISION + { TYPE_BOOL, false, (size_t)(&((ShapeDescFlags_Type*)0)->NX_SF_CLOTH_TWOWAY), NULL, 0 }, // shapeDescTemplate.flags.NX_SF_CLOTH_TWOWAY + { TYPE_BOOL, false, (size_t)(&((ShapeDescFlags_Type*)0)->NX_SF_SOFTBODY_DRAIN), NULL, 0 }, // shapeDescTemplate.flags.NX_SF_SOFTBODY_DRAIN + { TYPE_BOOL, false, (size_t)(&((ShapeDescFlags_Type*)0)->NX_SF_SOFTBODY_DISABLE_COLLISION), NULL, 0 }, // shapeDescTemplate.flags.NX_SF_SOFTBODY_DISABLE_COLLISION + { TYPE_BOOL, false, (size_t)(&((ShapeDescFlags_Type*)0)->NX_SF_SOFTBODY_TWOWAY), NULL, 0 }, // shapeDescTemplate.flags.NX_SF_SOFTBODY_TWOWAY + { TYPE_U16, false, (size_t)(&((ShapeDescTemplate_Type*)0)->collisionGroup), NULL, 0 }, // shapeDescTemplate.collisionGroup + { TYPE_STRUCT, false, (size_t)(&((ShapeDescTemplate_Type*)0)->groupsMask), CHILDREN(134), 5 }, // shapeDescTemplate.groupsMask + { TYPE_BOOL, false, (size_t)(&((GroupsMask_Type*)0)->useGroupsMask), NULL, 0 }, // shapeDescTemplate.groupsMask.useGroupsMask + { TYPE_U32, false, (size_t)(&((GroupsMask_Type*)0)->bits0), NULL, 0 }, // shapeDescTemplate.groupsMask.bits0 + { TYPE_U32, false, (size_t)(&((GroupsMask_Type*)0)->bits1), NULL, 0 }, // shapeDescTemplate.groupsMask.bits1 + { TYPE_U32, false, (size_t)(&((GroupsMask_Type*)0)->bits2), NULL, 0 }, // shapeDescTemplate.groupsMask.bits2 + { TYPE_U32, false, (size_t)(&((GroupsMask_Type*)0)->bits3), NULL, 0 }, // shapeDescTemplate.groupsMask.bits3 + { TYPE_U16, false, (size_t)(&((ShapeDescTemplate_Type*)0)->materialIndex), NULL, 0 }, // shapeDescTemplate.materialIndex + { TYPE_F32, false, (size_t)(&((ShapeDescTemplate_Type*)0)->density), NULL, 0 }, // shapeDescTemplate.density + { TYPE_F32, false, (size_t)(&((ShapeDescTemplate_Type*)0)->skinWidth), NULL, 0 }, // shapeDescTemplate.skinWidth + { TYPE_U64, false, (size_t)(&((ShapeDescTemplate_Type*)0)->userData), NULL, 0 }, // shapeDescTemplate.userData + { TYPE_U64, false, (size_t)(&((ShapeDescTemplate_Type*)0)->name), NULL, 0 }, // shapeDescTemplate.name + { TYPE_STRUCT, false, (size_t)(&((ParametersStruct*)0)->actorDescTemplate), CHILDREN(139), 9 }, // actorDescTemplate + { TYPE_STRUCT, false, (size_t)(&((ActorDescTemplate_Type*)0)->flags), CHILDREN(148), 7 }, // actorDescTemplate.flags + { TYPE_BOOL, false, (size_t)(&((ActorDescFlags_Type*)0)->NX_AF_DISABLE_COLLISION), NULL, 0 }, // actorDescTemplate.flags.NX_AF_DISABLE_COLLISION + { TYPE_BOOL, false, (size_t)(&((ActorDescFlags_Type*)0)->NX_AF_DISABLE_RESPONSE), NULL, 0 }, // actorDescTemplate.flags.NX_AF_DISABLE_RESPONSE + { TYPE_BOOL, false, (size_t)(&((ActorDescFlags_Type*)0)->NX_AF_LOCK_COM), NULL, 0 }, // actorDescTemplate.flags.NX_AF_LOCK_COM + { TYPE_BOOL, false, (size_t)(&((ActorDescFlags_Type*)0)->NX_AF_FLUID_DISABLE_COLLISION), NULL, 0 }, // actorDescTemplate.flags.NX_AF_FLUID_DISABLE_COLLISION + { TYPE_BOOL, false, (size_t)(&((ActorDescFlags_Type*)0)->NX_AF_CONTACT_MODIFICATION), NULL, 0 }, // actorDescTemplate.flags.NX_AF_CONTACT_MODIFICATION + { TYPE_BOOL, false, (size_t)(&((ActorDescFlags_Type*)0)->NX_AF_FORCE_CONE_FRICTION), NULL, 0 }, // actorDescTemplate.flags.NX_AF_FORCE_CONE_FRICTION + { TYPE_BOOL, false, (size_t)(&((ActorDescFlags_Type*)0)->NX_AF_USER_ACTOR_PAIR_FILTERING), NULL, 0 }, // actorDescTemplate.flags.NX_AF_USER_ACTOR_PAIR_FILTERING + { TYPE_F32, false, (size_t)(&((ActorDescTemplate_Type*)0)->density), NULL, 0 }, // actorDescTemplate.density + { TYPE_U16, false, (size_t)(&((ActorDescTemplate_Type*)0)->actorCollisionGroup), NULL, 0 }, // actorDescTemplate.actorCollisionGroup + { TYPE_U16, false, (size_t)(&((ActorDescTemplate_Type*)0)->dominanceGroup), NULL, 0 }, // actorDescTemplate.dominanceGroup + { TYPE_STRUCT, false, (size_t)(&((ActorDescTemplate_Type*)0)->contactReportFlags), CHILDREN(155), 12 }, // actorDescTemplate.contactReportFlags + { TYPE_BOOL, false, (size_t)(&((ContactPairFlag_Type*)0)->NX_IGNORE_PAIR), NULL, 0 }, // actorDescTemplate.contactReportFlags.NX_IGNORE_PAIR + { TYPE_BOOL, false, (size_t)(&((ContactPairFlag_Type*)0)->NX_NOTIFY_ON_START_TOUCH), NULL, 0 }, // actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_START_TOUCH + { TYPE_BOOL, false, (size_t)(&((ContactPairFlag_Type*)0)->NX_NOTIFY_ON_END_TOUCH), NULL, 0 }, // actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_END_TOUCH + { TYPE_BOOL, false, (size_t)(&((ContactPairFlag_Type*)0)->NX_NOTIFY_ON_TOUCH), NULL, 0 }, // actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_TOUCH + { TYPE_BOOL, false, (size_t)(&((ContactPairFlag_Type*)0)->NX_NOTIFY_ON_IMPACT), NULL, 0 }, // actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_IMPACT + { TYPE_BOOL, false, (size_t)(&((ContactPairFlag_Type*)0)->NX_NOTIFY_ON_ROLL), NULL, 0 }, // actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_ROLL + { TYPE_BOOL, false, (size_t)(&((ContactPairFlag_Type*)0)->NX_NOTIFY_ON_SLIDE), NULL, 0 }, // actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_SLIDE + { TYPE_BOOL, false, (size_t)(&((ContactPairFlag_Type*)0)->NX_NOTIFY_FORCES), NULL, 0 }, // actorDescTemplate.contactReportFlags.NX_NOTIFY_FORCES + { TYPE_BOOL, false, (size_t)(&((ContactPairFlag_Type*)0)->NX_NOTIFY_ON_START_TOUCH_FORCE_THRESHOLD), NULL, 0 }, // actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_START_TOUCH_FORCE_THRESHOLD + { TYPE_BOOL, false, (size_t)(&((ContactPairFlag_Type*)0)->NX_NOTIFY_ON_END_TOUCH_FORCE_THRESHOLD), NULL, 0 }, // actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_END_TOUCH_FORCE_THRESHOLD + { TYPE_BOOL, false, (size_t)(&((ContactPairFlag_Type*)0)->NX_NOTIFY_ON_TOUCH_FORCE_THRESHOLD), NULL, 0 }, // actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_TOUCH_FORCE_THRESHOLD + { TYPE_BOOL, false, (size_t)(&((ContactPairFlag_Type*)0)->NX_NOTIFY_CONTACT_MODIFICATION), NULL, 0 }, // actorDescTemplate.contactReportFlags.NX_NOTIFY_CONTACT_MODIFICATION + { TYPE_U16, false, (size_t)(&((ActorDescTemplate_Type*)0)->forceFieldMaterial), NULL, 0 }, // actorDescTemplate.forceFieldMaterial + { TYPE_U64, false, (size_t)(&((ActorDescTemplate_Type*)0)->userData), NULL, 0 }, // actorDescTemplate.userData + { TYPE_U64, false, (size_t)(&((ActorDescTemplate_Type*)0)->name), NULL, 0 }, // actorDescTemplate.name + { TYPE_U64, false, (size_t)(&((ActorDescTemplate_Type*)0)->compartment), NULL, 0 }, // actorDescTemplate.compartment + { TYPE_STRUCT, false, (size_t)(&((ParametersStruct*)0)->bodyDescTemplate), CHILDREN(167), 12 }, // bodyDescTemplate + { TYPE_STRUCT, false, (size_t)(&((BodyDescTemplate_Type*)0)->flags), CHILDREN(179), 4 }, // bodyDescTemplate.flags + { TYPE_BOOL, false, (size_t)(&((BodyDescFlags_Type*)0)->NX_BF_DISABLE_GRAVITY), NULL, 0 }, // bodyDescTemplate.flags.NX_BF_DISABLE_GRAVITY + { TYPE_BOOL, false, (size_t)(&((BodyDescFlags_Type*)0)->NX_BF_FILTER_SLEEP_VEL), NULL, 0 }, // bodyDescTemplate.flags.NX_BF_FILTER_SLEEP_VEL + { TYPE_BOOL, false, (size_t)(&((BodyDescFlags_Type*)0)->NX_BF_ENERGY_SLEEP_TEST), NULL, 0 }, // bodyDescTemplate.flags.NX_BF_ENERGY_SLEEP_TEST + { TYPE_BOOL, false, (size_t)(&((BodyDescFlags_Type*)0)->NX_BF_VISUALIZATION), NULL, 0 }, // bodyDescTemplate.flags.NX_BF_VISUALIZATION + { TYPE_F32, false, (size_t)(&((BodyDescTemplate_Type*)0)->wakeUpCounter), NULL, 0 }, // bodyDescTemplate.wakeUpCounter + { TYPE_F32, false, (size_t)(&((BodyDescTemplate_Type*)0)->linearDamping), NULL, 0 }, // bodyDescTemplate.linearDamping + { TYPE_F32, false, (size_t)(&((BodyDescTemplate_Type*)0)->angularDamping), NULL, 0 }, // bodyDescTemplate.angularDamping + { TYPE_F32, false, (size_t)(&((BodyDescTemplate_Type*)0)->maxAngularVelocity), NULL, 0 }, // bodyDescTemplate.maxAngularVelocity + { TYPE_F32, false, (size_t)(&((BodyDescTemplate_Type*)0)->CCDMotionThreshold), NULL, 0 }, // bodyDescTemplate.CCDMotionThreshold + { TYPE_F32, false, (size_t)(&((BodyDescTemplate_Type*)0)->sleepLinearVelocity), NULL, 0 }, // bodyDescTemplate.sleepLinearVelocity + { TYPE_F32, false, (size_t)(&((BodyDescTemplate_Type*)0)->sleepAngularVelocity), NULL, 0 }, // bodyDescTemplate.sleepAngularVelocity + { TYPE_U32, false, (size_t)(&((BodyDescTemplate_Type*)0)->solverIterationCount), NULL, 0 }, // bodyDescTemplate.solverIterationCount + { TYPE_F32, false, (size_t)(&((BodyDescTemplate_Type*)0)->sleepEnergyThreshold), NULL, 0 }, // bodyDescTemplate.sleepEnergyThreshold + { TYPE_F32, false, (size_t)(&((BodyDescTemplate_Type*)0)->sleepDamping), NULL, 0 }, // bodyDescTemplate.sleepDamping + { TYPE_F32, false, (size_t)(&((BodyDescTemplate_Type*)0)->contactReportThreshold), NULL, 0 }, // bodyDescTemplate.contactReportThreshold + { TYPE_STRUCT, false, (size_t)(&((ParametersStruct*)0)->p3ShapeDescTemplate), CHILDREN(183), 8 }, // p3ShapeDescTemplate + { TYPE_STRUCT, false, (size_t)(&((P3ShapeDescTemplate_Type*)0)->flags), CHILDREN(191), 6 }, // p3ShapeDescTemplate.flags + { TYPE_BOOL, false, (size_t)(&((P3ShapeFlags_Type*)0)->eSIMULATION_SHAPE), NULL, 0 }, // p3ShapeDescTemplate.flags.eSIMULATION_SHAPE + { TYPE_BOOL, false, (size_t)(&((P3ShapeFlags_Type*)0)->eSCENE_QUERY_SHAPE), NULL, 0 }, // p3ShapeDescTemplate.flags.eSCENE_QUERY_SHAPE + { TYPE_BOOL, false, (size_t)(&((P3ShapeFlags_Type*)0)->eTRIGGER_SHAPE), NULL, 0 }, // p3ShapeDescTemplate.flags.eTRIGGER_SHAPE + { TYPE_BOOL, false, (size_t)(&((P3ShapeFlags_Type*)0)->eVISUALIZATION), NULL, 0 }, // p3ShapeDescTemplate.flags.eVISUALIZATION + { TYPE_BOOL, false, (size_t)(&((P3ShapeFlags_Type*)0)->ePARTICLE_DRAIN), NULL, 0 }, // p3ShapeDescTemplate.flags.ePARTICLE_DRAIN + { TYPE_BOOL, false, (size_t)(&((P3ShapeFlags_Type*)0)->eDEFORMABLE_DRAIN), NULL, 0 }, // p3ShapeDescTemplate.flags.eDEFORMABLE_DRAIN + { TYPE_STRUCT, false, (size_t)(&((P3ShapeDescTemplate_Type*)0)->simulationFilterData), CHILDREN(197), 4 }, // p3ShapeDescTemplate.simulationFilterData + { TYPE_U32, false, (size_t)(&((P3FilterData_Type*)0)->word0), NULL, 0 }, // p3ShapeDescTemplate.simulationFilterData.word0 + { TYPE_U32, false, (size_t)(&((P3FilterData_Type*)0)->word1), NULL, 0 }, // p3ShapeDescTemplate.simulationFilterData.word1 + { TYPE_U32, false, (size_t)(&((P3FilterData_Type*)0)->word2), NULL, 0 }, // p3ShapeDescTemplate.simulationFilterData.word2 + { TYPE_U32, false, (size_t)(&((P3FilterData_Type*)0)->word3), NULL, 0 }, // p3ShapeDescTemplate.simulationFilterData.word3 + { TYPE_STRUCT, false, (size_t)(&((P3ShapeDescTemplate_Type*)0)->queryFilterData), CHILDREN(201), 4 }, // p3ShapeDescTemplate.queryFilterData + { TYPE_U32, false, (size_t)(&((P3FilterData_Type*)0)->word0), NULL, 0 }, // p3ShapeDescTemplate.queryFilterData.word0 + { TYPE_U32, false, (size_t)(&((P3FilterData_Type*)0)->word1), NULL, 0 }, // p3ShapeDescTemplate.queryFilterData.word1 + { TYPE_U32, false, (size_t)(&((P3FilterData_Type*)0)->word2), NULL, 0 }, // p3ShapeDescTemplate.queryFilterData.word2 + { TYPE_U32, false, (size_t)(&((P3FilterData_Type*)0)->word3), NULL, 0 }, // p3ShapeDescTemplate.queryFilterData.word3 + { TYPE_U64, false, (size_t)(&((P3ShapeDescTemplate_Type*)0)->material), NULL, 0 }, // p3ShapeDescTemplate.material + { TYPE_F32, false, (size_t)(&((P3ShapeDescTemplate_Type*)0)->contactOffset), NULL, 0 }, // p3ShapeDescTemplate.contactOffset + { TYPE_F32, false, (size_t)(&((P3ShapeDescTemplate_Type*)0)->restOffset), NULL, 0 }, // p3ShapeDescTemplate.restOffset + { TYPE_U64, false, (size_t)(&((P3ShapeDescTemplate_Type*)0)->userData), NULL, 0 }, // p3ShapeDescTemplate.userData + { TYPE_U64, false, (size_t)(&((P3ShapeDescTemplate_Type*)0)->name), NULL, 0 }, // p3ShapeDescTemplate.name + { TYPE_STRUCT, false, (size_t)(&((ParametersStruct*)0)->p3ActorDescTemplate), CHILDREN(205), 7 }, // p3ActorDescTemplate + { TYPE_STRUCT, false, (size_t)(&((P3ActorDescTemplate_Type*)0)->flags), CHILDREN(212), 3 }, // p3ActorDescTemplate.flags + { TYPE_BOOL, false, (size_t)(&((P3ActorFlags_Type*)0)->eVISUALIZATION), NULL, 0 }, // p3ActorDescTemplate.flags.eVISUALIZATION + { TYPE_BOOL, false, (size_t)(&((P3ActorFlags_Type*)0)->eDISABLE_GRAVITY), NULL, 0 }, // p3ActorDescTemplate.flags.eDISABLE_GRAVITY + { TYPE_BOOL, false, (size_t)(&((P3ActorFlags_Type*)0)->eSEND_SLEEP_NOTIFIES), NULL, 0 }, // p3ActorDescTemplate.flags.eSEND_SLEEP_NOTIFIES + { TYPE_U8, false, (size_t)(&((P3ActorDescTemplate_Type*)0)->dominanceGroup), NULL, 0 }, // p3ActorDescTemplate.dominanceGroup + { TYPE_U8, false, (size_t)(&((P3ActorDescTemplate_Type*)0)->ownerClient), NULL, 0 }, // p3ActorDescTemplate.ownerClient + { TYPE_U32, false, (size_t)(&((P3ActorDescTemplate_Type*)0)->clientBehaviorBits), NULL, 0 }, // p3ActorDescTemplate.clientBehaviorBits + { TYPE_STRUCT, false, (size_t)(&((P3ActorDescTemplate_Type*)0)->contactReportFlags), CHILDREN(215), 15 }, // p3ActorDescTemplate.contactReportFlags + { TYPE_BOOL, false, (size_t)(&((P3PairFlag_Type*)0)->eSOLVE_CONTACT), NULL, 0 }, // p3ActorDescTemplate.contactReportFlags.eSOLVE_CONTACT + { TYPE_BOOL, false, (size_t)(&((P3PairFlag_Type*)0)->eMODIFY_CONTACTS), NULL, 0 }, // p3ActorDescTemplate.contactReportFlags.eMODIFY_CONTACTS + { TYPE_BOOL, false, (size_t)(&((P3PairFlag_Type*)0)->eNOTIFY_TOUCH_FOUND), NULL, 0 }, // p3ActorDescTemplate.contactReportFlags.eNOTIFY_TOUCH_FOUND + { TYPE_BOOL, false, (size_t)(&((P3PairFlag_Type*)0)->eNOTIFY_TOUCH_PERSISTS), NULL, 0 }, // p3ActorDescTemplate.contactReportFlags.eNOTIFY_TOUCH_PERSISTS + { TYPE_BOOL, false, (size_t)(&((P3PairFlag_Type*)0)->eNOTIFY_TOUCH_LOST), NULL, 0 }, // p3ActorDescTemplate.contactReportFlags.eNOTIFY_TOUCH_LOST + { TYPE_BOOL, false, (size_t)(&((P3PairFlag_Type*)0)->eNOTIFY_THRESHOLD_FORCE_FOUND), NULL, 0 }, // p3ActorDescTemplate.contactReportFlags.eNOTIFY_THRESHOLD_FORCE_FOUND + { TYPE_BOOL, false, (size_t)(&((P3PairFlag_Type*)0)->eNOTIFY_THRESHOLD_FORCE_PERSISTS), NULL, 0 }, // p3ActorDescTemplate.contactReportFlags.eNOTIFY_THRESHOLD_FORCE_PERSISTS + { TYPE_BOOL, false, (size_t)(&((P3PairFlag_Type*)0)->eNOTIFY_THRESHOLD_FORCE_LOST), NULL, 0 }, // p3ActorDescTemplate.contactReportFlags.eNOTIFY_THRESHOLD_FORCE_LOST + { TYPE_BOOL, false, (size_t)(&((P3PairFlag_Type*)0)->eNOTIFY_CONTACT_POINTS), NULL, 0 }, // p3ActorDescTemplate.contactReportFlags.eNOTIFY_CONTACT_POINTS + { TYPE_BOOL, false, (size_t)(&((P3PairFlag_Type*)0)->eNOTIFY_CONTACT_FORCES), NULL, 0 }, // p3ActorDescTemplate.contactReportFlags.eNOTIFY_CONTACT_FORCES + { TYPE_BOOL, false, (size_t)(&((P3PairFlag_Type*)0)->eNOTIFY_CONTACT_FORCE_PER_POINT), NULL, 0 }, // p3ActorDescTemplate.contactReportFlags.eNOTIFY_CONTACT_FORCE_PER_POINT + { TYPE_BOOL, false, (size_t)(&((P3PairFlag_Type*)0)->eNOTIFY_CONTACT_FEATURE_INDICES_PER_POINT), NULL, 0 }, // p3ActorDescTemplate.contactReportFlags.eNOTIFY_CONTACT_FEATURE_INDICES_PER_POINT + { TYPE_BOOL, false, (size_t)(&((P3PairFlag_Type*)0)->eDETECT_CCD_CONTACT), NULL, 0 }, // p3ActorDescTemplate.contactReportFlags.eDETECT_CCD_CONTACT + { TYPE_BOOL, false, (size_t)(&((P3PairFlag_Type*)0)->eCONTACT_DEFAULT), NULL, 0 }, // p3ActorDescTemplate.contactReportFlags.eCONTACT_DEFAULT + { TYPE_BOOL, false, (size_t)(&((P3PairFlag_Type*)0)->eTRIGGER_DEFAULT), NULL, 0 }, // p3ActorDescTemplate.contactReportFlags.eTRIGGER_DEFAULT + { TYPE_U64, false, (size_t)(&((P3ActorDescTemplate_Type*)0)->userData), NULL, 0 }, // p3ActorDescTemplate.userData + { TYPE_U64, false, (size_t)(&((P3ActorDescTemplate_Type*)0)->name), NULL, 0 }, // p3ActorDescTemplate.name + { TYPE_STRUCT, false, (size_t)(&((ParametersStruct*)0)->p3BodyDescTemplate), CHILDREN(230), 11 }, // p3BodyDescTemplate + { TYPE_F32, false, (size_t)(&((P3BodyDescTemplate_Type*)0)->density), NULL, 0 }, // p3BodyDescTemplate.density + { TYPE_STRUCT, false, (size_t)(&((P3BodyDescTemplate_Type*)0)->flags), CHILDREN(241), 2 }, // p3BodyDescTemplate.flags + { TYPE_BOOL, false, (size_t)(&((P3BodyDescFlags_Type*)0)->eKINEMATIC), NULL, 0 }, // p3BodyDescTemplate.flags.eKINEMATIC + { TYPE_BOOL, false, (size_t)(&((P3BodyDescFlags_Type*)0)->eENABLE_CCD), NULL, 0 }, // p3BodyDescTemplate.flags.eENABLE_CCD + { TYPE_F32, false, (size_t)(&((P3BodyDescTemplate_Type*)0)->sleepThreshold), NULL, 0 }, // p3BodyDescTemplate.sleepThreshold + { TYPE_F32, false, (size_t)(&((P3BodyDescTemplate_Type*)0)->wakeUpCounter), NULL, 0 }, // p3BodyDescTemplate.wakeUpCounter + { TYPE_F32, false, (size_t)(&((P3BodyDescTemplate_Type*)0)->linearDamping), NULL, 0 }, // p3BodyDescTemplate.linearDamping + { TYPE_F32, false, (size_t)(&((P3BodyDescTemplate_Type*)0)->angularDamping), NULL, 0 }, // p3BodyDescTemplate.angularDamping + { TYPE_F32, false, (size_t)(&((P3BodyDescTemplate_Type*)0)->maxAngularVelocity), NULL, 0 }, // p3BodyDescTemplate.maxAngularVelocity + { TYPE_U32, false, (size_t)(&((P3BodyDescTemplate_Type*)0)->solverIterationCount), NULL, 0 }, // p3BodyDescTemplate.solverIterationCount + { TYPE_U32, false, (size_t)(&((P3BodyDescTemplate_Type*)0)->velocityIterationCount), NULL, 0 }, // p3BodyDescTemplate.velocityIterationCount + { TYPE_F32, false, (size_t)(&((P3BodyDescTemplate_Type*)0)->contactReportThreshold), NULL, 0 }, // p3BodyDescTemplate.contactReportThreshold + { TYPE_F32, false, (size_t)(&((P3BodyDescTemplate_Type*)0)->sleepLinearVelocity), NULL, 0 }, // p3BodyDescTemplate.sleepLinearVelocity + { TYPE_STRUCT, false, (size_t)(&((ParametersStruct*)0)->structureSettings), CHILDREN(243), 3 }, // structureSettings + { TYPE_BOOL, false, (size_t)(&((StructureSettings_Type*)0)->useStressSolver), NULL, 0 }, // structureSettings.useStressSolver + { TYPE_F32, false, (size_t)(&((StructureSettings_Type*)0)->stressSolverTimeDelay), NULL, 0 }, // structureSettings.stressSolverTimeDelay + { TYPE_F32, false, (size_t)(&((StructureSettings_Type*)0)->stressSolverMassThreshold), NULL, 0 }, // structureSettings.stressSolverMassThreshold + { TYPE_STRUCT, false, (size_t)(&((ParametersStruct*)0)->defaultBehaviorGroup), CHILDREN(246), 12 }, // defaultBehaviorGroup + { TYPE_STRING, false, (size_t)(&((BehaviorGroup_Type*)0)->name), NULL, 0 }, // defaultBehaviorGroup.name + { TYPE_F32, false, (size_t)(&((BehaviorGroup_Type*)0)->damageThreshold), NULL, 0 }, // defaultBehaviorGroup.damageThreshold + { TYPE_F32, false, (size_t)(&((BehaviorGroup_Type*)0)->damageToRadius), NULL, 0 }, // defaultBehaviorGroup.damageToRadius + { TYPE_STRUCT, false, (size_t)(&((BehaviorGroup_Type*)0)->damageSpread), CHILDREN(258), 3 }, // defaultBehaviorGroup.damageSpread + { TYPE_F32, false, (size_t)(&((DamageSpreadFunction_Type*)0)->minimumRadius), NULL, 0 }, // defaultBehaviorGroup.damageSpread.minimumRadius + { TYPE_F32, false, (size_t)(&((DamageSpreadFunction_Type*)0)->radiusMultiplier), NULL, 0 }, // defaultBehaviorGroup.damageSpread.radiusMultiplier + { TYPE_F32, false, (size_t)(&((DamageSpreadFunction_Type*)0)->falloffExponent), NULL, 0 }, // defaultBehaviorGroup.damageSpread.falloffExponent + { TYPE_STRUCT, false, (size_t)(&((BehaviorGroup_Type*)0)->damageColorSpread), CHILDREN(261), 3 }, // defaultBehaviorGroup.damageColorSpread + { TYPE_F32, false, (size_t)(&((DamageSpreadFunction_Type*)0)->minimumRadius), NULL, 0 }, // defaultBehaviorGroup.damageColorSpread.minimumRadius + { TYPE_F32, false, (size_t)(&((DamageSpreadFunction_Type*)0)->radiusMultiplier), NULL, 0 }, // defaultBehaviorGroup.damageColorSpread.radiusMultiplier + { TYPE_F32, false, (size_t)(&((DamageSpreadFunction_Type*)0)->falloffExponent), NULL, 0 }, // defaultBehaviorGroup.damageColorSpread.falloffExponent + { TYPE_VEC4, false, (size_t)(&((BehaviorGroup_Type*)0)->damageColorChange), NULL, 0 }, // defaultBehaviorGroup.damageColorChange + { TYPE_F32, false, (size_t)(&((BehaviorGroup_Type*)0)->materialStrength), NULL, 0 }, // defaultBehaviorGroup.materialStrength + { TYPE_F32, false, (size_t)(&((BehaviorGroup_Type*)0)->density), NULL, 0 }, // defaultBehaviorGroup.density + { TYPE_F32, false, (size_t)(&((BehaviorGroup_Type*)0)->fadeOut), NULL, 0 }, // defaultBehaviorGroup.fadeOut + { TYPE_F32, false, (size_t)(&((BehaviorGroup_Type*)0)->maxDepenetrationVelocity), NULL, 0 }, // defaultBehaviorGroup.maxDepenetrationVelocity + { TYPE_STRUCT, false, (size_t)(&((BehaviorGroup_Type*)0)->groupsMask), CHILDREN(264), 5 }, // defaultBehaviorGroup.groupsMask + { TYPE_BOOL, false, (size_t)(&((GroupsMask_Type*)0)->useGroupsMask), NULL, 0 }, // defaultBehaviorGroup.groupsMask.useGroupsMask + { TYPE_U32, false, (size_t)(&((GroupsMask_Type*)0)->bits0), NULL, 0 }, // defaultBehaviorGroup.groupsMask.bits0 + { TYPE_U32, false, (size_t)(&((GroupsMask_Type*)0)->bits1), NULL, 0 }, // defaultBehaviorGroup.groupsMask.bits1 + { TYPE_U32, false, (size_t)(&((GroupsMask_Type*)0)->bits2), NULL, 0 }, // defaultBehaviorGroup.groupsMask.bits2 + { TYPE_U32, false, (size_t)(&((GroupsMask_Type*)0)->bits3), NULL, 0 }, // defaultBehaviorGroup.groupsMask.bits3 + { TYPE_U64, false, (size_t)(&((BehaviorGroup_Type*)0)->userData), NULL, 0 }, // defaultBehaviorGroup.userData + { TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->behaviorGroups), CHILDREN(269), 1 }, // behaviorGroups + { TYPE_STRUCT, false, 1 * sizeof(BehaviorGroup_Type), CHILDREN(270), 12 }, // behaviorGroups[] + { TYPE_STRING, false, (size_t)(&((BehaviorGroup_Type*)0)->name), NULL, 0 }, // behaviorGroups[].name + { TYPE_F32, false, (size_t)(&((BehaviorGroup_Type*)0)->damageThreshold), NULL, 0 }, // behaviorGroups[].damageThreshold + { TYPE_F32, false, (size_t)(&((BehaviorGroup_Type*)0)->damageToRadius), NULL, 0 }, // behaviorGroups[].damageToRadius + { TYPE_STRUCT, false, (size_t)(&((BehaviorGroup_Type*)0)->damageSpread), CHILDREN(282), 3 }, // behaviorGroups[].damageSpread + { TYPE_F32, false, (size_t)(&((DamageSpreadFunction_Type*)0)->minimumRadius), NULL, 0 }, // behaviorGroups[].damageSpread.minimumRadius + { TYPE_F32, false, (size_t)(&((DamageSpreadFunction_Type*)0)->radiusMultiplier), NULL, 0 }, // behaviorGroups[].damageSpread.radiusMultiplier + { TYPE_F32, false, (size_t)(&((DamageSpreadFunction_Type*)0)->falloffExponent), NULL, 0 }, // behaviorGroups[].damageSpread.falloffExponent + { TYPE_STRUCT, false, (size_t)(&((BehaviorGroup_Type*)0)->damageColorSpread), CHILDREN(285), 3 }, // behaviorGroups[].damageColorSpread + { TYPE_F32, false, (size_t)(&((DamageSpreadFunction_Type*)0)->minimumRadius), NULL, 0 }, // behaviorGroups[].damageColorSpread.minimumRadius + { TYPE_F32, false, (size_t)(&((DamageSpreadFunction_Type*)0)->radiusMultiplier), NULL, 0 }, // behaviorGroups[].damageColorSpread.radiusMultiplier + { TYPE_F32, false, (size_t)(&((DamageSpreadFunction_Type*)0)->falloffExponent), NULL, 0 }, // behaviorGroups[].damageColorSpread.falloffExponent + { TYPE_VEC4, false, (size_t)(&((BehaviorGroup_Type*)0)->damageColorChange), NULL, 0 }, // behaviorGroups[].damageColorChange + { TYPE_F32, false, (size_t)(&((BehaviorGroup_Type*)0)->materialStrength), NULL, 0 }, // behaviorGroups[].materialStrength + { TYPE_F32, false, (size_t)(&((BehaviorGroup_Type*)0)->density), NULL, 0 }, // behaviorGroups[].density + { TYPE_F32, false, (size_t)(&((BehaviorGroup_Type*)0)->fadeOut), NULL, 0 }, // behaviorGroups[].fadeOut + { TYPE_F32, false, (size_t)(&((BehaviorGroup_Type*)0)->maxDepenetrationVelocity), NULL, 0 }, // behaviorGroups[].maxDepenetrationVelocity + { TYPE_STRUCT, false, (size_t)(&((BehaviorGroup_Type*)0)->groupsMask), CHILDREN(288), 5 }, // behaviorGroups[].groupsMask + { TYPE_BOOL, false, (size_t)(&((GroupsMask_Type*)0)->useGroupsMask), NULL, 0 }, // behaviorGroups[].groupsMask.useGroupsMask + { TYPE_U32, false, (size_t)(&((GroupsMask_Type*)0)->bits0), NULL, 0 }, // behaviorGroups[].groupsMask.bits0 + { TYPE_U32, false, (size_t)(&((GroupsMask_Type*)0)->bits1), NULL, 0 }, // behaviorGroups[].groupsMask.bits1 + { TYPE_U32, false, (size_t)(&((GroupsMask_Type*)0)->bits2), NULL, 0 }, // behaviorGroups[].groupsMask.bits2 + { TYPE_U32, false, (size_t)(&((GroupsMask_Type*)0)->bits3), NULL, 0 }, // behaviorGroups[].groupsMask.bits3 + { TYPE_U64, false, (size_t)(&((BehaviorGroup_Type*)0)->userData), NULL, 0 }, // behaviorGroups[].userData + { TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->deleteChunksLeavingUserDefinedBB), NULL, 0 }, // deleteChunksLeavingUserDefinedBB + { TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->deleteChunksEnteringUserDefinedBB), NULL, 0 }, // deleteChunksEnteringUserDefinedBB +}; + + +bool DestructibleActorParam::mBuiltFlag = false; +NvParameterized::MutexType DestructibleActorParam::mBuiltFlagMutex; + +DestructibleActorParam::DestructibleActorParam(NvParameterized::Traits* traits, void* buf, int32_t* refCount) : + NvParameters(traits, buf, refCount) +{ + //mParameterizedTraits->registerFactory(className(), &DestructibleActorParamFactoryInst); + + if (!buf) //Do not init data if it is inplace-deserialized + { + initDynamicArrays(); + initStrings(); + initReferences(); + initDefaults(); + } +} + +DestructibleActorParam::~DestructibleActorParam() +{ + freeStrings(); + freeReferences(); + freeDynamicArrays(); +} + +void DestructibleActorParam::destroy() +{ + // We cache these fields here to avoid overwrite in destructor + bool doDeallocateSelf = mDoDeallocateSelf; + NvParameterized::Traits* traits = mParameterizedTraits; + int32_t* refCount = mRefCount; + void* buf = mBuffer; + + this->~DestructibleActorParam(); + + NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf); +} + +const NvParameterized::DefinitionImpl* DestructibleActorParam::getParameterDefinitionTree(void) +{ + if (!mBuiltFlag) // Double-checked lock + { + NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex); + if (!mBuiltFlag) + { + buildTree(); + } + } + + return(&ParamDefTable[0]); +} + +const NvParameterized::DefinitionImpl* DestructibleActorParam::getParameterDefinitionTree(void) const +{ + DestructibleActorParam* tmpParam = const_cast<DestructibleActorParam*>(this); + + if (!mBuiltFlag) // Double-checked lock + { + NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex); + if (!mBuiltFlag) + { + tmpParam->buildTree(); + } + } + + return(&ParamDefTable[0]); +} + +NvParameterized::ErrorType DestructibleActorParam::getParameterHandle(const char* long_name, Handle& handle) const +{ + ErrorType Ret = NvParameters::getParameterHandle(long_name, handle); + if (Ret != ERROR_NONE) + { + return(Ret); + } + + size_t offset; + void* ptr; + + getVarPtr(handle, ptr, offset); + + if (ptr == NULL) + { + return(ERROR_INDEX_OUT_OF_RANGE); + } + + return(ERROR_NONE); +} + +NvParameterized::ErrorType DestructibleActorParam::getParameterHandle(const char* long_name, Handle& handle) +{ + ErrorType Ret = NvParameters::getParameterHandle(long_name, handle); + if (Ret != ERROR_NONE) + { + return(Ret); + } + + size_t offset; + void* ptr; + + getVarPtr(handle, ptr, offset); + + if (ptr == NULL) + { + return(ERROR_INDEX_OUT_OF_RANGE); + } + + return(ERROR_NONE); +} + +void DestructibleActorParam::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const +{ + ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<DestructibleActorParam::ParametersStruct*>(¶meters()), handle, offset); +} + + +/* Dynamic Handle Indices */ +/* [0] - overrideSkinnedMaterialNames (not an array of structs) */ +/* [0] - overrideStaticMaterialNames (not an array of structs) */ +/* [1,0] - behaviorGroups.name */ + +void DestructibleActorParam::freeParameterDefinitionTable(NvParameterized::Traits* traits) +{ + if (!traits) + { + return; + } + + if (!mBuiltFlag) // Double-checked lock + { + return; + } + + NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex); + + if (!mBuiltFlag) + { + return; + } + + for (uint32_t i = 0; i < NumParamDefs; ++i) + { + ParamDefTable[i].~DefinitionImpl(); + } + + traits->free(ParamDefTable); + + mBuiltFlag = false; +} + +#define PDEF_PTR(index) (&ParamDefTable[index]) + +void DestructibleActorParam::buildTree(void) +{ + + uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs; + ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize)); + memset(ParamDefTable, 0, allocSize); + + for (uint32_t i = 0; i < NumParamDefs; ++i) + { + NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits); + } + + // Initialize DefinitionImpl node: nodeIndex=0, longName="" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0]; + ParamDef->init("", TYPE_STRUCT, "STRUCT", true); + + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=1, longName="crumbleEmitterName" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1]; + ParamDef->init("crumbleEmitterName", TYPE_STRING, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The name of the MeshParticleSystem to use for crumbling. This overrides the crumble system defined\nin the DestructibleAsset if specified.\n", true); + HintTable[1].init("shortDescription", "The name of the MeshParticleSystem to use for crumbling", true); + ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=2, longName="crumbleParticleSpacing" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2]; + ParamDef->init("crumbleParticleSpacing", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "How far apart to space the particles when crumling. If set to zero or a negative value, then the spacing is taken to be the crumble emitter's particle radius, if the\ncrumble emitter exists. This spacing will be used when placing particle positions in the crumble emitter and the crumble buffer callback. Note - if there is no crumble emitter\nbut there is a crumble buffer callback, then this value must be positive in order to have a proper spacing for the callback. Otherwise, the callback will not be called.\nThe default value is 0.\n", true); + HintTable[1].init("shortDescription", "How far apart to space the particles when crumbling", true); + ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=3, longName="dustEmitterName" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3]; + ParamDef->init("dustEmitterName", TYPE_STRING, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The name of the MeshParticleSystem to use for fracture-line dust. This overrides the dust system defined\nin the DestructibleAsset if specified.\n", true); + HintTable[1].init("shortDescription", "The name of the MeshParticleSystem to use for fracture-line dust", true); + ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=4, longName="dustParticleSpacing" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4]; + ParamDef->init("dustParticleSpacing", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "How far apart to space the particles when crumling. If set to zero or a negative value, then the spacing is taken to be the dust emitter's particle radius, if the\ndust emitter exists. This spacing will be used when placing particle positions in the dust emitter and the dust particle buffer callback. Note - if there is no dust emitter\nbut there is a dust particle buffer callback, then this value must be positive in order to have a proper spacing for the callback. Otherwise, the callback will not be called.\nThe default value is 0.\n", true); + HintTable[1].init("shortDescription", "How far apart to space the particles when creating dust particles", true); + ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=5, longName="globalPose" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5]; + ParamDef->init("globalPose", TYPE_TRANSFORM, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Initial global pose of undamaged destructible\n", true); + HintTable[1].init("shortDescription", "The initial pose where the destructible actor will be put into the scene", true); + ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=6, longName="scale" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[6]; + ParamDef->init("scale", TYPE_VEC3, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "3D Scale\n", true); + HintTable[1].init("shortDescription", "3D Scale", true); + ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=7, longName="dynamic" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[7]; + ParamDef->init("dynamic", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Whether or not the destructible starts life as a dynamic actor\n", true); + HintTable[1].init("shortDescription", "Whether or not the destructible starts life as a dynamic actor", true); + ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=8, longName="supportDepth" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[8]; + ParamDef->init("supportDepth", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The chunk hierarchy depth at which to create a support graph. Higher depth levels give more detailed support,\nbut will give a higher computational load. Chunks below the support depth will never be supported.\n", true); + HintTable[1].init("shortDescription", "The chunk hierarchy depth at which to create a support graph.", true); + ParamDefTable[8].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=9, longName="formExtendedStructures" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[9]; + ParamDef->init("formExtendedStructures", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If initially static, the destructible will become part of an extended support structure if it is\nin contact with another static destructible that also has this flag set.\n", true); + HintTable[1].init("shortDescription", "If initially static, the destructible will become part of an extended support structure if it is in contact with another static destructible that also has this flag set.", true); + ParamDefTable[9].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=10, longName="performDetailedOverlapTestForExtendedStructures" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[10]; + ParamDef->init("performDetailedOverlapTestForExtendedStructures", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "When testing for chunk overlap with other destructibles in an extended structure (see formExtendedStructures), perform detailed collision test. Otherwise, just test AABBs.\nDefault = TRUE.\n", true); + HintTable[1].init("shortDescription", "When testing for chunk overlap with other destructibles, perform detailed collision test. Otherwise, just test AABBs.", true); + ParamDefTable[10].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=11, longName="keepPreviousFrameBoneBuffer" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[11]; + ParamDef->init("keepPreviousFrameBoneBuffer", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If true, the skinned mesh will hold a bone buffer for the last frame. The poses in the new buffer correspond the poses in the current frame buffer,\n chunk was not visible in the last frame.", true); + HintTable[1].init("shortDescription", "If true, the skinned mesh will hold a bone buffer for the last frame", true); + ParamDefTable[11].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=12, longName="doNotCreateRenderable" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[12]; + ParamDef->init("doNotCreateRenderable", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If true, a renderable will not be created for the destructible actor. This prevents unnecessary updates when the APEX render API is not being used.", true); + HintTable[1].init("shortDescription", "If true, a renderable will not be created for the destructible actor", true); + ParamDefTable[12].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=13, longName="useAssetDefinedSupport" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[13]; + ParamDef->init("useAssetDefinedSupport", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If set, then chunks which are tagged as 'support' chunks (via DestructibleChunkDesc::isSupportChunk)\nwill have environmental support in static destructibles.\nNote: if both ASSET_DEFINED_SUPPORT and WORLD_SUPPORT are set, then chunks must be tagged as\n'support' chunks AND overlap the PxScene's static geometry in order to be environmentally supported.\n", true); + HintTable[1].init("shortDescription", "If set, then chunks which are tagged as 'support' chunks", true); + ParamDefTable[13].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=14, longName="useWorldSupport" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[14]; + ParamDef->init("useWorldSupport", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If set, then chunks which overlap the PxScene\'s static geometry will have environmental support in\nstatic destructibles.\nNote: if both ASSET_DEFINED_SUPPORT and WORLD_SUPPORT are set, then chunks must be tagged as\n'support' chunks AND overlap the PxScene's static geometry in order to be environmentally supported.\n", true); + HintTable[1].init("shortDescription", "If set, then chunks which overlap the PxScene's static geometry will have environmental support", true); + ParamDefTable[14].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=15, longName="renderStaticChunksSeparately" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[15]; + ParamDef->init("renderStaticChunksSeparately", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If true, static chunks will be renderered separately from dynamic chunks, as a single mesh (not using skinning).\nThis parameter is ignored if the \'dynamic\' parameter is true.\nDefault value = false.\n", true); + HintTable[1].init("shortDescription", "Whether or not to render static chunks in a separate mesh", true); + ParamDefTable[15].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=16, longName="keepVisibleBonesPacked" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[16]; + ParamDef->init("keepVisibleBonesPacked", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Parameter passed into skinned ApexRenderMeshActor. If true, visible bone matrices are packed into the bone render buffer, and a per-actor vertex buffer is created to handle re-indexed bones.\nDefault value = true.\n", true); + HintTable[1].init("shortDescription", "Parameter passed into skinned ApexRenderMeshActor", true); + ParamDefTable[16].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=17, longName="createChunkEvents" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[17]; + ParamDef->init("createChunkEvents", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Whether or not to create an event buffer for chunk.\nIf true, the user has access to a chunk event buffer, which currently holds visibility state change events.\nThe user must empty this buffer themselves after reading, otherwise it will continue to grow as new events are added.\nDefault value = false.\n", true); + HintTable[1].init("shortDescription", "Whether or not to create an event buffer for chunks", true); + ParamDefTable[17].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=18, longName="overrideSkinnedMaterialNames" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[18]; + ParamDef->init("overrideSkinnedMaterialNames", TYPE_ARRAY, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Per-actor material names, to override those in the asset, for skinned rendering.", true); + HintTable[1].init("shortDescription", "Per-actor material names, to override those in the asset, for skinned rendering", true); + ParamDefTable[18].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + ParamDef->setArraySize(-1); + static const uint8_t dynHandleIndices[1] = { 0, }; + ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1); + + } + + // Initialize DefinitionImpl node: nodeIndex=19, longName="overrideSkinnedMaterialNames[]" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[19]; + ParamDef->init("overrideSkinnedMaterialNames", TYPE_STRING, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Per-actor material names, to override those in the asset, for skinned rendering.", true); + HintTable[1].init("shortDescription", "Per-actor material names, to override those in the asset, for skinned rendering", true); + ParamDefTable[19].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=20, longName="overrideStaticMaterialNames" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[20]; + ParamDef->init("overrideStaticMaterialNames", TYPE_ARRAY, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Per-actor material names, to override those in the asset, for static rendering.", true); + HintTable[1].init("shortDescription", "Per-actor material names, to override those in the asset, for static rendering", true); + ParamDefTable[20].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + ParamDef->setArraySize(-1); + static const uint8_t dynHandleIndices[1] = { 0, }; + ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1); + + } + + // Initialize DefinitionImpl node: nodeIndex=21, longName="overrideStaticMaterialNames[]" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[21]; + ParamDef->init("overrideStaticMaterialNames", TYPE_STRING, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Per-actor material names, to override those in the asset, for static rendering.", true); + HintTable[1].init("shortDescription", "Per-actor material names, to override those in the asset, for static rendering", true); + ParamDefTable[21].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=22, longName="sleepVelocityFrameDecayConstant" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[22]; + ParamDef->init("sleepVelocityFrameDecayConstant", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Frame memory decay constant used for actor velocity smoothing. Valid range: [1.0,infinity). Roughly speaking,\n the number of frames for which past velocities have significance. A value of 1.0 (or less) gives no smoothing.", true); + HintTable[1].init("shortDescription", "Frame memory decay constant used for actor velocity smoothing. Valid range: [1.0,infinity).", true); + ParamDefTable[22].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=23, longName="useHardSleeping" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[23]; + ParamDef->init("useHardSleeping", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If true, turn chunk islands kinematic when they sleep. These islands may be turned dynamic again if enough damage is applied.", true); + HintTable[1].init("shortDescription", "If true, turn chunk islands kinematic when they sleep.", true); + ParamDefTable[23].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=24, longName="destructibleParameters" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[24]; + ParamDef->init("destructibleParameters", TYPE_STRUCT, "DestructibleParameters", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Parameters controlling the destruction properties - damage thresholds, damage radius multipliers, etc.\n", true); + HintTable[1].init("shortDescription", "Parameters controlling the destruction properties - damage thresholds, damage radius multipliers, etc.", true); + ParamDefTable[24].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=25, longName="destructibleParameters.damageCap" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[25]; + ParamDef->init("damageCap", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Limits the amount of damage applied to a chunk. This is useful for preventing the entire destructible\nfrom getting pulverized by a very large application of damage. This can easily happen when impact damage is\nused, and the damage amount is proportional to the impact force (see forceToDamage).\n", true); + HintTable[1].init("shortDescription", "Limits the amount of damage applied to a chunk.", true); + ParamDefTable[25].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=26, longName="destructibleParameters.forceToDamage" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[26]; + ParamDef->init("forceToDamage", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If a chunk is at a depth which takes impact damage (see NxDestructibleDepthParameters),\nthen when a chunk has a collision in the NxScene, it will take damage equal to forceToDamage mulitplied by\nthe impact force.\nThe default value is zero, which effectively disables impact damage.\n", true); + HintTable[1].init("shortDescription", "Multiplier to calculate applied damage from an impact.", true); + ParamDefTable[26].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=27, longName="destructibleParameters.impactVelocityThreshold" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[27]; + ParamDef->init("impactVelocityThreshold", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Large impact force may be reported if rigid bodies are spawned inside one another. In this case the relative velocity of the two\nobjects will be low. This variable allows the user to set a minimum velocity threshold for impacts to ensure that the objects are\nmoving at a min velocity in order for the impact force to be considered.\n", true); + HintTable[1].init("shortDescription", "Large impact force may be reported if rigid bodies are spawned inside one another.", true); + ParamDefTable[27].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=28, longName="destructibleParameters.minimumFractureDepth" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[28]; + ParamDef->init("minimumFractureDepth", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Chunks will not be broken free below this depth.\n", true); + HintTable[1].init("shortDescription", "The chunks will not be broken free below this depth.", true); + ParamDefTable[28].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=29, longName="destructibleParameters.impactDamageDefaultDepth" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[29]; + ParamDef->init("impactDamageDefaultDepth", TYPE_I32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The default depth to which chunks will take impact damage. This default may be overridden in the depth settings.\n", true); + HintTable[1].init("shortDescription", "The default depth to which chunks will take impact damage.", true); + ParamDefTable[29].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=30, longName="destructibleParameters.debrisDepth" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[30]; + ParamDef->init("debrisDepth", TYPE_I32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The chunk hierarchy depth at which chunks are considered to be 'debris.' Chunks at this depth or\nbelow will be considered for various debris settings, such as debrisLifetime.\nNegative values indicate that no chunk depth is considered debris.\nDefault value is -1.\n", true); + HintTable[1].init("shortDescription", "The chunk hierarchy depth at which chunks are considered to be 'debris.'", true); + ParamDefTable[30].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=31, longName="destructibleParameters.essentialDepth" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[31]; + ParamDef->init("essentialDepth", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The chunk hierarchy depth up to which chunks will always be processed. These chunks are considered\nto be essential either for gameplay or visually.\nThe minimum value is 0, meaning the level 0 chunk is always considered essential.\nDefault value is 0.\n", true); + HintTable[1].init("shortDescription", "The chunk hierarchy depth up to which chunks will always be processed", true); + ParamDefTable[31].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=32, longName="destructibleParameters.debrisLifetimeMin" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[32]; + ParamDef->init("debrisLifetimeMin", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "'Debris chunks' (see debrisDepth, above) will be destroyed after a time (in seconds)\nseparated from non-debris chunks. The actual lifetime is interpolated between\ndebrisLifetimeMin and debrisLifetimeMax (see below), based upon the module\'s LOD setting.\nTo disable lifetime, clear the NxDestructibleDepthParametersFlag::DEBRIS_TIMEOUT\nflag in the flags field. If debrisLifetimeMax < debrisLifetimeMin, the mean of the two\nis used for both.\nDefault debrisLifetimeMin = 1.0, debrisLifetimeMax = 10.0f.\n", true); + HintTable[1].init("shortDescription", "Minimum time to destroy debris", true); + ParamDefTable[32].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=33, longName="destructibleParameters.debrisLifetimeMax" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[33]; + ParamDef->init("debrisLifetimeMax", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "'Debris chunks' (see debrisDepth, above) will be destroyed after a time (in seconds)\nseparated from non-debris chunks. The actual lifetime is interpolated between\ndebrisLifetimeMin (see above) and debrisLifetimeMax, based upon the module\'s LOD setting.\nTo disable lifetime, clear the NxDestructibleDepthParametersFlag::DEBRIS_TIMEOUT\nflag in the flags field. If debrisLifetimeMax < debrisLifetimeMin, the mean of the two\nis used for both.\nDefault debrisLifetimeMin = 1.0, debrisLifetimeMax = 10.0f.\n", true); + HintTable[1].init("shortDescription", "Maximum time to destroy debris", true); + ParamDefTable[33].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=34, longName="destructibleParameters.debrisMaxSeparationMin" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[34]; + ParamDef->init("debrisMaxSeparationMin", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "'Debris chunks' (see debrisDepth, above) will be destroyed if they are separated from\ntheir origin by a distance greater than maxSeparation. The actual maxSeparation is\ninterpolated between debrisMaxSeparationMin and debrisMaxSeparationMax (see below),\nbased upon the module\'s LOD setting. To disable maxSeparation, clear the\nNX_DESTRUCTIBLE_DEBRIS_MAX_SEPARATION flag in the flags field.\nIf debrisMaxSeparationMax < debrisMaxSeparationMin, the mean of the two is used for both.\nDefault debrisMaxSeparationMin = 1.0, debrisMaxSeparationMax = 10.0f.\n", true); + HintTable[1].init("shortDescription", "Minimum separation distance", true); + ParamDefTable[34].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=35, longName="destructibleParameters.debrisMaxSeparationMax" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[35]; + ParamDef->init("debrisMaxSeparationMax", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "'Debris chunks' (see debrisDepth, above) will be destroyed if they are separated from\ntheir origin by a distance greater than maxSeparation. The actual maxSeparation is\ninterpolated between debrisMaxSeparationMin (see above) and debrisMaxSeparationMax,\nbased upon the module\'s LOD setting. To disable maxSeparation, clear the\nNX_DESTRUCTIBLE_DEBRIS_MAX_SEPARATION flag in the flags field.\nIf debrisMaxSeparationMax < debrisMaxSeparationMin, the mean of the two is used for both.\nDefault debrisMaxSeparationMin = 1.0, debrisMaxSeparationMax = 10.0f.\n", true); + HintTable[1].init("shortDescription", "Minimum separation distance", true); + ParamDefTable[35].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=36, longName="destructibleParameters.debrisDestructionProbability" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[36]; + ParamDef->init("debrisDestructionProbability", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The probablity that a debris chunk, when fractured, will simply be destroyed instead of becoming dynamic or breaking down\n further into child chunks. Valid range = [0.0,1.0]. Default value = 0.0.", true); + HintTable[1].init("shortDescription", "The probablity that a debris chunk, when fractured, will simply be destroyed", true); + ParamDefTable[36].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=37, longName="destructibleParameters.validBounds" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[37]; + ParamDef->init("validBounds", TYPE_BOUNDS3, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "A bounding box around each NxDestructibleActor created, defining a range of validity\nfor chunks that break free. These bounds are scaled and translated with the\nNxDestructibleActor\'s scale and position, but they are not rotated with the\nNxDestructibleActor.\n", true); + HintTable[1].init("shortDescription", "valid bounding region for debris", true); + ParamDefTable[37].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=38, longName="destructibleParameters.maxChunkSpeed" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[38]; + ParamDef->init("maxChunkSpeed", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If greater than 0, the chunks' speeds will not be allowed to exceed this value. Use 0\nto disable this feature (this is the default).\n", true); + HintTable[1].init("shortDescription", "Maximum speed of a chunk", true); + ParamDefTable[38].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=39, longName="destructibleParameters.flags" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[39]; + ParamDef->init("flags", TYPE_STRUCT, "DestructibleParametersFlag", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "A collection of flags defined in NxDestructibleParametersFlag.\n", true); + HintTable[1].init("shortDescription", "A collection of flags defined in DestructibleParametersFlag.", true); + ParamDefTable[39].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=40, longName="destructibleParameters.flags.ACCUMULATE_DAMAGE" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[40]; + ParamDef->init("ACCUMULATE_DAMAGE", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If set, chunks will 'remember' damage applied to them, so that many applications of a damage amount\nbelow damageThreshold will eventually fracture the chunk. If not set, a single application of\ndamage must exceed damageThreshold in order to fracture the chunk.\n", true); + HintTable[1].init("shortDescription", "Determines if chunks accumulate damage", true); + ParamDefTable[40].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=41, longName="destructibleParameters.flags.DEBRIS_TIMEOUT" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[41]; + ParamDef->init("DEBRIS_TIMEOUT", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Whether or not chunks at or deeper than the 'debris' depth (see NxDestructibleParameters::debrisDepth)\nwill time out. The lifetime is a value between NxDestructibleParameters::debrisLifetimeMin and\nNxDestructibleParameters::debrisLifetimeMax, based upon the destructible module\'s LOD setting.\n", true); + HintTable[1].init("shortDescription", "Whether or not chunks at or deeper than the 'debris' depth will timeout", true); + ParamDefTable[41].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=42, longName="destructibleParameters.flags.DEBRIS_MAX_SEPARATION" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[42]; + ParamDef->init("DEBRIS_MAX_SEPARATION", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Whether or not chunks at or deeper than the 'debris' depth (see NxDestructibleParameters::debrisDepth)\nwill be removed if they separate too far from their origins. The maxSeparation is a value between\nNxDestructibleParameters::debrisMaxSeparationMin and NxDestructibleParameters::debrisMaxSeparationMax,\nbased upon the destructible module\'s LOD setting.\n", true); + HintTable[1].init("shortDescription", "Whether or not chunks at or deeper than the 'debris' depth will be removed if separated too far", true); + ParamDefTable[42].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=43, longName="destructibleParameters.flags.CRUMBLE_SMALLEST_CHUNKS" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[43]; + ParamDef->init("CRUMBLE_SMALLEST_CHUNKS", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If set, the smallest chunks may be further broken down, either by fluid crumbles (if a crumble particle\nsystem is specified in the NxDestructibleActorDesc), or by simply removing the chunk if no crumble\nparticle system is specified. Note: the 'smallest chunks' are normally defined to be the deepest level\nof the fracture hierarchy. However, they may be taken from higher levels of the hierarchy if\nNxModuleDestructible::setMaxChunkDepthOffset is called with a non-zero value.\n", true); + HintTable[1].init("shortDescription", "If set, the smallest chunks may be further broken down", true); + ParamDefTable[43].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=44, longName="destructibleParameters.flags.ACCURATE_RAYCASTS" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[44]; + ParamDef->init("ACCURATE_RAYCASTS", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If set, the NxDestructibleActor::rayCast function will search within the nearest visible chunk hit\nfor collisions with child chunks. This is used to get a better raycast position and normal, in\ncase the parent collision volume does not tightly fit the graphics mesh. The returned chunk index\nwill always be that of the visible parent that is intersected, however.\n", true); + HintTable[1].init("shortDescription", "If set, the NxDestructibleActor::rayCast function will search within the nearest visible chunk hit", true); + ParamDefTable[44].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=45, longName="destructibleParameters.flags.USE_VALID_BOUNDS" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[45]; + ParamDef->init("USE_VALID_BOUNDS", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If set, the validBounds field of NxDestructibleParameters will be used. These bounds are translated\n(but not scaled or rotated) to the origin of the destructible actor. If a chunk or chunk island moves\noutside of those bounds, it is destroyed.\n", true); + HintTable[1].init("shortDescription", "If set, the validBounds field of NxDestructibleParameters will be used.", true); + ParamDefTable[45].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=46, longName="destructibleParameters.flags.CRUMBLE_VIA_RUNTIME_FRACTURE" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[46]; + ParamDef->init("CRUMBLE_VIA_RUNTIME_FRACTURE", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If set, crumbled chunks will use the runtime fracture pipeline. The chunk will be procedurally broken\ndestroyed using either the default or a specified fracture pattern.\n", true); + HintTable[1].init("shortDescription", "If set, crumbled chunks will use the runtime fracture pipeline.", true); + ParamDefTable[46].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=47, longName="destructibleParameters.fractureImpulseScale" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[47]; + ParamDef->init("fractureImpulseScale", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Scale factor used to apply an impulse force along the normal of chunk when fractured. This is used\nin order to 'push' the pieces out as they fracture.\n", true); + HintTable[1].init("shortDescription", "Scale factor used to apply an impulse force along the normal of chunk when fractured.", true); + ParamDefTable[47].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=48, longName="destructibleParameters.damageDepthLimit" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[48]; + ParamDef->init("damageDepthLimit", TYPE_U16, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "How deep in the hierarchy damage will be propagated, relative to the chunk hit.", true); + HintTable[1].init("shortDescription", "How deep in the hierarchy damage will be propagated, relative to the chunk hit.", true); + ParamDefTable[48].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=49, longName="destructibleParameters.dynamicChunkDominanceGroup" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[49]; + ParamDef->init("dynamicChunkDominanceGroup", TYPE_U16, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Optional dominance group for dynamic chunks created when fractured. (ignored if > 31)\n", true); + HintTable[1].init("shortDescription", "Optional dominance group for dynamic chunks created when fractured.", true); + ParamDefTable[49].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=50, longName="destructibleParameters.dynamicChunksGroupsMask" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[50]; + ParamDef->init("dynamicChunksGroupsMask", TYPE_STRUCT, "GroupsMask", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Optional groups mask for dynamic chunks created when fractured.\n", true); + HintTable[1].init("shortDescription", "Optional groups mask for dynamic chunks created when fractured.", true); + ParamDefTable[50].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=51, longName="destructibleParameters.dynamicChunksGroupsMask.useGroupsMask" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[51]; + ParamDef->init("useGroupsMask", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Whether or not the groupsMask should be used. If so, then this will be applied to all NxShapes\n created to represent this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Whether or not the groupsMask should be used", true); + ParamDefTable[51].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=52, longName="destructibleParameters.dynamicChunksGroupsMask.bits0" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[52]; + ParamDef->init("bits0", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If useGroupsMask is true, this is bits0 of the groups mask. See the PhysX documentation for more on groups masks.", true); + HintTable[1].init("shortDescription", "bits0 of the groups mask", true); + ParamDefTable[52].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=53, longName="destructibleParameters.dynamicChunksGroupsMask.bits1" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[53]; + ParamDef->init("bits1", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If useGroupsMask is true, this is bits1 of the groups mask. See the PhysX documentation for more on groups masks.", true); + HintTable[1].init("shortDescription", "bits1 of the groups mask", true); + ParamDefTable[53].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=54, longName="destructibleParameters.dynamicChunksGroupsMask.bits2" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[54]; + ParamDef->init("bits2", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If useGroupsMask is true, this is bits2 of the groups mask. See the PhysX documentation for more on groups masks.", true); + HintTable[1].init("shortDescription", "bits2 of the groups mask", true); + ParamDefTable[54].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=55, longName="destructibleParameters.dynamicChunksGroupsMask.bits3" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[55]; + ParamDef->init("bits3", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If useGroupsMask is true, this is bits3 of the groups mask. See the PhysX documentation for more on groups masks.", true); + HintTable[1].init("shortDescription", "bits3 of the groups mask", true); + ParamDefTable[55].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=56, longName="destructibleParameters.runtimeFracture" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[56]; + ParamDef->init("runtimeFracture", TYPE_STRUCT, "RuntimeFracture", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Runtime Fracture Settings. 'CRUMBLE_VIA_RUNTIME_FRACTURE' must be set for this to do anything.\n", true); + HintTable[1].init("shortDescription", "Runtime Fracture Settings", true); + ParamDefTable[56].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=57, longName="destructibleParameters.runtimeFracture.RuntimeFractureType" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[57]; + ParamDef->init("RuntimeFractureType", TYPE_ENUM, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("shortDescription", "Which type of fracture pattern to choose", true); + ParamDefTable[57].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + static const char* const EnumVals[] = { "VORONOI", "GLASS" }; + ParamDefTable[57].setEnumVals((const char**)EnumVals, 2); + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=58, longName="destructibleParameters.runtimeFracture.sheetFracture" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[58]; + ParamDef->init("sheetFracture", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If true, align fracture pattern to largest face. \nIf false, the fracture pattern will be aligned to the hit normal with each fracture.\n", true); + HintTable[1].init("shortDescription", "If true, align fracture pattern to largest face", true); + ParamDefTable[58].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=59, longName="destructibleParameters.runtimeFracture.depthLimit" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[59]; + ParamDef->init("depthLimit", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Number of times deep a chunk can be fractured. Can help limit the number of chunks produced by\nruntime fracture.\n", true); + HintTable[1].init("shortDescription", "Number of times deep a chunk can be fractured.", true); + ParamDefTable[59].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=60, longName="destructibleParameters.runtimeFracture.destroyIfAtDepthLimit" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[60]; + ParamDef->init("destroyIfAtDepthLimit", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If true, destroy chunks when they hit their depth limit. \nIf false, then chunks at their depth limit will not fracture but will have a force applied.\n", true); + HintTable[1].init("shortDescription", "Destroy chunk if at depth limit", true); + ParamDefTable[60].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=61, longName="destructibleParameters.runtimeFracture.minConvexSize" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[61]; + ParamDef->init("minConvexSize", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Minimum Convex Size. Minimum size of convex produced by a fracture.\n", true); + HintTable[1].init("shortDescription", "Minimum Convex Size.", true); + ParamDefTable[61].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=62, longName="destructibleParameters.runtimeFracture.impulseScale" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[62]; + ParamDef->init("impulseScale", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Scales impulse applied by a fracture.\n", true); + HintTable[1].init("shortDescription", "Scales impulse applied by a fracture.", true); + ParamDefTable[62].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=63, longName="destructibleParameters.runtimeFracture.glass" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[63]; + ParamDef->init("glass", TYPE_STRUCT, "FractureGlass", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Glass Fracture Pattern Settings.\n", true); + HintTable[1].init("shortDescription", "Glass Fracture Pattern Settings.", true); + ParamDefTable[63].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=64, longName="destructibleParameters.runtimeFracture.glass.numSectors" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[64]; + ParamDef->init("numSectors", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Number of angular slices in the glass fracture pattern. \n", true); + HintTable[1].init("shortDescription", "Number of angular slices.", true); + ParamDefTable[64].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=65, longName="destructibleParameters.runtimeFracture.glass.sectorRand" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[65]; + ParamDef->init("sectorRand", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Creates variance in the angle of slices. A value of zero results in all angular slices having the same angle.\n", true); + HintTable[1].init("shortDescription", "Creates variance in the angle of slices.", true); + ParamDefTable[65].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=66, longName="destructibleParameters.runtimeFracture.glass.firstSegmentSize" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[66]; + ParamDef->init("firstSegmentSize", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The minimum shard size. Shards below this size will not be created and thus not visible.\n", true); + HintTable[1].init("shortDescription", "The minimum shard size.", true); + ParamDefTable[66].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=67, longName="destructibleParameters.runtimeFracture.glass.segmentScale" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[67]; + ParamDef->init("segmentScale", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Scales the radial spacing in the glass fracture pattern. A larger value results in radially longer shards.\n", true); + HintTable[1].init("shortDescription", "Scales the radial spacing.", true); + ParamDefTable[67].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=68, longName="destructibleParameters.runtimeFracture.glass.segmentRand" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[68]; + ParamDef->init("segmentRand", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Creates variance in the radial size of shards. A value of zero results in a low noise circular pattern.\n", true); + HintTable[1].init("shortDescription", "Creates variance in the radial size of shards.", true); + ParamDefTable[68].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=69, longName="destructibleParameters.runtimeFracture.voronoi" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[69]; + ParamDef->init("voronoi", TYPE_STRUCT, "FractureVoronoi", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Voronoi Fracture Pattern Settings.\n", true); + HintTable[1].init("shortDescription", "Voronoi Fracture Pattern Settings.", true); + ParamDefTable[69].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=70, longName="destructibleParameters.runtimeFracture.voronoi.dimensions" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[70]; + ParamDef->init("dimensions", TYPE_VEC3, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The size of the entire block. \n", true); + HintTable[1].init("shortDescription", "The size of the entire block", true); + ParamDefTable[70].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=71, longName="destructibleParameters.runtimeFracture.voronoi.numCells" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[71]; + ParamDef->init("numCells", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Number of Cells corresponds to the number of chunks to create during the fracture, default value is only one chunk.\n", true); + HintTable[1].init("shortDescription", "Max Number of Cells to create.", true); + ParamDefTable[71].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=72, longName="destructibleParameters.runtimeFracture.voronoi.biasExp" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[72]; + ParamDef->init("biasExp", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Bias Exponential value is used in distributing voronoi points which is used to fracture the original chunk.\n", true); + HintTable[1].init("shortDescription", "Bias Exponential value.", true); + ParamDefTable[72].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=73, longName="destructibleParameters.runtimeFracture.voronoi.maxDist" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[73]; + ParamDef->init("maxDist", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "This is to prevent a illegal voronoi point that's used to generate voronoi chunks.\n", true); + HintTable[1].init("shortDescription", "The max distance a Voronoi point away from origin.", true); + ParamDefTable[73].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=74, longName="destructibleParameters.runtimeFracture.attachment" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[74]; + ParamDef->init("attachment", TYPE_STRUCT, "FractureAttachment", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Attachment Settings. Allows the sides of a runtime fracture chunk to be kinematic rather than dynamic.\n", true); + HintTable[1].init("shortDescription", "Attachment Settings", true); + ParamDefTable[74].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=75, longName="destructibleParameters.runtimeFracture.attachment.posX" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[75]; + ParamDef->init("posX", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If true, make the positive x side of the sheet an attachment point.\n", true); + HintTable[1].init("shortDescription", "Attach to positive x side of sheet.", true); + ParamDefTable[75].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=76, longName="destructibleParameters.runtimeFracture.attachment.negX" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[76]; + ParamDef->init("negX", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If true, make the negative x side of the sheet an attachment point.\n", true); + HintTable[1].init("shortDescription", "Attach to negative x side of sheet.", true); + ParamDefTable[76].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=77, longName="destructibleParameters.runtimeFracture.attachment.posY" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[77]; + ParamDef->init("posY", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If true, make the positive y side of the sheet an attachment point.\n", true); + HintTable[1].init("shortDescription", "Attach to positive y side of sheet.", true); + ParamDefTable[77].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=78, longName="destructibleParameters.runtimeFracture.attachment.negY" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[78]; + ParamDef->init("negY", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If true, make the negative y side of the sheet an attachment point.\n", true); + HintTable[1].init("shortDescription", "Attach to negative y side of sheet.", true); + ParamDefTable[78].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=79, longName="destructibleParameters.runtimeFracture.attachment.posZ" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[79]; + ParamDef->init("posZ", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If true, make the positive z side of the sheet an attachment point.\n", true); + HintTable[1].init("shortDescription", "Attach to positive z side of sheet.", true); + ParamDefTable[79].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=80, longName="destructibleParameters.runtimeFracture.attachment.negZ" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[80]; + ParamDef->init("negZ", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If true, make the negative z side of the sheet an attachment point.\n", true); + HintTable[1].init("shortDescription", "Attach to negative z side of sheet.", true); + ParamDefTable[80].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=81, longName="destructibleParameters.supportStrength" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[81]; + ParamDef->init("supportStrength", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The larger the supportStrength is, the harder it will break under stressSolver. SupportStrength should be larger\nthan 0.0 so that it is not extremely fragile.\nDefault supportStrength = -1.0 which means strength is turned off initially.\n", true); + HintTable[1].init("shortDescription", "The support strength threshold for breaking chunks in stressSolver", true); + ParamDefTable[81].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=82, longName="destructibleParameters.legacyChunkBoundsTestSetting" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[82]; + ParamDef->init("legacyChunkBoundsTestSetting", TYPE_I8, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Whether or not to use the old chunk bounds testing for damage, or use the module setting. A value of 0 forces the new method to be used.\nA positive value forces the old method to be used. Negative values cause the global (NxModuleDestructible) setting to be used.\n", true); + HintTable[1].init("shortDescription", "Whether or not to use the old chunk bounds testing for damage, or use the module setting.", true); + ParamDefTable[82].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=83, longName="destructibleParameters.legacyDamageRadiusSpreadSetting" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[83]; + ParamDef->init("legacyDamageRadiusSpreadSetting", TYPE_I8, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("END", "", true); + ParamDefTable[83].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("END", "", true); + HintTable[1].init("longDescription", "Whether or not to use the old damage spread method, or use the module setting. A value of 0 forces the new method to be used.\nA positive value forces the old method to be used. Negative values cause the global (NxModuleDestructible) setting to be used.\n", true); + HintTable[2].init("shortDescription", "Whether or not to use the old damage spread method, or use the module setting.", true); + ParamDefTable[83].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=84, longName="destructibleParameters.alwaysDrawScatterMesh" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[84]; + ParamDef->init("alwaysDrawScatterMesh", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Scatter mesh visibility is controlled by LOD. If asset has more than one depth level, scatter mesh is not drawn.\n This flag forces drawing of scatter mesh on chunks with depth > 1.", true); + HintTable[1].init("shortDescription", "Always draw scatter mesh on the chunks with depth > 1", true); + ParamDefTable[84].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=85, longName="depthParameters" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[85]; + ParamDef->init("depthParameters", TYPE_ARRAY, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Parameters that apply to every chunk at a given level (see DestructibleDepthParameters)\nthe element [0] of the array applies to the level 0 (unfractured) chunk, element [1] applies\nto the level 1 chunks, etc.\n", true); + HintTable[1].init("shortDescription", "Parameters that apply to every chunk at a given level (see DestructibleDepthParameters).", true); + ParamDefTable[85].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + ParamDef->setArraySize(-1); + } + + // Initialize DefinitionImpl node: nodeIndex=86, longName="depthParameters[]" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[86]; + ParamDef->init("depthParameters", TYPE_STRUCT, "DestructibleDepthParameters", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Parameters that apply to every chunk at a given level (see DestructibleDepthParameters)\nthe element [0] of the array applies to the level 0 (unfractured) chunk, element [1] applies\nto the level 1 chunks, etc.\n", true); + HintTable[1].init("shortDescription", "Parameters that apply to every chunk at a given level (see DestructibleDepthParameters).", true); + ParamDefTable[86].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=87, longName="depthParameters[].OVERRIDE_IMPACT_DAMAGE" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[87]; + ParamDef->init("OVERRIDE_IMPACT_DAMAGE", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Chunks at this hierarchy depth level will take impact damage iff OVERRIDE_IMPACT_DAMAGE_VALUE = TRUE, no matter the setting of impactDamageDefaultDepth.\n", true); + HintTable[1].init("shortDescription", "If true, chunks at this hierarchy depth level will take impact damage iff OVERRIDE_IMPACT_DAMAGE_VALUE = TRUE, no matter the setting of impactDamageDefaultDepth.", true); + ParamDefTable[87].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=88, longName="depthParameters[].OVERRIDE_IMPACT_DAMAGE_VALUE" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[88]; + ParamDef->init("OVERRIDE_IMPACT_DAMAGE_VALUE", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If OVERRIDE_IMPACT_DAMAGE = TRUE, chunks at this hierarchy depth level will take impact damage iff OVERRIDE_IMPACT_DAMAGE_VALUE = TRUE.\n", true); + HintTable[1].init("shortDescription", "If OVERRIDE_IMPACT_DAMAGE = TRUE, chunks at this hierarchy depth level will take impact damage iff OVERRIDE_IMPACT_DAMAGE_VALUE = TRUE.", true); + ParamDefTable[88].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=89, longName="depthParameters[].IGNORE_POSE_UPDATES" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[89]; + ParamDef->init("IGNORE_POSE_UPDATES", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Chunks at this depth should have pose updates ignored.\n", true); + HintTable[1].init("shortDescription", "Chunks at this depth should have pose updates ignored.", true); + ParamDefTable[89].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=90, longName="depthParameters[].IGNORE_RAYCAST_CALLBACKS" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[90]; + ParamDef->init("IGNORE_RAYCAST_CALLBACKS", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Chunks at this depth should be ignored in raycast callbacks.\n", true); + HintTable[1].init("shortDescription", "Chunks at this depth should be ignored in raycast callbacks.", true); + ParamDefTable[90].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=91, longName="depthParameters[].IGNORE_CONTACT_CALLBACKS" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[91]; + ParamDef->init("IGNORE_CONTACT_CALLBACKS", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Chunks at this depth should be ignored in contact callbacks.\n", true); + HintTable[1].init("shortDescription", "Chunks at this depth should be ignored in contact callbacks.", true); + ParamDefTable[91].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=92, longName="depthParameters[].USER_FLAG_0" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[92]; + ParamDef->init("USER_FLAG_0", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "User defined flag.\n", true); + HintTable[1].init("shortDescription", "User defined flag.", true); + ParamDefTable[92].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=93, longName="depthParameters[].USER_FLAG_1" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[93]; + ParamDef->init("USER_FLAG_1", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "User defined flag.\n", true); + HintTable[1].init("shortDescription", "User defined flag.", true); + ParamDefTable[93].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=94, longName="depthParameters[].USER_FLAG_2" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[94]; + ParamDef->init("USER_FLAG_2", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "User defined flag.\n", true); + HintTable[1].init("shortDescription", "User defined flag.", true); + ParamDefTable[94].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=95, longName="depthParameters[].USER_FLAG_3" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[95]; + ParamDef->init("USER_FLAG_3", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "User defined flag.\n", true); + HintTable[1].init("shortDescription", "User defined flag.", true); + ParamDefTable[95].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=96, longName="shapeDescTemplate" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[96]; + ParamDef->init("shapeDescTemplate", TYPE_STRUCT, "ShapeDescTemplate", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("editorDisplay", "false", true); + ParamDefTable[96].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("editorDisplay", "false", true); + HintTable[1].init("longDescription", "Contains the parameters the application can override on any actor shapes created.", true); + HintTable[2].init("shortDescription", "Contains the parameters the application can override on any actor shapes created", true); + ParamDefTable[96].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=97, longName="shapeDescTemplate.flags" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[97]; + ParamDef->init("flags", TYPE_STRUCT, "ShapeDescFlags", true); + + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=98, longName="shapeDescTemplate.flags.NX_TRIGGER_ON_ENTER" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[98]; + ParamDef->init("NX_TRIGGER_ON_ENTER", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Trigger callback will be called when a shape enters the trigger volume. This flag is applied to all\n NxShapes generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Trigger callback will be called when a shape enters the trigger volume.", true); + ParamDefTable[98].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=99, longName="shapeDescTemplate.flags.NX_TRIGGER_ON_LEAVE" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[99]; + ParamDef->init("NX_TRIGGER_ON_LEAVE", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Trigger callback will be called after a shape leaves the trigger volume. This flag is applied to all\n NxShapes generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Trigger callback will be called after a shape leaves the trigger volume.", true); + ParamDefTable[99].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=100, longName="shapeDescTemplate.flags.NX_TRIGGER_ON_STAY" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[100]; + ParamDef->init("NX_TRIGGER_ON_STAY", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Trigger callback will be called while a shape is intersecting the trigger volume. This flag is applied to all\n NxShapes generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Trigger callback will be called while a shape is intersecting the trigger volume.", true); + ParamDefTable[100].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=101, longName="shapeDescTemplate.flags.NX_SF_VISUALIZATION" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[101]; + ParamDef->init("NX_SF_VISUALIZATION", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Enable debug renderer for shapes. This flag is applied to all\n NxShapes generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Enable debug renderer for shapes", true); + ParamDefTable[101].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=102, longName="shapeDescTemplate.flags.NX_SF_DISABLE_COLLISION" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[102]; + ParamDef->init("NX_SF_DISABLE_COLLISION", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Disable collision detection for shapes (counterpart of NX_AF_DISABLE_COLLISION). This flag is applied to all\n NxShapes generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Disable collision detection for shapes (counterpart of NX_AF_DISABLE_COLLISION)", true); + ParamDefTable[102].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=103, longName="shapeDescTemplate.flags.NX_SF_FEATURE_INDICES" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[103]; + ParamDef->init("NX_SF_FEATURE_INDICES", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Enable feature indices in contact stream. This flag is applied to all\n NxShapes generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Enable feature indices in contact stream.", true); + ParamDefTable[103].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=104, longName="shapeDescTemplate.flags.NX_SF_DISABLE_RAYCASTING" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[104]; + ParamDef->init("NX_SF_DISABLE_RAYCASTING", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Disable raycasting for shapes. This flag is applied to all\n NxShapes generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Disable raycasting for shapes", true); + ParamDefTable[104].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=105, longName="shapeDescTemplate.flags.NX_SF_POINT_CONTACT_FORCE" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[105]; + ParamDef->init("NX_SF_POINT_CONTACT_FORCE", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Enable contact force reporting per contact point in contact stream (otherwise we only report force per actor pair). This flag is applied to all\n NxShapes generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Enable contact force reporting per contact point in contact stream (otherwise we only report force per actor pair)", true); + ParamDefTable[105].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=106, longName="shapeDescTemplate.flags.NX_SF_FLUID_DRAIN" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[106]; + ParamDef->init("NX_SF_FLUID_DRAIN", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Sets a shape to be a fluid drain. This flag is applied to all\n NxShapes generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Sets a shape to be a fluid drain.", true); + ParamDefTable[106].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=107, longName="shapeDescTemplate.flags.NX_SF_FLUID_DISABLE_COLLISION" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[107]; + ParamDef->init("NX_SF_FLUID_DISABLE_COLLISION", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Disable collision with fluids. This flag is applied to all\n NxShapes generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Disable collision with fluids.", true); + ParamDefTable[107].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=108, longName="shapeDescTemplate.flags.NX_SF_FLUID_TWOWAY" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[108]; + ParamDef->init("NX_SF_FLUID_TWOWAY", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Enables the reaction of a shapes actor on fluid collision. This flag is applied to all\n NxShapes generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Enables the reaction of a shapes actor on fluid collision.", true); + ParamDefTable[108].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=109, longName="shapeDescTemplate.flags.NX_SF_DISABLE_RESPONSE" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[109]; + ParamDef->init("NX_SF_DISABLE_RESPONSE", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Disable collision response for shapes (counterpart of NX_AF_DISABLE_RESPONSE). This flag is applied to all\n NxShapes generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Disable collision response for shapes (counterpart of NX_AF_DISABLE_RESPONSE)", true); + ParamDefTable[109].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=110, longName="shapeDescTemplate.flags.NX_SF_DYNAMIC_DYNAMIC_CCD" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[110]; + ParamDef->init("NX_SF_DYNAMIC_DYNAMIC_CCD", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Enable dynamic-dynamic CCD for shapes. Used only when CCD is globally enabled and shape have a CCD skeleton. This flag is applied to all\n NxShapes generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Enable dynamic-dynamic CCD for shapes. Used only when CCD is globally enabled and shape have a CCD skeleton.", true); + ParamDefTable[110].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=111, longName="shapeDescTemplate.flags.NX_SF_DISABLE_SCENE_QUERIES" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[111]; + ParamDef->init("NX_SF_DISABLE_SCENE_QUERIES", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Disable participation in ray casts, overlap tests and sweeps. This flag is applied to all\n NxShapes generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Disable participation in ray casts, overlap tests and sweeps.", true); + ParamDefTable[111].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=112, longName="shapeDescTemplate.flags.NX_SF_CLOTH_DRAIN" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[112]; + ParamDef->init("NX_SF_CLOTH_DRAIN", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Sets a shape to be a cloth drain. This flag is applied to all\n NxShapes generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Sets a shape to be a cloth drain.", true); + ParamDefTable[112].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=113, longName="shapeDescTemplate.flags.NX_SF_CLOTH_DISABLE_COLLISION" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[113]; + ParamDef->init("NX_SF_CLOTH_DISABLE_COLLISION", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Disable collision with cloths. This flag is applied to all\n NxShapes generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Disable collision with cloths.", true); + ParamDefTable[113].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=114, longName="shapeDescTemplate.flags.NX_SF_CLOTH_TWOWAY" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[114]; + ParamDef->init("NX_SF_CLOTH_TWOWAY", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Enables the reaction of a shapes actor on cloth collision. This flag is applied to all\n NxShapes generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Enables the reaction of a shapes actor on cloth collision.", true); + ParamDefTable[114].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=115, longName="shapeDescTemplate.flags.NX_SF_SOFTBODY_DRAIN" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[115]; + ParamDef->init("NX_SF_SOFTBODY_DRAIN", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Sets a shape to be a soft body drain. This flag is applied to all\n NxShapes generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Sets a shape to be a soft body drain.", true); + ParamDefTable[115].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=116, longName="shapeDescTemplate.flags.NX_SF_SOFTBODY_DISABLE_COLLISION" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[116]; + ParamDef->init("NX_SF_SOFTBODY_DISABLE_COLLISION", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Disable collision with soft bodies. This flag is applied to all\n NxShapes generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Disable collision with soft bodies.", true); + ParamDefTable[116].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=117, longName="shapeDescTemplate.flags.NX_SF_SOFTBODY_TWOWAY" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[117]; + ParamDef->init("NX_SF_SOFTBODY_TWOWAY", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Enables the reaction of a shape's actor on soft body collision. This flag is applied to all\n NxShapes generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Enables the reaction of a shape's actor on soft body collision.", true); + ParamDefTable[117].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=118, longName="shapeDescTemplate.collisionGroup" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[118]; + ParamDef->init("collisionGroup", TYPE_U16, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Sets which collision group shapes are part of.\n Default group is 0. Maximum possible group is 31. Collision groups are sets of shapes which may or may not be set to collision detect with each other; this can be set using NxScene::setGroupCollisionFlag() Sleeping: Does NOT wake the associated actor up automatically. param[in] collisionGroup The collision group for shapes.\n This is applied to all NxShapes generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Sets which collision group shapes are part of.", true); + ParamDefTable[118].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=119, longName="shapeDescTemplate.groupsMask" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[119]; + ParamDef->init("groupsMask", TYPE_STRUCT, "GroupsMask", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Sets the 128-bit mask used for collision filtering.\n This is applied to all NxShapes generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Sets the 128-bit mask used for collision filtering.", true); + ParamDefTable[119].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=120, longName="shapeDescTemplate.groupsMask.useGroupsMask" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[120]; + ParamDef->init("useGroupsMask", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Whether or not the groupsMask should be used. If so, then this will be applied to all NxShapes\n created to represent this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Whether or not the groupsMask should be used", true); + ParamDefTable[120].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=121, longName="shapeDescTemplate.groupsMask.bits0" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[121]; + ParamDef->init("bits0", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If useGroupsMask is true, this is bits0 of the groups mask. See the PhysX documentation for more on groups masks.", true); + HintTable[1].init("shortDescription", "bits0 of the groups mask", true); + ParamDefTable[121].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=122, longName="shapeDescTemplate.groupsMask.bits1" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[122]; + ParamDef->init("bits1", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If useGroupsMask is true, this is bits1 of the groups mask. See the PhysX documentation for more on groups masks.", true); + HintTable[1].init("shortDescription", "bits1 of the groups mask", true); + ParamDefTable[122].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=123, longName="shapeDescTemplate.groupsMask.bits2" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[123]; + ParamDef->init("bits2", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If useGroupsMask is true, this is bits2 of the groups mask. See the PhysX documentation for more on groups masks.", true); + HintTable[1].init("shortDescription", "bits2 of the groups mask", true); + ParamDefTable[123].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=124, longName="shapeDescTemplate.groupsMask.bits3" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[124]; + ParamDef->init("bits3", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If useGroupsMask is true, this is bits3 of the groups mask. See the PhysX documentation for more on groups masks.", true); + HintTable[1].init("shortDescription", "bits3 of the groups mask", true); + ParamDefTable[124].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=125, longName="shapeDescTemplate.materialIndex" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[125]; + ParamDef->init("materialIndex", TYPE_U16, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The material index of a shape.\n This is applied to all NxShapes generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "The material index of a shape.", true); + ParamDefTable[125].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=126, longName="shapeDescTemplate.density" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[126]; + ParamDef->init("density", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The density of this individual shape when computing mass inertial properties for a rigidbody (unless a valid mass >0.0 is provided). Note that this will only be used if the body has a zero inertia tensor, or if you call NxActor::updateMassFromShapes explicitly.\n This is applied to all NxShapes generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "The density of an individual shape.", true); + ParamDefTable[126].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=127, longName="shapeDescTemplate.skinWidth" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[127]; + ParamDef->init("skinWidth", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Specifies by how much shapes can interpenetrate; if -1 it uses the global default.\n This is applied to all NxShapes generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Specifies by how much shapes can interpenetrate; if -1 it uses the global default", true); + ParamDefTable[127].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=128, longName="shapeDescTemplate.userData" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[128]; + ParamDef->init("userData", TYPE_U64, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("editorDisplay", "false", true); + ParamDefTable[128].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("editorDisplay", "false", true); + HintTable[1].init("longDescription", "Optional user data pointer.\n This is applied to all NxShapes generated for this destructible's chunks.", true); + HintTable[2].init("shortDescription", "Optional user data pointer", true); + ParamDefTable[128].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=129, longName="shapeDescTemplate.name" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[129]; + ParamDef->init("name", TYPE_U64, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("editorDisplay", "false", true); + ParamDefTable[129].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("editorDisplay", "false", true); + HintTable[1].init("longDescription", "Optional name string for a shape; must be set by the application and must be a persistent pointer.\n This is applied to all NxShapes generated for this destructible's chunks.", true); + HintTable[2].init("shortDescription", "Optional name string for a shape.", true); + ParamDefTable[129].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=130, longName="actorDescTemplate" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[130]; + ParamDef->init("actorDescTemplate", TYPE_STRUCT, "ActorDescTemplate", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("editorDisplay", "false", true); + ParamDefTable[130].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("editorDisplay", "false", true); + HintTable[1].init("longDescription", "Contains the parameters the application can override on any actors created.", true); + HintTable[2].init("shortDescription", "Contains the parameters the application can override on any actors created", true); + ParamDefTable[130].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=131, longName="actorDescTemplate.flags" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[131]; + ParamDef->init("flags", TYPE_STRUCT, "ActorDescFlags", true); + + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=132, longName="actorDescTemplate.flags.NX_AF_DISABLE_COLLISION" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[132]; + ParamDef->init("NX_AF_DISABLE_COLLISION", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Enable/disable collision detection.\n This flag will be applied to all NxActors generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Enable/disable collision detection", true); + ParamDefTable[132].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=133, longName="actorDescTemplate.flags.NX_AF_DISABLE_RESPONSE" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[133]; + ParamDef->init("NX_AF_DISABLE_RESPONSE", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Enable/disable collision response (reports contacts but dont use them).\n This flag will be applied to all NxActors generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Enable/disable collision response (reports contacts but dont use them)", true); + ParamDefTable[133].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=134, longName="actorDescTemplate.flags.NX_AF_LOCK_COM" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[134]; + ParamDef->init("NX_AF_LOCK_COM", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Disables COM update when computing inertial properties at creation time.\n This flag will be applied to all NxActors generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Disables COM update when computing inertial properties at creation time.", true); + ParamDefTable[134].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=135, longName="actorDescTemplate.flags.NX_AF_FLUID_DISABLE_COLLISION" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[135]; + ParamDef->init("NX_AF_FLUID_DISABLE_COLLISION", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Disables COM update when computing inertial properties at creation time.\n This flag will be applied to all NxActors generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Disables COM update when computing inertial properties at creation time.", true); + ParamDefTable[135].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=136, longName="actorDescTemplate.flags.NX_AF_CONTACT_MODIFICATION" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[136]; + ParamDef->init("NX_AF_CONTACT_MODIFICATION", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Turn on contact modification callback for the actor.\n This flag will be applied to all NxActors generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Turn on contact modification callback for the actor.", true); + ParamDefTable[136].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=137, longName="actorDescTemplate.flags.NX_AF_FORCE_CONE_FRICTION" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[137]; + ParamDef->init("NX_AF_FORCE_CONE_FRICTION", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Force cone friction to be used for this actor.\n This flag will be applied to all NxActors generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Force cone friction to be used for this actor.", true); + ParamDefTable[137].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=138, longName="actorDescTemplate.flags.NX_AF_USER_ACTOR_PAIR_FILTERING" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[138]; + ParamDef->init("NX_AF_USER_ACTOR_PAIR_FILTERING", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Enable/disable custom contact filtering.\n This flag will be applied to all NxActors generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Enable/disable custom contact filtering.", true); + ParamDefTable[138].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=139, longName="actorDescTemplate.density" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[139]; + ParamDef->init("density", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Density to be applied to the whole actor. If the body descriptor contains a zero mass but the actor descriptor contains a non-zero density, we compute a new mass automatically from the density and a shapes.\n This will be applied to all NxActors generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Density to be applied to the whole actor.", true); + ParamDefTable[139].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=140, longName="actorDescTemplate.actorCollisionGroup" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[140]; + ParamDef->init("actorCollisionGroup", TYPE_U16, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Sets which NxActorGroup an actor is part of.\n This will be applied to all NxActors generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Sets which NxActorGroup an actor is part of", true); + ParamDefTable[140].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=141, longName="actorDescTemplate.dominanceGroup" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[141]; + ParamDef->init("dominanceGroup", TYPE_U16, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Dominance group for an actor.\n This will be applied to all NxActors generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Dominance group for an actor.", true); + ParamDefTable[141].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=142, longName="actorDescTemplate.contactReportFlags" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[142]; + ParamDef->init("contactReportFlags", TYPE_STRUCT, "ContactPairFlag", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Combination of ContactPairFlag flags.\n This will be applied to all NxActors generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Combination of ContactPairFlag flags", true); + ParamDefTable[142].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=143, longName="actorDescTemplate.contactReportFlags.NX_IGNORE_PAIR" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[143]; + ParamDef->init("NX_IGNORE_PAIR", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Disable contact generation for this pair. See the PhysX documentation for more about contact reporting.", true); + HintTable[1].init("shortDescription", "Disable contact generation for this pair", true); + ParamDefTable[143].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=144, longName="actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_START_TOUCH" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[144]; + ParamDef->init("NX_NOTIFY_ON_START_TOUCH", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Pair callback will be called when the pair starts to be in contact. See the PhysX documentation for more about contact reporting.", true); + HintTable[1].init("shortDescription", "Pair callback will be called when the pair starts to be in contact", true); + ParamDefTable[144].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=145, longName="actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_END_TOUCH" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[145]; + ParamDef->init("NX_NOTIFY_ON_END_TOUCH", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Pair callback will be called when the pair stops to be in contact. See the PhysX documentation for more about contact reporting.", true); + HintTable[1].init("shortDescription", "Pair callback will be called when the pair stops to be in contact", true); + ParamDefTable[145].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=146, longName="actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_TOUCH" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[146]; + ParamDef->init("NX_NOTIFY_ON_TOUCH", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Pair callback will keep getting called while the pair is in contact. See the PhysX documentation for more about contact reporting.", true); + HintTable[1].init("shortDescription", "Pair callback will keep getting called while the pair is in contact", true); + ParamDefTable[146].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=147, longName="actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_IMPACT" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[147]; + ParamDef->init("NX_NOTIFY_ON_IMPACT", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "[Not yet implemented] pair callback will be called when it may be appropriate for the pair to play an impact sound. See the PhysX documentation for more about contact reporting.", true); + HintTable[1].init("shortDescription", "[Not yet implemented] pair callback will be called when it may be appropriate for the pair to play an impact sound", true); + ParamDefTable[147].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=148, longName="actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_ROLL" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[148]; + ParamDef->init("NX_NOTIFY_ON_ROLL", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "[Not yet implemented] pair callback will be called when the pair is in contact and rolling. See the PhysX documentation for more about contact reporting.", true); + HintTable[1].init("shortDescription", "[Not yet implemented] pair callback will be called when the pair is in contact and rolling.", true); + ParamDefTable[148].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=149, longName="actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_SLIDE" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[149]; + ParamDef->init("NX_NOTIFY_ON_SLIDE", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "[Not yet implemented] pair callback will be called when the pair is in contact and sliding (and not rolling). See the PhysX documentation for more about contact reporting.", true); + HintTable[1].init("shortDescription", "[Not yet implemented] pair callback will be called when the pair is in contact and sliding (and not rolling).", true); + ParamDefTable[149].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=150, longName="actorDescTemplate.contactReportFlags.NX_NOTIFY_FORCES" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[150]; + ParamDef->init("NX_NOTIFY_FORCES", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The (summed total) friction force and normal force will be given in the NxContactPair variable in the contact report. See the PhysX documentation for more about contact reporting.", true); + HintTable[1].init("shortDescription", "The (summed total) friction force and normal force will be given in the NxContactPair variable in the contact report.", true); + ParamDefTable[150].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=151, longName="actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_START_TOUCH_FORCE_THRESHOLD" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[151]; + ParamDef->init("NX_NOTIFY_ON_START_TOUCH_FORCE_THRESHOLD", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Pair callback will be called when the contact force between two actors falls below the actor-defined force thresholds. See the PhysX documentation for more about contact reporting.", true); + HintTable[1].init("shortDescription", "Pair callback will be called when the contact force between two actors falls below the actor-defined force thresholds", true); + ParamDefTable[151].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=152, longName="actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_END_TOUCH_FORCE_THRESHOLD" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[152]; + ParamDef->init("NX_NOTIFY_ON_END_TOUCH_FORCE_THRESHOLD", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Pair callback will be called when the contact force between two actors falls below the actor-defined force thresholds. See the PhysX documentation for more about contact reporting.", true); + HintTable[1].init("shortDescription", "Pair callback will be called when the contact force between two actors falls below the actor-defined force thresholds", true); + ParamDefTable[152].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=153, longName="actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_TOUCH_FORCE_THRESHOLD" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[153]; + ParamDef->init("NX_NOTIFY_ON_TOUCH_FORCE_THRESHOLD", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Pair callback will keep getting called while the contact force between two actors exceeds one of the actor-defined force thresholds. See the PhysX documentation for more about contact reporting.", true); + HintTable[1].init("shortDescription", "Pair callback will keep getting called while the contact force between two actors exceeds one of the actor-defined force thresholds", true); + ParamDefTable[153].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=154, longName="actorDescTemplate.contactReportFlags.NX_NOTIFY_CONTACT_MODIFICATION" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[154]; + ParamDef->init("NX_NOTIFY_CONTACT_MODIFICATION", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Generate a callback for all associated contact constraints, making it possible to edit the constraint. This flag is not included in NX_NOTIFY_ALL for performance reasons. see NxUserContactModify. See the PhysX documentation for more about contact reporting.", true); + HintTable[1].init("shortDescription", "Generate a callback for all associated contact constraints, making it possible to edit the constraint. This flag is not included in NX_NOTIFY_ALL for performance reasons. see NxUserContactModify.", true); + ParamDefTable[154].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=155, longName="actorDescTemplate.forceFieldMaterial" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[155]; + ParamDef->init("forceFieldMaterial", TYPE_U16, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Force Field Material Index, index != 0 has to be created.\n This will be applied to all NxActors generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Force Field Material Index", true); + ParamDefTable[155].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=156, longName="actorDescTemplate.userData" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[156]; + ParamDef->init("userData", TYPE_U64, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("editorDisplay", "false", true); + ParamDefTable[156].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("editorDisplay", "false", true); + HintTable[1].init("longDescription", "Optional user data pointer.\n This will be applied to all NxActors generated for this destructible's chunks.", true); + HintTable[2].init("shortDescription", "Optional user data pointer", true); + ParamDefTable[156].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=157, longName="actorDescTemplate.name" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[157]; + ParamDef->init("name", TYPE_U64, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("editorDisplay", "false", true); + ParamDefTable[157].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("editorDisplay", "false", true); + HintTable[1].init("longDescription", "Optional name string for a shape; must be set by the application and must be a persistent pointer.\n This will be applied to all NxActors generated for this destructible's chunks.", true); + HintTable[2].init("shortDescription", "Optional name string for a shape; must be set by the application and must be a persistent pointer.", true); + ParamDefTable[157].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=158, longName="actorDescTemplate.compartment" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[158]; + ParamDef->init("compartment", TYPE_U64, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("editorDisplay", "false", true); + ParamDefTable[158].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("editorDisplay", "false", true); + HintTable[1].init("longDescription", "Optional compartment pointer; must be set by the application.\n This will be applied to all NxActors generated for this destructible's chunks.", true); + HintTable[2].init("shortDescription", "Optional compartment pointer", true); + ParamDefTable[158].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=159, longName="bodyDescTemplate" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[159]; + ParamDef->init("bodyDescTemplate", TYPE_STRUCT, "BodyDescTemplate", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("editorDisplay", "false", true); + ParamDefTable[159].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("editorDisplay", "false", true); + HintTable[1].init("longDescription", "Contains the parameterse that the application can override for the body descriptor of rigid body actors created.", true); + HintTable[2].init("shortDescription", "Contains the parameterse that the application can override for the body descriptor of rigid body actors created", true); + ParamDefTable[159].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=160, longName="bodyDescTemplate.flags" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[160]; + ParamDef->init("flags", TYPE_STRUCT, "BodyDescFlags", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Combination of body descriptor flags.\n This will be applied to all NxActors generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Combination of body descriptor flags", true); + ParamDefTable[160].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=161, longName="bodyDescTemplate.flags.NX_BF_DISABLE_GRAVITY" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[161]; + ParamDef->init("NX_BF_DISABLE_GRAVITY", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Set if gravity should not be applied on this body.\n This will be applied to all NxActors generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Set if gravity should not be applied on this body", true); + ParamDefTable[161].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=162, longName="bodyDescTemplate.flags.NX_BF_FILTER_SLEEP_VEL" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[162]; + ParamDef->init("NX_BF_FILTER_SLEEP_VEL", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Filter velocities used keep body awake. The filter reduces rapid oscillations and transient spikes.\n This will be applied to all NxActors generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Filter velocities used keep body awake. The filter reduces rapid oscillations and transient spikes", true); + ParamDefTable[162].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=163, longName="bodyDescTemplate.flags.NX_BF_ENERGY_SLEEP_TEST" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[163]; + ParamDef->init("NX_BF_ENERGY_SLEEP_TEST", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Enables energy-based sleeping algorithm.\n This will be applied to all NxActors generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Enables energy-based sleeping algorithm", true); + ParamDefTable[163].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=164, longName="bodyDescTemplate.flags.NX_BF_VISUALIZATION" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[164]; + ParamDef->init("NX_BF_VISUALIZATION", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Enables debug visualization for this body.\n This will be applied to all NxActors generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Enables debug visualization for this body", true); + ParamDefTable[164].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=165, longName="bodyDescTemplate.wakeUpCounter" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[165]; + ParamDef->init("wakeUpCounter", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The bodys initial wake up counter.\n This will be applied to all NxActors generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "The bodys initial wake up counter", true); + ParamDefTable[165].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=166, longName="bodyDescTemplate.linearDamping" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[166]; + ParamDef->init("linearDamping", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Linear damping applied to the body.\n This will be applied to all NxActors generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Linear damping applied to the body", true); + ParamDefTable[166].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=167, longName="bodyDescTemplate.angularDamping" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[167]; + ParamDef->init("angularDamping", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Angular damping applied to the body.\n This will be applied to all NxActors generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Angular damping applied to the body", true); + ParamDefTable[167].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=168, longName="bodyDescTemplate.maxAngularVelocity" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[168]; + ParamDef->init("maxAngularVelocity", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Maximum allowed angular velocity.\n This will be applied to all NxActors generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Maximum allowed angular velocity", true); + ParamDefTable[168].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=169, longName="bodyDescTemplate.CCDMotionThreshold" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[169]; + ParamDef->init("CCDMotionThreshold", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "When CCD is globally enabled, it is still not performed if the motion distance of all points on the body is below this threshold.\n This will be applied to all NxActors generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Distance threshold for CCD", true); + ParamDefTable[169].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=170, longName="bodyDescTemplate.sleepLinearVelocity" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[170]; + ParamDef->init("sleepLinearVelocity", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Maximum linear velocity at which body can go to sleep.\n This will be applied to all NxActors generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Maximum linear velocity at which body can go to sleep", true); + ParamDefTable[170].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=171, longName="bodyDescTemplate.sleepAngularVelocity" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[171]; + ParamDef->init("sleepAngularVelocity", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Maximum angular velocity at which body can go to sleep.\n This will be applied to all NxActors generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Maximum angular velocity at which body can go to sleep", true); + ParamDefTable[171].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=172, longName="bodyDescTemplate.solverIterationCount" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[172]; + ParamDef->init("solverIterationCount", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Number of solver iterations performed when processing joint/contacts connected to this body.\n This will be applied to all NxActors generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Number of solver iterations performed when processing joint/contacts connected to this body", true); + ParamDefTable[172].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=173, longName="bodyDescTemplate.sleepEnergyThreshold" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[173]; + ParamDef->init("sleepEnergyThreshold", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Threshold for the energy-based sleeping algorithm. Only used when the NX_BF_ENERGY_SLEEP_TEST flag is set.\n This will be applied to all NxActors generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Threshold for the energy-based sleeping algorithm. Only used when the NX_BF_ENERGY_SLEEP_TEST flag is set", true); + ParamDefTable[173].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=174, longName="bodyDescTemplate.sleepDamping" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[174]; + ParamDef->init("sleepDamping", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Damping factor for bodies that are about to sleep.\n This will be applied to all NxActors generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Damping factor for bodies that are about to sleep", true); + ParamDefTable[174].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=175, longName="bodyDescTemplate.contactReportThreshold" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[175]; + ParamDef->init("contactReportThreshold", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The force threshold for contact reports.\n This will be applied to all NxActors generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "The force threshold for contact reports", true); + ParamDefTable[175].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=176, longName="p3ShapeDescTemplate" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[176]; + ParamDef->init("p3ShapeDescTemplate", TYPE_STRUCT, "P3ShapeDescTemplate", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("editorDisplay", "false", true); + ParamDefTable[176].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("editorDisplay", "false", true); + HintTable[1].init("longDescription", "Contains the parameters the application can override on any actor shapes created.", true); + HintTable[2].init("shortDescription", "Contains the parameters the application can override on any actor shapes created", true); + ParamDefTable[176].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=177, longName="p3ShapeDescTemplate.flags" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[177]; + ParamDef->init("flags", TYPE_STRUCT, "P3ShapeFlags", true); + + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=178, longName="p3ShapeDescTemplate.flags.eSIMULATION_SHAPE" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[178]; + ParamDef->init("eSIMULATION_SHAPE", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("shortDescription", "The shape will partake in collision in the physical simulation.", true); + ParamDefTable[178].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=179, longName="p3ShapeDescTemplate.flags.eSCENE_QUERY_SHAPE" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[179]; + ParamDef->init("eSCENE_QUERY_SHAPE", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("shortDescription", "The shape will partake in scene queries (ray casts, overlap tests, sweeps, ...). ", true); + ParamDefTable[179].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=180, longName="p3ShapeDescTemplate.flags.eTRIGGER_SHAPE" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[180]; + ParamDef->init("eTRIGGER_SHAPE", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The shape is a trigger which can send reports whenever other shapes enter/leave its volume.\n\nNote:\nTriangle meshes and heightfields can not be triggers. Shape creation will fail in these cases.\nShapes marked as triggers do not collide with other objects. If an object should act both as a trigger shape and a collision shape then create a rigid body with two shapes, one being a trigger shape and the other a collision shape.\n", true); + HintTable[1].init("shortDescription", "The shape is a trigger which can send reports whenever other shapes enter/leave its volume. ", true); + ParamDefTable[180].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=181, longName="p3ShapeDescTemplate.flags.eVISUALIZATION" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[181]; + ParamDef->init("eVISUALIZATION", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("shortDescription", "Enable debug renderer for this shape", true); + ParamDefTable[181].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=182, longName="p3ShapeDescTemplate.flags.ePARTICLE_DRAIN" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[182]; + ParamDef->init("ePARTICLE_DRAIN", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("shortDescription", "Sets the shape to be a particle drain", true); + ParamDefTable[182].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=183, longName="p3ShapeDescTemplate.flags.eDEFORMABLE_DRAIN" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[183]; + ParamDef->init("eDEFORMABLE_DRAIN", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("shortDescription", "Sets the shape to be a deformable drain", true); + ParamDefTable[183].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=184, longName="p3ShapeDescTemplate.simulationFilterData" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[184]; + ParamDef->init("simulationFilterData", TYPE_STRUCT, "P3FilterData", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Sets the user definable collision filter data.\n This is applied to all shapes generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Sets the user definable collision filter data", true); + ParamDefTable[184].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=185, longName="p3ShapeDescTemplate.simulationFilterData.word0" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[185]; + ParamDef->init("word0", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("shortDescription", "word0 of the filter data", true); + ParamDefTable[185].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=186, longName="p3ShapeDescTemplate.simulationFilterData.word1" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[186]; + ParamDef->init("word1", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("shortDescription", "word1 of the filter data", true); + ParamDefTable[186].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=187, longName="p3ShapeDescTemplate.simulationFilterData.word2" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[187]; + ParamDef->init("word2", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("shortDescription", "word2 of the filter data", true); + ParamDefTable[187].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=188, longName="p3ShapeDescTemplate.simulationFilterData.word3" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[188]; + ParamDef->init("word3", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("shortDescription", "word3 of the filter data", true); + ParamDefTable[188].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=189, longName="p3ShapeDescTemplate.queryFilterData" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[189]; + ParamDef->init("queryFilterData", TYPE_STRUCT, "P3FilterData", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Sets the user definable query filter data.\n This is applied to all shapes generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Sets the user definable query filter data", true); + ParamDefTable[189].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=190, longName="p3ShapeDescTemplate.queryFilterData.word0" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[190]; + ParamDef->init("word0", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("shortDescription", "word0 of the filter data", true); + ParamDefTable[190].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=191, longName="p3ShapeDescTemplate.queryFilterData.word1" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[191]; + ParamDef->init("word1", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("shortDescription", "word1 of the filter data", true); + ParamDefTable[191].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=192, longName="p3ShapeDescTemplate.queryFilterData.word2" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[192]; + ParamDef->init("word2", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("shortDescription", "word2 of the filter data", true); + ParamDefTable[192].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=193, longName="p3ShapeDescTemplate.queryFilterData.word3" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[193]; + ParamDef->init("word3", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("shortDescription", "word3 of the filter data", true); + ParamDefTable[193].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=194, longName="p3ShapeDescTemplate.material" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[194]; + ParamDef->init("material", TYPE_U64, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "A PxMaterial pointer for the shape.\n This is applied to all shapes generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "A PxMaterial pointer for the shape", true); + ParamDefTable[194].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=195, longName="p3ShapeDescTemplate.contactOffset" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[195]; + ParamDef->init("contactOffset", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Sets the contact offset; if -1 it uses the global default.\n This is applied to all shapes generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Sets the contact offset", true); + ParamDefTable[195].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=196, longName="p3ShapeDescTemplate.restOffset" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[196]; + ParamDef->init("restOffset", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Sets the rest offset; if -1 it uses the global default.\n This is applied to all shapes generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Sets the rest offset", true); + ParamDefTable[196].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=197, longName="p3ShapeDescTemplate.userData" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[197]; + ParamDef->init("userData", TYPE_U64, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("editorDisplay", "false", true); + ParamDefTable[197].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("editorDisplay", "false", true); + HintTable[1].init("longDescription", "Optional user data pointer.\n This is applied to all shapes generated for this destructible's chunks.", true); + HintTable[2].init("shortDescription", "Optional user data pointer", true); + ParamDefTable[197].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=198, longName="p3ShapeDescTemplate.name" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[198]; + ParamDef->init("name", TYPE_U64, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("editorDisplay", "false", true); + ParamDefTable[198].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("editorDisplay", "false", true); + HintTable[1].init("longDescription", "Optional name string for a shape; must be set by the application and must be a persistent pointer.\n This is applied to all shapes generated for this destructible's chunks.", true); + HintTable[2].init("shortDescription", "Optional name string for a shape.", true); + ParamDefTable[198].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=199, longName="p3ActorDescTemplate" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[199]; + ParamDef->init("p3ActorDescTemplate", TYPE_STRUCT, "P3ActorDescTemplate", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("editorDisplay", "false", true); + ParamDefTable[199].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("editorDisplay", "false", true); + HintTable[1].init("longDescription", "Contains the parameters the application can override on any actors created.", true); + HintTable[2].init("shortDescription", "Contains the parameters the application can override on any actors created", true); + ParamDefTable[199].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=200, longName="p3ActorDescTemplate.flags" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[200]; + ParamDef->init("flags", TYPE_STRUCT, "P3ActorFlags", true); + + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=201, longName="p3ActorDescTemplate.flags.eVISUALIZATION" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[201]; + ParamDef->init("eVISUALIZATION", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Enable debug renderer for this actor.\n This flag will be applied to all actors generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Enable debug renderer for this actor", true); + ParamDefTable[201].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=202, longName="p3ActorDescTemplate.flags.eDISABLE_GRAVITY" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[202]; + ParamDef->init("eDISABLE_GRAVITY", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Disables scene gravity for this actor.\n This flag will be applied to all actors generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Disables scene gravity for this actor", true); + ParamDefTable[202].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=203, longName="p3ActorDescTemplate.flags.eSEND_SLEEP_NOTIFIES" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[203]; + ParamDef->init("eSEND_SLEEP_NOTIFIES", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Enables the sending of PxSimulationEventCallback::onWake() and PxSimulationEventCallback::onSleep() notify events.\n This flag will be applied to all actors generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Enables the sending of PxSimulationEventCallback::onWake() and PxSimulationEventCallback::onSleep() notify events", true); + ParamDefTable[203].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=204, longName="p3ActorDescTemplate.dominanceGroup" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[204]; + ParamDef->init("dominanceGroup", TYPE_U8, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Assigns dynamic actors a dominance group identifier.\n This will be applied to all actors generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Assigns dynamic actors a dominance group identifier.", true); + ParamDefTable[204].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=205, longName="p3ActorDescTemplate.ownerClient" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[205]; + ParamDef->init("ownerClient", TYPE_U8, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Sets the owner client of an actor.\n This will be applied to all actors generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Sets the owner client of an actor.", true); + ParamDefTable[205].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=206, longName="p3ActorDescTemplate.clientBehaviorBits" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[206]; + ParamDef->init("clientBehaviorBits", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Changes the behavior bits initially specified with PxActorDesc::clientBehaviorBits.\n This will be applied to all actors generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Changes the behavior bits initially specified with PxActorDesc::clientBehaviorBits.", true); + ParamDefTable[206].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=207, longName="p3ActorDescTemplate.contactReportFlags" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[207]; + ParamDef->init("contactReportFlags", TYPE_STRUCT, "P3PairFlag", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Combination of P3PairFlag flags.\n This will be applied to all shapes generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Combination of P3PairFlag flags", true); + ParamDefTable[207].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=208, longName="p3ActorDescTemplate.contactReportFlags.eSOLVE_CONTACT" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[208]; + ParamDef->init("eSOLVE_CONTACT", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Process the contacts of this collision pair in the dynamics solver.\n\nNote: Only takes effect if the colliding actors are rigid bodies.\n", true); + HintTable[1].init("shortDescription", "Process the contacts of this collision pair in the dynamics solver. ", true); + ParamDefTable[208].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=209, longName="p3ActorDescTemplate.contactReportFlags.eMODIFY_CONTACTS" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[209]; + ParamDef->init("eMODIFY_CONTACTS", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Call contact modification callback for this collision pair.\n\nNote: Only takes effect if the colliding actors are rigid bodies.\n", true); + HintTable[1].init("shortDescription", "Call contact modification callback for this collision pair. ", true); + ParamDefTable[209].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=210, longName="p3ActorDescTemplate.contactReportFlags.eNOTIFY_TOUCH_FOUND" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[210]; + ParamDef->init("eNOTIFY_TOUCH_FOUND", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Call contact report callback or trigger callback when this collision pair starts to be in contact.\nIf one of the two collision objects is a trigger shape (see PxShapeFlag::eTRIGGER_SHAPE) then the trigger callback will get called as soon as the other object enters the trigger volume. If none of the two collision objects is a trigger shape then the contact report callback will get called when the actors of this collision pair start to be in contact.\n\nNote: Only takes effect if the colliding actors are rigid bodies.\n", true); + HintTable[1].init("shortDescription", "Call contact report callback or trigger callback when this collision pair starts to be in contact", true); + ParamDefTable[210].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=211, longName="p3ActorDescTemplate.contactReportFlags.eNOTIFY_TOUCH_PERSISTS" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[211]; + ParamDef->init("eNOTIFY_TOUCH_PERSISTS", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Process the contacts of this collision pair in the dynamics solver.\n\nNote: Only takes effect if the colliding actors are rigid bodies.\n", true); + HintTable[1].init("shortDescription", "Call contact report callback or trigger callback while this collision pair is in contact", true); + ParamDefTable[211].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=212, longName="p3ActorDescTemplate.contactReportFlags.eNOTIFY_TOUCH_LOST" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[212]; + ParamDef->init("eNOTIFY_TOUCH_LOST", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Call contact report callback or trigger callback when this collision pair stops to be in contact.\nIf one of the two collision objects is a trigger shape (see PxShapeFlag::eTRIGGER_SHAPE) then the trigger callback will get called as soon as the other object leaves the trigger volume. If none of the two collision objects is a trigger shape then the contact report callback will get called when the actors of this collision pair stop to be in contact.\n\nNote: Only takes effect if the colliding actors are rigid bodies.\n", true); + HintTable[1].init("shortDescription", " Call contact report callback or trigger callback when this collision pair stops to be in contact.", true); + ParamDefTable[212].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=213, longName="p3ActorDescTemplate.contactReportFlags.eNOTIFY_THRESHOLD_FORCE_FOUND" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[213]; + ParamDef->init("eNOTIFY_THRESHOLD_FORCE_FOUND", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Call contact report callback when the contact force between the actors of this collision pair exceeds one of the actor-defined force thresholds.\n\nNote: Only takes effect if the colliding actors are rigid bodies\n", true); + HintTable[1].init("shortDescription", "Call contact report callback when the contact force between the actors of this collision pair exceeds one of the actor-defined force thresholds.", true); + ParamDefTable[213].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=214, longName="p3ActorDescTemplate.contactReportFlags.eNOTIFY_THRESHOLD_FORCE_PERSISTS" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[214]; + ParamDef->init("eNOTIFY_THRESHOLD_FORCE_PERSISTS", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Call contact report callback when the contact force between the actors of this collision pair continues to exceed one of the actor-defined force thresholds.\n\nNote: Only takes effect if the colliding actors are rigid bodies.\n", true); + HintTable[1].init("shortDescription", "Call contact report callback when the contact force between the actors of this collision pair continues to exceed one of the actor-defined force thresholds", true); + ParamDefTable[214].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=215, longName="p3ActorDescTemplate.contactReportFlags.eNOTIFY_THRESHOLD_FORCE_LOST" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[215]; + ParamDef->init("eNOTIFY_THRESHOLD_FORCE_LOST", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Call contact report callback when the contact force between the actors of this collision pair falls below one of the actor-defined force thresholds (includes the case where this collision pair stops being in contact).\n\nNote: Only takes effect if the colliding actors are rigid bodies\n", true); + HintTable[1].init("shortDescription", "Call contact report callback when the contact force between the actors of this collision pair falls below one of the actor-defined force thresholds (includes the case where this collision pair stops being in contact).", true); + ParamDefTable[215].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=216, longName="p3ActorDescTemplate.contactReportFlags.eNOTIFY_CONTACT_POINTS" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[216]; + ParamDef->init("eNOTIFY_CONTACT_POINTS", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Provide contact points in contact reports for this collision pair.\n\nNote: Only takes effect if the colliding actors are rigid bodies.\n", true); + HintTable[1].init("shortDescription", "Provide contact points in contact reports for this collision pair.", true); + ParamDefTable[216].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=217, longName="p3ActorDescTemplate.contactReportFlags.eNOTIFY_CONTACT_FORCES" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[217]; + ParamDef->init("eNOTIFY_CONTACT_FORCES", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Provide the (summed total) friction force and normal force in contact reports for this collision pair (see PxContactPair).\n\nNote: Only takes effect if the colliding actors are rigid bodies\n", true); + HintTable[1].init("shortDescription", "Provide the (summed total) friction force and normal force in contact reports for this collision pair (see PxContactPair).", true); + ParamDefTable[217].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=218, longName="p3ActorDescTemplate.contactReportFlags.eNOTIFY_CONTACT_FORCE_PER_POINT" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[218]; + ParamDef->init("eNOTIFY_CONTACT_FORCE_PER_POINT", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Provide contact forces per contact point in contact reports for this collision pair.\n\nNote: Only takes effect if the colliding actors are rigid bodies.\n", true); + HintTable[1].init("shortDescription", "Provide contact forces per contact point in contact reports for this collision pair.", true); + ParamDefTable[218].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=219, longName="p3ActorDescTemplate.contactReportFlags.eNOTIFY_CONTACT_FEATURE_INDICES_PER_POINT" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[219]; + ParamDef->init("eNOTIFY_CONTACT_FEATURE_INDICES_PER_POINT", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Provide feature indices per contact point in contact reports for this collision pair.\n\nNote: Only takes effect if the colliding actors are rigid bodies.\n", true); + HintTable[1].init("shortDescription", "Provide feature indices per contact point in contact reports for this collision pair.", true); + ParamDefTable[219].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=220, longName="p3ActorDescTemplate.contactReportFlags.eDETECT_CCD_CONTACT" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[220]; + ParamDef->init("eDETECT_CCD_CONTACT", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "This flag is used to indicate whether this pair generates CCD contacts. \n\nThe contacts will only be responded to if eSOLVE_CONTACT is enabled on this pair.\nThe scene must have PxSceneFlag::eENABLE_CCD enabled to use this feature.\nNon-static bodies of the pair should have PxRigidBodyFlag::eENABLE_CCD specified for this feature to work correctly.\nThis flag is not supported with trigger shapes. However, CCD trigger events can be emulated using non-trigger shapes \nand requesting eNOTIFY_TOUCH_FOUND and eNOTIFY_TOUCH_LOST and not raising eSOLVE_CONTACT on the pair.\n", true); + HintTable[1].init("shortDescription", "This flag is used to indicate whether this pair generates CCD contacts.", true); + ParamDefTable[220].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=221, longName="p3ActorDescTemplate.contactReportFlags.eCONTACT_DEFAULT" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[221]; + ParamDef->init("eCONTACT_DEFAULT", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("shortDescription", "Provided default flag to do simple contact processing for this collision pair.", true); + ParamDefTable[221].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=222, longName="p3ActorDescTemplate.contactReportFlags.eTRIGGER_DEFAULT" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[222]; + ParamDef->init("eTRIGGER_DEFAULT", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("shortDescription", "Provided default flag to get commonly used trigger behavior for this collision pair.", true); + ParamDefTable[222].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=223, longName="p3ActorDescTemplate.userData" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[223]; + ParamDef->init("userData", TYPE_U64, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("editorDisplay", "false", true); + ParamDefTable[223].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("editorDisplay", "false", true); + HintTable[1].init("longDescription", "Optional user data pointer.\n This will be applied to all actors generated for this destructible's chunks.", true); + HintTable[2].init("shortDescription", "Optional user data pointer", true); + ParamDefTable[223].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=224, longName="p3ActorDescTemplate.name" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[224]; + ParamDef->init("name", TYPE_U64, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("editorDisplay", "false", true); + ParamDefTable[224].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("editorDisplay", "false", true); + HintTable[1].init("longDescription", "Optional name string for a shape; must be set by the application and must be a persistent pointer.\n This will be applied to all actors generated for this destructible's chunks.", true); + HintTable[2].init("shortDescription", "Optional name string for a shape; must be set by the application and must be a persistent pointer.", true); + ParamDefTable[224].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=225, longName="p3BodyDescTemplate" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[225]; + ParamDef->init("p3BodyDescTemplate", TYPE_STRUCT, "P3BodyDescTemplate", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("editorDisplay", "false", true); + ParamDefTable[225].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("editorDisplay", "false", true); + HintTable[1].init("longDescription", "Contains the parameterse that the application can override for the body descriptor of rigid body actors created.", true); + HintTable[2].init("shortDescription", "Contains the parameterse that the application can override for the body descriptor of rigid body actors created", true); + ParamDefTable[225].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=226, longName="p3BodyDescTemplate.density" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[226]; + ParamDef->init("density", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The density of the body. Used to compute the mass of the body. If the body descriptor contains a zero mass but the actor descriptor contains a non-zero density, we compute a new mass automatically from the density and a shapes.\n This will be applied to all actors generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "The density of the body. Used to compute the mass of the body.", true); + ParamDefTable[226].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=227, longName="p3BodyDescTemplate.flags" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[227]; + ParamDef->init("flags", TYPE_STRUCT, "P3BodyDescFlags", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Combination of body descriptor flags.\n This will be applied to all actors generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Combination of body descriptor flags", true); + ParamDefTable[227].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=228, longName="p3BodyDescTemplate.flags.eKINEMATIC" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[228]; + ParamDef->init("eKINEMATIC", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Kinematic actors are special dynamic actors that are not influenced by forces (such as gravity), and have no momentum. They are considered to have infinite mass and can be moved around the world using the moveKinematic() method. They will push regular dynamic actors out of the way. Kinematics will not collide with static or other kinematic objects.\nKinematic actors are great for moving platforms or characters, where direct motion control is desired.\nYou can not connect Reduced joints to kinematic actors. Lagrange joints work ok if the platform is moving with a relatively low, uniform velocity.\n This will be applied to all actors generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Enables kinematic mode for the actor", true); + ParamDefTable[228].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=229, longName="p3BodyDescTemplate.flags.eENABLE_CCD" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[229]; + ParamDef->init("eENABLE_CCD", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Enables swept integration for the actor.\n If this flag is raised and swept integration is enabled on the scene, then this body will be simulated by the CCD system to ensure that collisions are not missed due to \n high-speed motion. Note, individual shape pairs still need to enable PxPairFlag::eDETECT_CCD_CONTACT in the collision filtering to enable the CCD to respond to \n individual interactions.", true); + HintTable[1].init("shortDescription", "Enables swept integration for the actor.", true); + ParamDefTable[229].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=230, longName="p3BodyDescTemplate.sleepThreshold" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[230]; + ParamDef->init("sleepThreshold", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Sets the mass-normalized kinetic energy threshold below which an actor may go to sleep.\n This will be applied to all actors generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Sets the mass-normalized kinetic energy threshold below which an actor may go to sleep.", true); + ParamDefTable[230].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=231, longName="p3BodyDescTemplate.wakeUpCounter" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[231]; + ParamDef->init("wakeUpCounter", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The bodys initial wake up counter.\n This will be applied to all actors generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "The bodys initial wake up counter", true); + ParamDefTable[231].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=232, longName="p3BodyDescTemplate.linearDamping" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[232]; + ParamDef->init("linearDamping", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Linear damping applied to the body.\n This will be applied to all actors generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Linear damping applied to the body", true); + ParamDefTable[232].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=233, longName="p3BodyDescTemplate.angularDamping" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[233]; + ParamDef->init("angularDamping", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Sets the angular damping coefficient.\n This will be applied to all actors generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Sets the angular damping coefficient", true); + ParamDefTable[233].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=234, longName="p3BodyDescTemplate.maxAngularVelocity" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[234]; + ParamDef->init("maxAngularVelocity", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Maximum allowed angular velocity.\n This will be applied to all actors generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Maximum allowed angular velocity", true); + ParamDefTable[234].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=235, longName="p3BodyDescTemplate.solverIterationCount" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[235]; + ParamDef->init("solverIterationCount", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Sets the solver iteration counts for the body.\nThe solver iteration count determines how accurately joints and contacts are resolved. If you are having trouble with jointed bodies oscillating and behaving erratically, then setting a higher position iteration count may improve their stability.\nIf intersecting bodies are being depenetrated too violently, increase the number of velocity iterations.", true); + HintTable[1].init("shortDescription", "Sets the solver iteration counts for the body", true); + ParamDefTable[235].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=236, longName="p3BodyDescTemplate.velocityIterationCount" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[236]; + ParamDef->init("velocityIterationCount", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Sets the velocity solver iteration counts for the body.\nThe solver iteration count determines how accurately joints and contacts are resolved. If you are having trouble with jointed bodies oscillating and behaving erratically, then setting a higher position iteration count may improve their stability.\nIf intersecting bodies are being depenetrated too violently, increase the number of velocity iterations.", true); + HintTable[1].init("shortDescription", "Sets the velocity solver iteration counts for the body", true); + ParamDefTable[236].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=237, longName="p3BodyDescTemplate.contactReportThreshold" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[237]; + ParamDef->init("contactReportThreshold", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The force threshold for contact reports.\n This will be applied to all actors generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "The force threshold for contact reports", true); + ParamDefTable[237].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=238, longName="p3BodyDescTemplate.sleepLinearVelocity" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[238]; + ParamDef->init("sleepLinearVelocity", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Maximum linear velocity at which body can go to sleep.\n This will be applied to all actors generated for this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Maximum linear velocity at which body can go to sleep", true); + ParamDefTable[238].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=239, longName="structureSettings" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[239]; + ParamDef->init("structureSettings", TYPE_STRUCT, "StructureSettings", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("editorDisplay", "false", true); + ParamDefTable[239].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("editorDisplay", "false", true); + HintTable[1].init("longDescription", "Contains parameters that affect structure-wide settings.", true); + HintTable[2].init("shortDescription", "Contains parameters that affect structure-wide settings", true); + ParamDefTable[239].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=240, longName="structureSettings.useStressSolver" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[240]; + ParamDef->init("useStressSolver", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Determines whether to invoke the use of the stress solver. The stress solver is a self-checking mechanism\nemployed within the structure, with the purpose of detecting and breaking off overly-strained links to masses\nof chunks. Its behavior can be tweaked by customizing the parameters stressSolverTimeDelay and stressSolverMassThreshold.\n", true); + HintTable[1].init("shortDescription", "If true, the structure containing this actor will use the stress solver.", true); + ParamDefTable[240].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=241, longName="structureSettings.stressSolverTimeDelay" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[241]; + ParamDef->init("stressSolverTimeDelay", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Determines the amount of time to run down until an identified overly-strained link breaks. From the time the stress\nsolver qualifies a link as being overly-strained, this value will be used to count down to the actual breaking-off\nevent being executed. This should always be some positive value.\n", true); + HintTable[1].init("shortDescription", "The structure containing this actor will use the minimum stressSolverTimeDelay of all actors in the structure.", true); + ParamDefTable[241].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=242, longName="structureSettings.stressSolverMassThreshold" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[242]; + ParamDef->init("stressSolverMassThreshold", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Determines the minimum threshold mass to meet before an indentified overly-strained link breaks. This mass threshold\nis part of the condition that the stress solver uses to qualify whether a link is overly-strained. The accumulated sum\nof the chunk masses that the link is supporting will be used against this value. This should always be some positive value.\n", true); + HintTable[1].init("shortDescription", "The structure containing this actor will use the minimum stressSolverMassThreshold of all actors in the structure.", true); + ParamDefTable[242].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=243, longName="defaultBehaviorGroup" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[243]; + ParamDef->init("defaultBehaviorGroup", TYPE_STRUCT, "BehaviorGroup", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The default behavior group referenced by chunks. Each chunk references a behavior group for chunk-specific reactions.", true); + HintTable[1].init("shortDescription", "The default behavior group referenced by chunks", true); + ParamDefTable[243].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=244, longName="defaultBehaviorGroup.name" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[244]; + ParamDef->init("name", TYPE_STRING, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Name of behavior group, eg Concrete or Glass.", true); + HintTable[1].init("shortDescription", "Name of behavior group", true); + ParamDefTable[244].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=245, longName="defaultBehaviorGroup.damageThreshold" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[245]; + ParamDef->init("damageThreshold", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The damage amount which will cause a chunk to fracture (break free) from the destructible.\n This is obtained from the damage value passed into the DestructibleActor::applyDamage,\n or DestructibleActor::applyRadiusDamage, or via impact (see 'forceToDamage', below).", true); + HintTable[1].init("shortDescription", "The damage amount which will cause a chunk to fracture (break free) from the destructible.", true); + ParamDefTable[245].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=246, longName="defaultBehaviorGroup.damageToRadius" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[246]; + ParamDef->init("damageToRadius", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Controls the distance into the destructible to propagate damage. The damage applied to the chunk\n is multiplied by damageToRadius, to get the propagation distance. All chunks within the radius\n will have damage applied to them. The damage applied to each chunk varies with distance to the damage\n application position. Full damage is taken at zero distance, and zero damage at the damage radius.\n NOTE: This parameter is deprecated for point and radius damage. It will be used for those types of damage if legacy damage\n behavior is enabled with ModuleDestructible::setUseLegacyDamageRadiusSpread. Otherwise, the new parameters\n damageSpread.minimumRadius, damageSpread.radiusMultiplier, and damageSpread.falloffExponent are used. For impact damage, this parameter\n will continue to be used, however the radius will no longer scale with object size. The radius will continue\n to scale with the damage as a fraction of damageThreshold, however. If legacy damage behavior is used, this parameter\n will behave as before with respect to impact damage as well (scaling with object size).", true); + HintTable[1].init("shortDescription", "Controls the distance into the destructible to propagate damage.", true); + ParamDefTable[246].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=247, longName="defaultBehaviorGroup.damageSpread" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[247]; + ParamDef->init("damageSpread", TYPE_STRUCT, "DamageSpreadFunction", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Describes the radius and damage envelope function for damage applied to the destructible.", true); + HintTable[1].init("shortDescription", "Describes the radius and damage envelope function for damage applied to the destructible.", true); + ParamDefTable[247].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=248, longName="defaultBehaviorGroup.damageSpread.minimumRadius" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[248]; + ParamDef->init("minimumRadius", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The minimum radius of damage spread when damage is applied. The formula for the damage radius is\n radius = minimumRadius + (input radius) * radiusMultiplier.", true); + HintTable[1].init("shortDescription", "The minimum radius of damage spread when damage is applied.", true); + ParamDefTable[248].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=249, longName="defaultBehaviorGroup.damageSpread.radiusMultiplier" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[249]; + ParamDef->init("radiusMultiplier", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "A scale to apply to the input damage radius when damage is applied. The formula for the damage radius is\n radius = minimumRadius + (input radius) * radiusMultiplier.", true); + HintTable[1].init("shortDescription", "A scale to apply to the input damage radius when damage is applied.", true); + ParamDefTable[249].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=250, longName="defaultBehaviorGroup.damageSpread.falloffExponent" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[250]; + ParamDef->init("falloffExponent", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "How damage varies between the minimum radius and the calculated damage radius. The formula for the damage radius is\n radius = minimumRadius + (input radius) * radiusMultiplier.\n Within the minimumRadius, the full damage is applied to chunks. Past the minimumRadius, the formla for damage is:\n damage = (input damage) * ((radius - distance)/(radius - minimumRadius))^falloffExponent.\n Note: falloffExponent = 0.0 gives no falloff, so that damage = (input damage) over the entire range [0, radius).\n falloffExponent = 1.0 gives linear falloff.", true); + HintTable[1].init("shortDescription", "How damage varies between the minimum radius and the calculated damage radius.", true); + ParamDefTable[250].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=251, longName="defaultBehaviorGroup.damageColorSpread" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[251]; + ParamDef->init("damageColorSpread", TYPE_STRUCT, "DamageSpreadFunction", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Describes the radius and damage envelope function for color channel damage modification applied to the destructible.", true); + HintTable[1].init("shortDescription", "Describes the radius and damage envelope function for color channel damage modification applied to the destructible.", true); + ParamDefTable[251].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=252, longName="defaultBehaviorGroup.damageColorSpread.minimumRadius" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[252]; + ParamDef->init("minimumRadius", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The minimum radius of damage spread when damage is applied. The formula for the damage radius is\n radius = minimumRadius + (input radius) * radiusMultiplier.", true); + HintTable[1].init("shortDescription", "The minimum radius of damage spread when damage is applied.", true); + ParamDefTable[252].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=253, longName="defaultBehaviorGroup.damageColorSpread.radiusMultiplier" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[253]; + ParamDef->init("radiusMultiplier", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "A scale to apply to the input damage radius when damage is applied. The formula for the damage radius is\n radius = minimumRadius + (input radius) * radiusMultiplier.", true); + HintTable[1].init("shortDescription", "A scale to apply to the input damage radius when damage is applied.", true); + ParamDefTable[253].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=254, longName="defaultBehaviorGroup.damageColorSpread.falloffExponent" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[254]; + ParamDef->init("falloffExponent", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "How damage varies between the minimum radius and the calculated damage radius. The formula for the damage radius is\n radius = minimumRadius + (input radius) * radiusMultiplier.\n Within the minimumRadius, the full damage is applied to chunks. Past the minimumRadius, the formla for damage is:\n damage = (input damage) * ((radius - distance)/(radius - minimumRadius))^falloffExponent.\n Note: falloffExponent = 0.0 gives no falloff, so that damage = (input damage) over the entire range [0, radius).\n falloffExponent = 1.0 gives linear falloff.", true); + HintTable[1].init("shortDescription", "How damage varies between the minimum radius and the calculated damage radius.", true); + ParamDefTable[254].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=255, longName="defaultBehaviorGroup.damageColorChange" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[255]; + ParamDef->init("damageColorChange", TYPE_VEC4, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Describes how damage changes the color of vertices in the render mesh. If this vector is non-zero, then a dynamic\n (per-actor) color channel will be created and initialized to the asset's color channel, if it exists. Damage taken will go through\n the spread and envelope function described by damageColorSpread, and each color will be modified by the resulting damage, scaled\n by the values in damageColorChange. The change to color channel C is given by\n color[C] = clamp(color[C] + damageColorChange[C]*255*min(1.0, damage/damageThreshold), 0, 255).", true); + HintTable[1].init("shortDescription", "Describes how damage changes the color of vertices in the render mesh.", true); + ParamDefTable[255].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=256, longName="defaultBehaviorGroup.materialStrength" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[256]; + ParamDef->init("materialStrength", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "When a chunk takes impact damage due to physical contact (see see DestructibleDepthParameters), this parameter\n is the maximum impulse the contact can generate. Weak materials such as glass may have this set to a low value, so that\n heavier objects will pass through them during fracture.\n N.B.: Setting this parameter to 0 disables the impulse cap; that is, zero is interpreted as infinite.\n Default value = 0.0f.", true); + HintTable[1].init("shortDescription", "When a chunk takes impact, this is the maximum impulse the contact can generate.", true); + ParamDefTable[256].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=257, longName="defaultBehaviorGroup.density" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[257]; + ParamDef->init("density", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Chunk density. (TODO: better description)", true); + HintTable[1].init("shortDescription", "Chunk density", true); + ParamDefTable[257].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=258, longName="defaultBehaviorGroup.fadeOut" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[258]; + ParamDef->init("fadeOut", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Chunk fade out. (TODO: better description)", true); + HintTable[1].init("shortDescription", "Chunk fade out", true); + ParamDefTable[258].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=259, longName="defaultBehaviorGroup.maxDepenetrationVelocity" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[259]; + ParamDef->init("maxDepenetrationVelocity", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "In case some chunk is created inside static geometry it will be pushed out of it without limiting it's velocity. Sometimes it's not desirable, \n so this parameter can limit depenetration velocity. Keep in mind, that for low values you can see chunks 'floating' off the static meshes, which is also not always desirable.", true); + HintTable[1].init("shortDescription", "Chunk maximum depenetration velocity", true); + ParamDefTable[259].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=260, longName="defaultBehaviorGroup.groupsMask" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[260]; + ParamDef->init("groupsMask", TYPE_STRUCT, "GroupsMask", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Optional groups mask for dynamic chunks created when fractured.", true); + HintTable[1].init("shortDescription", "Optional groups mask for dynamic chunks created when fractured", true); + ParamDefTable[260].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=261, longName="defaultBehaviorGroup.groupsMask.useGroupsMask" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[261]; + ParamDef->init("useGroupsMask", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Whether or not the groupsMask should be used. If so, then this will be applied to all NxShapes\n created to represent this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Whether or not the groupsMask should be used", true); + ParamDefTable[261].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=262, longName="defaultBehaviorGroup.groupsMask.bits0" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[262]; + ParamDef->init("bits0", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If useGroupsMask is true, this is bits0 of the groups mask. See the PhysX documentation for more on groups masks.", true); + HintTable[1].init("shortDescription", "bits0 of the groups mask", true); + ParamDefTable[262].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=263, longName="defaultBehaviorGroup.groupsMask.bits1" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[263]; + ParamDef->init("bits1", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If useGroupsMask is true, this is bits1 of the groups mask. See the PhysX documentation for more on groups masks.", true); + HintTable[1].init("shortDescription", "bits1 of the groups mask", true); + ParamDefTable[263].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=264, longName="defaultBehaviorGroup.groupsMask.bits2" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[264]; + ParamDef->init("bits2", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If useGroupsMask is true, this is bits2 of the groups mask. See the PhysX documentation for more on groups masks.", true); + HintTable[1].init("shortDescription", "bits2 of the groups mask", true); + ParamDefTable[264].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=265, longName="defaultBehaviorGroup.groupsMask.bits3" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[265]; + ParamDef->init("bits3", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If useGroupsMask is true, this is bits3 of the groups mask. See the PhysX documentation for more on groups masks.", true); + HintTable[1].init("shortDescription", "bits3 of the groups mask", true); + ParamDefTable[265].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=266, longName="defaultBehaviorGroup.userData" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[266]; + ParamDef->init("userData", TYPE_U64, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "User data field. This 64-bit field can be set and retrieved by the user at runtime.", true); + HintTable[1].init("shortDescription", "User data field.", true); + ParamDefTable[266].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=267, longName="behaviorGroups" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[267]; + ParamDef->init("behaviorGroups", TYPE_ARRAY, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The array of behavior groups referenced by chunks. Each chunk references a behavior group for chunk-specific reactions.", true); + HintTable[1].init("shortDescription", "The array of behavior groups referenced by chunks", true); + ParamDefTable[267].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + ParamDef->setArraySize(-1); + static const uint8_t dynHandleIndices[2] = { 1, 0, }; + ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 2); + + } + + // Initialize DefinitionImpl node: nodeIndex=268, longName="behaviorGroups[]" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[268]; + ParamDef->init("behaviorGroups", TYPE_STRUCT, "BehaviorGroup", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The array of behavior groups referenced by chunks. Each chunk references a behavior group for chunk-specific reactions.", true); + HintTable[1].init("shortDescription", "The array of behavior groups referenced by chunks", true); + ParamDefTable[268].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=269, longName="behaviorGroups[].name" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[269]; + ParamDef->init("name", TYPE_STRING, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Name of behavior group, eg Concrete or Glass.", true); + HintTable[1].init("shortDescription", "Name of behavior group", true); + ParamDefTable[269].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=270, longName="behaviorGroups[].damageThreshold" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[270]; + ParamDef->init("damageThreshold", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The damage amount which will cause a chunk to fracture (break free) from the destructible.\n This is obtained from the damage value passed into the DestructibleActor::applyDamage,\n or DestructibleActor::applyRadiusDamage, or via impact (see 'forceToDamage', below).", true); + HintTable[1].init("shortDescription", "The damage amount which will cause a chunk to fracture (break free) from the destructible.", true); + ParamDefTable[270].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=271, longName="behaviorGroups[].damageToRadius" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[271]; + ParamDef->init("damageToRadius", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Controls the distance into the destructible to propagate damage. The damage applied to the chunk\n is multiplied by damageToRadius, to get the propagation distance. All chunks within the radius\n will have damage applied to them. The damage applied to each chunk varies with distance to the damage\n application position. Full damage is taken at zero distance, and zero damage at the damage radius.\n NOTE: This parameter is deprecated for point and radius damage. It will be used for those types of damage if legacy damage\n behavior is enabled with ModuleDestructible::setUseLegacyDamageRadiusSpread. Otherwise, the new parameters\n damageSpread.minimumRadius, damageSpread.radiusMultiplier, and damageSpread.falloffExponent are used. For impact damage, this parameter\n will continue to be used, however the radius will no longer scale with object size. The radius will continue\n to scale with the damage as a fraction of damageThreshold, however. If legacy damage behavior is used, this parameter\n will behave as before with respect to impact damage as well (scaling with object size).", true); + HintTable[1].init("shortDescription", "Controls the distance into the destructible to propagate damage.", true); + ParamDefTable[271].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=272, longName="behaviorGroups[].damageSpread" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[272]; + ParamDef->init("damageSpread", TYPE_STRUCT, "DamageSpreadFunction", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Describes the radius and damage envelope function for damage applied to the destructible.", true); + HintTable[1].init("shortDescription", "Describes the radius and damage envelope function for damage applied to the destructible.", true); + ParamDefTable[272].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=273, longName="behaviorGroups[].damageSpread.minimumRadius" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[273]; + ParamDef->init("minimumRadius", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The minimum radius of damage spread when damage is applied. The formula for the damage radius is\n radius = minimumRadius + (input radius) * radiusMultiplier.", true); + HintTable[1].init("shortDescription", "The minimum radius of damage spread when damage is applied.", true); + ParamDefTable[273].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=274, longName="behaviorGroups[].damageSpread.radiusMultiplier" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[274]; + ParamDef->init("radiusMultiplier", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "A scale to apply to the input damage radius when damage is applied. The formula for the damage radius is\n radius = minimumRadius + (input radius) * radiusMultiplier.", true); + HintTable[1].init("shortDescription", "A scale to apply to the input damage radius when damage is applied.", true); + ParamDefTable[274].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=275, longName="behaviorGroups[].damageSpread.falloffExponent" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[275]; + ParamDef->init("falloffExponent", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "How damage varies between the minimum radius and the calculated damage radius. The formula for the damage radius is\n radius = minimumRadius + (input radius) * radiusMultiplier.\n Within the minimumRadius, the full damage is applied to chunks. Past the minimumRadius, the formla for damage is:\n damage = (input damage) * ((radius - distance)/(radius - minimumRadius))^falloffExponent.\n Note: falloffExponent = 0.0 gives no falloff, so that damage = (input damage) over the entire range [0, radius).\n falloffExponent = 1.0 gives linear falloff.", true); + HintTable[1].init("shortDescription", "How damage varies between the minimum radius and the calculated damage radius.", true); + ParamDefTable[275].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=276, longName="behaviorGroups[].damageColorSpread" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[276]; + ParamDef->init("damageColorSpread", TYPE_STRUCT, "DamageSpreadFunction", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Describes the radius and damage envelope function for color channel damage modification applied to the destructible.", true); + HintTable[1].init("shortDescription", "Describes the radius and damage envelope function for color channel damage modification applied to the destructible.", true); + ParamDefTable[276].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=277, longName="behaviorGroups[].damageColorSpread.minimumRadius" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[277]; + ParamDef->init("minimumRadius", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The minimum radius of damage spread when damage is applied. The formula for the damage radius is\n radius = minimumRadius + (input radius) * radiusMultiplier.", true); + HintTable[1].init("shortDescription", "The minimum radius of damage spread when damage is applied.", true); + ParamDefTable[277].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=278, longName="behaviorGroups[].damageColorSpread.radiusMultiplier" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[278]; + ParamDef->init("radiusMultiplier", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "A scale to apply to the input damage radius when damage is applied. The formula for the damage radius is\n radius = minimumRadius + (input radius) * radiusMultiplier.", true); + HintTable[1].init("shortDescription", "A scale to apply to the input damage radius when damage is applied.", true); + ParamDefTable[278].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=279, longName="behaviorGroups[].damageColorSpread.falloffExponent" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[279]; + ParamDef->init("falloffExponent", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "How damage varies between the minimum radius and the calculated damage radius. The formula for the damage radius is\n radius = minimumRadius + (input radius) * radiusMultiplier.\n Within the minimumRadius, the full damage is applied to chunks. Past the minimumRadius, the formla for damage is:\n damage = (input damage) * ((radius - distance)/(radius - minimumRadius))^falloffExponent.\n Note: falloffExponent = 0.0 gives no falloff, so that damage = (input damage) over the entire range [0, radius).\n falloffExponent = 1.0 gives linear falloff.", true); + HintTable[1].init("shortDescription", "How damage varies between the minimum radius and the calculated damage radius.", true); + ParamDefTable[279].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=280, longName="behaviorGroups[].damageColorChange" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[280]; + ParamDef->init("damageColorChange", TYPE_VEC4, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Describes how damage changes the color of vertices in the render mesh. If this vector is non-zero, then a dynamic\n (per-actor) color channel will be created and initialized to the asset's color channel, if it exists. Damage taken will go through\n the spread and envelope function described by damageColorSpread, and each color will be modified by the resulting damage, scaled\n by the values in damageColorChange. The change to color channel C is given by\n color[C] = clamp(color[C] + damageColorChange[C]*255*min(1.0, damage/damageThreshold), 0, 255).", true); + HintTable[1].init("shortDescription", "Describes how damage changes the color of vertices in the render mesh.", true); + ParamDefTable[280].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=281, longName="behaviorGroups[].materialStrength" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[281]; + ParamDef->init("materialStrength", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "When a chunk takes impact damage due to physical contact (see see DestructibleDepthParameters), this parameter\n is the maximum impulse the contact can generate. Weak materials such as glass may have this set to a low value, so that\n heavier objects will pass through them during fracture.\n N.B.: Setting this parameter to 0 disables the impulse cap; that is, zero is interpreted as infinite.\n Default value = 0.0f.", true); + HintTable[1].init("shortDescription", "When a chunk takes impact, this is the maximum impulse the contact can generate.", true); + ParamDefTable[281].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=282, longName="behaviorGroups[].density" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[282]; + ParamDef->init("density", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Chunk density. (TODO: better description)", true); + HintTable[1].init("shortDescription", "Chunk density", true); + ParamDefTable[282].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=283, longName="behaviorGroups[].fadeOut" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[283]; + ParamDef->init("fadeOut", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Chunk fade out. (TODO: better description)", true); + HintTable[1].init("shortDescription", "Chunk fade out", true); + ParamDefTable[283].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=284, longName="behaviorGroups[].maxDepenetrationVelocity" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[284]; + ParamDef->init("maxDepenetrationVelocity", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "In case some chunk is created inside static geometry it will be pushed out of it without limiting it's velocity. Sometimes it's not desirable, \n so this parameter can limit depenetration velocity. Keep in mind, that for low values you can see chunks 'floating' off the static meshes, which is also not always desirable.", true); + HintTable[1].init("shortDescription", "Chunk maximum depenetration velocity", true); + ParamDefTable[284].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=285, longName="behaviorGroups[].groupsMask" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[285]; + ParamDef->init("groupsMask", TYPE_STRUCT, "GroupsMask", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Optional groups mask for dynamic chunks created when fractured.", true); + HintTable[1].init("shortDescription", "Optional groups mask for dynamic chunks created when fractured", true); + ParamDefTable[285].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=286, longName="behaviorGroups[].groupsMask.useGroupsMask" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[286]; + ParamDef->init("useGroupsMask", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Whether or not the groupsMask should be used. If so, then this will be applied to all NxShapes\n created to represent this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Whether or not the groupsMask should be used", true); + ParamDefTable[286].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=287, longName="behaviorGroups[].groupsMask.bits0" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[287]; + ParamDef->init("bits0", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If useGroupsMask is true, this is bits0 of the groups mask. See the PhysX documentation for more on groups masks.", true); + HintTable[1].init("shortDescription", "bits0 of the groups mask", true); + ParamDefTable[287].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=288, longName="behaviorGroups[].groupsMask.bits1" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[288]; + ParamDef->init("bits1", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If useGroupsMask is true, this is bits1 of the groups mask. See the PhysX documentation for more on groups masks.", true); + HintTable[1].init("shortDescription", "bits1 of the groups mask", true); + ParamDefTable[288].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=289, longName="behaviorGroups[].groupsMask.bits2" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[289]; + ParamDef->init("bits2", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If useGroupsMask is true, this is bits2 of the groups mask. See the PhysX documentation for more on groups masks.", true); + HintTable[1].init("shortDescription", "bits2 of the groups mask", true); + ParamDefTable[289].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=290, longName="behaviorGroups[].groupsMask.bits3" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[290]; + ParamDef->init("bits3", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If useGroupsMask is true, this is bits3 of the groups mask. See the PhysX documentation for more on groups masks.", true); + HintTable[1].init("shortDescription", "bits3 of the groups mask", true); + ParamDefTable[290].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=291, longName="behaviorGroups[].userData" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[291]; + ParamDef->init("userData", TYPE_U64, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "User data field. This 64-bit field can be set and retrieved by the user at runtime.", true); + HintTable[1].init("shortDescription", "User data field.", true); + ParamDefTable[291].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=292, longName="deleteChunksLeavingUserDefinedBB" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[292]; + ParamDef->init("deleteChunksLeavingUserDefinedBB", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The user can specify arbitrary number of bounding boxes in the scene using ApexScene::addBoundingBox interface along with the flag, which marks a bounding box \n as either UserBoundingBoxFlags::ENTER or UserBoundingBoxFlags::LEAVE. If user also specifies 'deleteChunksLeavingUserDefinedBB' flag to true, then chunks that are leaving a bounding box marked as\n UserBoundingBoxFlags::LEAVE are going to be deleted. User can specify more complex deletion volumes by combining 2 types of bounding boxes.", true); + HintTable[1].init("shortDescription", "Whether or not the destructible chunks are going to be deleted upon leaving any user-defined bounding box.", true); + ParamDefTable[292].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=293, longName="deleteChunksEnteringUserDefinedBB" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[293]; + ParamDef->init("deleteChunksEnteringUserDefinedBB", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The user can specify arbitrary number of bounding boxes in the scene using ApexScene::addBoundingBox interface along with the flag, which marks a bounding box \n as either UserBoundingBoxFlags::ENTER or UserBoundingBoxFlags::LEAVE. If user also specifies 'deleteChunksEnteringUserDefinedBB' flag to true, then chunks that are entering a bounding box marked as\n UserBoundingBoxFlags::ENTER are going to be deleted. User can specify more complex deletion volumes by combining 2 types of bounding boxes.", true); + HintTable[1].init("shortDescription", "Whether or not the destructible chunks are going to be deleted upon entering any user-defined bounding box.", true); + ParamDefTable[293].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // SetChildren for: nodeIndex=0, longName="" + { + static Definition* Children[34]; + Children[0] = PDEF_PTR(1); + Children[1] = PDEF_PTR(2); + Children[2] = PDEF_PTR(3); + Children[3] = PDEF_PTR(4); + Children[4] = PDEF_PTR(5); + Children[5] = PDEF_PTR(6); + Children[6] = PDEF_PTR(7); + Children[7] = PDEF_PTR(8); + Children[8] = PDEF_PTR(9); + Children[9] = PDEF_PTR(10); + Children[10] = PDEF_PTR(11); + Children[11] = PDEF_PTR(12); + Children[12] = PDEF_PTR(13); + Children[13] = PDEF_PTR(14); + Children[14] = PDEF_PTR(15); + Children[15] = PDEF_PTR(16); + Children[16] = PDEF_PTR(17); + Children[17] = PDEF_PTR(18); + Children[18] = PDEF_PTR(20); + Children[19] = PDEF_PTR(22); + Children[20] = PDEF_PTR(23); + Children[21] = PDEF_PTR(24); + Children[22] = PDEF_PTR(85); + Children[23] = PDEF_PTR(96); + Children[24] = PDEF_PTR(130); + Children[25] = PDEF_PTR(159); + Children[26] = PDEF_PTR(176); + Children[27] = PDEF_PTR(199); + Children[28] = PDEF_PTR(225); + Children[29] = PDEF_PTR(239); + Children[30] = PDEF_PTR(243); + Children[31] = PDEF_PTR(267); + Children[32] = PDEF_PTR(292); + Children[33] = PDEF_PTR(293); + + ParamDefTable[0].setChildren(Children, 34); + } + + // SetChildren for: nodeIndex=18, longName="overrideSkinnedMaterialNames" + { + static Definition* Children[1]; + Children[0] = PDEF_PTR(19); + + ParamDefTable[18].setChildren(Children, 1); + } + + // SetChildren for: nodeIndex=20, longName="overrideStaticMaterialNames" + { + static Definition* Children[1]; + Children[0] = PDEF_PTR(21); + + ParamDefTable[20].setChildren(Children, 1); + } + + // SetChildren for: nodeIndex=24, longName="destructibleParameters" + { + static Definition* Children[24]; + Children[0] = PDEF_PTR(25); + Children[1] = PDEF_PTR(26); + Children[2] = PDEF_PTR(27); + Children[3] = PDEF_PTR(28); + Children[4] = PDEF_PTR(29); + Children[5] = PDEF_PTR(30); + Children[6] = PDEF_PTR(31); + Children[7] = PDEF_PTR(32); + Children[8] = PDEF_PTR(33); + Children[9] = PDEF_PTR(34); + Children[10] = PDEF_PTR(35); + Children[11] = PDEF_PTR(36); + Children[12] = PDEF_PTR(37); + Children[13] = PDEF_PTR(38); + Children[14] = PDEF_PTR(39); + Children[15] = PDEF_PTR(47); + Children[16] = PDEF_PTR(48); + Children[17] = PDEF_PTR(49); + Children[18] = PDEF_PTR(50); + Children[19] = PDEF_PTR(56); + Children[20] = PDEF_PTR(81); + Children[21] = PDEF_PTR(82); + Children[22] = PDEF_PTR(83); + Children[23] = PDEF_PTR(84); + + ParamDefTable[24].setChildren(Children, 24); + } + + // SetChildren for: nodeIndex=39, longName="destructibleParameters.flags" + { + static Definition* Children[7]; + Children[0] = PDEF_PTR(40); + Children[1] = PDEF_PTR(41); + Children[2] = PDEF_PTR(42); + Children[3] = PDEF_PTR(43); + Children[4] = PDEF_PTR(44); + Children[5] = PDEF_PTR(45); + Children[6] = PDEF_PTR(46); + + ParamDefTable[39].setChildren(Children, 7); + } + + // SetChildren for: nodeIndex=50, longName="destructibleParameters.dynamicChunksGroupsMask" + { + static Definition* Children[5]; + Children[0] = PDEF_PTR(51); + Children[1] = PDEF_PTR(52); + Children[2] = PDEF_PTR(53); + Children[3] = PDEF_PTR(54); + Children[4] = PDEF_PTR(55); + + ParamDefTable[50].setChildren(Children, 5); + } + + // SetChildren for: nodeIndex=56, longName="destructibleParameters.runtimeFracture" + { + static Definition* Children[9]; + Children[0] = PDEF_PTR(57); + Children[1] = PDEF_PTR(58); + Children[2] = PDEF_PTR(59); + Children[3] = PDEF_PTR(60); + Children[4] = PDEF_PTR(61); + Children[5] = PDEF_PTR(62); + Children[6] = PDEF_PTR(63); + Children[7] = PDEF_PTR(69); + Children[8] = PDEF_PTR(74); + + ParamDefTable[56].setChildren(Children, 9); + } + + // SetChildren for: nodeIndex=63, longName="destructibleParameters.runtimeFracture.glass" + { + static Definition* Children[5]; + Children[0] = PDEF_PTR(64); + Children[1] = PDEF_PTR(65); + Children[2] = PDEF_PTR(66); + Children[3] = PDEF_PTR(67); + Children[4] = PDEF_PTR(68); + + ParamDefTable[63].setChildren(Children, 5); + } + + // SetChildren for: nodeIndex=69, longName="destructibleParameters.runtimeFracture.voronoi" + { + static Definition* Children[4]; + Children[0] = PDEF_PTR(70); + Children[1] = PDEF_PTR(71); + Children[2] = PDEF_PTR(72); + Children[3] = PDEF_PTR(73); + + ParamDefTable[69].setChildren(Children, 4); + } + + // SetChildren for: nodeIndex=74, longName="destructibleParameters.runtimeFracture.attachment" + { + static Definition* Children[6]; + Children[0] = PDEF_PTR(75); + Children[1] = PDEF_PTR(76); + Children[2] = PDEF_PTR(77); + Children[3] = PDEF_PTR(78); + Children[4] = PDEF_PTR(79); + Children[5] = PDEF_PTR(80); + + ParamDefTable[74].setChildren(Children, 6); + } + + // SetChildren for: nodeIndex=85, longName="depthParameters" + { + static Definition* Children[1]; + Children[0] = PDEF_PTR(86); + + ParamDefTable[85].setChildren(Children, 1); + } + + // SetChildren for: nodeIndex=86, longName="depthParameters[]" + { + static Definition* Children[9]; + Children[0] = PDEF_PTR(87); + Children[1] = PDEF_PTR(88); + Children[2] = PDEF_PTR(89); + Children[3] = PDEF_PTR(90); + Children[4] = PDEF_PTR(91); + Children[5] = PDEF_PTR(92); + Children[6] = PDEF_PTR(93); + Children[7] = PDEF_PTR(94); + Children[8] = PDEF_PTR(95); + + ParamDefTable[86].setChildren(Children, 9); + } + + // SetChildren for: nodeIndex=96, longName="shapeDescTemplate" + { + static Definition* Children[8]; + Children[0] = PDEF_PTR(97); + Children[1] = PDEF_PTR(118); + Children[2] = PDEF_PTR(119); + Children[3] = PDEF_PTR(125); + Children[4] = PDEF_PTR(126); + Children[5] = PDEF_PTR(127); + Children[6] = PDEF_PTR(128); + Children[7] = PDEF_PTR(129); + + ParamDefTable[96].setChildren(Children, 8); + } + + // SetChildren for: nodeIndex=97, longName="shapeDescTemplate.flags" + { + static Definition* Children[20]; + Children[0] = PDEF_PTR(98); + Children[1] = PDEF_PTR(99); + Children[2] = PDEF_PTR(100); + Children[3] = PDEF_PTR(101); + Children[4] = PDEF_PTR(102); + Children[5] = PDEF_PTR(103); + Children[6] = PDEF_PTR(104); + Children[7] = PDEF_PTR(105); + Children[8] = PDEF_PTR(106); + Children[9] = PDEF_PTR(107); + Children[10] = PDEF_PTR(108); + Children[11] = PDEF_PTR(109); + Children[12] = PDEF_PTR(110); + Children[13] = PDEF_PTR(111); + Children[14] = PDEF_PTR(112); + Children[15] = PDEF_PTR(113); + Children[16] = PDEF_PTR(114); + Children[17] = PDEF_PTR(115); + Children[18] = PDEF_PTR(116); + Children[19] = PDEF_PTR(117); + + ParamDefTable[97].setChildren(Children, 20); + } + + // SetChildren for: nodeIndex=119, longName="shapeDescTemplate.groupsMask" + { + static Definition* Children[5]; + Children[0] = PDEF_PTR(120); + Children[1] = PDEF_PTR(121); + Children[2] = PDEF_PTR(122); + Children[3] = PDEF_PTR(123); + Children[4] = PDEF_PTR(124); + + ParamDefTable[119].setChildren(Children, 5); + } + + // SetChildren for: nodeIndex=130, longName="actorDescTemplate" + { + static Definition* Children[9]; + Children[0] = PDEF_PTR(131); + Children[1] = PDEF_PTR(139); + Children[2] = PDEF_PTR(140); + Children[3] = PDEF_PTR(141); + Children[4] = PDEF_PTR(142); + Children[5] = PDEF_PTR(155); + Children[6] = PDEF_PTR(156); + Children[7] = PDEF_PTR(157); + Children[8] = PDEF_PTR(158); + + ParamDefTable[130].setChildren(Children, 9); + } + + // SetChildren for: nodeIndex=131, longName="actorDescTemplate.flags" + { + static Definition* Children[7]; + Children[0] = PDEF_PTR(132); + Children[1] = PDEF_PTR(133); + Children[2] = PDEF_PTR(134); + Children[3] = PDEF_PTR(135); + Children[4] = PDEF_PTR(136); + Children[5] = PDEF_PTR(137); + Children[6] = PDEF_PTR(138); + + ParamDefTable[131].setChildren(Children, 7); + } + + // SetChildren for: nodeIndex=142, longName="actorDescTemplate.contactReportFlags" + { + static Definition* Children[12]; + Children[0] = PDEF_PTR(143); + Children[1] = PDEF_PTR(144); + Children[2] = PDEF_PTR(145); + Children[3] = PDEF_PTR(146); + Children[4] = PDEF_PTR(147); + Children[5] = PDEF_PTR(148); + Children[6] = PDEF_PTR(149); + Children[7] = PDEF_PTR(150); + Children[8] = PDEF_PTR(151); + Children[9] = PDEF_PTR(152); + Children[10] = PDEF_PTR(153); + Children[11] = PDEF_PTR(154); + + ParamDefTable[142].setChildren(Children, 12); + } + + // SetChildren for: nodeIndex=159, longName="bodyDescTemplate" + { + static Definition* Children[12]; + Children[0] = PDEF_PTR(160); + Children[1] = PDEF_PTR(165); + Children[2] = PDEF_PTR(166); + Children[3] = PDEF_PTR(167); + Children[4] = PDEF_PTR(168); + Children[5] = PDEF_PTR(169); + Children[6] = PDEF_PTR(170); + Children[7] = PDEF_PTR(171); + Children[8] = PDEF_PTR(172); + Children[9] = PDEF_PTR(173); + Children[10] = PDEF_PTR(174); + Children[11] = PDEF_PTR(175); + + ParamDefTable[159].setChildren(Children, 12); + } + + // SetChildren for: nodeIndex=160, longName="bodyDescTemplate.flags" + { + static Definition* Children[4]; + Children[0] = PDEF_PTR(161); + Children[1] = PDEF_PTR(162); + Children[2] = PDEF_PTR(163); + Children[3] = PDEF_PTR(164); + + ParamDefTable[160].setChildren(Children, 4); + } + + // SetChildren for: nodeIndex=176, longName="p3ShapeDescTemplate" + { + static Definition* Children[8]; + Children[0] = PDEF_PTR(177); + Children[1] = PDEF_PTR(184); + Children[2] = PDEF_PTR(189); + Children[3] = PDEF_PTR(194); + Children[4] = PDEF_PTR(195); + Children[5] = PDEF_PTR(196); + Children[6] = PDEF_PTR(197); + Children[7] = PDEF_PTR(198); + + ParamDefTable[176].setChildren(Children, 8); + } + + // SetChildren for: nodeIndex=177, longName="p3ShapeDescTemplate.flags" + { + static Definition* Children[6]; + Children[0] = PDEF_PTR(178); + Children[1] = PDEF_PTR(179); + Children[2] = PDEF_PTR(180); + Children[3] = PDEF_PTR(181); + Children[4] = PDEF_PTR(182); + Children[5] = PDEF_PTR(183); + + ParamDefTable[177].setChildren(Children, 6); + } + + // SetChildren for: nodeIndex=184, longName="p3ShapeDescTemplate.simulationFilterData" + { + static Definition* Children[4]; + Children[0] = PDEF_PTR(185); + Children[1] = PDEF_PTR(186); + Children[2] = PDEF_PTR(187); + Children[3] = PDEF_PTR(188); + + ParamDefTable[184].setChildren(Children, 4); + } + + // SetChildren for: nodeIndex=189, longName="p3ShapeDescTemplate.queryFilterData" + { + static Definition* Children[4]; + Children[0] = PDEF_PTR(190); + Children[1] = PDEF_PTR(191); + Children[2] = PDEF_PTR(192); + Children[3] = PDEF_PTR(193); + + ParamDefTable[189].setChildren(Children, 4); + } + + // SetChildren for: nodeIndex=199, longName="p3ActorDescTemplate" + { + static Definition* Children[7]; + Children[0] = PDEF_PTR(200); + Children[1] = PDEF_PTR(204); + Children[2] = PDEF_PTR(205); + Children[3] = PDEF_PTR(206); + Children[4] = PDEF_PTR(207); + Children[5] = PDEF_PTR(223); + Children[6] = PDEF_PTR(224); + + ParamDefTable[199].setChildren(Children, 7); + } + + // SetChildren for: nodeIndex=200, longName="p3ActorDescTemplate.flags" + { + static Definition* Children[3]; + Children[0] = PDEF_PTR(201); + Children[1] = PDEF_PTR(202); + Children[2] = PDEF_PTR(203); + + ParamDefTable[200].setChildren(Children, 3); + } + + // SetChildren for: nodeIndex=207, longName="p3ActorDescTemplate.contactReportFlags" + { + static Definition* Children[15]; + Children[0] = PDEF_PTR(208); + Children[1] = PDEF_PTR(209); + Children[2] = PDEF_PTR(210); + Children[3] = PDEF_PTR(211); + Children[4] = PDEF_PTR(212); + Children[5] = PDEF_PTR(213); + Children[6] = PDEF_PTR(214); + Children[7] = PDEF_PTR(215); + Children[8] = PDEF_PTR(216); + Children[9] = PDEF_PTR(217); + Children[10] = PDEF_PTR(218); + Children[11] = PDEF_PTR(219); + Children[12] = PDEF_PTR(220); + Children[13] = PDEF_PTR(221); + Children[14] = PDEF_PTR(222); + + ParamDefTable[207].setChildren(Children, 15); + } + + // SetChildren for: nodeIndex=225, longName="p3BodyDescTemplate" + { + static Definition* Children[11]; + Children[0] = PDEF_PTR(226); + Children[1] = PDEF_PTR(227); + Children[2] = PDEF_PTR(230); + Children[3] = PDEF_PTR(231); + Children[4] = PDEF_PTR(232); + Children[5] = PDEF_PTR(233); + Children[6] = PDEF_PTR(234); + Children[7] = PDEF_PTR(235); + Children[8] = PDEF_PTR(236); + Children[9] = PDEF_PTR(237); + Children[10] = PDEF_PTR(238); + + ParamDefTable[225].setChildren(Children, 11); + } + + // SetChildren for: nodeIndex=227, longName="p3BodyDescTemplate.flags" + { + static Definition* Children[2]; + Children[0] = PDEF_PTR(228); + Children[1] = PDEF_PTR(229); + + ParamDefTable[227].setChildren(Children, 2); + } + + // SetChildren for: nodeIndex=239, longName="structureSettings" + { + static Definition* Children[3]; + Children[0] = PDEF_PTR(240); + Children[1] = PDEF_PTR(241); + Children[2] = PDEF_PTR(242); + + ParamDefTable[239].setChildren(Children, 3); + } + + // SetChildren for: nodeIndex=243, longName="defaultBehaviorGroup" + { + static Definition* Children[12]; + Children[0] = PDEF_PTR(244); + Children[1] = PDEF_PTR(245); + Children[2] = PDEF_PTR(246); + Children[3] = PDEF_PTR(247); + Children[4] = PDEF_PTR(251); + Children[5] = PDEF_PTR(255); + Children[6] = PDEF_PTR(256); + Children[7] = PDEF_PTR(257); + Children[8] = PDEF_PTR(258); + Children[9] = PDEF_PTR(259); + Children[10] = PDEF_PTR(260); + Children[11] = PDEF_PTR(266); + + ParamDefTable[243].setChildren(Children, 12); + } + + // SetChildren for: nodeIndex=247, longName="defaultBehaviorGroup.damageSpread" + { + static Definition* Children[3]; + Children[0] = PDEF_PTR(248); + Children[1] = PDEF_PTR(249); + Children[2] = PDEF_PTR(250); + + ParamDefTable[247].setChildren(Children, 3); + } + + // SetChildren for: nodeIndex=251, longName="defaultBehaviorGroup.damageColorSpread" + { + static Definition* Children[3]; + Children[0] = PDEF_PTR(252); + Children[1] = PDEF_PTR(253); + Children[2] = PDEF_PTR(254); + + ParamDefTable[251].setChildren(Children, 3); + } + + // SetChildren for: nodeIndex=260, longName="defaultBehaviorGroup.groupsMask" + { + static Definition* Children[5]; + Children[0] = PDEF_PTR(261); + Children[1] = PDEF_PTR(262); + Children[2] = PDEF_PTR(263); + Children[3] = PDEF_PTR(264); + Children[4] = PDEF_PTR(265); + + ParamDefTable[260].setChildren(Children, 5); + } + + // SetChildren for: nodeIndex=267, longName="behaviorGroups" + { + static Definition* Children[1]; + Children[0] = PDEF_PTR(268); + + ParamDefTable[267].setChildren(Children, 1); + } + + // SetChildren for: nodeIndex=268, longName="behaviorGroups[]" + { + static Definition* Children[12]; + Children[0] = PDEF_PTR(269); + Children[1] = PDEF_PTR(270); + Children[2] = PDEF_PTR(271); + Children[3] = PDEF_PTR(272); + Children[4] = PDEF_PTR(276); + Children[5] = PDEF_PTR(280); + Children[6] = PDEF_PTR(281); + Children[7] = PDEF_PTR(282); + Children[8] = PDEF_PTR(283); + Children[9] = PDEF_PTR(284); + Children[10] = PDEF_PTR(285); + Children[11] = PDEF_PTR(291); + + ParamDefTable[268].setChildren(Children, 12); + } + + // SetChildren for: nodeIndex=272, longName="behaviorGroups[].damageSpread" + { + static Definition* Children[3]; + Children[0] = PDEF_PTR(273); + Children[1] = PDEF_PTR(274); + Children[2] = PDEF_PTR(275); + + ParamDefTable[272].setChildren(Children, 3); + } + + // SetChildren for: nodeIndex=276, longName="behaviorGroups[].damageColorSpread" + { + static Definition* Children[3]; + Children[0] = PDEF_PTR(277); + Children[1] = PDEF_PTR(278); + Children[2] = PDEF_PTR(279); + + ParamDefTable[276].setChildren(Children, 3); + } + + // SetChildren for: nodeIndex=285, longName="behaviorGroups[].groupsMask" + { + static Definition* Children[5]; + Children[0] = PDEF_PTR(286); + Children[1] = PDEF_PTR(287); + Children[2] = PDEF_PTR(288); + Children[3] = PDEF_PTR(289); + Children[4] = PDEF_PTR(290); + + ParamDefTable[285].setChildren(Children, 5); + } + + mBuiltFlag = true; + +} +void DestructibleActorParam::initStrings(void) +{ + crumbleEmitterName.isAllocated = false; + crumbleEmitterName.buf = (const char*)0; + dustEmitterName.isAllocated = false; + dustEmitterName.buf = (const char*)0; + defaultBehaviorGroup.name.isAllocated = true; + defaultBehaviorGroup.name.buf = NULL; +} + +void DestructibleActorParam::initDynamicArrays(void) +{ + overrideSkinnedMaterialNames.buf = NULL; + overrideSkinnedMaterialNames.isAllocated = true; + overrideSkinnedMaterialNames.elementSize = sizeof(NvParameterized::DummyStringStruct); + overrideSkinnedMaterialNames.arraySizes[0] = 0; + overrideStaticMaterialNames.buf = NULL; + overrideStaticMaterialNames.isAllocated = true; + overrideStaticMaterialNames.elementSize = sizeof(NvParameterized::DummyStringStruct); + overrideStaticMaterialNames.arraySizes[0] = 0; + depthParameters.buf = NULL; + depthParameters.isAllocated = true; + depthParameters.elementSize = sizeof(DestructibleDepthParameters_Type); + depthParameters.arraySizes[0] = 0; + behaviorGroups.buf = NULL; + behaviorGroups.isAllocated = true; + behaviorGroups.elementSize = sizeof(BehaviorGroup_Type); + behaviorGroups.arraySizes[0] = 0; +} + +void DestructibleActorParam::initDefaults(void) +{ + + freeStrings(); + freeReferences(); + freeDynamicArrays(); + crumbleParticleSpacing = float(0); + dustParticleSpacing = float(0); + globalPose = physx::PxTransform(physx::PxIdentity); + scale = physx::PxVec3(init(1, 1, 1)); + dynamic = bool(true); + supportDepth = uint32_t(0); + formExtendedStructures = bool(false); + performDetailedOverlapTestForExtendedStructures = bool(true); + keepPreviousFrameBoneBuffer = bool(false); + doNotCreateRenderable = bool(false); + useAssetDefinedSupport = bool(false); + useWorldSupport = bool(false); + renderStaticChunksSeparately = bool(false); + keepVisibleBonesPacked = bool(true); + createChunkEvents = bool(false); + sleepVelocityFrameDecayConstant = float(1); + useHardSleeping = bool(false); + destructibleParameters.damageCap = float(0); + destructibleParameters.forceToDamage = float(0); + destructibleParameters.impactVelocityThreshold = float(0); + destructibleParameters.minimumFractureDepth = uint32_t(0); + destructibleParameters.impactDamageDefaultDepth = int32_t(-1); + destructibleParameters.debrisDepth = int32_t(-1); + destructibleParameters.essentialDepth = uint32_t(0); + destructibleParameters.debrisLifetimeMin = float(1); + destructibleParameters.debrisLifetimeMax = float(10); + destructibleParameters.debrisMaxSeparationMin = float(1); + destructibleParameters.debrisMaxSeparationMax = float(10); + destructibleParameters.debrisDestructionProbability = float(0); + destructibleParameters.validBounds = physx::PxBounds3(init(-1000, -1000, -1000, 1000, 1000, 1000)); + destructibleParameters.maxChunkSpeed = float(0); + destructibleParameters.flags.ACCUMULATE_DAMAGE = bool(true); + destructibleParameters.flags.DEBRIS_TIMEOUT = bool(false); + destructibleParameters.flags.DEBRIS_MAX_SEPARATION = bool(false); + destructibleParameters.flags.CRUMBLE_SMALLEST_CHUNKS = bool(false); + destructibleParameters.flags.ACCURATE_RAYCASTS = bool(false); + destructibleParameters.flags.USE_VALID_BOUNDS = bool(false); + destructibleParameters.flags.CRUMBLE_VIA_RUNTIME_FRACTURE = bool(false); + destructibleParameters.fractureImpulseScale = float(0); + destructibleParameters.damageDepthLimit = uint16_t(UINT16_MAX); + destructibleParameters.dynamicChunkDominanceGroup = uint16_t(UINT16_MAX); + destructibleParameters.dynamicChunksGroupsMask.useGroupsMask = bool(false); + destructibleParameters.dynamicChunksGroupsMask.bits0 = uint32_t(0); + destructibleParameters.dynamicChunksGroupsMask.bits1 = uint32_t(0); + destructibleParameters.dynamicChunksGroupsMask.bits2 = uint32_t(0); + destructibleParameters.dynamicChunksGroupsMask.bits3 = uint32_t(0); + destructibleParameters.runtimeFracture.RuntimeFractureType = (const char*)"VORONOI"; + destructibleParameters.runtimeFracture.sheetFracture = bool(true); + destructibleParameters.runtimeFracture.depthLimit = uint32_t(2); + destructibleParameters.runtimeFracture.destroyIfAtDepthLimit = bool(false); + destructibleParameters.runtimeFracture.minConvexSize = float(0.02); + destructibleParameters.runtimeFracture.impulseScale = float(1); + destructibleParameters.runtimeFracture.glass.numSectors = uint32_t(10); + destructibleParameters.runtimeFracture.glass.sectorRand = float(0.3); + destructibleParameters.runtimeFracture.glass.firstSegmentSize = float(0.06); + destructibleParameters.runtimeFracture.glass.segmentScale = float(1.4); + destructibleParameters.runtimeFracture.glass.segmentRand = float(0.3); + destructibleParameters.runtimeFracture.voronoi.dimensions = physx::PxVec3(physx::PxVec3(10.0f)); + destructibleParameters.runtimeFracture.voronoi.numCells = uint32_t(1); + destructibleParameters.runtimeFracture.voronoi.biasExp = float(10); + destructibleParameters.runtimeFracture.voronoi.maxDist = float(PX_MAX_F32); + destructibleParameters.runtimeFracture.attachment.posX = bool(false); + destructibleParameters.runtimeFracture.attachment.negX = bool(false); + destructibleParameters.runtimeFracture.attachment.posY = bool(false); + destructibleParameters.runtimeFracture.attachment.negY = bool(false); + destructibleParameters.runtimeFracture.attachment.posZ = bool(false); + destructibleParameters.runtimeFracture.attachment.negZ = bool(false); + destructibleParameters.supportStrength = float(-1); + destructibleParameters.legacyChunkBoundsTestSetting = int8_t(-1); + destructibleParameters.legacyDamageRadiusSpreadSetting = int8_t(-1); + destructibleParameters.alwaysDrawScatterMesh = bool(false); + shapeDescTemplate.flags.NX_TRIGGER_ON_ENTER = bool(false); + shapeDescTemplate.flags.NX_TRIGGER_ON_LEAVE = bool(false); + shapeDescTemplate.flags.NX_TRIGGER_ON_STAY = bool(false); + shapeDescTemplate.flags.NX_SF_VISUALIZATION = bool(true); + shapeDescTemplate.flags.NX_SF_DISABLE_COLLISION = bool(false); + shapeDescTemplate.flags.NX_SF_FEATURE_INDICES = bool(false); + shapeDescTemplate.flags.NX_SF_DISABLE_RAYCASTING = bool(false); + shapeDescTemplate.flags.NX_SF_POINT_CONTACT_FORCE = bool(false); + shapeDescTemplate.flags.NX_SF_FLUID_DRAIN = bool(false); + shapeDescTemplate.flags.NX_SF_FLUID_DISABLE_COLLISION = bool(false); + shapeDescTemplate.flags.NX_SF_FLUID_TWOWAY = bool(false); + shapeDescTemplate.flags.NX_SF_DISABLE_RESPONSE = bool(false); + shapeDescTemplate.flags.NX_SF_DYNAMIC_DYNAMIC_CCD = bool(false); + shapeDescTemplate.flags.NX_SF_DISABLE_SCENE_QUERIES = bool(false); + shapeDescTemplate.flags.NX_SF_CLOTH_DRAIN = bool(false); + shapeDescTemplate.flags.NX_SF_CLOTH_DISABLE_COLLISION = bool(false); + shapeDescTemplate.flags.NX_SF_CLOTH_TWOWAY = bool(true); + shapeDescTemplate.flags.NX_SF_SOFTBODY_DRAIN = bool(false); + shapeDescTemplate.flags.NX_SF_SOFTBODY_DISABLE_COLLISION = bool(false); + shapeDescTemplate.flags.NX_SF_SOFTBODY_TWOWAY = bool(true); + shapeDescTemplate.collisionGroup = uint16_t(0); + shapeDescTemplate.groupsMask.useGroupsMask = bool(false); + shapeDescTemplate.groupsMask.bits0 = uint32_t(0); + shapeDescTemplate.groupsMask.bits1 = uint32_t(0); + shapeDescTemplate.groupsMask.bits2 = uint32_t(0); + shapeDescTemplate.groupsMask.bits3 = uint32_t(0); + shapeDescTemplate.materialIndex = uint16_t(0); + shapeDescTemplate.density = float(1); + shapeDescTemplate.skinWidth = float(-1); + shapeDescTemplate.userData = uint64_t(0); + shapeDescTemplate.name = uint64_t(0); + actorDescTemplate.flags.NX_AF_DISABLE_COLLISION = bool(false); + actorDescTemplate.flags.NX_AF_DISABLE_RESPONSE = bool(false); + actorDescTemplate.flags.NX_AF_LOCK_COM = bool(false); + actorDescTemplate.flags.NX_AF_FLUID_DISABLE_COLLISION = bool(false); + actorDescTemplate.flags.NX_AF_CONTACT_MODIFICATION = bool(false); + actorDescTemplate.flags.NX_AF_FORCE_CONE_FRICTION = bool(false); + actorDescTemplate.flags.NX_AF_USER_ACTOR_PAIR_FILTERING = bool(false); + actorDescTemplate.density = float(1); + actorDescTemplate.actorCollisionGroup = uint16_t(0); + actorDescTemplate.dominanceGroup = uint16_t(0); + actorDescTemplate.contactReportFlags.NX_IGNORE_PAIR = bool(false); + actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_START_TOUCH = bool(false); + actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_END_TOUCH = bool(false); + actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_TOUCH = bool(false); + actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_IMPACT = bool(false); + actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_ROLL = bool(false); + actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_SLIDE = bool(false); + actorDescTemplate.contactReportFlags.NX_NOTIFY_FORCES = bool(false); + actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_START_TOUCH_FORCE_THRESHOLD = bool(false); + actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_END_TOUCH_FORCE_THRESHOLD = bool(false); + actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_TOUCH_FORCE_THRESHOLD = bool(false); + actorDescTemplate.contactReportFlags.NX_NOTIFY_CONTACT_MODIFICATION = bool(false); + actorDescTemplate.forceFieldMaterial = uint16_t(0); + actorDescTemplate.userData = uint64_t(0); + actorDescTemplate.name = uint64_t(0); + actorDescTemplate.compartment = uint64_t(0); + bodyDescTemplate.flags.NX_BF_DISABLE_GRAVITY = bool(false); + bodyDescTemplate.flags.NX_BF_FILTER_SLEEP_VEL = bool(false); + bodyDescTemplate.flags.NX_BF_ENERGY_SLEEP_TEST = bool(true); + bodyDescTemplate.flags.NX_BF_VISUALIZATION = bool(true); + bodyDescTemplate.wakeUpCounter = float(0.4); + bodyDescTemplate.linearDamping = float(0); + bodyDescTemplate.angularDamping = float(0.05); + bodyDescTemplate.maxAngularVelocity = float(-1); + bodyDescTemplate.CCDMotionThreshold = float(0); + bodyDescTemplate.sleepLinearVelocity = float(-1); + bodyDescTemplate.sleepAngularVelocity = float(-1); + bodyDescTemplate.solverIterationCount = uint32_t(4); + bodyDescTemplate.sleepEnergyThreshold = float(0.005); + bodyDescTemplate.sleepDamping = float(0); + bodyDescTemplate.contactReportThreshold = float(PX_MAX_F32); + p3ShapeDescTemplate.flags.eSIMULATION_SHAPE = bool(true); + p3ShapeDescTemplate.flags.eSCENE_QUERY_SHAPE = bool(true); + p3ShapeDescTemplate.flags.eTRIGGER_SHAPE = bool(false); + p3ShapeDescTemplate.flags.eVISUALIZATION = bool(true); + p3ShapeDescTemplate.flags.ePARTICLE_DRAIN = bool(false); + p3ShapeDescTemplate.flags.eDEFORMABLE_DRAIN = bool(false); + p3ShapeDescTemplate.simulationFilterData.word0 = uint32_t(0); + p3ShapeDescTemplate.simulationFilterData.word1 = uint32_t(0); + p3ShapeDescTemplate.simulationFilterData.word2 = uint32_t(0); + p3ShapeDescTemplate.simulationFilterData.word3 = uint32_t(0); + p3ShapeDescTemplate.queryFilterData.word0 = uint32_t(0); + p3ShapeDescTemplate.queryFilterData.word1 = uint32_t(0); + p3ShapeDescTemplate.queryFilterData.word2 = uint32_t(0); + p3ShapeDescTemplate.queryFilterData.word3 = uint32_t(0); + p3ShapeDescTemplate.material = uint64_t(0); + p3ShapeDescTemplate.contactOffset = float(0.02); + p3ShapeDescTemplate.restOffset = float(0); + p3ShapeDescTemplate.userData = uint64_t(0); + p3ShapeDescTemplate.name = uint64_t(0); + p3ActorDescTemplate.flags.eVISUALIZATION = bool(true); + p3ActorDescTemplate.flags.eDISABLE_GRAVITY = bool(false); + p3ActorDescTemplate.flags.eSEND_SLEEP_NOTIFIES = bool(true); + p3ActorDescTemplate.dominanceGroup = uint8_t(0); + p3ActorDescTemplate.ownerClient = uint8_t(0); + p3ActorDescTemplate.clientBehaviorBits = uint32_t(0); + p3ActorDescTemplate.contactReportFlags.eSOLVE_CONTACT = bool(false); + p3ActorDescTemplate.contactReportFlags.eMODIFY_CONTACTS = bool(false); + p3ActorDescTemplate.contactReportFlags.eNOTIFY_TOUCH_FOUND = bool(false); + p3ActorDescTemplate.contactReportFlags.eNOTIFY_TOUCH_PERSISTS = bool(false); + p3ActorDescTemplate.contactReportFlags.eNOTIFY_TOUCH_LOST = bool(false); + p3ActorDescTemplate.contactReportFlags.eNOTIFY_THRESHOLD_FORCE_FOUND = bool(false); + p3ActorDescTemplate.contactReportFlags.eNOTIFY_THRESHOLD_FORCE_PERSISTS = bool(false); + p3ActorDescTemplate.contactReportFlags.eNOTIFY_THRESHOLD_FORCE_LOST = bool(false); + p3ActorDescTemplate.contactReportFlags.eNOTIFY_CONTACT_POINTS = bool(false); + p3ActorDescTemplate.contactReportFlags.eNOTIFY_CONTACT_FORCES = bool(false); + p3ActorDescTemplate.contactReportFlags.eNOTIFY_CONTACT_FORCE_PER_POINT = bool(false); + p3ActorDescTemplate.contactReportFlags.eNOTIFY_CONTACT_FEATURE_INDICES_PER_POINT = bool(false); + p3ActorDescTemplate.contactReportFlags.eDETECT_CCD_CONTACT = bool(false); + p3ActorDescTemplate.contactReportFlags.eCONTACT_DEFAULT = bool(false); + p3ActorDescTemplate.contactReportFlags.eTRIGGER_DEFAULT = bool(false); + p3ActorDescTemplate.userData = uint64_t(0); + p3ActorDescTemplate.name = uint64_t(0); + p3BodyDescTemplate.density = float(1); + p3BodyDescTemplate.flags.eKINEMATIC = bool(false); + p3BodyDescTemplate.flags.eENABLE_CCD = bool(false); + p3BodyDescTemplate.sleepThreshold = float(0.005); + p3BodyDescTemplate.wakeUpCounter = float(0.4); + p3BodyDescTemplate.linearDamping = float(0); + p3BodyDescTemplate.angularDamping = float(0.05); + p3BodyDescTemplate.maxAngularVelocity = float(7); + p3BodyDescTemplate.solverIterationCount = uint32_t(4); + p3BodyDescTemplate.velocityIterationCount = uint32_t(1); + p3BodyDescTemplate.contactReportThreshold = float(PX_MAX_F32); + p3BodyDescTemplate.sleepLinearVelocity = float(-1); + structureSettings.useStressSolver = bool(false); + structureSettings.stressSolverTimeDelay = float(1.0); + structureSettings.stressSolverMassThreshold = float(0.0); + defaultBehaviorGroup.damageThreshold = float(1); + defaultBehaviorGroup.damageToRadius = float(0.1); + defaultBehaviorGroup.damageSpread.minimumRadius = float(0); + defaultBehaviorGroup.damageSpread.radiusMultiplier = float(1); + defaultBehaviorGroup.damageSpread.falloffExponent = float(1); + defaultBehaviorGroup.damageColorSpread.minimumRadius = float(0); + defaultBehaviorGroup.damageColorSpread.radiusMultiplier = float(1); + defaultBehaviorGroup.damageColorSpread.falloffExponent = float(1); + defaultBehaviorGroup.damageColorChange = physx::PxVec4(initVec4(0, 0, 0, 0)); + defaultBehaviorGroup.materialStrength = float(0); + defaultBehaviorGroup.density = float(0); + defaultBehaviorGroup.fadeOut = float(1); + defaultBehaviorGroup.maxDepenetrationVelocity = float(PX_MAX_F32); + defaultBehaviorGroup.groupsMask.useGroupsMask = bool(false); + defaultBehaviorGroup.groupsMask.bits0 = uint32_t(0); + defaultBehaviorGroup.groupsMask.bits1 = uint32_t(0); + defaultBehaviorGroup.groupsMask.bits2 = uint32_t(0); + defaultBehaviorGroup.groupsMask.bits3 = uint32_t(0); + defaultBehaviorGroup.userData = uint64_t(0); + deleteChunksLeavingUserDefinedBB = bool(false); + deleteChunksEnteringUserDefinedBB = bool(false); + + initDynamicArrays(); + initStrings(); + initReferences(); +} + +void DestructibleActorParam::initReferences(void) +{ +} + +void DestructibleActorParam::freeDynamicArrays(void) +{ + if (overrideSkinnedMaterialNames.isAllocated && overrideSkinnedMaterialNames.buf) + { + mParameterizedTraits->free(overrideSkinnedMaterialNames.buf); + } + if (overrideStaticMaterialNames.isAllocated && overrideStaticMaterialNames.buf) + { + mParameterizedTraits->free(overrideStaticMaterialNames.buf); + } + if (depthParameters.isAllocated && depthParameters.buf) + { + mParameterizedTraits->free(depthParameters.buf); + } + if (behaviorGroups.isAllocated && behaviorGroups.buf) + { + mParameterizedTraits->free(behaviorGroups.buf); + } +} + +void DestructibleActorParam::freeStrings(void) +{ + + if (crumbleEmitterName.isAllocated && crumbleEmitterName.buf) + { + mParameterizedTraits->strfree((char*)crumbleEmitterName.buf); + } + + if (dustEmitterName.isAllocated && dustEmitterName.buf) + { + mParameterizedTraits->strfree((char*)dustEmitterName.buf); + } + + for (int i = 0; i < overrideSkinnedMaterialNames.arraySizes[0]; ++i) + { + if (overrideSkinnedMaterialNames.buf[i].isAllocated && overrideSkinnedMaterialNames.buf[i].buf) + { + mParameterizedTraits->strfree((char*)overrideSkinnedMaterialNames.buf[i].buf); + } + } + + for (int i = 0; i < overrideStaticMaterialNames.arraySizes[0]; ++i) + { + if (overrideStaticMaterialNames.buf[i].isAllocated && overrideStaticMaterialNames.buf[i].buf) + { + mParameterizedTraits->strfree((char*)overrideStaticMaterialNames.buf[i].buf); + } + } + + if (defaultBehaviorGroup.name.isAllocated && defaultBehaviorGroup.name.buf) + { + mParameterizedTraits->strfree((char*)defaultBehaviorGroup.name.buf); + } + + for (int i = 0; i < behaviorGroups.arraySizes[0]; ++i) + { + if (behaviorGroups.buf[i].name.isAllocated && behaviorGroups.buf[i].name.buf) + { + mParameterizedTraits->strfree((char*)behaviorGroups.buf[i].name.buf); + } + } +} + +void DestructibleActorParam::freeReferences(void) +{ +} + +} // namespace destructible +} // namespace nvidia diff --git a/APEX_1.4/module/destructible/src/autogen/DestructibleActorState.cpp b/APEX_1.4/module/destructible/src/autogen/DestructibleActorState.cpp new file mode 100644 index 00000000..f8a85c69 --- /dev/null +++ b/APEX_1.4/module/destructible/src/autogen/DestructibleActorState.cpp @@ -0,0 +1,2137 @@ +// 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-2015 NVIDIA Corporation. All rights reserved. + +// This file was generated by NvParameterized/scripts/GenParameterized.pl + + +#include "DestructibleActorState.h" +#include <string.h> +#include <stdlib.h> + +using namespace NvParameterized; + +namespace nvidia +{ +namespace destructible +{ + +using namespace DestructibleActorStateNS; + +const char* const DestructibleActorStateFactory::vptr = + NvParameterized::getVptr<DestructibleActorState, DestructibleActorState::ClassAlignment>(); + +const uint32_t NumParamDefs = 69; +static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs]; + + +static const size_t ParamLookupChildrenTable[] = +{ + 1, 2, 3, 4, 5, 66, 67, 68, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 28, 29, 30, 31, 37, 62, 63, 64, 65, 21, 22, 23, 24, 25, 26, 27, 32, 33, 34, 35, 36, + 38, 39, 40, 41, 42, 43, 44, 50, 55, 45, 46, 47, 48, 49, 51, 52, 53, 54, 56, 57, 58, + 59, 60, 61, +}; + +#define TENUM(type) nvidia::##type +#define CHILDREN(index) &ParamLookupChildrenTable[index] +static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] = +{ + { TYPE_STRUCT, false, 0, CHILDREN(0), 8 }, + { TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->enableCrumbleEmitter), NULL, 0 }, // enableCrumbleEmitter + { TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->enableDustEmitter), NULL, 0 }, // enableDustEmitter + { TYPE_U32, false, (size_t)(&((ParametersStruct*)0)->lod), NULL, 0 }, // lod + { TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->forceLod), NULL, 0 }, // forceLod + { TYPE_STRUCT, false, (size_t)(&((ParametersStruct*)0)->destructibleParameters), CHILDREN(8), 24 }, // destructibleParameters + { TYPE_F32, false, (size_t)(&((DestructibleParameters_Type*)0)->damageCap), NULL, 0 }, // destructibleParameters.damageCap + { TYPE_F32, false, (size_t)(&((DestructibleParameters_Type*)0)->forceToDamage), NULL, 0 }, // destructibleParameters.forceToDamage + { TYPE_F32, false, (size_t)(&((DestructibleParameters_Type*)0)->impactVelocityThreshold), NULL, 0 }, // destructibleParameters.impactVelocityThreshold + { TYPE_U32, false, (size_t)(&((DestructibleParameters_Type*)0)->minimumFractureDepth), NULL, 0 }, // destructibleParameters.minimumFractureDepth + { TYPE_I32, false, (size_t)(&((DestructibleParameters_Type*)0)->impactDamageDefaultDepth), NULL, 0 }, // destructibleParameters.impactDamageDefaultDepth + { TYPE_I32, false, (size_t)(&((DestructibleParameters_Type*)0)->debrisDepth), NULL, 0 }, // destructibleParameters.debrisDepth + { TYPE_U32, false, (size_t)(&((DestructibleParameters_Type*)0)->essentialDepth), NULL, 0 }, // destructibleParameters.essentialDepth + { TYPE_F32, false, (size_t)(&((DestructibleParameters_Type*)0)->debrisLifetimeMin), NULL, 0 }, // destructibleParameters.debrisLifetimeMin + { TYPE_F32, false, (size_t)(&((DestructibleParameters_Type*)0)->debrisLifetimeMax), NULL, 0 }, // destructibleParameters.debrisLifetimeMax + { TYPE_F32, false, (size_t)(&((DestructibleParameters_Type*)0)->debrisMaxSeparationMin), NULL, 0 }, // destructibleParameters.debrisMaxSeparationMin + { TYPE_F32, false, (size_t)(&((DestructibleParameters_Type*)0)->debrisMaxSeparationMax), NULL, 0 }, // destructibleParameters.debrisMaxSeparationMax + { TYPE_F32, false, (size_t)(&((DestructibleParameters_Type*)0)->debrisDestructionProbability), NULL, 0 }, // destructibleParameters.debrisDestructionProbability + { TYPE_BOUNDS3, false, (size_t)(&((DestructibleParameters_Type*)0)->validBounds), NULL, 0 }, // destructibleParameters.validBounds + { TYPE_F32, false, (size_t)(&((DestructibleParameters_Type*)0)->maxChunkSpeed), NULL, 0 }, // destructibleParameters.maxChunkSpeed + { TYPE_STRUCT, false, (size_t)(&((DestructibleParameters_Type*)0)->flags), CHILDREN(32), 7 }, // destructibleParameters.flags + { TYPE_BOOL, false, (size_t)(&((DestructibleParametersFlag_Type*)0)->ACCUMULATE_DAMAGE), NULL, 0 }, // destructibleParameters.flags.ACCUMULATE_DAMAGE + { TYPE_BOOL, false, (size_t)(&((DestructibleParametersFlag_Type*)0)->DEBRIS_TIMEOUT), NULL, 0 }, // destructibleParameters.flags.DEBRIS_TIMEOUT + { TYPE_BOOL, false, (size_t)(&((DestructibleParametersFlag_Type*)0)->DEBRIS_MAX_SEPARATION), NULL, 0 }, // destructibleParameters.flags.DEBRIS_MAX_SEPARATION + { TYPE_BOOL, false, (size_t)(&((DestructibleParametersFlag_Type*)0)->CRUMBLE_SMALLEST_CHUNKS), NULL, 0 }, // destructibleParameters.flags.CRUMBLE_SMALLEST_CHUNKS + { TYPE_BOOL, false, (size_t)(&((DestructibleParametersFlag_Type*)0)->ACCURATE_RAYCASTS), NULL, 0 }, // destructibleParameters.flags.ACCURATE_RAYCASTS + { TYPE_BOOL, false, (size_t)(&((DestructibleParametersFlag_Type*)0)->USE_VALID_BOUNDS), NULL, 0 }, // destructibleParameters.flags.USE_VALID_BOUNDS + { TYPE_BOOL, false, (size_t)(&((DestructibleParametersFlag_Type*)0)->CRUMBLE_VIA_RUNTIME_FRACTURE), NULL, 0 }, // destructibleParameters.flags.CRUMBLE_VIA_RUNTIME_FRACTURE + { TYPE_F32, false, (size_t)(&((DestructibleParameters_Type*)0)->fractureImpulseScale), NULL, 0 }, // destructibleParameters.fractureImpulseScale + { TYPE_U16, false, (size_t)(&((DestructibleParameters_Type*)0)->damageDepthLimit), NULL, 0 }, // destructibleParameters.damageDepthLimit + { TYPE_U16, false, (size_t)(&((DestructibleParameters_Type*)0)->dynamicChunkDominanceGroup), NULL, 0 }, // destructibleParameters.dynamicChunkDominanceGroup + { TYPE_STRUCT, false, (size_t)(&((DestructibleParameters_Type*)0)->dynamicChunksGroupsMask), CHILDREN(39), 5 }, // destructibleParameters.dynamicChunksGroupsMask + { TYPE_BOOL, false, (size_t)(&((GroupsMask_Type*)0)->useGroupsMask), NULL, 0 }, // destructibleParameters.dynamicChunksGroupsMask.useGroupsMask + { TYPE_U32, false, (size_t)(&((GroupsMask_Type*)0)->bits0), NULL, 0 }, // destructibleParameters.dynamicChunksGroupsMask.bits0 + { TYPE_U32, false, (size_t)(&((GroupsMask_Type*)0)->bits1), NULL, 0 }, // destructibleParameters.dynamicChunksGroupsMask.bits1 + { TYPE_U32, false, (size_t)(&((GroupsMask_Type*)0)->bits2), NULL, 0 }, // destructibleParameters.dynamicChunksGroupsMask.bits2 + { TYPE_U32, false, (size_t)(&((GroupsMask_Type*)0)->bits3), NULL, 0 }, // destructibleParameters.dynamicChunksGroupsMask.bits3 + { TYPE_STRUCT, false, (size_t)(&((DestructibleParameters_Type*)0)->runtimeFracture), CHILDREN(44), 9 }, // destructibleParameters.runtimeFracture + { TYPE_ENUM, false, (size_t)(&((RuntimeFracture_Type*)0)->RuntimeFractureType), NULL, 0 }, // destructibleParameters.runtimeFracture.RuntimeFractureType + { TYPE_BOOL, false, (size_t)(&((RuntimeFracture_Type*)0)->sheetFracture), NULL, 0 }, // destructibleParameters.runtimeFracture.sheetFracture + { TYPE_U32, false, (size_t)(&((RuntimeFracture_Type*)0)->depthLimit), NULL, 0 }, // destructibleParameters.runtimeFracture.depthLimit + { TYPE_BOOL, false, (size_t)(&((RuntimeFracture_Type*)0)->destroyIfAtDepthLimit), NULL, 0 }, // destructibleParameters.runtimeFracture.destroyIfAtDepthLimit + { TYPE_F32, false, (size_t)(&((RuntimeFracture_Type*)0)->minConvexSize), NULL, 0 }, // destructibleParameters.runtimeFracture.minConvexSize + { TYPE_F32, false, (size_t)(&((RuntimeFracture_Type*)0)->impulseScale), NULL, 0 }, // destructibleParameters.runtimeFracture.impulseScale + { TYPE_STRUCT, false, (size_t)(&((RuntimeFracture_Type*)0)->glass), CHILDREN(53), 5 }, // destructibleParameters.runtimeFracture.glass + { TYPE_U32, false, (size_t)(&((FractureGlass_Type*)0)->numSectors), NULL, 0 }, // destructibleParameters.runtimeFracture.glass.numSectors + { TYPE_F32, false, (size_t)(&((FractureGlass_Type*)0)->sectorRand), NULL, 0 }, // destructibleParameters.runtimeFracture.glass.sectorRand + { TYPE_F32, false, (size_t)(&((FractureGlass_Type*)0)->firstSegmentSize), NULL, 0 }, // destructibleParameters.runtimeFracture.glass.firstSegmentSize + { TYPE_F32, false, (size_t)(&((FractureGlass_Type*)0)->segmentScale), NULL, 0 }, // destructibleParameters.runtimeFracture.glass.segmentScale + { TYPE_F32, false, (size_t)(&((FractureGlass_Type*)0)->segmentRand), NULL, 0 }, // destructibleParameters.runtimeFracture.glass.segmentRand + { TYPE_STRUCT, false, (size_t)(&((RuntimeFracture_Type*)0)->voronoi), CHILDREN(58), 4 }, // destructibleParameters.runtimeFracture.voronoi + { TYPE_VEC3, false, (size_t)(&((FractureVoronoi_Type*)0)->dimensions), NULL, 0 }, // destructibleParameters.runtimeFracture.voronoi.dimensions + { TYPE_U32, false, (size_t)(&((FractureVoronoi_Type*)0)->numCells), NULL, 0 }, // destructibleParameters.runtimeFracture.voronoi.numCells + { TYPE_F32, false, (size_t)(&((FractureVoronoi_Type*)0)->biasExp), NULL, 0 }, // destructibleParameters.runtimeFracture.voronoi.biasExp + { TYPE_F32, false, (size_t)(&((FractureVoronoi_Type*)0)->maxDist), NULL, 0 }, // destructibleParameters.runtimeFracture.voronoi.maxDist + { TYPE_STRUCT, false, (size_t)(&((RuntimeFracture_Type*)0)->attachment), CHILDREN(62), 6 }, // destructibleParameters.runtimeFracture.attachment + { TYPE_BOOL, false, (size_t)(&((FractureAttachment_Type*)0)->posX), NULL, 0 }, // destructibleParameters.runtimeFracture.attachment.posX + { TYPE_BOOL, false, (size_t)(&((FractureAttachment_Type*)0)->negX), NULL, 0 }, // destructibleParameters.runtimeFracture.attachment.negX + { TYPE_BOOL, false, (size_t)(&((FractureAttachment_Type*)0)->posY), NULL, 0 }, // destructibleParameters.runtimeFracture.attachment.posY + { TYPE_BOOL, false, (size_t)(&((FractureAttachment_Type*)0)->negY), NULL, 0 }, // destructibleParameters.runtimeFracture.attachment.negY + { TYPE_BOOL, false, (size_t)(&((FractureAttachment_Type*)0)->posZ), NULL, 0 }, // destructibleParameters.runtimeFracture.attachment.posZ + { TYPE_BOOL, false, (size_t)(&((FractureAttachment_Type*)0)->negZ), NULL, 0 }, // destructibleParameters.runtimeFracture.attachment.negZ + { TYPE_F32, false, (size_t)(&((DestructibleParameters_Type*)0)->supportStrength), NULL, 0 }, // destructibleParameters.supportStrength + { TYPE_I8, false, (size_t)(&((DestructibleParameters_Type*)0)->legacyChunkBoundsTestSetting), NULL, 0 }, // destructibleParameters.legacyChunkBoundsTestSetting + { TYPE_I8, false, (size_t)(&((DestructibleParameters_Type*)0)->legacyDamageRadiusSpreadSetting), NULL, 0 }, // destructibleParameters.legacyDamageRadiusSpreadSetting + { TYPE_BOOL, false, (size_t)(&((DestructibleParameters_Type*)0)->alwaysDrawScatterMesh), NULL, 0 }, // destructibleParameters.alwaysDrawScatterMesh + { TYPE_U64, false, (size_t)(&((ParametersStruct*)0)->userData), NULL, 0 }, // userData + { TYPE_REF, false, (size_t)(&((ParametersStruct*)0)->actorParameters), NULL, 0 }, // actorParameters + { TYPE_REF, false, (size_t)(&((ParametersStruct*)0)->actorChunks), NULL, 0 }, // actorChunks +}; + + +bool DestructibleActorState::mBuiltFlag = false; +NvParameterized::MutexType DestructibleActorState::mBuiltFlagMutex; + +DestructibleActorState::DestructibleActorState(NvParameterized::Traits* traits, void* buf, int32_t* refCount) : + NvParameters(traits, buf, refCount) +{ + //mParameterizedTraits->registerFactory(className(), &DestructibleActorStateFactoryInst); + + if (!buf) //Do not init data if it is inplace-deserialized + { + initDynamicArrays(); + initStrings(); + initReferences(); + initDefaults(); + } +} + +DestructibleActorState::~DestructibleActorState() +{ + freeStrings(); + freeReferences(); + freeDynamicArrays(); +} + +void DestructibleActorState::destroy() +{ + // We cache these fields here to avoid overwrite in destructor + bool doDeallocateSelf = mDoDeallocateSelf; + NvParameterized::Traits* traits = mParameterizedTraits; + int32_t* refCount = mRefCount; + void* buf = mBuffer; + + this->~DestructibleActorState(); + + NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf); +} + +const NvParameterized::DefinitionImpl* DestructibleActorState::getParameterDefinitionTree(void) +{ + if (!mBuiltFlag) // Double-checked lock + { + NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex); + if (!mBuiltFlag) + { + buildTree(); + } + } + + return(&ParamDefTable[0]); +} + +const NvParameterized::DefinitionImpl* DestructibleActorState::getParameterDefinitionTree(void) const +{ + DestructibleActorState* tmpParam = const_cast<DestructibleActorState*>(this); + + if (!mBuiltFlag) // Double-checked lock + { + NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex); + if (!mBuiltFlag) + { + tmpParam->buildTree(); + } + } + + return(&ParamDefTable[0]); +} + +NvParameterized::ErrorType DestructibleActorState::getParameterHandle(const char* long_name, Handle& handle) const +{ + ErrorType Ret = NvParameters::getParameterHandle(long_name, handle); + if (Ret != ERROR_NONE) + { + return(Ret); + } + + size_t offset; + void* ptr; + + getVarPtr(handle, ptr, offset); + + if (ptr == NULL) + { + return(ERROR_INDEX_OUT_OF_RANGE); + } + + return(ERROR_NONE); +} + +NvParameterized::ErrorType DestructibleActorState::getParameterHandle(const char* long_name, Handle& handle) +{ + ErrorType Ret = NvParameters::getParameterHandle(long_name, handle); + if (Ret != ERROR_NONE) + { + return(Ret); + } + + size_t offset; + void* ptr; + + getVarPtr(handle, ptr, offset); + + if (ptr == NULL) + { + return(ERROR_INDEX_OUT_OF_RANGE); + } + + return(ERROR_NONE); +} + +void DestructibleActorState::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const +{ + ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<DestructibleActorState::ParametersStruct*>(¶meters()), handle, offset); +} + + +/* Dynamic Handle Indices */ + +void DestructibleActorState::freeParameterDefinitionTable(NvParameterized::Traits* traits) +{ + if (!traits) + { + return; + } + + if (!mBuiltFlag) // Double-checked lock + { + return; + } + + NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex); + + if (!mBuiltFlag) + { + return; + } + + for (uint32_t i = 0; i < NumParamDefs; ++i) + { + ParamDefTable[i].~DefinitionImpl(); + } + + traits->free(ParamDefTable); + + mBuiltFlag = false; +} + +#define PDEF_PTR(index) (&ParamDefTable[index]) + +void DestructibleActorState::buildTree(void) +{ + + uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs; + ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize)); + memset(ParamDefTable, 0, allocSize); + + for (uint32_t i = 0; i < NumParamDefs; ++i) + { + NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits); + } + + // Initialize DefinitionImpl node: nodeIndex=0, longName="" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0]; + ParamDef->init("", TYPE_STRUCT, "STRUCT", true); + + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=1, longName="enableCrumbleEmitter" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1]; + ParamDef->init("enableCrumbleEmitter", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Whether or not the crumble emitter is active.", true); + HintTable[1].init("shortDescription", "Whether or not the crumble emitter is active", true); + ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=2, longName="enableDustEmitter" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2]; + ParamDef->init("enableDustEmitter", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Whether or not the dust emitter is active.", true); + HintTable[1].init("shortDescription", "Whether or not the dust emitter is active", true); + ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=3, longName="lod" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3]; + ParamDef->init("lod", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Destructible actor LOD.", true); + HintTable[1].init("shortDescription", "Destructible actor LOD", true); + ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=4, longName="forceLod" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4]; + ParamDef->init("forceLod", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Whether or not to force LOD behavior on the actor.", true); + HintTable[1].init("shortDescription", "Whether or not to force LOD behavior on the actor", true); + ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=5, longName="destructibleParameters" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5]; + ParamDef->init("destructibleParameters", TYPE_STRUCT, "DestructibleParameters", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Parameters that control destruction of a destructible actor.", true); + HintTable[1].init("shortDescription", "Parameters that control destruction of a destructible actor", true); + ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=6, longName="destructibleParameters.damageCap" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[6]; + ParamDef->init("damageCap", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Limits the amount of damage applied to a chunk. This is useful for preventing the entire destructible\nfrom getting pulverized by a very large application of damage. This can easily happen when impact damage is\nused, and the damage amount is proportional to the impact force (see forceToDamage).\n", true); + HintTable[1].init("shortDescription", "Limits the amount of damage applied to a chunk.", true); + ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=7, longName="destructibleParameters.forceToDamage" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[7]; + ParamDef->init("forceToDamage", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If a chunk is at a depth which takes impact damage (see NxDestructibleDepthParameters),\nthen when a chunk has a collision in the NxScene, it will take damage equal to forceToDamage mulitplied by\nthe impact force.\nThe default value is zero, which effectively disables impact damage.\n", true); + HintTable[1].init("shortDescription", "Multiplier to calculate applied damage from an impact.", true); + ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=8, longName="destructibleParameters.impactVelocityThreshold" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[8]; + ParamDef->init("impactVelocityThreshold", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Large impact force may be reported if rigid bodies are spawned inside one another. In this case the relative velocity of the two\nobjects will be low. This variable allows the user to set a minimum velocity threshold for impacts to ensure that the objects are\nmoving at a min velocity in order for the impact force to be considered.\n", true); + HintTable[1].init("shortDescription", "Large impact force may be reported if rigid bodies are spawned inside one another.", true); + ParamDefTable[8].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=9, longName="destructibleParameters.minimumFractureDepth" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[9]; + ParamDef->init("minimumFractureDepth", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Chunks will not be broken free below this depth.\n", true); + HintTable[1].init("shortDescription", "The chunks will not be broken free below this depth.", true); + ParamDefTable[9].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=10, longName="destructibleParameters.impactDamageDefaultDepth" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[10]; + ParamDef->init("impactDamageDefaultDepth", TYPE_I32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The default depth to which chunks will take impact damage. This default may be overridden in the depth settings.\n", true); + HintTable[1].init("shortDescription", "The default depth to which chunks will take impact damage.", true); + ParamDefTable[10].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=11, longName="destructibleParameters.debrisDepth" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[11]; + ParamDef->init("debrisDepth", TYPE_I32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The chunk hierarchy depth at which chunks are considered to be 'debris.' Chunks at this depth or\nbelow will be considered for various debris settings, such as debrisLifetime.\nNegative values indicate that no chunk depth is considered debris.\nDefault value is -1.\n", true); + HintTable[1].init("shortDescription", "The chunk hierarchy depth at which chunks are considered to be 'debris.'", true); + ParamDefTable[11].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=12, longName="destructibleParameters.essentialDepth" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[12]; + ParamDef->init("essentialDepth", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The chunk hierarchy depth up to which chunks will always be processed. These chunks are considered\nto be essential either for gameplay or visually.\nThe minimum value is 0, meaning the level 0 chunk is always considered essential.\nDefault value is 0.\n", true); + HintTable[1].init("shortDescription", "The chunk hierarchy depth up to which chunks will always be processed", true); + ParamDefTable[12].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=13, longName="destructibleParameters.debrisLifetimeMin" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[13]; + ParamDef->init("debrisLifetimeMin", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "'Debris chunks' (see debrisDepth, above) will be destroyed after a time (in seconds)\nseparated from non-debris chunks. The actual lifetime is interpolated between\ndebrisLifetimeMin and debrisLifetimeMax (see below), based upon the module\'s LOD setting.\nTo disable lifetime, clear the NxDestructibleDepthParametersFlag::DEBRIS_TIMEOUT\nflag in the flags field. If debrisLifetimeMax < debrisLifetimeMin, the mean of the two\nis used for both.\nDefault debrisLifetimeMin = 1.0, debrisLifetimeMax = 10.0f.\n", true); + HintTable[1].init("shortDescription", "Minimum time to destroy debris", true); + ParamDefTable[13].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=14, longName="destructibleParameters.debrisLifetimeMax" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[14]; + ParamDef->init("debrisLifetimeMax", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "'Debris chunks' (see debrisDepth, above) will be destroyed after a time (in seconds)\nseparated from non-debris chunks. The actual lifetime is interpolated between\ndebrisLifetimeMin (see above) and debrisLifetimeMax, based upon the module\'s LOD setting.\nTo disable lifetime, clear the NxDestructibleDepthParametersFlag::DEBRIS_TIMEOUT\nflag in the flags field. If debrisLifetimeMax < debrisLifetimeMin, the mean of the two\nis used for both.\nDefault debrisLifetimeMin = 1.0, debrisLifetimeMax = 10.0f.\n", true); + HintTable[1].init("shortDescription", "Maximum time to destroy debris", true); + ParamDefTable[14].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=15, longName="destructibleParameters.debrisMaxSeparationMin" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[15]; + ParamDef->init("debrisMaxSeparationMin", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "'Debris chunks' (see debrisDepth, above) will be destroyed if they are separated from\ntheir origin by a distance greater than maxSeparation. The actual maxSeparation is\ninterpolated between debrisMaxSeparationMin and debrisMaxSeparationMax (see below),\nbased upon the module\'s LOD setting. To disable maxSeparation, clear the\nNX_DESTRUCTIBLE_DEBRIS_MAX_SEPARATION flag in the flags field.\nIf debrisMaxSeparationMax < debrisMaxSeparationMin, the mean of the two is used for both.\nDefault debrisMaxSeparationMin = 1.0, debrisMaxSeparationMax = 10.0f.\n", true); + HintTable[1].init("shortDescription", "Minimum separation distance", true); + ParamDefTable[15].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=16, longName="destructibleParameters.debrisMaxSeparationMax" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[16]; + ParamDef->init("debrisMaxSeparationMax", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "'Debris chunks' (see debrisDepth, above) will be destroyed if they are separated from\ntheir origin by a distance greater than maxSeparation. The actual maxSeparation is\ninterpolated between debrisMaxSeparationMin (see above) and debrisMaxSeparationMax,\nbased upon the module\'s LOD setting. To disable maxSeparation, clear the\nNX_DESTRUCTIBLE_DEBRIS_MAX_SEPARATION flag in the flags field.\nIf debrisMaxSeparationMax < debrisMaxSeparationMin, the mean of the two is used for both.\nDefault debrisMaxSeparationMin = 1.0, debrisMaxSeparationMax = 10.0f.\n", true); + HintTable[1].init("shortDescription", "Minimum separation distance", true); + ParamDefTable[16].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=17, longName="destructibleParameters.debrisDestructionProbability" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[17]; + ParamDef->init("debrisDestructionProbability", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The probablity that a debris chunk, when fractured, will simply be destroyed instead of becoming dynamic or breaking down\n further into child chunks. Valid range = [0.0,1.0]. Default value = 0.0.", true); + HintTable[1].init("shortDescription", "The probablity that a debris chunk, when fractured, will simply be destroyed", true); + ParamDefTable[17].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=18, longName="destructibleParameters.validBounds" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[18]; + ParamDef->init("validBounds", TYPE_BOUNDS3, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "A bounding box around each NxDestructibleActor created, defining a range of validity\nfor chunks that break free. These bounds are scaled and translated with the\nNxDestructibleActor\'s scale and position, but they are not rotated with the\nNxDestructibleActor.\n", true); + HintTable[1].init("shortDescription", "valid bounding region for debris", true); + ParamDefTable[18].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=19, longName="destructibleParameters.maxChunkSpeed" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[19]; + ParamDef->init("maxChunkSpeed", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If greater than 0, the chunks' speeds will not be allowed to exceed this value. Use 0\nto disable this feature (this is the default).\n", true); + HintTable[1].init("shortDescription", "Maximum speed of a chunk", true); + ParamDefTable[19].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=20, longName="destructibleParameters.flags" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[20]; + ParamDef->init("flags", TYPE_STRUCT, "DestructibleParametersFlag", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "A collection of flags defined in NxDestructibleParametersFlag.\n", true); + HintTable[1].init("shortDescription", "A collection of flags defined in DestructibleParametersFlag.", true); + ParamDefTable[20].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=21, longName="destructibleParameters.flags.ACCUMULATE_DAMAGE" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[21]; + ParamDef->init("ACCUMULATE_DAMAGE", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If set, chunks will 'remember' damage applied to them, so that many applications of a damage amount\nbelow damageThreshold will eventually fracture the chunk. If not set, a single application of\ndamage must exceed damageThreshold in order to fracture the chunk.\n", true); + HintTable[1].init("shortDescription", "Determines if chunks accumulate damage", true); + ParamDefTable[21].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=22, longName="destructibleParameters.flags.DEBRIS_TIMEOUT" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[22]; + ParamDef->init("DEBRIS_TIMEOUT", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Whether or not chunks at or deeper than the 'debris' depth (see NxDestructibleParameters::debrisDepth)\nwill time out. The lifetime is a value between NxDestructibleParameters::debrisLifetimeMin and\nNxDestructibleParameters::debrisLifetimeMax, based upon the destructible module\'s LOD setting.\n", true); + HintTable[1].init("shortDescription", "Whether or not chunks at or deeper than the 'debris' depth will timeout", true); + ParamDefTable[22].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=23, longName="destructibleParameters.flags.DEBRIS_MAX_SEPARATION" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[23]; + ParamDef->init("DEBRIS_MAX_SEPARATION", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Whether or not chunks at or deeper than the 'debris' depth (see NxDestructibleParameters::debrisDepth)\nwill be removed if they separate too far from their origins. The maxSeparation is a value between\nNxDestructibleParameters::debrisMaxSeparationMin and NxDestructibleParameters::debrisMaxSeparationMax,\nbased upon the destructible module\'s LOD setting.\n", true); + HintTable[1].init("shortDescription", "Whether or not chunks at or deeper than the 'debris' depth will be removed if separated too far", true); + ParamDefTable[23].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=24, longName="destructibleParameters.flags.CRUMBLE_SMALLEST_CHUNKS" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[24]; + ParamDef->init("CRUMBLE_SMALLEST_CHUNKS", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If set, the smallest chunks may be further broken down, either by fluid crumbles (if a crumble particle\nsystem is specified in the NxDestructibleActorDesc), or by simply removing the chunk if no crumble\nparticle system is specified. Note: the 'smallest chunks' are normally defined to be the deepest level\nof the fracture hierarchy. However, they may be taken from higher levels of the hierarchy if\nNxModuleDestructible::setMaxChunkDepthOffset is called with a non-zero value.\n", true); + HintTable[1].init("shortDescription", "If set, the smallest chunks may be further broken down", true); + ParamDefTable[24].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=25, longName="destructibleParameters.flags.ACCURATE_RAYCASTS" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[25]; + ParamDef->init("ACCURATE_RAYCASTS", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If set, the NxDestructibleActor::rayCast function will search within the nearest visible chunk hit\nfor collisions with child chunks. This is used to get a better raycast position and normal, in\ncase the parent collision volume does not tightly fit the graphics mesh. The returned chunk index\nwill always be that of the visible parent that is intersected, however.\n", true); + HintTable[1].init("shortDescription", "If set, the NxDestructibleActor::rayCast function will search within the nearest visible chunk hit", true); + ParamDefTable[25].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=26, longName="destructibleParameters.flags.USE_VALID_BOUNDS" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[26]; + ParamDef->init("USE_VALID_BOUNDS", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If set, the validBounds field of NxDestructibleParameters will be used. These bounds are translated\n(but not scaled or rotated) to the origin of the destructible actor. If a chunk or chunk island moves\noutside of those bounds, it is destroyed.\n", true); + HintTable[1].init("shortDescription", "If set, the validBounds field of NxDestructibleParameters will be used.", true); + ParamDefTable[26].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=27, longName="destructibleParameters.flags.CRUMBLE_VIA_RUNTIME_FRACTURE" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[27]; + ParamDef->init("CRUMBLE_VIA_RUNTIME_FRACTURE", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If set, crumbled chunks will use the runtime fracture pipeline. The chunk will be procedurally broken\ndestroyed using either the default or a specified fracture pattern.\n", true); + HintTable[1].init("shortDescription", "If set, crumbled chunks will use the runtime fracture pipeline.", true); + ParamDefTable[27].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=28, longName="destructibleParameters.fractureImpulseScale" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[28]; + ParamDef->init("fractureImpulseScale", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Scale factor used to apply an impulse force along the normal of chunk when fractured. This is used\nin order to 'push' the pieces out as they fracture.\n", true); + HintTable[1].init("shortDescription", "Scale factor used to apply an impulse force along the normal of chunk when fractured.", true); + ParamDefTable[28].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=29, longName="destructibleParameters.damageDepthLimit" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[29]; + ParamDef->init("damageDepthLimit", TYPE_U16, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "How deep in the hierarchy damage will be propagated, relative to the chunk hit.", true); + HintTable[1].init("shortDescription", "How deep in the hierarchy damage will be propagated, relative to the chunk hit.", true); + ParamDefTable[29].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=30, longName="destructibleParameters.dynamicChunkDominanceGroup" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[30]; + ParamDef->init("dynamicChunkDominanceGroup", TYPE_U16, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Optional dominance group for dynamic chunks created when fractured. (ignored if > 31)\n", true); + HintTable[1].init("shortDescription", "Optional dominance group for dynamic chunks created when fractured.", true); + ParamDefTable[30].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=31, longName="destructibleParameters.dynamicChunksGroupsMask" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[31]; + ParamDef->init("dynamicChunksGroupsMask", TYPE_STRUCT, "GroupsMask", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Optional groups mask for dynamic chunks created when fractured.\n", true); + HintTable[1].init("shortDescription", "Optional groups mask for dynamic chunks created when fractured.", true); + ParamDefTable[31].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=32, longName="destructibleParameters.dynamicChunksGroupsMask.useGroupsMask" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[32]; + ParamDef->init("useGroupsMask", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Whether or not the groupsMask should be used. If so, then this will be applied to all NxShapes\n created to represent this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Whether or not the groupsMask should be used", true); + ParamDefTable[32].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=33, longName="destructibleParameters.dynamicChunksGroupsMask.bits0" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[33]; + ParamDef->init("bits0", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If useGroupsMask is true, this is bits0 of the groups mask. See the PhysX documentation for more on groups masks.", true); + HintTable[1].init("shortDescription", "bits0 of the groups mask", true); + ParamDefTable[33].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=34, longName="destructibleParameters.dynamicChunksGroupsMask.bits1" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[34]; + ParamDef->init("bits1", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If useGroupsMask is true, this is bits1 of the groups mask. See the PhysX documentation for more on groups masks.", true); + HintTable[1].init("shortDescription", "bits1 of the groups mask", true); + ParamDefTable[34].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=35, longName="destructibleParameters.dynamicChunksGroupsMask.bits2" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[35]; + ParamDef->init("bits2", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If useGroupsMask is true, this is bits2 of the groups mask. See the PhysX documentation for more on groups masks.", true); + HintTable[1].init("shortDescription", "bits2 of the groups mask", true); + ParamDefTable[35].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=36, longName="destructibleParameters.dynamicChunksGroupsMask.bits3" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[36]; + ParamDef->init("bits3", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If useGroupsMask is true, this is bits3 of the groups mask. See the PhysX documentation for more on groups masks.", true); + HintTable[1].init("shortDescription", "bits3 of the groups mask", true); + ParamDefTable[36].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=37, longName="destructibleParameters.runtimeFracture" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[37]; + ParamDef->init("runtimeFracture", TYPE_STRUCT, "RuntimeFracture", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Runtime Fracture Settings. 'CRUMBLE_VIA_RUNTIME_FRACTURE' must be set for this to do anything.\n", true); + HintTable[1].init("shortDescription", "Runtime Fracture Settings", true); + ParamDefTable[37].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=38, longName="destructibleParameters.runtimeFracture.RuntimeFractureType" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[38]; + ParamDef->init("RuntimeFractureType", TYPE_ENUM, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("shortDescription", "Which type of fracture pattern to choose", true); + ParamDefTable[38].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + static const char* const EnumVals[] = { "VORONOI", "GLASS" }; + ParamDefTable[38].setEnumVals((const char**)EnumVals, 2); + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=39, longName="destructibleParameters.runtimeFracture.sheetFracture" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[39]; + ParamDef->init("sheetFracture", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If true, align fracture pattern to largest face. \nIf false, the fracture pattern will be aligned to the hit normal with each fracture.\n", true); + HintTable[1].init("shortDescription", "If true, align fracture pattern to largest face", true); + ParamDefTable[39].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=40, longName="destructibleParameters.runtimeFracture.depthLimit" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[40]; + ParamDef->init("depthLimit", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Number of times deep a chunk can be fractured. Can help limit the number of chunks produced by\nruntime fracture.\n", true); + HintTable[1].init("shortDescription", "Number of times deep a chunk can be fractured.", true); + ParamDefTable[40].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=41, longName="destructibleParameters.runtimeFracture.destroyIfAtDepthLimit" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[41]; + ParamDef->init("destroyIfAtDepthLimit", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If true, destroy chunks when they hit their depth limit. \nIf false, then chunks at their depth limit will not fracture but will have a force applied.\n", true); + HintTable[1].init("shortDescription", "Destroy chunk if at depth limit", true); + ParamDefTable[41].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=42, longName="destructibleParameters.runtimeFracture.minConvexSize" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[42]; + ParamDef->init("minConvexSize", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Minimum Convex Size. Minimum size of convex produced by a fracture.\n", true); + HintTable[1].init("shortDescription", "Minimum Convex Size.", true); + ParamDefTable[42].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=43, longName="destructibleParameters.runtimeFracture.impulseScale" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[43]; + ParamDef->init("impulseScale", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Scales impulse applied by a fracture.\n", true); + HintTable[1].init("shortDescription", "Scales impulse applied by a fracture.", true); + ParamDefTable[43].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=44, longName="destructibleParameters.runtimeFracture.glass" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[44]; + ParamDef->init("glass", TYPE_STRUCT, "FractureGlass", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Glass Fracture Pattern Settings.\n", true); + HintTable[1].init("shortDescription", "Glass Fracture Pattern Settings.", true); + ParamDefTable[44].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=45, longName="destructibleParameters.runtimeFracture.glass.numSectors" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[45]; + ParamDef->init("numSectors", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Number of angular slices in the glass fracture pattern. \n", true); + HintTable[1].init("shortDescription", "Number of angular slices.", true); + ParamDefTable[45].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=46, longName="destructibleParameters.runtimeFracture.glass.sectorRand" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[46]; + ParamDef->init("sectorRand", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Creates variance in the angle of slices. A value of zero results in all angular slices having the same angle.\n", true); + HintTable[1].init("shortDescription", "Creates variance in the angle of slices.", true); + ParamDefTable[46].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=47, longName="destructibleParameters.runtimeFracture.glass.firstSegmentSize" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[47]; + ParamDef->init("firstSegmentSize", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The minimum shard size. Shards below this size will not be created and thus not visible.\n", true); + HintTable[1].init("shortDescription", "The minimum shard size.", true); + ParamDefTable[47].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=48, longName="destructibleParameters.runtimeFracture.glass.segmentScale" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[48]; + ParamDef->init("segmentScale", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Scales the radial spacing in the glass fracture pattern. A larger value results in radially longer shards.\n", true); + HintTable[1].init("shortDescription", "Scales the radial spacing.", true); + ParamDefTable[48].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=49, longName="destructibleParameters.runtimeFracture.glass.segmentRand" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[49]; + ParamDef->init("segmentRand", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Creates variance in the radial size of shards. A value of zero results in a low noise circular pattern.\n", true); + HintTable[1].init("shortDescription", "Creates variance in the radial size of shards.", true); + ParamDefTable[49].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=50, longName="destructibleParameters.runtimeFracture.voronoi" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[50]; + ParamDef->init("voronoi", TYPE_STRUCT, "FractureVoronoi", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Voronoi Fracture Pattern Settings.\n", true); + HintTable[1].init("shortDescription", "Voronoi Fracture Pattern Settings.", true); + ParamDefTable[50].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=51, longName="destructibleParameters.runtimeFracture.voronoi.dimensions" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[51]; + ParamDef->init("dimensions", TYPE_VEC3, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The size of the entire block. \n", true); + HintTable[1].init("shortDescription", "The size of the entire block", true); + ParamDefTable[51].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=52, longName="destructibleParameters.runtimeFracture.voronoi.numCells" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[52]; + ParamDef->init("numCells", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Number of Cells corresponds to the number of chunks to create during the fracture, default value is only one chunk.\n", true); + HintTable[1].init("shortDescription", "Max Number of Cells to create.", true); + ParamDefTable[52].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=53, longName="destructibleParameters.runtimeFracture.voronoi.biasExp" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[53]; + ParamDef->init("biasExp", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Bias Exponential value is used in distributing voronoi points which is used to fracture the original chunk.\n", true); + HintTable[1].init("shortDescription", "Bias Exponential value.", true); + ParamDefTable[53].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=54, longName="destructibleParameters.runtimeFracture.voronoi.maxDist" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[54]; + ParamDef->init("maxDist", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "This is to prevent a illegal voronoi point that's used to generate voronoi chunks.\n", true); + HintTable[1].init("shortDescription", "The max distance a Voronoi point away from origin.", true); + ParamDefTable[54].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=55, longName="destructibleParameters.runtimeFracture.attachment" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[55]; + ParamDef->init("attachment", TYPE_STRUCT, "FractureAttachment", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Attachment Settings. Allows the sides of a runtime fracture chunk to be kinematic rather than dynamic.\n", true); + HintTable[1].init("shortDescription", "Attachment Settings", true); + ParamDefTable[55].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=56, longName="destructibleParameters.runtimeFracture.attachment.posX" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[56]; + ParamDef->init("posX", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If true, make the positive x side of the sheet an attachment point.\n", true); + HintTable[1].init("shortDescription", "Attach to positive x side of sheet.", true); + ParamDefTable[56].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=57, longName="destructibleParameters.runtimeFracture.attachment.negX" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[57]; + ParamDef->init("negX", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If true, make the negative x side of the sheet an attachment point.\n", true); + HintTable[1].init("shortDescription", "Attach to negative x side of sheet.", true); + ParamDefTable[57].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=58, longName="destructibleParameters.runtimeFracture.attachment.posY" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[58]; + ParamDef->init("posY", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If true, make the positive y side of the sheet an attachment point.\n", true); + HintTable[1].init("shortDescription", "Attach to positive y side of sheet.", true); + ParamDefTable[58].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=59, longName="destructibleParameters.runtimeFracture.attachment.negY" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[59]; + ParamDef->init("negY", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If true, make the negative y side of the sheet an attachment point.\n", true); + HintTable[1].init("shortDescription", "Attach to negative y side of sheet.", true); + ParamDefTable[59].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=60, longName="destructibleParameters.runtimeFracture.attachment.posZ" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[60]; + ParamDef->init("posZ", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If true, make the positive z side of the sheet an attachment point.\n", true); + HintTable[1].init("shortDescription", "Attach to positive z side of sheet.", true); + ParamDefTable[60].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=61, longName="destructibleParameters.runtimeFracture.attachment.negZ" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[61]; + ParamDef->init("negZ", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If true, make the negative z side of the sheet an attachment point.\n", true); + HintTable[1].init("shortDescription", "Attach to negative z side of sheet.", true); + ParamDefTable[61].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=62, longName="destructibleParameters.supportStrength" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[62]; + ParamDef->init("supportStrength", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The larger the supportStrength is, the harder it will break under stressSolver. SupportStrength should be larger\nthan 0.0 so that it is not extremely fragile.\nDefault supportStrength = -1.0 which means strength is turned off initially.\n", true); + HintTable[1].init("shortDescription", "The support strength threshold for breaking chunks in stressSolver", true); + ParamDefTable[62].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=63, longName="destructibleParameters.legacyChunkBoundsTestSetting" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[63]; + ParamDef->init("legacyChunkBoundsTestSetting", TYPE_I8, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Whether or not to use the old chunk bounds testing for damage, or use the module setting. A value of 0 forces the new method to be used.\nA positive value forces the old method to be used. Negative values cause the global (NxModuleDestructible) setting to be used.\n", true); + HintTable[1].init("shortDescription", "Whether or not to use the old chunk bounds testing for damage, or use the module setting.", true); + ParamDefTable[63].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=64, longName="destructibleParameters.legacyDamageRadiusSpreadSetting" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[64]; + ParamDef->init("legacyDamageRadiusSpreadSetting", TYPE_I8, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("END", "", true); + ParamDefTable[64].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("END", "", true); + HintTable[1].init("longDescription", "Whether or not to use the old damage spread method, or use the module setting. A value of 0 forces the new method to be used.\nA positive value forces the old method to be used. Negative values cause the global (NxModuleDestructible) setting to be used.\n", true); + HintTable[2].init("shortDescription", "Whether or not to use the old damage spread method, or use the module setting.", true); + ParamDefTable[64].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=65, longName="destructibleParameters.alwaysDrawScatterMesh" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[65]; + ParamDef->init("alwaysDrawScatterMesh", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Scatter mesh visibility is controlled by LOD. If asset has more than one depth level, scatter mesh is not drawn.\n This flag forces drawing of scatter mesh on chunks with depth > 1.", true); + HintTable[1].init("shortDescription", "Always draw scatter mesh on the chunks with depth > 1", true); + ParamDefTable[65].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=66, longName="userData" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[66]; + ParamDef->init("userData", TYPE_U64, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("editorDisplay", "false", true); + ParamDefTable[66].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("editorDisplay", "false", true); + HintTable[1].init("longDescription", "Optional user data pointer. Note: Any pointer references will not be properly serialized.", true); + HintTable[2].init("shortDescription", "Optional user data pointer", true); + ParamDefTable[66].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=67, longName="actorParameters" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[67]; + ParamDef->init("actorParameters", TYPE_REF, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("INCLUDED", uint64_t(1), true); + ParamDefTable[67].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("INCLUDED", uint64_t(1), true); + HintTable[1].init("longDescription", "The destructible actor parameters.", true); + HintTable[2].init("shortDescription", "The destructible actor parameters", true); + ParamDefTable[67].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + static const char* const RefVariantVals[] = { "DestructibleActorParam" }; + ParamDefTable[67].setRefVariantVals((const char**)RefVariantVals, 1); + + + + } + + // Initialize DefinitionImpl node: nodeIndex=68, longName="actorChunks" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[68]; + ParamDef->init("actorChunks", TYPE_REF, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("INCLUDED", uint64_t(1), true); + ParamDefTable[68].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("INCLUDED", uint64_t(1), true); + HintTable[1].init("longDescription", "The actor's chunk data.", true); + HintTable[2].init("shortDescription", "The actor's chunk data", true); + ParamDefTable[68].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + static const char* const RefVariantVals[] = { "DestructibleActorChunks" }; + ParamDefTable[68].setRefVariantVals((const char**)RefVariantVals, 1); + + + + } + + // SetChildren for: nodeIndex=0, longName="" + { + static Definition* Children[8]; + Children[0] = PDEF_PTR(1); + Children[1] = PDEF_PTR(2); + Children[2] = PDEF_PTR(3); + Children[3] = PDEF_PTR(4); + Children[4] = PDEF_PTR(5); + Children[5] = PDEF_PTR(66); + Children[6] = PDEF_PTR(67); + Children[7] = PDEF_PTR(68); + + ParamDefTable[0].setChildren(Children, 8); + } + + // SetChildren for: nodeIndex=5, longName="destructibleParameters" + { + static Definition* Children[24]; + Children[0] = PDEF_PTR(6); + Children[1] = PDEF_PTR(7); + Children[2] = PDEF_PTR(8); + Children[3] = PDEF_PTR(9); + Children[4] = PDEF_PTR(10); + Children[5] = PDEF_PTR(11); + Children[6] = PDEF_PTR(12); + Children[7] = PDEF_PTR(13); + Children[8] = PDEF_PTR(14); + Children[9] = PDEF_PTR(15); + Children[10] = PDEF_PTR(16); + Children[11] = PDEF_PTR(17); + Children[12] = PDEF_PTR(18); + Children[13] = PDEF_PTR(19); + Children[14] = PDEF_PTR(20); + Children[15] = PDEF_PTR(28); + Children[16] = PDEF_PTR(29); + Children[17] = PDEF_PTR(30); + Children[18] = PDEF_PTR(31); + Children[19] = PDEF_PTR(37); + Children[20] = PDEF_PTR(62); + Children[21] = PDEF_PTR(63); + Children[22] = PDEF_PTR(64); + Children[23] = PDEF_PTR(65); + + ParamDefTable[5].setChildren(Children, 24); + } + + // SetChildren for: nodeIndex=20, longName="destructibleParameters.flags" + { + static Definition* Children[7]; + Children[0] = PDEF_PTR(21); + Children[1] = PDEF_PTR(22); + Children[2] = PDEF_PTR(23); + Children[3] = PDEF_PTR(24); + Children[4] = PDEF_PTR(25); + Children[5] = PDEF_PTR(26); + Children[6] = PDEF_PTR(27); + + ParamDefTable[20].setChildren(Children, 7); + } + + // SetChildren for: nodeIndex=31, longName="destructibleParameters.dynamicChunksGroupsMask" + { + static Definition* Children[5]; + Children[0] = PDEF_PTR(32); + Children[1] = PDEF_PTR(33); + Children[2] = PDEF_PTR(34); + Children[3] = PDEF_PTR(35); + Children[4] = PDEF_PTR(36); + + ParamDefTable[31].setChildren(Children, 5); + } + + // SetChildren for: nodeIndex=37, longName="destructibleParameters.runtimeFracture" + { + static Definition* Children[9]; + Children[0] = PDEF_PTR(38); + Children[1] = PDEF_PTR(39); + Children[2] = PDEF_PTR(40); + Children[3] = PDEF_PTR(41); + Children[4] = PDEF_PTR(42); + Children[5] = PDEF_PTR(43); + Children[6] = PDEF_PTR(44); + Children[7] = PDEF_PTR(50); + Children[8] = PDEF_PTR(55); + + ParamDefTable[37].setChildren(Children, 9); + } + + // SetChildren for: nodeIndex=44, longName="destructibleParameters.runtimeFracture.glass" + { + static Definition* Children[5]; + Children[0] = PDEF_PTR(45); + Children[1] = PDEF_PTR(46); + Children[2] = PDEF_PTR(47); + Children[3] = PDEF_PTR(48); + Children[4] = PDEF_PTR(49); + + ParamDefTable[44].setChildren(Children, 5); + } + + // SetChildren for: nodeIndex=50, longName="destructibleParameters.runtimeFracture.voronoi" + { + static Definition* Children[4]; + Children[0] = PDEF_PTR(51); + Children[1] = PDEF_PTR(52); + Children[2] = PDEF_PTR(53); + Children[3] = PDEF_PTR(54); + + ParamDefTable[50].setChildren(Children, 4); + } + + // SetChildren for: nodeIndex=55, longName="destructibleParameters.runtimeFracture.attachment" + { + static Definition* Children[6]; + Children[0] = PDEF_PTR(56); + Children[1] = PDEF_PTR(57); + Children[2] = PDEF_PTR(58); + Children[3] = PDEF_PTR(59); + Children[4] = PDEF_PTR(60); + Children[5] = PDEF_PTR(61); + + ParamDefTable[55].setChildren(Children, 6); + } + + mBuiltFlag = true; + +} +void DestructibleActorState::initStrings(void) +{ +} + +void DestructibleActorState::initDynamicArrays(void) +{ +} + +void DestructibleActorState::initDefaults(void) +{ + + freeStrings(); + freeReferences(); + freeDynamicArrays(); + enableCrumbleEmitter = bool(true); + enableDustEmitter = bool(true); + lod = uint32_t(0); + forceLod = bool(false); + destructibleParameters.damageCap = float(0); + destructibleParameters.forceToDamage = float(0); + destructibleParameters.impactVelocityThreshold = float(0); + destructibleParameters.minimumFractureDepth = uint32_t(0); + destructibleParameters.impactDamageDefaultDepth = int32_t(-1); + destructibleParameters.debrisDepth = int32_t(-1); + destructibleParameters.essentialDepth = uint32_t(0); + destructibleParameters.debrisLifetimeMin = float(1); + destructibleParameters.debrisLifetimeMax = float(10); + destructibleParameters.debrisMaxSeparationMin = float(1); + destructibleParameters.debrisMaxSeparationMax = float(10); + destructibleParameters.debrisDestructionProbability = float(0); + destructibleParameters.validBounds = physx::PxBounds3(init(-1000, -1000, -1000, 1000, 1000, 1000)); + destructibleParameters.maxChunkSpeed = float(0); + destructibleParameters.flags.ACCUMULATE_DAMAGE = bool(true); + destructibleParameters.flags.DEBRIS_TIMEOUT = bool(false); + destructibleParameters.flags.DEBRIS_MAX_SEPARATION = bool(false); + destructibleParameters.flags.CRUMBLE_SMALLEST_CHUNKS = bool(false); + destructibleParameters.flags.ACCURATE_RAYCASTS = bool(false); + destructibleParameters.flags.USE_VALID_BOUNDS = bool(false); + destructibleParameters.flags.CRUMBLE_VIA_RUNTIME_FRACTURE = bool(false); + destructibleParameters.fractureImpulseScale = float(0); + destructibleParameters.damageDepthLimit = uint16_t(UINT16_MAX); + destructibleParameters.dynamicChunkDominanceGroup = uint16_t(UINT16_MAX); + destructibleParameters.dynamicChunksGroupsMask.useGroupsMask = bool(false); + destructibleParameters.dynamicChunksGroupsMask.bits0 = uint32_t(0); + destructibleParameters.dynamicChunksGroupsMask.bits1 = uint32_t(0); + destructibleParameters.dynamicChunksGroupsMask.bits2 = uint32_t(0); + destructibleParameters.dynamicChunksGroupsMask.bits3 = uint32_t(0); + destructibleParameters.runtimeFracture.RuntimeFractureType = (const char*)"VORONOI"; + destructibleParameters.runtimeFracture.sheetFracture = bool(true); + destructibleParameters.runtimeFracture.depthLimit = uint32_t(2); + destructibleParameters.runtimeFracture.destroyIfAtDepthLimit = bool(false); + destructibleParameters.runtimeFracture.minConvexSize = float(0.02); + destructibleParameters.runtimeFracture.impulseScale = float(1); + destructibleParameters.runtimeFracture.glass.numSectors = uint32_t(10); + destructibleParameters.runtimeFracture.glass.sectorRand = float(0.3); + destructibleParameters.runtimeFracture.glass.firstSegmentSize = float(0.06); + destructibleParameters.runtimeFracture.glass.segmentScale = float(1.4); + destructibleParameters.runtimeFracture.glass.segmentRand = float(0.3); + destructibleParameters.runtimeFracture.voronoi.dimensions = physx::PxVec3(physx::PxVec3(10.0f)); + destructibleParameters.runtimeFracture.voronoi.numCells = uint32_t(1); + destructibleParameters.runtimeFracture.voronoi.biasExp = float(10); + destructibleParameters.runtimeFracture.voronoi.maxDist = float(PX_MAX_F32); + destructibleParameters.runtimeFracture.attachment.posX = bool(false); + destructibleParameters.runtimeFracture.attachment.negX = bool(false); + destructibleParameters.runtimeFracture.attachment.posY = bool(false); + destructibleParameters.runtimeFracture.attachment.negY = bool(false); + destructibleParameters.runtimeFracture.attachment.posZ = bool(false); + destructibleParameters.runtimeFracture.attachment.negZ = bool(false); + destructibleParameters.supportStrength = float(-1); + destructibleParameters.legacyChunkBoundsTestSetting = int8_t(-1); + destructibleParameters.legacyDamageRadiusSpreadSetting = int8_t(-1); + destructibleParameters.alwaysDrawScatterMesh = bool(false); + userData = uint64_t(0); + + initDynamicArrays(); + initStrings(); + initReferences(); +} + +void DestructibleActorState::initReferences(void) +{ + actorParameters = NULL; + + actorChunks = NULL; + +} + +void DestructibleActorState::freeDynamicArrays(void) +{ +} + +void DestructibleActorState::freeStrings(void) +{ +} + +void DestructibleActorState::freeReferences(void) +{ + if (actorParameters) + { + actorParameters->destroy(); + } + + if (actorChunks) + { + actorChunks->destroy(); + } + +} + +} // namespace destructible +} // namespace nvidia diff --git a/APEX_1.4/module/destructible/src/autogen/DestructibleAssetCollisionDataSet.cpp b/APEX_1.4/module/destructible/src/autogen/DestructibleAssetCollisionDataSet.cpp new file mode 100644 index 00000000..666048ef --- /dev/null +++ b/APEX_1.4/module/destructible/src/autogen/DestructibleAssetCollisionDataSet.cpp @@ -0,0 +1,525 @@ +// 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-2015 NVIDIA Corporation. All rights reserved. + +// This file was generated by NvParameterized/scripts/GenParameterized.pl + + +#include "DestructibleAssetCollisionDataSet.h" +#include <string.h> +#include <stdlib.h> + +using namespace NvParameterized; + +namespace nvidia +{ +namespace destructible +{ + +using namespace DestructibleAssetCollisionDataSetNS; + +const char* const DestructibleAssetCollisionDataSetFactory::vptr = + NvParameterized::getVptr<DestructibleAssetCollisionDataSet, DestructibleAssetCollisionDataSet::ClassAlignment>(); + +const uint32_t NumParamDefs = 8; +static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs]; + + +static const size_t ParamLookupChildrenTable[] = +{ + 1, 2, 3, 4, 6, 5, 7, +}; + +#define TENUM(type) nvidia::##type +#define CHILDREN(index) &ParamLookupChildrenTable[index] +static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] = +{ + { TYPE_STRUCT, false, 0, CHILDREN(0), 5 }, + { TYPE_STRING, false, (size_t)(&((ParametersStruct*)0)->assetName), NULL, 0 }, // assetName + { TYPE_U32, false, (size_t)(&((ParametersStruct*)0)->cookingPlatform), NULL, 0 }, // cookingPlatform + { TYPE_U32, false, (size_t)(&((ParametersStruct*)0)->cookingVersionNum), NULL, 0 }, // cookingVersionNum + { TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->scales), CHILDREN(5), 1 }, // scales + { TYPE_VEC3, false, 1 * sizeof(physx::PxVec3), NULL, 0 }, // scales[] + { TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->meshCookedCollisionStreamsAtScale), CHILDREN(6), 1 }, // meshCookedCollisionStreamsAtScale + { TYPE_REF, false, 1 * sizeof(NvParameterized::Interface*), NULL, 0 }, // meshCookedCollisionStreamsAtScale[] +}; + + +bool DestructibleAssetCollisionDataSet::mBuiltFlag = false; +NvParameterized::MutexType DestructibleAssetCollisionDataSet::mBuiltFlagMutex; + +DestructibleAssetCollisionDataSet::DestructibleAssetCollisionDataSet(NvParameterized::Traits* traits, void* buf, int32_t* refCount) : + NvParameters(traits, buf, refCount) +{ + //mParameterizedTraits->registerFactory(className(), &DestructibleAssetCollisionDataSetFactoryInst); + + if (!buf) //Do not init data if it is inplace-deserialized + { + initDynamicArrays(); + initStrings(); + initReferences(); + initDefaults(); + } +} + +DestructibleAssetCollisionDataSet::~DestructibleAssetCollisionDataSet() +{ + freeStrings(); + freeReferences(); + freeDynamicArrays(); +} + +void DestructibleAssetCollisionDataSet::destroy() +{ + // We cache these fields here to avoid overwrite in destructor + bool doDeallocateSelf = mDoDeallocateSelf; + NvParameterized::Traits* traits = mParameterizedTraits; + int32_t* refCount = mRefCount; + void* buf = mBuffer; + + this->~DestructibleAssetCollisionDataSet(); + + NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf); +} + +const NvParameterized::DefinitionImpl* DestructibleAssetCollisionDataSet::getParameterDefinitionTree(void) +{ + if (!mBuiltFlag) // Double-checked lock + { + NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex); + if (!mBuiltFlag) + { + buildTree(); + } + } + + return(&ParamDefTable[0]); +} + +const NvParameterized::DefinitionImpl* DestructibleAssetCollisionDataSet::getParameterDefinitionTree(void) const +{ + DestructibleAssetCollisionDataSet* tmpParam = const_cast<DestructibleAssetCollisionDataSet*>(this); + + if (!mBuiltFlag) // Double-checked lock + { + NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex); + if (!mBuiltFlag) + { + tmpParam->buildTree(); + } + } + + return(&ParamDefTable[0]); +} + +NvParameterized::ErrorType DestructibleAssetCollisionDataSet::getParameterHandle(const char* long_name, Handle& handle) const +{ + ErrorType Ret = NvParameters::getParameterHandle(long_name, handle); + if (Ret != ERROR_NONE) + { + return(Ret); + } + + size_t offset; + void* ptr; + + getVarPtr(handle, ptr, offset); + + if (ptr == NULL) + { + return(ERROR_INDEX_OUT_OF_RANGE); + } + + return(ERROR_NONE); +} + +NvParameterized::ErrorType DestructibleAssetCollisionDataSet::getParameterHandle(const char* long_name, Handle& handle) +{ + ErrorType Ret = NvParameters::getParameterHandle(long_name, handle); + if (Ret != ERROR_NONE) + { + return(Ret); + } + + size_t offset; + void* ptr; + + getVarPtr(handle, ptr, offset); + + if (ptr == NULL) + { + return(ERROR_INDEX_OUT_OF_RANGE); + } + + return(ERROR_NONE); +} + +void DestructibleAssetCollisionDataSet::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const +{ + ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<DestructibleAssetCollisionDataSet::ParametersStruct*>(¶meters()), handle, offset); +} + + +/* Dynamic Handle Indices */ +/* [0] - meshCookedCollisionStreamsAtScale (not an array of structs) */ + +void DestructibleAssetCollisionDataSet::freeParameterDefinitionTable(NvParameterized::Traits* traits) +{ + if (!traits) + { + return; + } + + if (!mBuiltFlag) // Double-checked lock + { + return; + } + + NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex); + + if (!mBuiltFlag) + { + return; + } + + for (uint32_t i = 0; i < NumParamDefs; ++i) + { + ParamDefTable[i].~DefinitionImpl(); + } + + traits->free(ParamDefTable); + + mBuiltFlag = false; +} + +#define PDEF_PTR(index) (&ParamDefTable[index]) + +void DestructibleAssetCollisionDataSet::buildTree(void) +{ + + uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs; + ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize)); + memset(ParamDefTable, 0, allocSize); + + for (uint32_t i = 0; i < NumParamDefs; ++i) + { + NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits); + } + + // Initialize DefinitionImpl node: nodeIndex=0, longName="" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0]; + ParamDef->init("", TYPE_STRUCT, "STRUCT", true); + + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=1, longName="assetName" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1]; + ParamDef->init("assetName", TYPE_STRING, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The name of the asset for which convex hulls are cooked.\n A convex hull may be cooked for each chunk in the asset, for each scale in the\n scales array.", true); + HintTable[1].init("shortDescription", "The name of the asset for which convex hulls are cooked", true); + ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=2, longName="cookingPlatform" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2]; + ParamDef->init("cookingPlatform", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The cooking platform for convex cooking. Currently unused.", true); + HintTable[1].init("shortDescription", "Currently unused", true); + ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=3, longName="cookingVersionNum" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3]; + ParamDef->init("cookingVersionNum", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "A version number for convex cooking. Currently unused.", true); + HintTable[1].init("shortDescription", "Currently unused", true); + ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=4, longName="scales" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4]; + ParamDef->init("scales", TYPE_ARRAY, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "An array of scales at which chunks in the asset are cooked.\n The size of the outer array of meshCookedCollisionStreamsAtScale\n and scales must be equal.", true); + HintTable[1].init("shortDescription", "An array of scales at which chunks in the asset are cooked", true); + ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + ParamDef->setArraySize(-1); + } + + // Initialize DefinitionImpl node: nodeIndex=5, longName="scales[]" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5]; + ParamDef->init("scales", TYPE_VEC3, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "An array of scales at which chunks in the asset are cooked.\n The size of the outer array of meshCookedCollisionStreamsAtScale\n and scales must be equal.", true); + HintTable[1].init("shortDescription", "An array of scales at which chunks in the asset are cooked", true); + ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=6, longName="meshCookedCollisionStreamsAtScale" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[6]; + ParamDef->init("meshCookedCollisionStreamsAtScale", TYPE_ARRAY, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("INCLUDED", uint64_t(1), true); + ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("INCLUDED", uint64_t(1), true); + HintTable[1].init("longDescription", "An array of arrays of collision hull byte streams.\n The outer array corresponds to different scales (given in the scales array).\n The inner array corresponds to different chunks within the asset.\n The size of the outer array of meshCookedCollisionStreamsAtScale\n and scales must be equal.", true); + HintTable[2].init("shortDescription", "An array of arrays of collision hull byte streams", true); + ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + static const char* const RefVariantVals[] = { "MeshCookedCollisionStreamsAtScale" }; + ParamDefTable[6].setRefVariantVals((const char**)RefVariantVals, 1); + + + ParamDef->setArraySize(-1); + static const uint8_t dynHandleIndices[1] = { 0, }; + ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1); + + } + + // Initialize DefinitionImpl node: nodeIndex=7, longName="meshCookedCollisionStreamsAtScale[]" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[7]; + ParamDef->init("meshCookedCollisionStreamsAtScale", TYPE_REF, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("INCLUDED", uint64_t(1), true); + ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("INCLUDED", uint64_t(1), true); + HintTable[1].init("longDescription", "An array of arrays of collision hull byte streams.\n The outer array corresponds to different scales (given in the scales array).\n The inner array corresponds to different chunks within the asset.\n The size of the outer array of meshCookedCollisionStreamsAtScale\n and scales must be equal.", true); + HintTable[2].init("shortDescription", "An array of arrays of collision hull byte streams", true); + ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + static const char* const RefVariantVals[] = { "MeshCookedCollisionStreamsAtScale" }; + ParamDefTable[7].setRefVariantVals((const char**)RefVariantVals, 1); + + + + } + + // SetChildren for: nodeIndex=0, longName="" + { + static Definition* Children[5]; + Children[0] = PDEF_PTR(1); + Children[1] = PDEF_PTR(2); + Children[2] = PDEF_PTR(3); + Children[3] = PDEF_PTR(4); + Children[4] = PDEF_PTR(6); + + ParamDefTable[0].setChildren(Children, 5); + } + + // SetChildren for: nodeIndex=4, longName="scales" + { + static Definition* Children[1]; + Children[0] = PDEF_PTR(5); + + ParamDefTable[4].setChildren(Children, 1); + } + + // SetChildren for: nodeIndex=6, longName="meshCookedCollisionStreamsAtScale" + { + static Definition* Children[1]; + Children[0] = PDEF_PTR(7); + + ParamDefTable[6].setChildren(Children, 1); + } + + mBuiltFlag = true; + +} +void DestructibleAssetCollisionDataSet::initStrings(void) +{ + assetName.isAllocated = true; + assetName.buf = NULL; +} + +void DestructibleAssetCollisionDataSet::initDynamicArrays(void) +{ + scales.buf = NULL; + scales.isAllocated = true; + scales.elementSize = sizeof(physx::PxVec3); + scales.arraySizes[0] = 0; + meshCookedCollisionStreamsAtScale.buf = NULL; + meshCookedCollisionStreamsAtScale.isAllocated = true; + meshCookedCollisionStreamsAtScale.elementSize = sizeof(NvParameterized::Interface*); + meshCookedCollisionStreamsAtScale.arraySizes[0] = 0; +} + +void DestructibleAssetCollisionDataSet::initDefaults(void) +{ + + freeStrings(); + freeReferences(); + freeDynamicArrays(); + cookingPlatform = uint32_t(UINT32_MAX); + cookingVersionNum = uint32_t(0); + + initDynamicArrays(); + initStrings(); + initReferences(); +} + +void DestructibleAssetCollisionDataSet::initReferences(void) +{ +} + +void DestructibleAssetCollisionDataSet::freeDynamicArrays(void) +{ + if (scales.isAllocated && scales.buf) + { + mParameterizedTraits->free(scales.buf); + } + if (meshCookedCollisionStreamsAtScale.isAllocated && meshCookedCollisionStreamsAtScale.buf) + { + mParameterizedTraits->free(meshCookedCollisionStreamsAtScale.buf); + } +} + +void DestructibleAssetCollisionDataSet::freeStrings(void) +{ + + if (assetName.isAllocated && assetName.buf) + { + mParameterizedTraits->strfree((char*)assetName.buf); + } +} + +void DestructibleAssetCollisionDataSet::freeReferences(void) +{ + + for (int i = 0; i < meshCookedCollisionStreamsAtScale.arraySizes[0]; ++i) + { + if (meshCookedCollisionStreamsAtScale.buf[i]) + { + meshCookedCollisionStreamsAtScale.buf[i]->destroy(); + } + } +} + +} // namespace destructible +} // namespace nvidia diff --git a/APEX_1.4/module/destructible/src/autogen/DestructibleAssetParameters.cpp b/APEX_1.4/module/destructible/src/autogen/DestructibleAssetParameters.cpp new file mode 100644 index 00000000..b404970d --- /dev/null +++ b/APEX_1.4/module/destructible/src/autogen/DestructibleAssetParameters.cpp @@ -0,0 +1,4829 @@ +// 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-2015 NVIDIA Corporation. All rights reserved. + +// This file was generated by NvParameterized/scripts/GenParameterized.pl + + +#include "DestructibleAssetParameters.h" +#include <string.h> +#include <stdlib.h> + +using namespace NvParameterized; + +namespace nvidia +{ +namespace destructible +{ + +using namespace DestructibleAssetParametersNS; + +const char* const DestructibleAssetParametersFactory::vptr = + NvParameterized::getVptr<DestructibleAssetParameters, DestructibleAssetParameters::ClassAlignment>(); + +const uint32_t NumParamDefs = 160; +static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs]; + + +static const size_t ParamLookupChildrenTable[] = +{ + 1, 2, 3, 4, 5, 23, 42, 43, 55, 57, 59, 120, 131, 132, 133, 134, 135, 136, 141, 143, + 144, 146, 148, 149, 150, 151, 152, 154, 156, 158, 6, 7, 8, 9, 13, 17, 18, 19, 20, + 21, 22, 10, 11, 12, 14, 15, 16, 24, 25, 26, 27, 28, 32, 36, 37, 38, 39, 40, 41, 29, + 30, 31, 33, 34, 35, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 56, 58, 60, 61, 62, + 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 82, 83, 84, 85, 91, 116, 117, 118, + 119, 75, 76, 77, 78, 79, 80, 81, 86, 87, 88, 89, 90, 92, 93, 94, 95, 96, 97, 98, + 104, 109, 99, 100, 101, 102, 103, 105, 106, 107, 108, 110, 111, 112, 113, 114, 115, + 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 137, 138, 139, 140, 142, 145, 147, + 153, 155, 157, 159, +}; + +#define TENUM(type) nvidia::##type +#define CHILDREN(index) &ParamLookupChildrenTable[index] +static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] = +{ + { TYPE_STRUCT, false, 0, CHILDREN(0), 30 }, + { TYPE_STRING, false, (size_t)(&((ParametersStruct*)0)->comments), NULL, 0 }, // comments + { TYPE_U32, false, (size_t)(&((ParametersStruct*)0)->depthCount), NULL, 0 }, // depthCount + { TYPE_U32, false, (size_t)(&((ParametersStruct*)0)->originalDepthCount), NULL, 0 }, // originalDepthCount + { TYPE_BOUNDS3, false, (size_t)(&((ParametersStruct*)0)->bounds), NULL, 0 }, // bounds + { TYPE_STRUCT, false, (size_t)(&((ParametersStruct*)0)->defaultBehaviorGroup), CHILDREN(30), 11 }, // defaultBehaviorGroup + { TYPE_STRING, false, (size_t)(&((BehaviorGroup_Type*)0)->name), NULL, 0 }, // defaultBehaviorGroup.name + { TYPE_F32, false, (size_t)(&((BehaviorGroup_Type*)0)->damageThreshold), NULL, 0 }, // defaultBehaviorGroup.damageThreshold + { TYPE_F32, false, (size_t)(&((BehaviorGroup_Type*)0)->damageToRadius), NULL, 0 }, // defaultBehaviorGroup.damageToRadius + { TYPE_STRUCT, false, (size_t)(&((BehaviorGroup_Type*)0)->damageSpread), CHILDREN(41), 3 }, // defaultBehaviorGroup.damageSpread + { TYPE_F32, false, (size_t)(&((DamageSpreadFunction_Type*)0)->minimumRadius), NULL, 0 }, // defaultBehaviorGroup.damageSpread.minimumRadius + { TYPE_F32, false, (size_t)(&((DamageSpreadFunction_Type*)0)->radiusMultiplier), NULL, 0 }, // defaultBehaviorGroup.damageSpread.radiusMultiplier + { TYPE_F32, false, (size_t)(&((DamageSpreadFunction_Type*)0)->falloffExponent), NULL, 0 }, // defaultBehaviorGroup.damageSpread.falloffExponent + { TYPE_STRUCT, false, (size_t)(&((BehaviorGroup_Type*)0)->damageColorSpread), CHILDREN(44), 3 }, // defaultBehaviorGroup.damageColorSpread + { TYPE_F32, false, (size_t)(&((DamageSpreadFunction_Type*)0)->minimumRadius), NULL, 0 }, // defaultBehaviorGroup.damageColorSpread.minimumRadius + { TYPE_F32, false, (size_t)(&((DamageSpreadFunction_Type*)0)->radiusMultiplier), NULL, 0 }, // defaultBehaviorGroup.damageColorSpread.radiusMultiplier + { TYPE_F32, false, (size_t)(&((DamageSpreadFunction_Type*)0)->falloffExponent), NULL, 0 }, // defaultBehaviorGroup.damageColorSpread.falloffExponent + { TYPE_VEC4, false, (size_t)(&((BehaviorGroup_Type*)0)->damageColorChange), NULL, 0 }, // defaultBehaviorGroup.damageColorChange + { TYPE_F32, false, (size_t)(&((BehaviorGroup_Type*)0)->materialStrength), NULL, 0 }, // defaultBehaviorGroup.materialStrength + { TYPE_F32, false, (size_t)(&((BehaviorGroup_Type*)0)->density), NULL, 0 }, // defaultBehaviorGroup.density + { TYPE_F32, false, (size_t)(&((BehaviorGroup_Type*)0)->fadeOut), NULL, 0 }, // defaultBehaviorGroup.fadeOut + { TYPE_F32, false, (size_t)(&((BehaviorGroup_Type*)0)->maxDepenetrationVelocity), NULL, 0 }, // defaultBehaviorGroup.maxDepenetrationVelocity + { TYPE_U64, false, (size_t)(&((BehaviorGroup_Type*)0)->userData), NULL, 0 }, // defaultBehaviorGroup.userData + { TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->behaviorGroups), CHILDREN(47), 1 }, // behaviorGroups + { TYPE_STRUCT, false, 1 * sizeof(BehaviorGroup_Type), CHILDREN(48), 11 }, // behaviorGroups[] + { TYPE_STRING, false, (size_t)(&((BehaviorGroup_Type*)0)->name), NULL, 0 }, // behaviorGroups[].name + { TYPE_F32, false, (size_t)(&((BehaviorGroup_Type*)0)->damageThreshold), NULL, 0 }, // behaviorGroups[].damageThreshold + { TYPE_F32, false, (size_t)(&((BehaviorGroup_Type*)0)->damageToRadius), NULL, 0 }, // behaviorGroups[].damageToRadius + { TYPE_STRUCT, false, (size_t)(&((BehaviorGroup_Type*)0)->damageSpread), CHILDREN(59), 3 }, // behaviorGroups[].damageSpread + { TYPE_F32, false, (size_t)(&((DamageSpreadFunction_Type*)0)->minimumRadius), NULL, 0 }, // behaviorGroups[].damageSpread.minimumRadius + { TYPE_F32, false, (size_t)(&((DamageSpreadFunction_Type*)0)->radiusMultiplier), NULL, 0 }, // behaviorGroups[].damageSpread.radiusMultiplier + { TYPE_F32, false, (size_t)(&((DamageSpreadFunction_Type*)0)->falloffExponent), NULL, 0 }, // behaviorGroups[].damageSpread.falloffExponent + { TYPE_STRUCT, false, (size_t)(&((BehaviorGroup_Type*)0)->damageColorSpread), CHILDREN(62), 3 }, // behaviorGroups[].damageColorSpread + { TYPE_F32, false, (size_t)(&((DamageSpreadFunction_Type*)0)->minimumRadius), NULL, 0 }, // behaviorGroups[].damageColorSpread.minimumRadius + { TYPE_F32, false, (size_t)(&((DamageSpreadFunction_Type*)0)->radiusMultiplier), NULL, 0 }, // behaviorGroups[].damageColorSpread.radiusMultiplier + { TYPE_F32, false, (size_t)(&((DamageSpreadFunction_Type*)0)->falloffExponent), NULL, 0 }, // behaviorGroups[].damageColorSpread.falloffExponent + { TYPE_VEC4, false, (size_t)(&((BehaviorGroup_Type*)0)->damageColorChange), NULL, 0 }, // behaviorGroups[].damageColorChange + { TYPE_F32, false, (size_t)(&((BehaviorGroup_Type*)0)->materialStrength), NULL, 0 }, // behaviorGroups[].materialStrength + { TYPE_F32, false, (size_t)(&((BehaviorGroup_Type*)0)->density), NULL, 0 }, // behaviorGroups[].density + { TYPE_F32, false, (size_t)(&((BehaviorGroup_Type*)0)->fadeOut), NULL, 0 }, // behaviorGroups[].fadeOut + { TYPE_F32, false, (size_t)(&((BehaviorGroup_Type*)0)->maxDepenetrationVelocity), NULL, 0 }, // behaviorGroups[].maxDepenetrationVelocity + { TYPE_U64, false, (size_t)(&((BehaviorGroup_Type*)0)->userData), NULL, 0 }, // behaviorGroups[].userData + { TYPE_I8, false, (size_t)(&((ParametersStruct*)0)->RTFractureBehaviorGroup), NULL, 0 }, // RTFractureBehaviorGroup + { TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->chunks), CHILDREN(65), 1 }, // chunks + { TYPE_STRUCT, false, 1 * sizeof(Chunk_Type), CHILDREN(66), 10 }, // chunks[] + { TYPE_U16, false, (size_t)(&((Chunk_Type*)0)->depth), NULL, 0 }, // chunks[].depth + { TYPE_U16, false, (size_t)(&((Chunk_Type*)0)->parentIndex), NULL, 0 }, // chunks[].parentIndex + { TYPE_U16, false, (size_t)(&((Chunk_Type*)0)->firstChildIndex), NULL, 0 }, // chunks[].firstChildIndex + { TYPE_U16, false, (size_t)(&((Chunk_Type*)0)->numChildren), NULL, 0 }, // chunks[].numChildren + { TYPE_U16, false, (size_t)(&((Chunk_Type*)0)->meshPartIndex), NULL, 0 }, // chunks[].meshPartIndex + { TYPE_U16, false, (size_t)(&((Chunk_Type*)0)->flags), NULL, 0 }, // chunks[].flags + { TYPE_VEC3, false, (size_t)(&((Chunk_Type*)0)->surfaceNormal), NULL, 0 }, // chunks[].surfaceNormal + { TYPE_I8, false, (size_t)(&((Chunk_Type*)0)->behaviorGroupIndex), NULL, 0 }, // chunks[].behaviorGroupIndex + { TYPE_U16, false, (size_t)(&((Chunk_Type*)0)->firstScatterMesh), NULL, 0 }, // chunks[].firstScatterMesh + { TYPE_U16, false, (size_t)(&((Chunk_Type*)0)->scatterMeshCount), NULL, 0 }, // chunks[].scatterMeshCount + { TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->chunkConvexHulls), CHILDREN(76), 1 }, // chunkConvexHulls + { TYPE_REF, false, 1 * sizeof(NvParameterized::Interface*), NULL, 0 }, // chunkConvexHulls[] + { TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->chunkConvexHullStartIndices), CHILDREN(77), 1 }, // chunkConvexHullStartIndices + { TYPE_U32, false, 1 * sizeof(uint32_t), NULL, 0 }, // chunkConvexHullStartIndices[] + { TYPE_STRUCT, false, (size_t)(&((ParametersStruct*)0)->destructibleParameters), CHILDREN(78), 24 }, // destructibleParameters + { TYPE_F32, false, (size_t)(&((DestructibleParameters_Type*)0)->damageCap), NULL, 0 }, // destructibleParameters.damageCap + { TYPE_F32, false, (size_t)(&((DestructibleParameters_Type*)0)->forceToDamage), NULL, 0 }, // destructibleParameters.forceToDamage + { TYPE_F32, false, (size_t)(&((DestructibleParameters_Type*)0)->impactVelocityThreshold), NULL, 0 }, // destructibleParameters.impactVelocityThreshold + { TYPE_U32, false, (size_t)(&((DestructibleParameters_Type*)0)->minimumFractureDepth), NULL, 0 }, // destructibleParameters.minimumFractureDepth + { TYPE_I32, false, (size_t)(&((DestructibleParameters_Type*)0)->impactDamageDefaultDepth), NULL, 0 }, // destructibleParameters.impactDamageDefaultDepth + { TYPE_I32, false, (size_t)(&((DestructibleParameters_Type*)0)->debrisDepth), NULL, 0 }, // destructibleParameters.debrisDepth + { TYPE_U32, false, (size_t)(&((DestructibleParameters_Type*)0)->essentialDepth), NULL, 0 }, // destructibleParameters.essentialDepth + { TYPE_F32, false, (size_t)(&((DestructibleParameters_Type*)0)->debrisLifetimeMin), NULL, 0 }, // destructibleParameters.debrisLifetimeMin + { TYPE_F32, false, (size_t)(&((DestructibleParameters_Type*)0)->debrisLifetimeMax), NULL, 0 }, // destructibleParameters.debrisLifetimeMax + { TYPE_F32, false, (size_t)(&((DestructibleParameters_Type*)0)->debrisMaxSeparationMin), NULL, 0 }, // destructibleParameters.debrisMaxSeparationMin + { TYPE_F32, false, (size_t)(&((DestructibleParameters_Type*)0)->debrisMaxSeparationMax), NULL, 0 }, // destructibleParameters.debrisMaxSeparationMax + { TYPE_F32, false, (size_t)(&((DestructibleParameters_Type*)0)->debrisDestructionProbability), NULL, 0 }, // destructibleParameters.debrisDestructionProbability + { TYPE_BOUNDS3, false, (size_t)(&((DestructibleParameters_Type*)0)->validBounds), NULL, 0 }, // destructibleParameters.validBounds + { TYPE_F32, false, (size_t)(&((DestructibleParameters_Type*)0)->maxChunkSpeed), NULL, 0 }, // destructibleParameters.maxChunkSpeed + { TYPE_STRUCT, false, (size_t)(&((DestructibleParameters_Type*)0)->flags), CHILDREN(102), 7 }, // destructibleParameters.flags + { TYPE_BOOL, false, (size_t)(&((DestructibleParametersFlag_Type*)0)->ACCUMULATE_DAMAGE), NULL, 0 }, // destructibleParameters.flags.ACCUMULATE_DAMAGE + { TYPE_BOOL, false, (size_t)(&((DestructibleParametersFlag_Type*)0)->DEBRIS_TIMEOUT), NULL, 0 }, // destructibleParameters.flags.DEBRIS_TIMEOUT + { TYPE_BOOL, false, (size_t)(&((DestructibleParametersFlag_Type*)0)->DEBRIS_MAX_SEPARATION), NULL, 0 }, // destructibleParameters.flags.DEBRIS_MAX_SEPARATION + { TYPE_BOOL, false, (size_t)(&((DestructibleParametersFlag_Type*)0)->CRUMBLE_SMALLEST_CHUNKS), NULL, 0 }, // destructibleParameters.flags.CRUMBLE_SMALLEST_CHUNKS + { TYPE_BOOL, false, (size_t)(&((DestructibleParametersFlag_Type*)0)->ACCURATE_RAYCASTS), NULL, 0 }, // destructibleParameters.flags.ACCURATE_RAYCASTS + { TYPE_BOOL, false, (size_t)(&((DestructibleParametersFlag_Type*)0)->USE_VALID_BOUNDS), NULL, 0 }, // destructibleParameters.flags.USE_VALID_BOUNDS + { TYPE_BOOL, false, (size_t)(&((DestructibleParametersFlag_Type*)0)->CRUMBLE_VIA_RUNTIME_FRACTURE), NULL, 0 }, // destructibleParameters.flags.CRUMBLE_VIA_RUNTIME_FRACTURE + { TYPE_F32, false, (size_t)(&((DestructibleParameters_Type*)0)->fractureImpulseScale), NULL, 0 }, // destructibleParameters.fractureImpulseScale + { TYPE_U16, false, (size_t)(&((DestructibleParameters_Type*)0)->damageDepthLimit), NULL, 0 }, // destructibleParameters.damageDepthLimit + { TYPE_U16, false, (size_t)(&((DestructibleParameters_Type*)0)->dynamicChunkDominanceGroup), NULL, 0 }, // destructibleParameters.dynamicChunkDominanceGroup + { TYPE_STRUCT, false, (size_t)(&((DestructibleParameters_Type*)0)->dynamicChunksGroupsMask), CHILDREN(109), 5 }, // destructibleParameters.dynamicChunksGroupsMask + { TYPE_BOOL, false, (size_t)(&((GroupsMask_Type*)0)->useGroupsMask), NULL, 0 }, // destructibleParameters.dynamicChunksGroupsMask.useGroupsMask + { TYPE_U32, false, (size_t)(&((GroupsMask_Type*)0)->bits0), NULL, 0 }, // destructibleParameters.dynamicChunksGroupsMask.bits0 + { TYPE_U32, false, (size_t)(&((GroupsMask_Type*)0)->bits1), NULL, 0 }, // destructibleParameters.dynamicChunksGroupsMask.bits1 + { TYPE_U32, false, (size_t)(&((GroupsMask_Type*)0)->bits2), NULL, 0 }, // destructibleParameters.dynamicChunksGroupsMask.bits2 + { TYPE_U32, false, (size_t)(&((GroupsMask_Type*)0)->bits3), NULL, 0 }, // destructibleParameters.dynamicChunksGroupsMask.bits3 + { TYPE_STRUCT, false, (size_t)(&((DestructibleParameters_Type*)0)->runtimeFracture), CHILDREN(114), 9 }, // destructibleParameters.runtimeFracture + { TYPE_ENUM, false, (size_t)(&((RuntimeFracture_Type*)0)->RuntimeFractureType), NULL, 0 }, // destructibleParameters.runtimeFracture.RuntimeFractureType + { TYPE_BOOL, false, (size_t)(&((RuntimeFracture_Type*)0)->sheetFracture), NULL, 0 }, // destructibleParameters.runtimeFracture.sheetFracture + { TYPE_U32, false, (size_t)(&((RuntimeFracture_Type*)0)->depthLimit), NULL, 0 }, // destructibleParameters.runtimeFracture.depthLimit + { TYPE_BOOL, false, (size_t)(&((RuntimeFracture_Type*)0)->destroyIfAtDepthLimit), NULL, 0 }, // destructibleParameters.runtimeFracture.destroyIfAtDepthLimit + { TYPE_F32, false, (size_t)(&((RuntimeFracture_Type*)0)->minConvexSize), NULL, 0 }, // destructibleParameters.runtimeFracture.minConvexSize + { TYPE_F32, false, (size_t)(&((RuntimeFracture_Type*)0)->impulseScale), NULL, 0 }, // destructibleParameters.runtimeFracture.impulseScale + { TYPE_STRUCT, false, (size_t)(&((RuntimeFracture_Type*)0)->glass), CHILDREN(123), 5 }, // destructibleParameters.runtimeFracture.glass + { TYPE_U32, false, (size_t)(&((FractureGlass_Type*)0)->numSectors), NULL, 0 }, // destructibleParameters.runtimeFracture.glass.numSectors + { TYPE_F32, false, (size_t)(&((FractureGlass_Type*)0)->sectorRand), NULL, 0 }, // destructibleParameters.runtimeFracture.glass.sectorRand + { TYPE_F32, false, (size_t)(&((FractureGlass_Type*)0)->firstSegmentSize), NULL, 0 }, // destructibleParameters.runtimeFracture.glass.firstSegmentSize + { TYPE_F32, false, (size_t)(&((FractureGlass_Type*)0)->segmentScale), NULL, 0 }, // destructibleParameters.runtimeFracture.glass.segmentScale + { TYPE_F32, false, (size_t)(&((FractureGlass_Type*)0)->segmentRand), NULL, 0 }, // destructibleParameters.runtimeFracture.glass.segmentRand + { TYPE_STRUCT, false, (size_t)(&((RuntimeFracture_Type*)0)->voronoi), CHILDREN(128), 4 }, // destructibleParameters.runtimeFracture.voronoi + { TYPE_VEC3, false, (size_t)(&((FractureVoronoi_Type*)0)->dimensions), NULL, 0 }, // destructibleParameters.runtimeFracture.voronoi.dimensions + { TYPE_U32, false, (size_t)(&((FractureVoronoi_Type*)0)->numCells), NULL, 0 }, // destructibleParameters.runtimeFracture.voronoi.numCells + { TYPE_F32, false, (size_t)(&((FractureVoronoi_Type*)0)->biasExp), NULL, 0 }, // destructibleParameters.runtimeFracture.voronoi.biasExp + { TYPE_F32, false, (size_t)(&((FractureVoronoi_Type*)0)->maxDist), NULL, 0 }, // destructibleParameters.runtimeFracture.voronoi.maxDist + { TYPE_STRUCT, false, (size_t)(&((RuntimeFracture_Type*)0)->attachment), CHILDREN(132), 6 }, // destructibleParameters.runtimeFracture.attachment + { TYPE_BOOL, false, (size_t)(&((FractureAttachment_Type*)0)->posX), NULL, 0 }, // destructibleParameters.runtimeFracture.attachment.posX + { TYPE_BOOL, false, (size_t)(&((FractureAttachment_Type*)0)->negX), NULL, 0 }, // destructibleParameters.runtimeFracture.attachment.negX + { TYPE_BOOL, false, (size_t)(&((FractureAttachment_Type*)0)->posY), NULL, 0 }, // destructibleParameters.runtimeFracture.attachment.posY + { TYPE_BOOL, false, (size_t)(&((FractureAttachment_Type*)0)->negY), NULL, 0 }, // destructibleParameters.runtimeFracture.attachment.negY + { TYPE_BOOL, false, (size_t)(&((FractureAttachment_Type*)0)->posZ), NULL, 0 }, // destructibleParameters.runtimeFracture.attachment.posZ + { TYPE_BOOL, false, (size_t)(&((FractureAttachment_Type*)0)->negZ), NULL, 0 }, // destructibleParameters.runtimeFracture.attachment.negZ + { TYPE_F32, false, (size_t)(&((DestructibleParameters_Type*)0)->supportStrength), NULL, 0 }, // destructibleParameters.supportStrength + { TYPE_I8, false, (size_t)(&((DestructibleParameters_Type*)0)->legacyChunkBoundsTestSetting), NULL, 0 }, // destructibleParameters.legacyChunkBoundsTestSetting + { TYPE_I8, false, (size_t)(&((DestructibleParameters_Type*)0)->legacyDamageRadiusSpreadSetting), NULL, 0 }, // destructibleParameters.legacyDamageRadiusSpreadSetting + { TYPE_BOOL, false, (size_t)(&((DestructibleParameters_Type*)0)->alwaysDrawScatterMesh), NULL, 0 }, // destructibleParameters.alwaysDrawScatterMesh + { TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->depthParameters), CHILDREN(138), 1 }, // depthParameters + { TYPE_STRUCT, false, 1 * sizeof(DestructibleDepthParameters_Type), CHILDREN(139), 9 }, // depthParameters[] + { TYPE_BOOL, false, (size_t)(&((DestructibleDepthParameters_Type*)0)->OVERRIDE_IMPACT_DAMAGE), NULL, 0 }, // depthParameters[].OVERRIDE_IMPACT_DAMAGE + { TYPE_BOOL, false, (size_t)(&((DestructibleDepthParameters_Type*)0)->OVERRIDE_IMPACT_DAMAGE_VALUE), NULL, 0 }, // depthParameters[].OVERRIDE_IMPACT_DAMAGE_VALUE + { TYPE_BOOL, false, (size_t)(&((DestructibleDepthParameters_Type*)0)->IGNORE_POSE_UPDATES), NULL, 0 }, // depthParameters[].IGNORE_POSE_UPDATES + { TYPE_BOOL, false, (size_t)(&((DestructibleDepthParameters_Type*)0)->IGNORE_RAYCAST_CALLBACKS), NULL, 0 }, // depthParameters[].IGNORE_RAYCAST_CALLBACKS + { TYPE_BOOL, false, (size_t)(&((DestructibleDepthParameters_Type*)0)->IGNORE_CONTACT_CALLBACKS), NULL, 0 }, // depthParameters[].IGNORE_CONTACT_CALLBACKS + { TYPE_BOOL, false, (size_t)(&((DestructibleDepthParameters_Type*)0)->USER_FLAG_0), NULL, 0 }, // depthParameters[].USER_FLAG_0 + { TYPE_BOOL, false, (size_t)(&((DestructibleDepthParameters_Type*)0)->USER_FLAG_1), NULL, 0 }, // depthParameters[].USER_FLAG_1 + { TYPE_BOOL, false, (size_t)(&((DestructibleDepthParameters_Type*)0)->USER_FLAG_2), NULL, 0 }, // depthParameters[].USER_FLAG_2 + { TYPE_BOOL, false, (size_t)(&((DestructibleDepthParameters_Type*)0)->USER_FLAG_3), NULL, 0 }, // depthParameters[].USER_FLAG_3 + { TYPE_STRING, false, (size_t)(&((ParametersStruct*)0)->crumbleEmitterName), NULL, 0 }, // crumbleEmitterName + { TYPE_STRING, false, (size_t)(&((ParametersStruct*)0)->dustEmitterName), NULL, 0 }, // dustEmitterName + { TYPE_REF, false, (size_t)(&((ParametersStruct*)0)->collisionData), NULL, 0 }, // collisionData + { TYPE_REF, false, (size_t)(&((ParametersStruct*)0)->renderMeshAsset), NULL, 0 }, // renderMeshAsset + { TYPE_U32, false, (size_t)(&((ParametersStruct*)0)->initialDestructibleActorAllowanceForInstancing), NULL, 0 }, // initialDestructibleActorAllowanceForInstancing + { TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->chunkInstanceInfo), CHILDREN(148), 1 }, // chunkInstanceInfo + { TYPE_STRUCT, false, 1 * sizeof(InstanceInfo_Type), CHILDREN(149), 3 }, // chunkInstanceInfo[] + { TYPE_U16, false, (size_t)(&((InstanceInfo_Type*)0)->partIndex), NULL, 0 }, // chunkInstanceInfo[].partIndex + { TYPE_VEC3, false, (size_t)(&((InstanceInfo_Type*)0)->chunkPositionOffset), NULL, 0 }, // chunkInstanceInfo[].chunkPositionOffset + { TYPE_VEC2, false, (size_t)(&((InstanceInfo_Type*)0)->chunkUVOffset), NULL, 0 }, // chunkInstanceInfo[].chunkUVOffset + { TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->staticMaterialNames), CHILDREN(152), 1 }, // staticMaterialNames + { TYPE_STRING, false, 1 * sizeof(NvParameterized::DummyStringStruct), NULL, 0 }, // staticMaterialNames[] + { TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->neighborPadding), NULL, 0 }, // neighborPadding + { TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->overlapsAtDepth), CHILDREN(153), 1 }, // overlapsAtDepth + { TYPE_REF, false, 1 * sizeof(NvParameterized::Interface*), NULL, 0 }, // overlapsAtDepth[] + { TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->firstChunkAtDepth), CHILDREN(154), 1 }, // firstChunkAtDepth + { TYPE_U32, false, 1 * sizeof(uint32_t), NULL, 0 }, // firstChunkAtDepth[] + { TYPE_U32, false, (size_t)(&((ParametersStruct*)0)->supportDepth), NULL, 0 }, // supportDepth + { TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->formExtendedStructures), NULL, 0 }, // formExtendedStructures + { TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->useAssetDefinedSupport), NULL, 0 }, // useAssetDefinedSupport + { TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->useWorldSupport), NULL, 0 }, // useWorldSupport + { TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->actorTransforms), CHILDREN(155), 1 }, // actorTransforms + { TYPE_MAT44, false, 1 * sizeof(physx::PxMat44), NULL, 0 }, // actorTransforms[] + { TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->scatterMeshAssets), CHILDREN(156), 1 }, // scatterMeshAssets + { TYPE_REF, false, 1 * sizeof(NvParameterized::Interface*), NULL, 0 }, // scatterMeshAssets[] + { TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->scatterMeshIndices), CHILDREN(157), 1 }, // scatterMeshIndices + { TYPE_U8, false, 1 * sizeof(uint8_t), NULL, 0 }, // scatterMeshIndices[] + { TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->scatterMeshTransforms), CHILDREN(158), 1 }, // scatterMeshTransforms + { TYPE_MAT44, false, 1 * sizeof(physx::PxMat44), NULL, 0 }, // scatterMeshTransforms[] +}; + + +bool DestructibleAssetParameters::mBuiltFlag = false; +NvParameterized::MutexType DestructibleAssetParameters::mBuiltFlagMutex; + +DestructibleAssetParameters::DestructibleAssetParameters(NvParameterized::Traits* traits, void* buf, int32_t* refCount) : + NvParameters(traits, buf, refCount) +{ + //mParameterizedTraits->registerFactory(className(), &DestructibleAssetParametersFactoryInst); + + if (!buf) //Do not init data if it is inplace-deserialized + { + initDynamicArrays(); + initStrings(); + initReferences(); + initDefaults(); + } +} + +DestructibleAssetParameters::~DestructibleAssetParameters() +{ + freeStrings(); + freeReferences(); + freeDynamicArrays(); +} + +void DestructibleAssetParameters::destroy() +{ + // We cache these fields here to avoid overwrite in destructor + bool doDeallocateSelf = mDoDeallocateSelf; + NvParameterized::Traits* traits = mParameterizedTraits; + int32_t* refCount = mRefCount; + void* buf = mBuffer; + + this->~DestructibleAssetParameters(); + + NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf); +} + +const NvParameterized::DefinitionImpl* DestructibleAssetParameters::getParameterDefinitionTree(void) +{ + if (!mBuiltFlag) // Double-checked lock + { + NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex); + if (!mBuiltFlag) + { + buildTree(); + } + } + + return(&ParamDefTable[0]); +} + +const NvParameterized::DefinitionImpl* DestructibleAssetParameters::getParameterDefinitionTree(void) const +{ + DestructibleAssetParameters* tmpParam = const_cast<DestructibleAssetParameters*>(this); + + if (!mBuiltFlag) // Double-checked lock + { + NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex); + if (!mBuiltFlag) + { + tmpParam->buildTree(); + } + } + + return(&ParamDefTable[0]); +} + +NvParameterized::ErrorType DestructibleAssetParameters::getParameterHandle(const char* long_name, Handle& handle) const +{ + ErrorType Ret = NvParameters::getParameterHandle(long_name, handle); + if (Ret != ERROR_NONE) + { + return(Ret); + } + + size_t offset; + void* ptr; + + getVarPtr(handle, ptr, offset); + + if (ptr == NULL) + { + return(ERROR_INDEX_OUT_OF_RANGE); + } + + return(ERROR_NONE); +} + +NvParameterized::ErrorType DestructibleAssetParameters::getParameterHandle(const char* long_name, Handle& handle) +{ + ErrorType Ret = NvParameters::getParameterHandle(long_name, handle); + if (Ret != ERROR_NONE) + { + return(Ret); + } + + size_t offset; + void* ptr; + + getVarPtr(handle, ptr, offset); + + if (ptr == NULL) + { + return(ERROR_INDEX_OUT_OF_RANGE); + } + + return(ERROR_NONE); +} + +void DestructibleAssetParameters::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const +{ + ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<DestructibleAssetParameters::ParametersStruct*>(¶meters()), handle, offset); +} + + +/* Dynamic Handle Indices */ +/* [1,0] - behaviorGroups.name */ +/* [0] - chunkConvexHulls (not an array of structs) */ +/* [0] - staticMaterialNames (not an array of structs) */ +/* [0] - overlapsAtDepth (not an array of structs) */ +/* [0] - scatterMeshAssets (not an array of structs) */ + +void DestructibleAssetParameters::freeParameterDefinitionTable(NvParameterized::Traits* traits) +{ + if (!traits) + { + return; + } + + if (!mBuiltFlag) // Double-checked lock + { + return; + } + + NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex); + + if (!mBuiltFlag) + { + return; + } + + for (uint32_t i = 0; i < NumParamDefs; ++i) + { + ParamDefTable[i].~DefinitionImpl(); + } + + traits->free(ParamDefTable); + + mBuiltFlag = false; +} + +#define PDEF_PTR(index) (&ParamDefTable[index]) + +void DestructibleAssetParameters::buildTree(void) +{ + + uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs; + ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize)); + memset(ParamDefTable, 0, allocSize); + + for (uint32_t i = 0; i < NumParamDefs; ++i) + { + NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits); + } + + // Initialize DefinitionImpl node: nodeIndex=0, longName="" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0]; + ParamDef->init("", TYPE_STRUCT, "STRUCT", true); + + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=1, longName="comments" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1]; + ParamDef->init("comments", TYPE_STRING, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Human-readable string which describes which tool created this asset, its version, etc.", true); + HintTable[1].init("shortDescription", "Human-readable string which describes which tool created this asset, its version, etc.", true); + ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=2, longName="depthCount" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2]; + ParamDef->init("depthCount", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The number of chunk depth levels. This is 1 for an unfractured mesh.", true); + HintTable[1].init("shortDescription", "The number of chunk depth levels", true); + ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=3, longName="originalDepthCount" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3]; + ParamDef->init("originalDepthCount", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The depth count when authored - this way we can tell how far it's been reduced.", true); + HintTable[1].init("shortDescription", "The depth count when authored", true); + ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=4, longName="bounds" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4]; + ParamDef->init("bounds", TYPE_BOUNDS3, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The axis-aligned bounding box of the destructible asset. This is the smallest AABB\n which contains all chunk AABBs.", true); + HintTable[1].init("shortDescription", "The AABB of the destructible asset", true); + ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=5, longName="defaultBehaviorGroup" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5]; + ParamDef->init("defaultBehaviorGroup", TYPE_STRUCT, "BehaviorGroup", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The default behavior group referenced by chunks. Each chunk references a behavior group for chunk-specific reactions.", true); + HintTable[1].init("shortDescription", "The default behavior group referenced by chunks", true); + ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=6, longName="defaultBehaviorGroup.name" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[6]; + ParamDef->init("name", TYPE_STRING, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Name of behavior group, eg Concrete or Glass.", true); + HintTable[1].init("shortDescription", "Name of behavior group", true); + ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=7, longName="defaultBehaviorGroup.damageThreshold" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[7]; + ParamDef->init("damageThreshold", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The damage amount which will cause a chunk to fracture (break free) from the destructible.\n This is obtained from the damage value passed into the DestructibleActor::applyDamage,\n or DestructibleActor::applyRadiusDamage, or via impact (see 'forceToDamage', below).", true); + HintTable[1].init("shortDescription", "The damage amount which will cause a chunk to fracture (break free) from the destructible.", true); + ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=8, longName="defaultBehaviorGroup.damageToRadius" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[8]; + ParamDef->init("damageToRadius", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Controls the distance into the destructible to propagate damage. The damage applied to the chunk\n is multiplied by damageToRadius, to get the propagation distance. All chunks within the radius\n will have damage applied to them. The damage applied to each chunk varies with distance to the damage\n application position. Full damage is taken at zero distance, and zero damage at the damage radius.\n NOTE: This parameter is deprecated for point and radius damage. It will be used for those types of damage if legacy damage\n behavior is enabled with ModuleDestructible::setUseLegacyDamageRadiusSpread. Otherwise, the new parameters\n damageSpread.minimumRadius, damageSpread.radiusMultiplier, and damageSpread.falloffExponent are used. For impact damage, this parameter\n will continue to be used, however the radius will no longer scale with object size. The radius will continue\n to scale with the damage as a fraction of damageThreshold, however. If legacy damage behavior is used, this parameter\n will behave as before with respect to impact damage as well (scaling with object size).", true); + HintTable[1].init("shortDescription", "Controls the distance into the destructible to propagate damage.", true); + ParamDefTable[8].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=9, longName="defaultBehaviorGroup.damageSpread" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[9]; + ParamDef->init("damageSpread", TYPE_STRUCT, "DamageSpreadFunction", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Describes the radius and damage envelope function for damage applied to the destructible.", true); + HintTable[1].init("shortDescription", "Describes the radius and damage envelope function for damage applied to the destructible.", true); + ParamDefTable[9].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=10, longName="defaultBehaviorGroup.damageSpread.minimumRadius" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[10]; + ParamDef->init("minimumRadius", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The minimum radius of damage spread when damage is applied. The formula for the damage radius is\n radius = minimumRadius + (input radius) * radiusMultiplier.", true); + HintTable[1].init("shortDescription", "The minimum radius of damage spread when damage is applied.", true); + ParamDefTable[10].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=11, longName="defaultBehaviorGroup.damageSpread.radiusMultiplier" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[11]; + ParamDef->init("radiusMultiplier", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "A scale to apply to the input damage radius when damage is applied. The formula for the damage radius is\n radius = minimumRadius + (input radius) * radiusMultiplier.", true); + HintTable[1].init("shortDescription", "A scale to apply to the input damage radius when damage is applied.", true); + ParamDefTable[11].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=12, longName="defaultBehaviorGroup.damageSpread.falloffExponent" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[12]; + ParamDef->init("falloffExponent", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "How damage varies between the minimum radius and the calculated damage radius. The formula for the damage radius is\n radius = minimumRadius + (input radius) * radiusMultiplier.\n Within the minimumRadius, the full damage is applied to chunks. Past the minimumRadius, the formla for damage is:\n damage = (input damage) * ((radius - distance)/(radius - minimumRadius))^falloffExponent.\n Note: falloffExponent = 0.0 gives no falloff, so that damage = (input damage) over the entire range [0, radius).\n falloffExponent = 1.0 gives linear falloff.", true); + HintTable[1].init("shortDescription", "How damage varies between the minimum radius and the calculated damage radius.", true); + ParamDefTable[12].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=13, longName="defaultBehaviorGroup.damageColorSpread" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[13]; + ParamDef->init("damageColorSpread", TYPE_STRUCT, "DamageSpreadFunction", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Describes the radius and damage envelope function for color channel damage modification applied to the destructible.", true); + HintTable[1].init("shortDescription", "Describes the radius and damage envelope function for color channel damage modification applied to the destructible.", true); + ParamDefTable[13].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=14, longName="defaultBehaviorGroup.damageColorSpread.minimumRadius" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[14]; + ParamDef->init("minimumRadius", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The minimum radius of damage spread when damage is applied. The formula for the damage radius is\n radius = minimumRadius + (input radius) * radiusMultiplier.", true); + HintTable[1].init("shortDescription", "The minimum radius of damage spread when damage is applied.", true); + ParamDefTable[14].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=15, longName="defaultBehaviorGroup.damageColorSpread.radiusMultiplier" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[15]; + ParamDef->init("radiusMultiplier", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "A scale to apply to the input damage radius when damage is applied. The formula for the damage radius is\n radius = minimumRadius + (input radius) * radiusMultiplier.", true); + HintTable[1].init("shortDescription", "A scale to apply to the input damage radius when damage is applied.", true); + ParamDefTable[15].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=16, longName="defaultBehaviorGroup.damageColorSpread.falloffExponent" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[16]; + ParamDef->init("falloffExponent", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "How damage varies between the minimum radius and the calculated damage radius. The formula for the damage radius is\n radius = minimumRadius + (input radius) * radiusMultiplier.\n Within the minimumRadius, the full damage is applied to chunks. Past the minimumRadius, the formla for damage is:\n damage = (input damage) * ((radius - distance)/(radius - minimumRadius))^falloffExponent.\n Note: falloffExponent = 0.0 gives no falloff, so that damage = (input damage) over the entire range [0, radius).\n falloffExponent = 1.0 gives linear falloff.", true); + HintTable[1].init("shortDescription", "How damage varies between the minimum radius and the calculated damage radius.", true); + ParamDefTable[16].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=17, longName="defaultBehaviorGroup.damageColorChange" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[17]; + ParamDef->init("damageColorChange", TYPE_VEC4, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Describes how damage changes the color of vertices in the render mesh. If this vector is non-zero, then a dynamic\n (per-actor) color channel will be created and initialized to the asset's color channel, if it exists. Damage taken will go through\n the spread and envelope function described by damageColoring, and each color will be modified by the resulting damage, scaled\n by the values in damageColorChange. The change to color channel C is given by\n color[C] = clamp(color[C] + damageColorChange[C]*255*min(1.0, damage/damageThreshold), 0, 255).", true); + HintTable[1].init("shortDescription", "Describes how damage changes the color of vertices in the render mesh.", true); + ParamDefTable[17].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=18, longName="defaultBehaviorGroup.materialStrength" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[18]; + ParamDef->init("materialStrength", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "When a chunk takes impact damage due to physical contact (see see DestructibleDepthParameters), this parameter\n is the maximum impulse the contact can generate. Weak materials such as glass may have this set to a low value, so that\n heavier objects will pass through them during fracture.\n N.B.: Setting this parameter to 0 disables the impulse cap; that is, zero is interpreted as infinite.\n Default value = 0.0f.", true); + HintTable[1].init("shortDescription", "When a chunk takes impact, this is the maximum impulse the contact can generate.", true); + ParamDefTable[18].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=19, longName="defaultBehaviorGroup.density" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[19]; + ParamDef->init("density", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Chunk density. (TODO: better description)", true); + HintTable[1].init("shortDescription", "Chunk density", true); + ParamDefTable[19].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=20, longName="defaultBehaviorGroup.fadeOut" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[20]; + ParamDef->init("fadeOut", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Chunk fade out. (TODO: better description)", true); + HintTable[1].init("shortDescription", "Chunk fade out", true); + ParamDefTable[20].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=21, longName="defaultBehaviorGroup.maxDepenetrationVelocity" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[21]; + ParamDef->init("maxDepenetrationVelocity", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "In case some chunk is created inside static geometry it will be pushed out of it without limiting it's velocity. Sometimes it's not desirable, \n so this parameter can limit depenetration velocity. Keep in mind, that for low values you can see chunks 'floating' off the static meshes, which is also not always desirable.", true); + HintTable[1].init("shortDescription", "Chunk maximum depenetration velocity", true); + ParamDefTable[21].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=22, longName="defaultBehaviorGroup.userData" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[22]; + ParamDef->init("userData", TYPE_U64, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "User data field. This 64-bit field can be set and retrieved by the user at runtime.", true); + HintTable[1].init("shortDescription", "User data field.", true); + ParamDefTable[22].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=23, longName="behaviorGroups" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[23]; + ParamDef->init("behaviorGroups", TYPE_ARRAY, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The array of behavior groups referenced by chunks. Each chunk references a behavior group for chunk-specific reactions.", true); + HintTable[1].init("shortDescription", "The array of behavior groups referenced by chunks", true); + ParamDefTable[23].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + ParamDef->setArraySize(-1); + static const uint8_t dynHandleIndices[2] = { 1, 0, }; + ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 2); + + } + + // Initialize DefinitionImpl node: nodeIndex=24, longName="behaviorGroups[]" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[24]; + ParamDef->init("behaviorGroups", TYPE_STRUCT, "BehaviorGroup", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The array of behavior groups referenced by chunks. Each chunk references a behavior group for chunk-specific reactions.", true); + HintTable[1].init("shortDescription", "The array of behavior groups referenced by chunks", true); + ParamDefTable[24].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=25, longName="behaviorGroups[].name" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[25]; + ParamDef->init("name", TYPE_STRING, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Name of behavior group, eg Concrete or Glass.", true); + HintTable[1].init("shortDescription", "Name of behavior group", true); + ParamDefTable[25].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=26, longName="behaviorGroups[].damageThreshold" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[26]; + ParamDef->init("damageThreshold", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The damage amount which will cause a chunk to fracture (break free) from the destructible.\n This is obtained from the damage value passed into the DestructibleActor::applyDamage,\n or DestructibleActor::applyRadiusDamage, or via impact (see 'forceToDamage', below).", true); + HintTable[1].init("shortDescription", "The damage amount which will cause a chunk to fracture (break free) from the destructible.", true); + ParamDefTable[26].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=27, longName="behaviorGroups[].damageToRadius" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[27]; + ParamDef->init("damageToRadius", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Controls the distance into the destructible to propagate damage. The damage applied to the chunk\n is multiplied by damageToRadius, to get the propagation distance. All chunks within the radius\n will have damage applied to them. The damage applied to each chunk varies with distance to the damage\n application position. Full damage is taken at zero distance, and zero damage at the damage radius.\n NOTE: This parameter is deprecated for point and radius damage. It will be used for those types of damage if legacy damage\n behavior is enabled with ModuleDestructible::setUseLegacyDamageRadiusSpread. Otherwise, the new parameters\n damageSpread.minimumRadius, damageSpread.radiusMultiplier, and damageSpread.falloffExponent are used. For impact damage, this parameter\n will continue to be used, however the radius will no longer scale with object size. The radius will continue\n to scale with the damage as a fraction of damageThreshold, however. If legacy damage behavior is used, this parameter\n will behave as before with respect to impact damage as well (scaling with object size).", true); + HintTable[1].init("shortDescription", "Controls the distance into the destructible to propagate damage.", true); + ParamDefTable[27].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=28, longName="behaviorGroups[].damageSpread" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[28]; + ParamDef->init("damageSpread", TYPE_STRUCT, "DamageSpreadFunction", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Describes the radius and damage envelope function for damage applied to the destructible.", true); + HintTable[1].init("shortDescription", "Describes the radius and damage envelope function for damage applied to the destructible.", true); + ParamDefTable[28].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=29, longName="behaviorGroups[].damageSpread.minimumRadius" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[29]; + ParamDef->init("minimumRadius", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The minimum radius of damage spread when damage is applied. The formula for the damage radius is\n radius = minimumRadius + (input radius) * radiusMultiplier.", true); + HintTable[1].init("shortDescription", "The minimum radius of damage spread when damage is applied.", true); + ParamDefTable[29].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=30, longName="behaviorGroups[].damageSpread.radiusMultiplier" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[30]; + ParamDef->init("radiusMultiplier", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "A scale to apply to the input damage radius when damage is applied. The formula for the damage radius is\n radius = minimumRadius + (input radius) * radiusMultiplier.", true); + HintTable[1].init("shortDescription", "A scale to apply to the input damage radius when damage is applied.", true); + ParamDefTable[30].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=31, longName="behaviorGroups[].damageSpread.falloffExponent" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[31]; + ParamDef->init("falloffExponent", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "How damage varies between the minimum radius and the calculated damage radius. The formula for the damage radius is\n radius = minimumRadius + (input radius) * radiusMultiplier.\n Within the minimumRadius, the full damage is applied to chunks. Past the minimumRadius, the formla for damage is:\n damage = (input damage) * ((radius - distance)/(radius - minimumRadius))^falloffExponent.\n Note: falloffExponent = 0.0 gives no falloff, so that damage = (input damage) over the entire range [0, radius).\n falloffExponent = 1.0 gives linear falloff.", true); + HintTable[1].init("shortDescription", "How damage varies between the minimum radius and the calculated damage radius.", true); + ParamDefTable[31].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=32, longName="behaviorGroups[].damageColorSpread" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[32]; + ParamDef->init("damageColorSpread", TYPE_STRUCT, "DamageSpreadFunction", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Describes the radius and damage envelope function for color channel damage modification applied to the destructible.", true); + HintTable[1].init("shortDescription", "Describes the radius and damage envelope function for color channel damage modification applied to the destructible.", true); + ParamDefTable[32].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=33, longName="behaviorGroups[].damageColorSpread.minimumRadius" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[33]; + ParamDef->init("minimumRadius", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The minimum radius of damage spread when damage is applied. The formula for the damage radius is\n radius = minimumRadius + (input radius) * radiusMultiplier.", true); + HintTable[1].init("shortDescription", "The minimum radius of damage spread when damage is applied.", true); + ParamDefTable[33].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=34, longName="behaviorGroups[].damageColorSpread.radiusMultiplier" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[34]; + ParamDef->init("radiusMultiplier", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "A scale to apply to the input damage radius when damage is applied. The formula for the damage radius is\n radius = minimumRadius + (input radius) * radiusMultiplier.", true); + HintTable[1].init("shortDescription", "A scale to apply to the input damage radius when damage is applied.", true); + ParamDefTable[34].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=35, longName="behaviorGroups[].damageColorSpread.falloffExponent" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[35]; + ParamDef->init("falloffExponent", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "How damage varies between the minimum radius and the calculated damage radius. The formula for the damage radius is\n radius = minimumRadius + (input radius) * radiusMultiplier.\n Within the minimumRadius, the full damage is applied to chunks. Past the minimumRadius, the formla for damage is:\n damage = (input damage) * ((radius - distance)/(radius - minimumRadius))^falloffExponent.\n Note: falloffExponent = 0.0 gives no falloff, so that damage = (input damage) over the entire range [0, radius).\n falloffExponent = 1.0 gives linear falloff.", true); + HintTable[1].init("shortDescription", "How damage varies between the minimum radius and the calculated damage radius.", true); + ParamDefTable[35].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=36, longName="behaviorGroups[].damageColorChange" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[36]; + ParamDef->init("damageColorChange", TYPE_VEC4, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Describes how damage changes the color of vertices in the render mesh. If this vector is non-zero, then a dynamic\n (per-actor) color channel will be created and initialized to the asset's color channel, if it exists. Damage taken will go through\n the spread and envelope function described by damageColoring, and each color will be modified by the resulting damage, scaled\n by the values in damageColorChange. The change to color channel C is given by\n color[C] = clamp(color[C] + damageColorChange[C]*255*min(1.0, damage/damageThreshold), 0, 255).", true); + HintTable[1].init("shortDescription", "Describes how damage changes the color of vertices in the render mesh.", true); + ParamDefTable[36].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=37, longName="behaviorGroups[].materialStrength" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[37]; + ParamDef->init("materialStrength", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "When a chunk takes impact damage due to physical contact (see see DestructibleDepthParameters), this parameter\n is the maximum impulse the contact can generate. Weak materials such as glass may have this set to a low value, so that\n heavier objects will pass through them during fracture.\n N.B.: Setting this parameter to 0 disables the impulse cap; that is, zero is interpreted as infinite.\n Default value = 0.0f.", true); + HintTable[1].init("shortDescription", "When a chunk takes impact, this is the maximum impulse the contact can generate.", true); + ParamDefTable[37].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=38, longName="behaviorGroups[].density" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[38]; + ParamDef->init("density", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Chunk density. (TODO: better description)", true); + HintTable[1].init("shortDescription", "Chunk density", true); + ParamDefTable[38].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=39, longName="behaviorGroups[].fadeOut" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[39]; + ParamDef->init("fadeOut", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Chunk fade out. (TODO: better description)", true); + HintTable[1].init("shortDescription", "Chunk fade out", true); + ParamDefTable[39].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=40, longName="behaviorGroups[].maxDepenetrationVelocity" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[40]; + ParamDef->init("maxDepenetrationVelocity", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "In case some chunk is created inside static geometry it will be pushed out of it without limiting it's velocity. Sometimes it's not desirable, \n so this parameter can limit depenetration velocity. Keep in mind, that for low values you can see chunks 'floating' off the static meshes, which is also not always desirable.", true); + HintTable[1].init("shortDescription", "Chunk maximum depenetration velocity", true); + ParamDefTable[40].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=41, longName="behaviorGroups[].userData" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[41]; + ParamDef->init("userData", TYPE_U64, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "User data field. This 64-bit field can be set and retrieved by the user at runtime.", true); + HintTable[1].init("shortDescription", "User data field.", true); + ParamDefTable[41].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=42, longName="RTFractureBehaviorGroup" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[42]; + ParamDef->init("RTFractureBehaviorGroup", TYPE_I8, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The array of behavior groups referenced by chunks. Each chunk references a behavior group for chunk-specific reactions.", true); + HintTable[1].init("shortDescription", "The array of behavior groups referenced by chunks", true); + ParamDefTable[42].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=43, longName="chunks" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[43]; + ParamDef->init("chunks", TYPE_ARRAY, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The array of chunks. Chunks are stored breadth-first in their hierarchy.", true); + HintTable[1].init("shortDescription", "The array of chunks", true); + ParamDefTable[43].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + ParamDef->setArraySize(-1); + } + + // Initialize DefinitionImpl node: nodeIndex=44, longName="chunks[]" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[44]; + ParamDef->init("chunks", TYPE_STRUCT, "Chunk", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The array of chunks. Chunks are stored breadth-first in their hierarchy.", true); + HintTable[1].init("shortDescription", "The array of chunks", true); + ParamDefTable[44].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=45, longName="chunks[].depth" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[45]; + ParamDef->init("depth", TYPE_U16, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The depth of the chunk in the hierarchy.\n Level 0 chunks correspond to the unfractured (original) mesh. Level 1 chunks\n are their children, formed by splitting level 0 chunks, etc.", true); + HintTable[1].init("shortDescription", "The depth of the chunk in the hierarchy", true); + ParamDefTable[45].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=46, longName="chunks[].parentIndex" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[46]; + ParamDef->init("parentIndex", TYPE_U16, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The index of the chunk's parent in the hierarchy.\n If the chunk has no parent (its depth is 0), then the parentIndex is -1.", true); + HintTable[1].init("shortDescription", "The index of the chunk's parent in the hierarchy", true); + ParamDefTable[46].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=47, longName="chunks[].firstChildIndex" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[47]; + ParamDef->init("firstChildIndex", TYPE_U16, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The index of this chunk's first child in the hierarchy.\n All children have contiguous chunk indices, and lie in the range\n [firstChildIndex,firstChildIndex+numChildren-1]. If the chunk has no children,\n this value is undefined.", true); + HintTable[1].init("shortDescription", "The index of this chunk's first child in the hierarchy", true); + ParamDefTable[47].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=48, longName="chunks[].numChildren" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[48]; + ParamDef->init("numChildren", TYPE_U16, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "This chunk's number of children. If not 0, firstChildIndex\n is valid (see firstChildIndex).", true); + HintTable[1].init("shortDescription", "This chunk's number of children", true); + ParamDefTable[48].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=49, longName="chunks[].meshPartIndex" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[49]; + ParamDef->init("meshPartIndex", TYPE_U16, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If this chunk is not instanced, this is the corresponding mesh part for this chunk,\n in the ApexRenderMeshAsset included within this destructible asset. If this chunk is instanced,\n this refers to the InstanceInfo in the asset (see InstanceInfo).", true); + HintTable[1].init("shortDescription", "The corresponding mesh part for this chunk", true); + ParamDefTable[49].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=50, longName="chunks[].flags" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[50]; + ParamDef->init("flags", TYPE_U16, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("editorDisplay", "false", true); + ParamDefTable[50].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("editorDisplay", "false", true); + HintTable[1].init("longDescription", "Flags which define individual chunk attributes, such as support,\n fractureability, etc.", true); + HintTable[2].init("shortDescription", "Flags which define individual chunk attributes", true); + ParamDefTable[50].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=51, longName="chunks[].surfaceNormal" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[51]; + ParamDef->init("surfaceNormal", TYPE_VEC3, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The average surface normal of this chunk. This is the normalized\n average of all triangle normals which are part of the original (unfractured) mesh.", true); + HintTable[1].init("shortDescription", "The average surface normal of this chunk", true); + ParamDefTable[51].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=52, longName="chunks[].behaviorGroupIndex" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[52]; + ParamDef->init("behaviorGroupIndex", TYPE_I8, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Behavior group this chunk is associated with. This includes flags, damage threshold, density, impact\n resistance, and collision mask.", true); + HintTable[1].init("shortDescription", "Behavior group this chunk is associated with", true); + ParamDefTable[52].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=53, longName="chunks[].firstScatterMesh" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[53]; + ParamDef->init("firstScatterMesh", TYPE_U16, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Index of first scatter mesh (in scatterMeshIndices and scatterMeshTransforms).", true); + HintTable[1].init("shortDescription", "Index of first scatter mesh (in scatterMeshIndices and scatterMeshTransforms)", true); + ParamDefTable[53].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=54, longName="chunks[].scatterMeshCount" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[54]; + ParamDef->init("scatterMeshCount", TYPE_U16, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Number of scatter meshes (in scatterMeshIndices and scatterMeshTransforms).", true); + HintTable[1].init("shortDescription", "Number of scatter meshes (in scatterMeshIndices and scatterMeshTransforms)", true); + ParamDefTable[54].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=55, longName="chunkConvexHulls" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[55]; + ParamDef->init("chunkConvexHulls", TYPE_ARRAY, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("INCLUDED", uint64_t(1), true); + ParamDefTable[55].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("INCLUDED", uint64_t(1), true); + HintTable[1].init("longDescription", "Convex hull data for each chunk. This is not cooked convex hull data\n used for PhysX collision. These hulls are used to (a) create cooked PhysX convex hulls, and (b)\n for APEX scene queries.", true); + HintTable[2].init("shortDescription", "Convex hull data for each chunk", true); + ParamDefTable[55].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + static const char* const RefVariantVals[] = { "ConvexHullParameters" }; + ParamDefTable[55].setRefVariantVals((const char**)RefVariantVals, 1); + + + ParamDef->setArraySize(-1); + static const uint8_t dynHandleIndices[1] = { 0, }; + ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1); + + } + + // Initialize DefinitionImpl node: nodeIndex=56, longName="chunkConvexHulls[]" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[56]; + ParamDef->init("chunkConvexHulls", TYPE_REF, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("INCLUDED", uint64_t(1), true); + ParamDefTable[56].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("INCLUDED", uint64_t(1), true); + HintTable[1].init("longDescription", "Convex hull data for each chunk. This is not cooked convex hull data\n used for PhysX collision. These hulls are used to (a) create cooked PhysX convex hulls, and (b)\n for APEX scene queries.", true); + HintTable[2].init("shortDescription", "Convex hull data for each chunk", true); + ParamDefTable[56].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + static const char* const RefVariantVals[] = { "ConvexHullParameters" }; + ParamDefTable[56].setRefVariantVals((const char**)RefVariantVals, 1); + + + + } + + // Initialize DefinitionImpl node: nodeIndex=57, longName="chunkConvexHullStartIndices" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[57]; + ParamDef->init("chunkConvexHullStartIndices", TYPE_ARRAY, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Map into array of convex hulls. The convex hulls for chunk i are in\n the chunkConvexHulls array, starting at chunkConvexHulls[i], and ending at chunkConvexHulls[i+1]-1.\n The array length is one greater than that of chunkConvexHulls.", true); + HintTable[1].init("shortDescription", "Map into array of convex hulls", true); + ParamDefTable[57].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + ParamDef->setArraySize(-1); + } + + // Initialize DefinitionImpl node: nodeIndex=58, longName="chunkConvexHullStartIndices[]" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[58]; + ParamDef->init("chunkConvexHullStartIndices", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Map into array of convex hulls. The convex hulls for chunk i are in\n the chunkConvexHulls array, starting at chunkConvexHulls[i], and ending at chunkConvexHulls[i+1]-1.\n The array length is one greater than that of chunkConvexHulls.", true); + HintTable[1].init("shortDescription", "Map into array of convex hulls", true); + ParamDefTable[58].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=59, longName="destructibleParameters" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[59]; + ParamDef->init("destructibleParameters", TYPE_STRUCT, "DestructibleParameters", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The default destructible properties for this asset. These may be overridden\n for an instance (destructible actor), as a copy of the parameters is also stored in the actor.", true); + HintTable[1].init("shortDescription", "The default destructible properties for this asset", true); + ParamDefTable[59].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=60, longName="destructibleParameters.damageCap" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[60]; + ParamDef->init("damageCap", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Limits the amount of damage applied to a chunk. This is useful for preventing the entire destructible\nfrom getting pulverized by a very large application of damage. This can easily happen when impact damage is\nused, and the damage amount is proportional to the impact force (see forceToDamage).\n", true); + HintTable[1].init("shortDescription", "Limits the amount of damage applied to a chunk.", true); + ParamDefTable[60].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=61, longName="destructibleParameters.forceToDamage" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[61]; + ParamDef->init("forceToDamage", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If a chunk is at a depth which takes impact damage (see NxDestructibleDepthParameters),\nthen when a chunk has a collision in the NxScene, it will take damage equal to forceToDamage mulitplied by\nthe impact force.\nThe default value is zero, which effectively disables impact damage.\n", true); + HintTable[1].init("shortDescription", "Multiplier to calculate applied damage from an impact.", true); + ParamDefTable[61].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=62, longName="destructibleParameters.impactVelocityThreshold" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[62]; + ParamDef->init("impactVelocityThreshold", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Large impact force may be reported if rigid bodies are spawned inside one another. In this case the relative velocity of the two\nobjects will be low. This variable allows the user to set a minimum velocity threshold for impacts to ensure that the objects are\nmoving at a min velocity in order for the impact force to be considered.\n", true); + HintTable[1].init("shortDescription", "Large impact force may be reported if rigid bodies are spawned inside one another.", true); + ParamDefTable[62].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=63, longName="destructibleParameters.minimumFractureDepth" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[63]; + ParamDef->init("minimumFractureDepth", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Chunks will not be broken free below this depth.\n", true); + HintTable[1].init("shortDescription", "The chunks will not be broken free below this depth.", true); + ParamDefTable[63].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=64, longName="destructibleParameters.impactDamageDefaultDepth" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[64]; + ParamDef->init("impactDamageDefaultDepth", TYPE_I32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The default depth to which chunks will take impact damage. This default may be overridden in the depth settings.\n", true); + HintTable[1].init("shortDescription", "The default depth to which chunks will take impact damage.", true); + ParamDefTable[64].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=65, longName="destructibleParameters.debrisDepth" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[65]; + ParamDef->init("debrisDepth", TYPE_I32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The chunk hierarchy depth at which chunks are considered to be 'debris.' Chunks at this depth or\nbelow will be considered for various debris settings, such as debrisLifetime.\nNegative values indicate that no chunk depth is considered debris.\nDefault value is -1.\n", true); + HintTable[1].init("shortDescription", "The chunk hierarchy depth at which chunks are considered to be 'debris.'", true); + ParamDefTable[65].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=66, longName="destructibleParameters.essentialDepth" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[66]; + ParamDef->init("essentialDepth", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The chunk hierarchy depth up to which chunks will always be processed. These chunks are considered\nto be essential either for gameplay or visually.\nThe minimum value is 0, meaning the level 0 chunk is always considered essential.\nDefault value is 0.\n", true); + HintTable[1].init("shortDescription", "The chunk hierarchy depth up to which chunks will always be processed", true); + ParamDefTable[66].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=67, longName="destructibleParameters.debrisLifetimeMin" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[67]; + ParamDef->init("debrisLifetimeMin", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "'Debris chunks' (see debrisDepth, above) will be destroyed after a time (in seconds)\nseparated from non-debris chunks. The actual lifetime is interpolated between\ndebrisLifetimeMin and debrisLifetimeMax (see below), based upon the module\'s LOD setting.\nTo disable lifetime, clear the NxDestructibleDepthParametersFlag::DEBRIS_TIMEOUT\nflag in the flags field. If debrisLifetimeMax < debrisLifetimeMin, the mean of the two\nis used for both.\nDefault debrisLifetimeMin = 1.0, debrisLifetimeMax = 10.0f.\n", true); + HintTable[1].init("shortDescription", "Minimum time to destroy debris", true); + ParamDefTable[67].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=68, longName="destructibleParameters.debrisLifetimeMax" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[68]; + ParamDef->init("debrisLifetimeMax", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "'Debris chunks' (see debrisDepth, above) will be destroyed after a time (in seconds)\nseparated from non-debris chunks. The actual lifetime is interpolated between\ndebrisLifetimeMin (see above) and debrisLifetimeMax, based upon the module\'s LOD setting.\nTo disable lifetime, clear the NxDestructibleDepthParametersFlag::DEBRIS_TIMEOUT\nflag in the flags field. If debrisLifetimeMax < debrisLifetimeMin, the mean of the two\nis used for both.\nDefault debrisLifetimeMin = 1.0, debrisLifetimeMax = 10.0f.\n", true); + HintTable[1].init("shortDescription", "Maximum time to destroy debris", true); + ParamDefTable[68].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=69, longName="destructibleParameters.debrisMaxSeparationMin" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[69]; + ParamDef->init("debrisMaxSeparationMin", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "'Debris chunks' (see debrisDepth, above) will be destroyed if they are separated from\ntheir origin by a distance greater than maxSeparation. The actual maxSeparation is\ninterpolated between debrisMaxSeparationMin and debrisMaxSeparationMax (see below),\nbased upon the module\'s LOD setting. To disable maxSeparation, clear the\nNX_DESTRUCTIBLE_DEBRIS_MAX_SEPARATION flag in the flags field.\nIf debrisMaxSeparationMax < debrisMaxSeparationMin, the mean of the two is used for both.\nDefault debrisMaxSeparationMin = 1.0, debrisMaxSeparationMax = 10.0f.\n", true); + HintTable[1].init("shortDescription", "Minimum separation distance", true); + ParamDefTable[69].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=70, longName="destructibleParameters.debrisMaxSeparationMax" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[70]; + ParamDef->init("debrisMaxSeparationMax", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "'Debris chunks' (see debrisDepth, above) will be destroyed if they are separated from\ntheir origin by a distance greater than maxSeparation. The actual maxSeparation is\ninterpolated between debrisMaxSeparationMin (see above) and debrisMaxSeparationMax,\nbased upon the module\'s LOD setting. To disable maxSeparation, clear the\nNX_DESTRUCTIBLE_DEBRIS_MAX_SEPARATION flag in the flags field.\nIf debrisMaxSeparationMax < debrisMaxSeparationMin, the mean of the two is used for both.\nDefault debrisMaxSeparationMin = 1.0, debrisMaxSeparationMax = 10.0f.\n", true); + HintTable[1].init("shortDescription", "Minimum separation distance", true); + ParamDefTable[70].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=71, longName="destructibleParameters.debrisDestructionProbability" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[71]; + ParamDef->init("debrisDestructionProbability", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The probablity that a debris chunk, when fractured, will simply be destroyed instead of becoming dynamic or breaking down\n further into child chunks. Valid range = [0.0,1.0]. Default value = 0.0.", true); + HintTable[1].init("shortDescription", "The probablity that a debris chunk, when fractured, will simply be destroyed", true); + ParamDefTable[71].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=72, longName="destructibleParameters.validBounds" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[72]; + ParamDef->init("validBounds", TYPE_BOUNDS3, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "A bounding box around each NxDestructibleActor created, defining a range of validity\nfor chunks that break free. These bounds are scaled and translated with the\nNxDestructibleActor\'s scale and position, but they are not rotated with the\nNxDestructibleActor.\n", true); + HintTable[1].init("shortDescription", "valid bounding region for debris", true); + ParamDefTable[72].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=73, longName="destructibleParameters.maxChunkSpeed" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[73]; + ParamDef->init("maxChunkSpeed", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If greater than 0, the chunks' speeds will not be allowed to exceed this value. Use 0\nto disable this feature (this is the default).\n", true); + HintTable[1].init("shortDescription", "Maximum speed of a chunk", true); + ParamDefTable[73].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=74, longName="destructibleParameters.flags" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[74]; + ParamDef->init("flags", TYPE_STRUCT, "DestructibleParametersFlag", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "A collection of flags defined in NxDestructibleParametersFlag.\n", true); + HintTable[1].init("shortDescription", "A collection of flags defined in DestructibleParametersFlag.", true); + ParamDefTable[74].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=75, longName="destructibleParameters.flags.ACCUMULATE_DAMAGE" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[75]; + ParamDef->init("ACCUMULATE_DAMAGE", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If set, chunks will 'remember' damage applied to them, so that many applications of a damage amount\nbelow damageThreshold will eventually fracture the chunk. If not set, a single application of\ndamage must exceed damageThreshold in order to fracture the chunk.\n", true); + HintTable[1].init("shortDescription", "Determines if chunks accumulate damage", true); + ParamDefTable[75].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=76, longName="destructibleParameters.flags.DEBRIS_TIMEOUT" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[76]; + ParamDef->init("DEBRIS_TIMEOUT", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Whether or not chunks at or deeper than the 'debris' depth (see NxDestructibleParameters::debrisDepth)\nwill time out. The lifetime is a value between NxDestructibleParameters::debrisLifetimeMin and\nNxDestructibleParameters::debrisLifetimeMax, based upon the destructible module\'s LOD setting.\n", true); + HintTable[1].init("shortDescription", "Whether or not chunks at or deeper than the 'debris' depth will timeout", true); + ParamDefTable[76].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=77, longName="destructibleParameters.flags.DEBRIS_MAX_SEPARATION" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[77]; + ParamDef->init("DEBRIS_MAX_SEPARATION", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Whether or not chunks at or deeper than the 'debris' depth (see NxDestructibleParameters::debrisDepth)\nwill be removed if they separate too far from their origins. The maxSeparation is a value between\nNxDestructibleParameters::debrisMaxSeparationMin and NxDestructibleParameters::debrisMaxSeparationMax,\nbased upon the destructible module\'s LOD setting.\n", true); + HintTable[1].init("shortDescription", "Whether or not chunks at or deeper than the 'debris' depth will be removed if separated too far", true); + ParamDefTable[77].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=78, longName="destructibleParameters.flags.CRUMBLE_SMALLEST_CHUNKS" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[78]; + ParamDef->init("CRUMBLE_SMALLEST_CHUNKS", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If set, the smallest chunks may be further broken down, either by fluid crumbles (if a crumble particle\nsystem is specified in the NxDestructibleActorDesc), or by simply removing the chunk if no crumble\nparticle system is specified. Note: the 'smallest chunks' are normally defined to be the deepest level\nof the fracture hierarchy. However, they may be taken from higher levels of the hierarchy if\nNxModuleDestructible::setMaxChunkDepthOffset is called with a non-zero value.\n", true); + HintTable[1].init("shortDescription", "If set, the smallest chunks may be further broken down", true); + ParamDefTable[78].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=79, longName="destructibleParameters.flags.ACCURATE_RAYCASTS" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[79]; + ParamDef->init("ACCURATE_RAYCASTS", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If set, the NxDestructibleActor::rayCast function will search within the nearest visible chunk hit\nfor collisions with child chunks. This is used to get a better raycast position and normal, in\ncase the parent collision volume does not tightly fit the graphics mesh. The returned chunk index\nwill always be that of the visible parent that is intersected, however.\n", true); + HintTable[1].init("shortDescription", "If set, the NxDestructibleActor::rayCast function will search within the nearest visible chunk hit", true); + ParamDefTable[79].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=80, longName="destructibleParameters.flags.USE_VALID_BOUNDS" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[80]; + ParamDef->init("USE_VALID_BOUNDS", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If set, the validBounds field of NxDestructibleParameters will be used. These bounds are translated\n(but not scaled or rotated) to the origin of the destructible actor. If a chunk or chunk island moves\noutside of those bounds, it is destroyed.\n", true); + HintTable[1].init("shortDescription", "If set, the validBounds field of NxDestructibleParameters will be used.", true); + ParamDefTable[80].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=81, longName="destructibleParameters.flags.CRUMBLE_VIA_RUNTIME_FRACTURE" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[81]; + ParamDef->init("CRUMBLE_VIA_RUNTIME_FRACTURE", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If set, crumbled chunks will use the runtime fracture pipeline. The chunk will be procedurally broken\ndestroyed using either the default or a specified fracture pattern.\n", true); + HintTable[1].init("shortDescription", "If set, crumbled chunks will use the runtime fracture pipeline.", true); + ParamDefTable[81].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=82, longName="destructibleParameters.fractureImpulseScale" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[82]; + ParamDef->init("fractureImpulseScale", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Scale factor used to apply an impulse force along the normal of chunk when fractured. This is used\nin order to 'push' the pieces out as they fracture.\n", true); + HintTable[1].init("shortDescription", "Scale factor used to apply an impulse force along the normal of chunk when fractured.", true); + ParamDefTable[82].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=83, longName="destructibleParameters.damageDepthLimit" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[83]; + ParamDef->init("damageDepthLimit", TYPE_U16, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "How deep in the hierarchy damage will be propagated, relative to the chunk hit.", true); + HintTable[1].init("shortDescription", "How deep in the hierarchy damage will be propagated, relative to the chunk hit.", true); + ParamDefTable[83].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=84, longName="destructibleParameters.dynamicChunkDominanceGroup" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[84]; + ParamDef->init("dynamicChunkDominanceGroup", TYPE_U16, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Optional dominance group for dynamic chunks created when fractured. (ignored if > 31)\n", true); + HintTable[1].init("shortDescription", "Optional dominance group for dynamic chunks created when fractured.", true); + ParamDefTable[84].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=85, longName="destructibleParameters.dynamicChunksGroupsMask" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[85]; + ParamDef->init("dynamicChunksGroupsMask", TYPE_STRUCT, "GroupsMask", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Optional groups mask for dynamic chunks created when fractured.\n", true); + HintTable[1].init("shortDescription", "Optional groups mask for dynamic chunks created when fractured.", true); + ParamDefTable[85].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=86, longName="destructibleParameters.dynamicChunksGroupsMask.useGroupsMask" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[86]; + ParamDef->init("useGroupsMask", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Whether or not the groupsMask should be used. If so, then this will be applied to all NxShapes\n created to represent this destructible's chunks.", true); + HintTable[1].init("shortDescription", "Whether or not the groupsMask should be used", true); + ParamDefTable[86].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=87, longName="destructibleParameters.dynamicChunksGroupsMask.bits0" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[87]; + ParamDef->init("bits0", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If useGroupsMask is true, this is bits0 of the groups mask. See the PhysX documentation for more on groups masks.", true); + HintTable[1].init("shortDescription", "bits0 of the groups mask", true); + ParamDefTable[87].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=88, longName="destructibleParameters.dynamicChunksGroupsMask.bits1" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[88]; + ParamDef->init("bits1", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If useGroupsMask is true, this is bits1 of the groups mask. See the PhysX documentation for more on groups masks.", true); + HintTable[1].init("shortDescription", "bits1 of the groups mask", true); + ParamDefTable[88].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=89, longName="destructibleParameters.dynamicChunksGroupsMask.bits2" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[89]; + ParamDef->init("bits2", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If useGroupsMask is true, this is bits2 of the groups mask. See the PhysX documentation for more on groups masks.", true); + HintTable[1].init("shortDescription", "bits2 of the groups mask", true); + ParamDefTable[89].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=90, longName="destructibleParameters.dynamicChunksGroupsMask.bits3" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[90]; + ParamDef->init("bits3", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If useGroupsMask is true, this is bits3 of the groups mask. See the PhysX documentation for more on groups masks.", true); + HintTable[1].init("shortDescription", "bits3 of the groups mask", true); + ParamDefTable[90].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=91, longName="destructibleParameters.runtimeFracture" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[91]; + ParamDef->init("runtimeFracture", TYPE_STRUCT, "RuntimeFracture", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Runtime Fracture Settings. 'CRUMBLE_VIA_RUNTIME_FRACTURE' must be set for this to do anything.\n", true); + HintTable[1].init("shortDescription", "Runtime Fracture Settings", true); + ParamDefTable[91].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=92, longName="destructibleParameters.runtimeFracture.RuntimeFractureType" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[92]; + ParamDef->init("RuntimeFractureType", TYPE_ENUM, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("shortDescription", "Which type of fracture pattern to choose", true); + ParamDefTable[92].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + static const char* const EnumVals[] = { "VORONOI", "GLASS" }; + ParamDefTable[92].setEnumVals((const char**)EnumVals, 2); + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=93, longName="destructibleParameters.runtimeFracture.sheetFracture" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[93]; + ParamDef->init("sheetFracture", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If true, align fracture pattern to largest face. \nIf false, the fracture pattern will be aligned to the hit normal with each fracture.\n", true); + HintTable[1].init("shortDescription", "If true, align fracture pattern to largest face", true); + ParamDefTable[93].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=94, longName="destructibleParameters.runtimeFracture.depthLimit" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[94]; + ParamDef->init("depthLimit", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Number of times deep a chunk can be fractured. Can help limit the number of chunks produced by\nruntime fracture.\n", true); + HintTable[1].init("shortDescription", "Number of times deep a chunk can be fractured.", true); + ParamDefTable[94].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=95, longName="destructibleParameters.runtimeFracture.destroyIfAtDepthLimit" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[95]; + ParamDef->init("destroyIfAtDepthLimit", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If true, destroy chunks when they hit their depth limit. \nIf false, then chunks at their depth limit will not fracture but will have a force applied.\n", true); + HintTable[1].init("shortDescription", "Destroy chunk if at depth limit", true); + ParamDefTable[95].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=96, longName="destructibleParameters.runtimeFracture.minConvexSize" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[96]; + ParamDef->init("minConvexSize", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Minimum Convex Size. Minimum size of convex produced by a fracture.\n", true); + HintTable[1].init("shortDescription", "Minimum Convex Size.", true); + ParamDefTable[96].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=97, longName="destructibleParameters.runtimeFracture.impulseScale" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[97]; + ParamDef->init("impulseScale", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Scales impulse applied by a fracture.\n", true); + HintTable[1].init("shortDescription", "Scales impulse applied by a fracture.", true); + ParamDefTable[97].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=98, longName="destructibleParameters.runtimeFracture.glass" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[98]; + ParamDef->init("glass", TYPE_STRUCT, "FractureGlass", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Glass Fracture Pattern Settings.\n", true); + HintTable[1].init("shortDescription", "Glass Fracture Pattern Settings.", true); + ParamDefTable[98].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=99, longName="destructibleParameters.runtimeFracture.glass.numSectors" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[99]; + ParamDef->init("numSectors", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Number of angular slices in the glass fracture pattern. \n", true); + HintTable[1].init("shortDescription", "Number of angular slices.", true); + ParamDefTable[99].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=100, longName="destructibleParameters.runtimeFracture.glass.sectorRand" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[100]; + ParamDef->init("sectorRand", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Creates variance in the angle of slices. A value of zero results in all angular slices having the same angle.\n", true); + HintTable[1].init("shortDescription", "Creates variance in the angle of slices.", true); + ParamDefTable[100].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=101, longName="destructibleParameters.runtimeFracture.glass.firstSegmentSize" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[101]; + ParamDef->init("firstSegmentSize", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The minimum shard size. Shards below this size will not be created and thus not visible.\n", true); + HintTable[1].init("shortDescription", "The minimum shard size.", true); + ParamDefTable[101].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=102, longName="destructibleParameters.runtimeFracture.glass.segmentScale" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[102]; + ParamDef->init("segmentScale", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Scales the radial spacing in the glass fracture pattern. A larger value results in radially longer shards.\n", true); + HintTable[1].init("shortDescription", "Scales the radial spacing.", true); + ParamDefTable[102].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=103, longName="destructibleParameters.runtimeFracture.glass.segmentRand" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[103]; + ParamDef->init("segmentRand", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Creates variance in the radial size of shards. A value of zero results in a low noise circular pattern.\n", true); + HintTable[1].init("shortDescription", "Creates variance in the radial size of shards.", true); + ParamDefTable[103].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=104, longName="destructibleParameters.runtimeFracture.voronoi" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[104]; + ParamDef->init("voronoi", TYPE_STRUCT, "FractureVoronoi", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Voronoi Fracture Pattern Settings.\n", true); + HintTable[1].init("shortDescription", "Voronoi Fracture Pattern Settings.", true); + ParamDefTable[104].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=105, longName="destructibleParameters.runtimeFracture.voronoi.dimensions" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[105]; + ParamDef->init("dimensions", TYPE_VEC3, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The size of the entire block. \n", true); + HintTable[1].init("shortDescription", "The size of the entire block", true); + ParamDefTable[105].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=106, longName="destructibleParameters.runtimeFracture.voronoi.numCells" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[106]; + ParamDef->init("numCells", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Number of Cells corresponds to the number of chunks to create during the fracture, default value is only one chunk.\n", true); + HintTable[1].init("shortDescription", "Max Number of Cells to create.", true); + ParamDefTable[106].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=107, longName="destructibleParameters.runtimeFracture.voronoi.biasExp" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[107]; + ParamDef->init("biasExp", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Bias Exponential value is used in distributing voronoi points which is used to fracture the original chunk.\n", true); + HintTable[1].init("shortDescription", "Bias Exponential value.", true); + ParamDefTable[107].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=108, longName="destructibleParameters.runtimeFracture.voronoi.maxDist" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[108]; + ParamDef->init("maxDist", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "This is to prevent a illegal voronoi point that's used to generate voronoi chunks.\n", true); + HintTable[1].init("shortDescription", "The max distance a Voronoi point away from origin.", true); + ParamDefTable[108].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=109, longName="destructibleParameters.runtimeFracture.attachment" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[109]; + ParamDef->init("attachment", TYPE_STRUCT, "FractureAttachment", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Attachment Settings. Allows the sides of a runtime fracture chunk to be kinematic rather than dynamic.\n", true); + HintTable[1].init("shortDescription", "Attachment Settings", true); + ParamDefTable[109].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=110, longName="destructibleParameters.runtimeFracture.attachment.posX" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[110]; + ParamDef->init("posX", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If true, make the positive x side of the sheet an attachment point.\n", true); + HintTable[1].init("shortDescription", "Attach to positive x side of sheet.", true); + ParamDefTable[110].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=111, longName="destructibleParameters.runtimeFracture.attachment.negX" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[111]; + ParamDef->init("negX", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If true, make the negative x side of the sheet an attachment point.\n", true); + HintTable[1].init("shortDescription", "Attach to negative x side of sheet.", true); + ParamDefTable[111].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=112, longName="destructibleParameters.runtimeFracture.attachment.posY" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[112]; + ParamDef->init("posY", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If true, make the positive y side of the sheet an attachment point.\n", true); + HintTable[1].init("shortDescription", "Attach to positive y side of sheet.", true); + ParamDefTable[112].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=113, longName="destructibleParameters.runtimeFracture.attachment.negY" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[113]; + ParamDef->init("negY", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If true, make the negative y side of the sheet an attachment point.\n", true); + HintTable[1].init("shortDescription", "Attach to negative y side of sheet.", true); + ParamDefTable[113].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=114, longName="destructibleParameters.runtimeFracture.attachment.posZ" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[114]; + ParamDef->init("posZ", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If true, make the positive z side of the sheet an attachment point.\n", true); + HintTable[1].init("shortDescription", "Attach to positive z side of sheet.", true); + ParamDefTable[114].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=115, longName="destructibleParameters.runtimeFracture.attachment.negZ" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[115]; + ParamDef->init("negZ", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If true, make the negative z side of the sheet an attachment point.\n", true); + HintTable[1].init("shortDescription", "Attach to negative z side of sheet.", true); + ParamDefTable[115].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=116, longName="destructibleParameters.supportStrength" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[116]; + ParamDef->init("supportStrength", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The larger the supportStrength is, the harder it will break under stressSolver. SupportStrength should be larger\nthan 0.0 so that it is not extremely fragile.\nDefault supportStrength = -1.0 which means strength is turned off initially.\n", true); + HintTable[1].init("shortDescription", "The support strength threshold for breaking chunks in stressSolver", true); + ParamDefTable[116].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=117, longName="destructibleParameters.legacyChunkBoundsTestSetting" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[117]; + ParamDef->init("legacyChunkBoundsTestSetting", TYPE_I8, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Whether or not to use the old chunk bounds testing for damage, or use the module setting. A value of 0 forces the new method to be used.\nA positive value forces the old method to be used. Negative values cause the global (NxModuleDestructible) setting to be used.\n", true); + HintTable[1].init("shortDescription", "Whether or not to use the old chunk bounds testing for damage, or use the module setting.", true); + ParamDefTable[117].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=118, longName="destructibleParameters.legacyDamageRadiusSpreadSetting" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[118]; + ParamDef->init("legacyDamageRadiusSpreadSetting", TYPE_I8, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("END", "", true); + ParamDefTable[118].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("END", "", true); + HintTable[1].init("longDescription", "Whether or not to use the old damage spread method, or use the module setting. A value of 0 forces the new method to be used.\nA positive value forces the old method to be used. Negative values cause the global (NxModuleDestructible) setting to be used.\n", true); + HintTable[2].init("shortDescription", "Whether or not to use the old damage spread method, or use the module setting.", true); + ParamDefTable[118].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=119, longName="destructibleParameters.alwaysDrawScatterMesh" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[119]; + ParamDef->init("alwaysDrawScatterMesh", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Scatter mesh visibility is controlled by LOD. If asset has more than one depth level, scatter mesh is not drawn.\n This flag forces drawing of scatter mesh on chunks with depth > 1.", true); + HintTable[1].init("shortDescription", "Always draw scatter mesh on the chunks with depth > 1", true); + ParamDefTable[119].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=120, longName="depthParameters" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[120]; + ParamDef->init("depthParameters", TYPE_ARRAY, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The default destructible depth parameters for this asset. These\n are properties that apply to all chunks at a particular level of the hierarchy. These may be overridden\n for an instance (destructible actor), as a copy of the parameters is also stored in the actor.", true); + HintTable[1].init("shortDescription", "The default destructible depth parameters for this asset", true); + ParamDefTable[120].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + ParamDef->setArraySize(-1); + } + + // Initialize DefinitionImpl node: nodeIndex=121, longName="depthParameters[]" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[121]; + ParamDef->init("depthParameters", TYPE_STRUCT, "DestructibleDepthParameters", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The default destructible depth parameters for this asset. These\n are properties that apply to all chunks at a particular level of the hierarchy. These may be overridden\n for an instance (destructible actor), as a copy of the parameters is also stored in the actor.", true); + HintTable[1].init("shortDescription", "The default destructible depth parameters for this asset", true); + ParamDefTable[121].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=122, longName="depthParameters[].OVERRIDE_IMPACT_DAMAGE" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[122]; + ParamDef->init("OVERRIDE_IMPACT_DAMAGE", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Chunks at this hierarchy depth level will take impact damage iff OVERRIDE_IMPACT_DAMAGE_VALUE = TRUE, no matter the setting of impactDamageDefaultDepth.\n", true); + HintTable[1].init("shortDescription", "If true, chunks at this hierarchy depth level will take impact damage iff OVERRIDE_IMPACT_DAMAGE_VALUE = TRUE, no matter the setting of impactDamageDefaultDepth.", true); + ParamDefTable[122].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=123, longName="depthParameters[].OVERRIDE_IMPACT_DAMAGE_VALUE" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[123]; + ParamDef->init("OVERRIDE_IMPACT_DAMAGE_VALUE", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If OVERRIDE_IMPACT_DAMAGE = TRUE, chunks at this hierarchy depth level will take impact damage iff OVERRIDE_IMPACT_DAMAGE_VALUE = TRUE.\n", true); + HintTable[1].init("shortDescription", "If OVERRIDE_IMPACT_DAMAGE = TRUE, chunks at this hierarchy depth level will take impact damage iff OVERRIDE_IMPACT_DAMAGE_VALUE = TRUE.", true); + ParamDefTable[123].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=124, longName="depthParameters[].IGNORE_POSE_UPDATES" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[124]; + ParamDef->init("IGNORE_POSE_UPDATES", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Chunks at this depth should have pose updates ignored.\n", true); + HintTable[1].init("shortDescription", "Chunks at this depth should have pose updates ignored.", true); + ParamDefTable[124].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=125, longName="depthParameters[].IGNORE_RAYCAST_CALLBACKS" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[125]; + ParamDef->init("IGNORE_RAYCAST_CALLBACKS", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Chunks at this depth should be ignored in raycast callbacks.\n", true); + HintTable[1].init("shortDescription", "Chunks at this depth should be ignored in raycast callbacks.", true); + ParamDefTable[125].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=126, longName="depthParameters[].IGNORE_CONTACT_CALLBACKS" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[126]; + ParamDef->init("IGNORE_CONTACT_CALLBACKS", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Chunks at this depth should be ignored in contact callbacks.\n", true); + HintTable[1].init("shortDescription", "Chunks at this depth should be ignored in contact callbacks.", true); + ParamDefTable[126].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=127, longName="depthParameters[].USER_FLAG_0" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[127]; + ParamDef->init("USER_FLAG_0", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "User defined flag.\n", true); + HintTable[1].init("shortDescription", "User defined flag.", true); + ParamDefTable[127].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=128, longName="depthParameters[].USER_FLAG_1" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[128]; + ParamDef->init("USER_FLAG_1", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "User defined flag.\n", true); + HintTable[1].init("shortDescription", "User defined flag.", true); + ParamDefTable[128].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=129, longName="depthParameters[].USER_FLAG_2" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[129]; + ParamDef->init("USER_FLAG_2", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "User defined flag.\n", true); + HintTable[1].init("shortDescription", "User defined flag.", true); + ParamDefTable[129].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=130, longName="depthParameters[].USER_FLAG_3" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[130]; + ParamDef->init("USER_FLAG_3", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "User defined flag.\n", true); + HintTable[1].init("shortDescription", "User defined flag.", true); + ParamDefTable[130].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=131, longName="crumbleEmitterName" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[131]; + ParamDef->init("crumbleEmitterName", TYPE_STRING, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The name of the crumble emitter to use when crumbling\n the smallest chunks.", true); + HintTable[1].init("shortDescription", "The name of the crumble emitter to use", true); + ParamDefTable[131].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=132, longName="dustEmitterName" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[132]; + ParamDef->init("dustEmitterName", TYPE_STRING, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The name of the dust emitter to use. If defined, dust particles\n will be spawned above the chunk surface traces when a chunk is fractured.", true); + HintTable[1].init("shortDescription", "The name of the dust emitter to use", true); + ParamDefTable[132].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=133, longName="collisionData" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[133]; + ParamDef->init("collisionData", TYPE_REF, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("INCLUDED", uint64_t(1), true); + ParamDefTable[133].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("INCLUDED", uint64_t(1), true); + HintTable[1].init("longDescription", "The cooked convex data for PhysX collision. All cooked convex hulls for a set of\n scales may be included", true); + HintTable[2].init("shortDescription", "The cooked convex data for PhysX collision", true); + ParamDefTable[133].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + static const char* const RefVariantVals[] = { "DestructibleAssetCollisionDataSet" }; + ParamDefTable[133].setRefVariantVals((const char**)RefVariantVals, 1); + + + + } + + // Initialize DefinitionImpl node: nodeIndex=134, longName="renderMeshAsset" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[134]; + ParamDef->init("renderMeshAsset", TYPE_REF, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("INCLUDED", uint64_t(1), true); + ParamDefTable[134].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("INCLUDED", uint64_t(1), true); + HintTable[1].init("longDescription", "The included render mesh asset.", true); + HintTable[2].init("shortDescription", "The included render mesh asset", true); + ParamDefTable[134].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + static const char* const RefVariantVals[] = { "RenderMeshAssetParameters" }; + ParamDefTable[134].setRefVariantVals((const char**)RefVariantVals, 1); + + + + } + + // Initialize DefinitionImpl node: nodeIndex=135, longName="initialDestructibleActorAllowanceForInstancing" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[135]; + ParamDef->init("initialDestructibleActorAllowanceForInstancing", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Initial actor estimate for instance buffer allocation.\n Used for setting instance buffer sizes.", true); + HintTable[1].init("shortDescription", "Initial actor estimate for instance buffer allocation", true); + ParamDefTable[135].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=136, longName="chunkInstanceInfo" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[136]; + ParamDef->init("chunkInstanceInfo", TYPE_ARRAY, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Per-instance data for each instanced chunk.", true); + HintTable[1].init("shortDescription", "Per-instance data for each instanced chunk", true); + ParamDefTable[136].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + ParamDef->setArraySize(-1); + } + + // Initialize DefinitionImpl node: nodeIndex=137, longName="chunkInstanceInfo[]" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[137]; + ParamDef->init("chunkInstanceInfo", TYPE_STRUCT, "InstanceInfo", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Per-instance data for each instanced chunk.", true); + HintTable[1].init("shortDescription", "Per-instance data for each instanced chunk", true); + ParamDefTable[137].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=138, longName="chunkInstanceInfo[].partIndex" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[138]; + ParamDef->init("partIndex", TYPE_U16, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The part instanced for this chunk.", true); + HintTable[1].init("shortDescription", "The part instanced for this chunk", true); + ParamDefTable[138].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=139, longName="chunkInstanceInfo[].chunkPositionOffset" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[139]; + ParamDef->init("chunkPositionOffset", TYPE_VEC3, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Translation for this chunk mesh within the asset.\n Normally a chunk needs no translation, but if a chunk is instanced within\n the asset, then this translation is needed.", true); + HintTable[1].init("shortDescription", "Translation for this chunk mesh within the asset", true); + ParamDefTable[139].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=140, longName="chunkInstanceInfo[].chunkUVOffset" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[140]; + ParamDef->init("chunkUVOffset", TYPE_VEC2, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "UV translation for this chunk mesh's vertices.", true); + HintTable[1].init("shortDescription", "UV translation for this chunk mesh's vertices", true); + ParamDefTable[140].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=141, longName="staticMaterialNames" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[141]; + ParamDef->init("staticMaterialNames", TYPE_ARRAY, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Alternative material names for the static render mesh, if it's created.", true); + HintTable[1].init("shortDescription", "Alternative material names for the static render mesh, if it's created", true); + ParamDefTable[141].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + ParamDef->setArraySize(-1); + static const uint8_t dynHandleIndices[1] = { 0, }; + ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1); + + } + + // Initialize DefinitionImpl node: nodeIndex=142, longName="staticMaterialNames[]" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[142]; + ParamDef->init("staticMaterialNames", TYPE_STRING, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Alternative material names for the static render mesh, if it's created.", true); + HintTable[1].init("shortDescription", "Alternative material names for the static render mesh, if it's created", true); + ParamDefTable[142].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=143, longName="neighborPadding" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[143]; + ParamDef->init("neighborPadding", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Padding used for chunk neighbor tests. This padding is relative to the largest diagonal\n of the asset's local bounding box.\n This value must be non-negative.\n Default value = 0.001f.", true); + HintTable[1].init("shortDescription", "Padding used for chunk neighbor tests.", true); + ParamDefTable[143].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=144, longName="overlapsAtDepth" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[144]; + ParamDef->init("overlapsAtDepth", TYPE_ARRAY, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("INCLUDED", uint64_t(1), true); + ParamDefTable[144].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("INCLUDED", uint64_t(1), true); + HintTable[1].init("longDescription", "The chunk overlaps (adjacencies) at each depth of the hierarchy.", true); + HintTable[2].init("shortDescription", "The chunk overlaps at each depth of the hierarchy", true); + ParamDefTable[144].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + static const char* const RefVariantVals[] = { "CachedOverlaps" }; + ParamDefTable[144].setRefVariantVals((const char**)RefVariantVals, 1); + + + ParamDef->setArraySize(-1); + static const uint8_t dynHandleIndices[1] = { 0, }; + ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1); + + } + + // Initialize DefinitionImpl node: nodeIndex=145, longName="overlapsAtDepth[]" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[145]; + ParamDef->init("overlapsAtDepth", TYPE_REF, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("INCLUDED", uint64_t(1), true); + ParamDefTable[145].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("INCLUDED", uint64_t(1), true); + HintTable[1].init("longDescription", "The chunk overlaps (adjacencies) at each depth of the hierarchy.", true); + HintTable[2].init("shortDescription", "The chunk overlaps at each depth of the hierarchy", true); + ParamDefTable[145].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + static const char* const RefVariantVals[] = { "CachedOverlaps" }; + ParamDefTable[145].setRefVariantVals((const char**)RefVariantVals, 1); + + + + } + + // Initialize DefinitionImpl node: nodeIndex=146, longName="firstChunkAtDepth" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[146]; + ParamDef->init("firstChunkAtDepth", TYPE_ARRAY, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The first index of chunks at each depth in the hierarchy. All chunks\n at a given depth are stored contiguously.", true); + HintTable[1].init("shortDescription", "The first index of chunks at each depth", true); + ParamDefTable[146].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + ParamDef->setArraySize(-1); + } + + // Initialize DefinitionImpl node: nodeIndex=147, longName="firstChunkAtDepth[]" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[147]; + ParamDef->init("firstChunkAtDepth", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The first index of chunks at each depth in the hierarchy. All chunks\n at a given depth are stored contiguously.", true); + HintTable[1].init("shortDescription", "The first index of chunks at each depth", true); + ParamDefTable[147].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=148, longName="supportDepth" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[148]; + ParamDef->init("supportDepth", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The chunk hierarchy depth at which to create a support graph. Higher depth levels give more detailed support,\nbut will give a higher computational load. Chunks below the support depth will never be supported.\n", true); + HintTable[1].init("shortDescription", "The chunk hierarchy depth at which to create a support graph.", true); + ParamDefTable[148].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=149, longName="formExtendedStructures" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[149]; + ParamDef->init("formExtendedStructures", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If initially static, the destructible will become part of an extended support structure if it is\nin contact with another static destructible that also has this flag set.\n", true); + HintTable[1].init("shortDescription", "If initially static, the destructible will become part of an extended support structure if it is in contact with another static destructible that also has this flag set.", true); + ParamDefTable[149].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=150, longName="useAssetDefinedSupport" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[150]; + ParamDef->init("useAssetDefinedSupport", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If set, then chunks which are tagged as 'support' chunks (via DestructibleChunkDesc::isSupportChunk)\nwill have environmental support in static destructibles.\nNote: if both ASSET_DEFINED_SUPPORT and WORLD_SUPPORT are set, then chunks must be tagged as\n'support' chunks AND overlap the PxScene's static geometry in order to be environmentally supported.\n", true); + HintTable[1].init("shortDescription", "If set, then chunks which are tagged as 'support' chunks", true); + ParamDefTable[150].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=151, longName="useWorldSupport" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[151]; + ParamDef->init("useWorldSupport", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If set, then chunks which overlap the PxScene\'s static geometry will have environmental support in\nstatic destructibles.\nNote: if both ASSET_DEFINED_SUPPORT and WORLD_SUPPORT are set, then chunks must be tagged as\n'support' chunks AND overlap the PxScene's static geometry in order to be environmentally supported.\n", true); + HintTable[1].init("shortDescription", "If set, then chunks which overlap the PxScene's static geometry will have environmental support", true); + ParamDefTable[151].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=152, longName="actorTransforms" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[152]; + ParamDef->init("actorTransforms", TYPE_ARRAY, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "List of actor poses (that may contain scaling) which may be saved in the asset for convenience.", true); + HintTable[1].init("shortDescription", "List of actor poses (that may contain scaling) which may be saved in the asset for convenience", true); + ParamDefTable[152].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + ParamDef->setArraySize(-1); + } + + // Initialize DefinitionImpl node: nodeIndex=153, longName="actorTransforms[]" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[153]; + ParamDef->init("actorTransforms", TYPE_MAT44, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "List of actor poses (that may contain scaling) which may be saved in the asset for convenience.", true); + HintTable[1].init("shortDescription", "List of actor poses (that may contain scaling) which may be saved in the asset for convenience", true); + ParamDefTable[153].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=154, longName="scatterMeshAssets" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[154]; + ParamDef->init("scatterMeshAssets", TYPE_ARRAY, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("INCLUDED", uint64_t(1), true); + ParamDefTable[154].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("INCLUDED", uint64_t(1), true); + HintTable[1].init("longDescription", "The included scatter mesh asset.", true); + HintTable[2].init("shortDescription", "The included scatter mesh assets", true); + ParamDefTable[154].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + static const char* const RefVariantVals[] = { "RenderMeshAssetParameters" }; + ParamDefTable[154].setRefVariantVals((const char**)RefVariantVals, 1); + + + ParamDef->setArraySize(-1); + static const uint8_t dynHandleIndices[1] = { 0, }; + ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1); + + } + + // Initialize DefinitionImpl node: nodeIndex=155, longName="scatterMeshAssets[]" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[155]; + ParamDef->init("scatterMeshAssets", TYPE_REF, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("INCLUDED", uint64_t(1), true); + ParamDefTable[155].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("INCLUDED", uint64_t(1), true); + HintTable[1].init("longDescription", "The included scatter mesh asset.", true); + HintTable[2].init("shortDescription", "The included scatter mesh assets", true); + ParamDefTable[155].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + static const char* const RefVariantVals[] = { "RenderMeshAssetParameters" }; + ParamDefTable[155].setRefVariantVals((const char**)RefVariantVals, 1); + + + + } + + // Initialize DefinitionImpl node: nodeIndex=156, longName="scatterMeshIndices" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[156]; + ParamDef->init("scatterMeshIndices", TYPE_ARRAY, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Array of indices for scatter meshes defined in the asset. Valid indices must be in the range [0,N), where N is the size of the scatterMeshAssets array.", true); + HintTable[1].init("shortDescription", "Array of indices for scatter meshes defined in the asset", true); + ParamDefTable[156].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + ParamDef->setArraySize(-1); + } + + // Initialize DefinitionImpl node: nodeIndex=157, longName="scatterMeshIndices[]" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[157]; + ParamDef->init("scatterMeshIndices", TYPE_U8, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Array of indices for scatter meshes defined in the asset. Valid indices must be in the range [0,N), where N is the size of the scatterMeshAssets array.", true); + HintTable[1].init("shortDescription", "Array of indices for scatter meshes defined in the asset", true); + ParamDefTable[157].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=158, longName="scatterMeshTransforms" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[158]; + ParamDef->init("scatterMeshTransforms", TYPE_ARRAY, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Array of chunk-relative transforms for scatter meshes defined in the asset. Must be the same size as scatterMeshIndices.", true); + HintTable[1].init("shortDescription", "Array of chunk-relative transforms for scatter meshes defined in the asset", true); + ParamDefTable[158].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + ParamDef->setArraySize(-1); + } + + // Initialize DefinitionImpl node: nodeIndex=159, longName="scatterMeshTransforms[]" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[159]; + ParamDef->init("scatterMeshTransforms", TYPE_MAT44, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Array of chunk-relative transforms for scatter meshes defined in the asset. Must be the same size as scatterMeshIndices.", true); + HintTable[1].init("shortDescription", "Array of chunk-relative transforms for scatter meshes defined in the asset", true); + ParamDefTable[159].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // SetChildren for: nodeIndex=0, longName="" + { + static Definition* Children[30]; + Children[0] = PDEF_PTR(1); + Children[1] = PDEF_PTR(2); + Children[2] = PDEF_PTR(3); + Children[3] = PDEF_PTR(4); + Children[4] = PDEF_PTR(5); + Children[5] = PDEF_PTR(23); + Children[6] = PDEF_PTR(42); + Children[7] = PDEF_PTR(43); + Children[8] = PDEF_PTR(55); + Children[9] = PDEF_PTR(57); + Children[10] = PDEF_PTR(59); + Children[11] = PDEF_PTR(120); + Children[12] = PDEF_PTR(131); + Children[13] = PDEF_PTR(132); + Children[14] = PDEF_PTR(133); + Children[15] = PDEF_PTR(134); + Children[16] = PDEF_PTR(135); + Children[17] = PDEF_PTR(136); + Children[18] = PDEF_PTR(141); + Children[19] = PDEF_PTR(143); + Children[20] = PDEF_PTR(144); + Children[21] = PDEF_PTR(146); + Children[22] = PDEF_PTR(148); + Children[23] = PDEF_PTR(149); + Children[24] = PDEF_PTR(150); + Children[25] = PDEF_PTR(151); + Children[26] = PDEF_PTR(152); + Children[27] = PDEF_PTR(154); + Children[28] = PDEF_PTR(156); + Children[29] = PDEF_PTR(158); + + ParamDefTable[0].setChildren(Children, 30); + } + + // SetChildren for: nodeIndex=5, longName="defaultBehaviorGroup" + { + static Definition* Children[11]; + Children[0] = PDEF_PTR(6); + Children[1] = PDEF_PTR(7); + Children[2] = PDEF_PTR(8); + Children[3] = PDEF_PTR(9); + Children[4] = PDEF_PTR(13); + Children[5] = PDEF_PTR(17); + Children[6] = PDEF_PTR(18); + Children[7] = PDEF_PTR(19); + Children[8] = PDEF_PTR(20); + Children[9] = PDEF_PTR(21); + Children[10] = PDEF_PTR(22); + + ParamDefTable[5].setChildren(Children, 11); + } + + // SetChildren for: nodeIndex=9, longName="defaultBehaviorGroup.damageSpread" + { + static Definition* Children[3]; + Children[0] = PDEF_PTR(10); + Children[1] = PDEF_PTR(11); + Children[2] = PDEF_PTR(12); + + ParamDefTable[9].setChildren(Children, 3); + } + + // SetChildren for: nodeIndex=13, longName="defaultBehaviorGroup.damageColorSpread" + { + static Definition* Children[3]; + Children[0] = PDEF_PTR(14); + Children[1] = PDEF_PTR(15); + Children[2] = PDEF_PTR(16); + + ParamDefTable[13].setChildren(Children, 3); + } + + // SetChildren for: nodeIndex=23, longName="behaviorGroups" + { + static Definition* Children[1]; + Children[0] = PDEF_PTR(24); + + ParamDefTable[23].setChildren(Children, 1); + } + + // SetChildren for: nodeIndex=24, longName="behaviorGroups[]" + { + static Definition* Children[11]; + Children[0] = PDEF_PTR(25); + Children[1] = PDEF_PTR(26); + Children[2] = PDEF_PTR(27); + Children[3] = PDEF_PTR(28); + Children[4] = PDEF_PTR(32); + Children[5] = PDEF_PTR(36); + Children[6] = PDEF_PTR(37); + Children[7] = PDEF_PTR(38); + Children[8] = PDEF_PTR(39); + Children[9] = PDEF_PTR(40); + Children[10] = PDEF_PTR(41); + + ParamDefTable[24].setChildren(Children, 11); + } + + // SetChildren for: nodeIndex=28, longName="behaviorGroups[].damageSpread" + { + static Definition* Children[3]; + Children[0] = PDEF_PTR(29); + Children[1] = PDEF_PTR(30); + Children[2] = PDEF_PTR(31); + + ParamDefTable[28].setChildren(Children, 3); + } + + // SetChildren for: nodeIndex=32, longName="behaviorGroups[].damageColorSpread" + { + static Definition* Children[3]; + Children[0] = PDEF_PTR(33); + Children[1] = PDEF_PTR(34); + Children[2] = PDEF_PTR(35); + + ParamDefTable[32].setChildren(Children, 3); + } + + // SetChildren for: nodeIndex=43, longName="chunks" + { + static Definition* Children[1]; + Children[0] = PDEF_PTR(44); + + ParamDefTable[43].setChildren(Children, 1); + } + + // SetChildren for: nodeIndex=44, longName="chunks[]" + { + static Definition* Children[10]; + Children[0] = PDEF_PTR(45); + Children[1] = PDEF_PTR(46); + Children[2] = PDEF_PTR(47); + Children[3] = PDEF_PTR(48); + Children[4] = PDEF_PTR(49); + Children[5] = PDEF_PTR(50); + Children[6] = PDEF_PTR(51); + Children[7] = PDEF_PTR(52); + Children[8] = PDEF_PTR(53); + Children[9] = PDEF_PTR(54); + + ParamDefTable[44].setChildren(Children, 10); + } + + // SetChildren for: nodeIndex=55, longName="chunkConvexHulls" + { + static Definition* Children[1]; + Children[0] = PDEF_PTR(56); + + ParamDefTable[55].setChildren(Children, 1); + } + + // SetChildren for: nodeIndex=57, longName="chunkConvexHullStartIndices" + { + static Definition* Children[1]; + Children[0] = PDEF_PTR(58); + + ParamDefTable[57].setChildren(Children, 1); + } + + // SetChildren for: nodeIndex=59, longName="destructibleParameters" + { + static Definition* Children[24]; + Children[0] = PDEF_PTR(60); + Children[1] = PDEF_PTR(61); + Children[2] = PDEF_PTR(62); + Children[3] = PDEF_PTR(63); + Children[4] = PDEF_PTR(64); + Children[5] = PDEF_PTR(65); + Children[6] = PDEF_PTR(66); + Children[7] = PDEF_PTR(67); + Children[8] = PDEF_PTR(68); + Children[9] = PDEF_PTR(69); + Children[10] = PDEF_PTR(70); + Children[11] = PDEF_PTR(71); + Children[12] = PDEF_PTR(72); + Children[13] = PDEF_PTR(73); + Children[14] = PDEF_PTR(74); + Children[15] = PDEF_PTR(82); + Children[16] = PDEF_PTR(83); + Children[17] = PDEF_PTR(84); + Children[18] = PDEF_PTR(85); + Children[19] = PDEF_PTR(91); + Children[20] = PDEF_PTR(116); + Children[21] = PDEF_PTR(117); + Children[22] = PDEF_PTR(118); + Children[23] = PDEF_PTR(119); + + ParamDefTable[59].setChildren(Children, 24); + } + + // SetChildren for: nodeIndex=74, longName="destructibleParameters.flags" + { + static Definition* Children[7]; + Children[0] = PDEF_PTR(75); + Children[1] = PDEF_PTR(76); + Children[2] = PDEF_PTR(77); + Children[3] = PDEF_PTR(78); + Children[4] = PDEF_PTR(79); + Children[5] = PDEF_PTR(80); + Children[6] = PDEF_PTR(81); + + ParamDefTable[74].setChildren(Children, 7); + } + + // SetChildren for: nodeIndex=85, longName="destructibleParameters.dynamicChunksGroupsMask" + { + static Definition* Children[5]; + Children[0] = PDEF_PTR(86); + Children[1] = PDEF_PTR(87); + Children[2] = PDEF_PTR(88); + Children[3] = PDEF_PTR(89); + Children[4] = PDEF_PTR(90); + + ParamDefTable[85].setChildren(Children, 5); + } + + // SetChildren for: nodeIndex=91, longName="destructibleParameters.runtimeFracture" + { + static Definition* Children[9]; + Children[0] = PDEF_PTR(92); + Children[1] = PDEF_PTR(93); + Children[2] = PDEF_PTR(94); + Children[3] = PDEF_PTR(95); + Children[4] = PDEF_PTR(96); + Children[5] = PDEF_PTR(97); + Children[6] = PDEF_PTR(98); + Children[7] = PDEF_PTR(104); + Children[8] = PDEF_PTR(109); + + ParamDefTable[91].setChildren(Children, 9); + } + + // SetChildren for: nodeIndex=98, longName="destructibleParameters.runtimeFracture.glass" + { + static Definition* Children[5]; + Children[0] = PDEF_PTR(99); + Children[1] = PDEF_PTR(100); + Children[2] = PDEF_PTR(101); + Children[3] = PDEF_PTR(102); + Children[4] = PDEF_PTR(103); + + ParamDefTable[98].setChildren(Children, 5); + } + + // SetChildren for: nodeIndex=104, longName="destructibleParameters.runtimeFracture.voronoi" + { + static Definition* Children[4]; + Children[0] = PDEF_PTR(105); + Children[1] = PDEF_PTR(106); + Children[2] = PDEF_PTR(107); + Children[3] = PDEF_PTR(108); + + ParamDefTable[104].setChildren(Children, 4); + } + + // SetChildren for: nodeIndex=109, longName="destructibleParameters.runtimeFracture.attachment" + { + static Definition* Children[6]; + Children[0] = PDEF_PTR(110); + Children[1] = PDEF_PTR(111); + Children[2] = PDEF_PTR(112); + Children[3] = PDEF_PTR(113); + Children[4] = PDEF_PTR(114); + Children[5] = PDEF_PTR(115); + + ParamDefTable[109].setChildren(Children, 6); + } + + // SetChildren for: nodeIndex=120, longName="depthParameters" + { + static Definition* Children[1]; + Children[0] = PDEF_PTR(121); + + ParamDefTable[120].setChildren(Children, 1); + } + + // SetChildren for: nodeIndex=121, longName="depthParameters[]" + { + static Definition* Children[9]; + Children[0] = PDEF_PTR(122); + Children[1] = PDEF_PTR(123); + Children[2] = PDEF_PTR(124); + Children[3] = PDEF_PTR(125); + Children[4] = PDEF_PTR(126); + Children[5] = PDEF_PTR(127); + Children[6] = PDEF_PTR(128); + Children[7] = PDEF_PTR(129); + Children[8] = PDEF_PTR(130); + + ParamDefTable[121].setChildren(Children, 9); + } + + // SetChildren for: nodeIndex=136, longName="chunkInstanceInfo" + { + static Definition* Children[1]; + Children[0] = PDEF_PTR(137); + + ParamDefTable[136].setChildren(Children, 1); + } + + // SetChildren for: nodeIndex=137, longName="chunkInstanceInfo[]" + { + static Definition* Children[3]; + Children[0] = PDEF_PTR(138); + Children[1] = PDEF_PTR(139); + Children[2] = PDEF_PTR(140); + + ParamDefTable[137].setChildren(Children, 3); + } + + // SetChildren for: nodeIndex=141, longName="staticMaterialNames" + { + static Definition* Children[1]; + Children[0] = PDEF_PTR(142); + + ParamDefTable[141].setChildren(Children, 1); + } + + // SetChildren for: nodeIndex=144, longName="overlapsAtDepth" + { + static Definition* Children[1]; + Children[0] = PDEF_PTR(145); + + ParamDefTable[144].setChildren(Children, 1); + } + + // SetChildren for: nodeIndex=146, longName="firstChunkAtDepth" + { + static Definition* Children[1]; + Children[0] = PDEF_PTR(147); + + ParamDefTable[146].setChildren(Children, 1); + } + + // SetChildren for: nodeIndex=152, longName="actorTransforms" + { + static Definition* Children[1]; + Children[0] = PDEF_PTR(153); + + ParamDefTable[152].setChildren(Children, 1); + } + + // SetChildren for: nodeIndex=154, longName="scatterMeshAssets" + { + static Definition* Children[1]; + Children[0] = PDEF_PTR(155); + + ParamDefTable[154].setChildren(Children, 1); + } + + // SetChildren for: nodeIndex=156, longName="scatterMeshIndices" + { + static Definition* Children[1]; + Children[0] = PDEF_PTR(157); + + ParamDefTable[156].setChildren(Children, 1); + } + + // SetChildren for: nodeIndex=158, longName="scatterMeshTransforms" + { + static Definition* Children[1]; + Children[0] = PDEF_PTR(159); + + ParamDefTable[158].setChildren(Children, 1); + } + + mBuiltFlag = true; + +} +void DestructibleAssetParameters::initStrings(void) +{ + comments.isAllocated = true; + comments.buf = NULL; + defaultBehaviorGroup.name.isAllocated = true; + defaultBehaviorGroup.name.buf = NULL; + crumbleEmitterName.isAllocated = true; + crumbleEmitterName.buf = NULL; + dustEmitterName.isAllocated = true; + dustEmitterName.buf = NULL; +} + +void DestructibleAssetParameters::initDynamicArrays(void) +{ + behaviorGroups.buf = NULL; + behaviorGroups.isAllocated = true; + behaviorGroups.elementSize = sizeof(BehaviorGroup_Type); + behaviorGroups.arraySizes[0] = 0; + chunks.buf = NULL; + chunks.isAllocated = true; + chunks.elementSize = sizeof(Chunk_Type); + chunks.arraySizes[0] = 0; + chunkConvexHulls.buf = NULL; + chunkConvexHulls.isAllocated = true; + chunkConvexHulls.elementSize = sizeof(NvParameterized::Interface*); + chunkConvexHulls.arraySizes[0] = 0; + chunkConvexHullStartIndices.buf = NULL; + chunkConvexHullStartIndices.isAllocated = true; + chunkConvexHullStartIndices.elementSize = sizeof(uint32_t); + chunkConvexHullStartIndices.arraySizes[0] = 0; + depthParameters.buf = NULL; + depthParameters.isAllocated = true; + depthParameters.elementSize = sizeof(DestructibleDepthParameters_Type); + depthParameters.arraySizes[0] = 0; + chunkInstanceInfo.buf = NULL; + chunkInstanceInfo.isAllocated = true; + chunkInstanceInfo.elementSize = sizeof(InstanceInfo_Type); + chunkInstanceInfo.arraySizes[0] = 0; + staticMaterialNames.buf = NULL; + staticMaterialNames.isAllocated = true; + staticMaterialNames.elementSize = sizeof(NvParameterized::DummyStringStruct); + staticMaterialNames.arraySizes[0] = 0; + overlapsAtDepth.buf = NULL; + overlapsAtDepth.isAllocated = true; + overlapsAtDepth.elementSize = sizeof(NvParameterized::Interface*); + overlapsAtDepth.arraySizes[0] = 0; + firstChunkAtDepth.buf = NULL; + firstChunkAtDepth.isAllocated = true; + firstChunkAtDepth.elementSize = sizeof(uint32_t); + firstChunkAtDepth.arraySizes[0] = 0; + actorTransforms.buf = NULL; + actorTransforms.isAllocated = true; + actorTransforms.elementSize = sizeof(physx::PxMat44); + actorTransforms.arraySizes[0] = 0; + scatterMeshAssets.buf = NULL; + scatterMeshAssets.isAllocated = true; + scatterMeshAssets.elementSize = sizeof(NvParameterized::Interface*); + scatterMeshAssets.arraySizes[0] = 0; + scatterMeshIndices.buf = NULL; + scatterMeshIndices.isAllocated = true; + scatterMeshIndices.elementSize = sizeof(uint8_t); + scatterMeshIndices.arraySizes[0] = 0; + scatterMeshTransforms.buf = NULL; + scatterMeshTransforms.isAllocated = true; + scatterMeshTransforms.elementSize = sizeof(physx::PxMat44); + scatterMeshTransforms.arraySizes[0] = 0; +} + +void DestructibleAssetParameters::initDefaults(void) +{ + + freeStrings(); + freeReferences(); + freeDynamicArrays(); + depthCount = uint32_t(0); + originalDepthCount = uint32_t(0); + defaultBehaviorGroup.damageThreshold = float(1); + defaultBehaviorGroup.damageToRadius = float(0.1); + defaultBehaviorGroup.damageSpread.minimumRadius = float(0); + defaultBehaviorGroup.damageSpread.radiusMultiplier = float(1); + defaultBehaviorGroup.damageSpread.falloffExponent = float(1); + defaultBehaviorGroup.damageColorSpread.minimumRadius = float(0); + defaultBehaviorGroup.damageColorSpread.radiusMultiplier = float(1); + defaultBehaviorGroup.damageColorSpread.falloffExponent = float(1); + defaultBehaviorGroup.damageColorChange = physx::PxVec4(initVec4(0, 0, 0, 0)); + defaultBehaviorGroup.materialStrength = float(0); + defaultBehaviorGroup.density = float(0); + defaultBehaviorGroup.fadeOut = float(1); + defaultBehaviorGroup.maxDepenetrationVelocity = float(PX_MAX_F32); + defaultBehaviorGroup.userData = uint64_t(0); + RTFractureBehaviorGroup = int8_t(-1); + destructibleParameters.damageCap = float(0); + destructibleParameters.forceToDamage = float(0); + destructibleParameters.impactVelocityThreshold = float(0); + destructibleParameters.minimumFractureDepth = uint32_t(0); + destructibleParameters.impactDamageDefaultDepth = int32_t(-1); + destructibleParameters.debrisDepth = int32_t(-1); + destructibleParameters.essentialDepth = uint32_t(0); + destructibleParameters.debrisLifetimeMin = float(1); + destructibleParameters.debrisLifetimeMax = float(10); + destructibleParameters.debrisMaxSeparationMin = float(1); + destructibleParameters.debrisMaxSeparationMax = float(10); + destructibleParameters.debrisDestructionProbability = float(0); + destructibleParameters.validBounds = physx::PxBounds3(init(-1000, -1000, -1000, 1000, 1000, 1000)); + destructibleParameters.maxChunkSpeed = float(0); + destructibleParameters.flags.ACCUMULATE_DAMAGE = bool(true); + destructibleParameters.flags.DEBRIS_TIMEOUT = bool(false); + destructibleParameters.flags.DEBRIS_MAX_SEPARATION = bool(false); + destructibleParameters.flags.CRUMBLE_SMALLEST_CHUNKS = bool(false); + destructibleParameters.flags.ACCURATE_RAYCASTS = bool(false); + destructibleParameters.flags.USE_VALID_BOUNDS = bool(false); + destructibleParameters.flags.CRUMBLE_VIA_RUNTIME_FRACTURE = bool(false); + destructibleParameters.fractureImpulseScale = float(0); + destructibleParameters.damageDepthLimit = uint16_t(UINT16_MAX); + destructibleParameters.dynamicChunkDominanceGroup = uint16_t(UINT16_MAX); + destructibleParameters.dynamicChunksGroupsMask.useGroupsMask = bool(false); + destructibleParameters.dynamicChunksGroupsMask.bits0 = uint32_t(0); + destructibleParameters.dynamicChunksGroupsMask.bits1 = uint32_t(0); + destructibleParameters.dynamicChunksGroupsMask.bits2 = uint32_t(0); + destructibleParameters.dynamicChunksGroupsMask.bits3 = uint32_t(0); + destructibleParameters.runtimeFracture.RuntimeFractureType = (const char*)"VORONOI"; + destructibleParameters.runtimeFracture.sheetFracture = bool(true); + destructibleParameters.runtimeFracture.depthLimit = uint32_t(2); + destructibleParameters.runtimeFracture.destroyIfAtDepthLimit = bool(false); + destructibleParameters.runtimeFracture.minConvexSize = float(0.02); + destructibleParameters.runtimeFracture.impulseScale = float(1); + destructibleParameters.runtimeFracture.glass.numSectors = uint32_t(10); + destructibleParameters.runtimeFracture.glass.sectorRand = float(0.3); + destructibleParameters.runtimeFracture.glass.firstSegmentSize = float(0.06); + destructibleParameters.runtimeFracture.glass.segmentScale = float(1.4); + destructibleParameters.runtimeFracture.glass.segmentRand = float(0.3); + destructibleParameters.runtimeFracture.voronoi.dimensions = physx::PxVec3(physx::PxVec3(10.0f)); + destructibleParameters.runtimeFracture.voronoi.numCells = uint32_t(1); + destructibleParameters.runtimeFracture.voronoi.biasExp = float(10); + destructibleParameters.runtimeFracture.voronoi.maxDist = float(PX_MAX_F32); + destructibleParameters.runtimeFracture.attachment.posX = bool(false); + destructibleParameters.runtimeFracture.attachment.negX = bool(false); + destructibleParameters.runtimeFracture.attachment.posY = bool(false); + destructibleParameters.runtimeFracture.attachment.negY = bool(false); + destructibleParameters.runtimeFracture.attachment.posZ = bool(false); + destructibleParameters.runtimeFracture.attachment.negZ = bool(false); + destructibleParameters.supportStrength = float(-1); + destructibleParameters.legacyChunkBoundsTestSetting = int8_t(-1); + destructibleParameters.legacyDamageRadiusSpreadSetting = int8_t(-1); + destructibleParameters.alwaysDrawScatterMesh = bool(false); + initialDestructibleActorAllowanceForInstancing = uint32_t(0); + neighborPadding = float(0.001); + supportDepth = uint32_t(0); + formExtendedStructures = bool(false); + useAssetDefinedSupport = bool(false); + useWorldSupport = bool(false); + + initDynamicArrays(); + initStrings(); + initReferences(); +} + +void DestructibleAssetParameters::initReferences(void) +{ + collisionData = NULL; + + renderMeshAsset = NULL; + +} + +void DestructibleAssetParameters::freeDynamicArrays(void) +{ + if (behaviorGroups.isAllocated && behaviorGroups.buf) + { + mParameterizedTraits->free(behaviorGroups.buf); + } + if (chunks.isAllocated && chunks.buf) + { + mParameterizedTraits->free(chunks.buf); + } + if (chunkConvexHulls.isAllocated && chunkConvexHulls.buf) + { + mParameterizedTraits->free(chunkConvexHulls.buf); + } + if (chunkConvexHullStartIndices.isAllocated && chunkConvexHullStartIndices.buf) + { + mParameterizedTraits->free(chunkConvexHullStartIndices.buf); + } + if (depthParameters.isAllocated && depthParameters.buf) + { + mParameterizedTraits->free(depthParameters.buf); + } + if (chunkInstanceInfo.isAllocated && chunkInstanceInfo.buf) + { + mParameterizedTraits->free(chunkInstanceInfo.buf); + } + if (staticMaterialNames.isAllocated && staticMaterialNames.buf) + { + mParameterizedTraits->free(staticMaterialNames.buf); + } + if (overlapsAtDepth.isAllocated && overlapsAtDepth.buf) + { + mParameterizedTraits->free(overlapsAtDepth.buf); + } + if (firstChunkAtDepth.isAllocated && firstChunkAtDepth.buf) + { + mParameterizedTraits->free(firstChunkAtDepth.buf); + } + if (actorTransforms.isAllocated && actorTransforms.buf) + { + mParameterizedTraits->free(actorTransforms.buf); + } + if (scatterMeshAssets.isAllocated && scatterMeshAssets.buf) + { + mParameterizedTraits->free(scatterMeshAssets.buf); + } + if (scatterMeshIndices.isAllocated && scatterMeshIndices.buf) + { + mParameterizedTraits->free(scatterMeshIndices.buf); + } + if (scatterMeshTransforms.isAllocated && scatterMeshTransforms.buf) + { + mParameterizedTraits->free(scatterMeshTransforms.buf); + } +} + +void DestructibleAssetParameters::freeStrings(void) +{ + + if (comments.isAllocated && comments.buf) + { + mParameterizedTraits->strfree((char*)comments.buf); + } + + if (defaultBehaviorGroup.name.isAllocated && defaultBehaviorGroup.name.buf) + { + mParameterizedTraits->strfree((char*)defaultBehaviorGroup.name.buf); + } + + for (int i = 0; i < behaviorGroups.arraySizes[0]; ++i) + { + if (behaviorGroups.buf[i].name.isAllocated && behaviorGroups.buf[i].name.buf) + { + mParameterizedTraits->strfree((char*)behaviorGroups.buf[i].name.buf); + } + } + + if (crumbleEmitterName.isAllocated && crumbleEmitterName.buf) + { + mParameterizedTraits->strfree((char*)crumbleEmitterName.buf); + } + + if (dustEmitterName.isAllocated && dustEmitterName.buf) + { + mParameterizedTraits->strfree((char*)dustEmitterName.buf); + } + + for (int i = 0; i < staticMaterialNames.arraySizes[0]; ++i) + { + if (staticMaterialNames.buf[i].isAllocated && staticMaterialNames.buf[i].buf) + { + mParameterizedTraits->strfree((char*)staticMaterialNames.buf[i].buf); + } + } +} + +void DestructibleAssetParameters::freeReferences(void) +{ + + for (int i = 0; i < chunkConvexHulls.arraySizes[0]; ++i) + { + if (chunkConvexHulls.buf[i]) + { + chunkConvexHulls.buf[i]->destroy(); + } + } + if (collisionData) + { + collisionData->destroy(); + } + + if (renderMeshAsset) + { + renderMeshAsset->destroy(); + } + + + for (int i = 0; i < overlapsAtDepth.arraySizes[0]; ++i) + { + if (overlapsAtDepth.buf[i]) + { + overlapsAtDepth.buf[i]->destroy(); + } + } + + for (int i = 0; i < scatterMeshAssets.arraySizes[0]; ++i) + { + if (scatterMeshAssets.buf[i]) + { + scatterMeshAssets.buf[i]->destroy(); + } + } +} + +} // namespace destructible +} // namespace nvidia diff --git a/APEX_1.4/module/destructible/src/autogen/DestructibleDebugRenderParams.cpp b/APEX_1.4/module/destructible/src/autogen/DestructibleDebugRenderParams.cpp new file mode 100644 index 00000000..f11fc194 --- /dev/null +++ b/APEX_1.4/module/destructible/src/autogen/DestructibleDebugRenderParams.cpp @@ -0,0 +1,508 @@ +// 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-2015 NVIDIA Corporation. All rights reserved. + +// This file was generated by NvParameterized/scripts/GenParameterized.pl + + +#include "DestructibleDebugRenderParams.h" +#include <string.h> +#include <stdlib.h> + +using namespace NvParameterized; + +namespace nvidia +{ +namespace destructible +{ + +using namespace DestructibleDebugRenderParamsNS; + +const char* const DestructibleDebugRenderParamsFactory::vptr = + NvParameterized::getVptr<DestructibleDebugRenderParams, DestructibleDebugRenderParams::ClassAlignment>(); + +const uint32_t NumParamDefs = 10; +static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs]; + + +static const size_t ParamLookupChildrenTable[] = +{ + 1, 2, 3, 4, 5, 6, 7, 8, 9, +}; + +#define TENUM(type) nvidia::##type +#define CHILDREN(index) &ParamLookupChildrenTable[index] +static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] = +{ + { TYPE_STRUCT, false, 0, CHILDREN(0), 9 }, + { TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->VISUALIZE_DESTRUCTIBLE_ACTOR), NULL, 0 }, // VISUALIZE_DESTRUCTIBLE_ACTOR + { TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->VISUALIZE_DESTRUCTIBLE_BOUNDS), NULL, 0 }, // VISUALIZE_DESTRUCTIBLE_BOUNDS + { TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->VISUALIZE_DESTRUCTIBLE_SUPPORT), NULL, 0 }, // VISUALIZE_DESTRUCTIBLE_SUPPORT + { TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->VISUALIZE_DESTRUCTIBLE_ACTOR_POSE), NULL, 0 }, // VISUALIZE_DESTRUCTIBLE_ACTOR_POSE + { TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->THRESHOLD_DISTANCE_DESTRUCTIBLE_ACTOR_POSE), NULL, 0 }, // THRESHOLD_DISTANCE_DESTRUCTIBLE_ACTOR_POSE + { TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->VISUALIZE_DESTRUCTIBLE_ACTOR_NAME), NULL, 0 }, // VISUALIZE_DESTRUCTIBLE_ACTOR_NAME + { TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->THRESHOLD_DISTANCE_DESTRUCTIBLE_ACTOR_NAME), NULL, 0 }, // THRESHOLD_DISTANCE_DESTRUCTIBLE_ACTOR_NAME + { TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->VISUALIZE_DESTRUCTIBLE_FRAGMENT_POSE), NULL, 0 }, // VISUALIZE_DESTRUCTIBLE_FRAGMENT_POSE + { TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->THRESHOLD_DISTANCE_DESTRUCTIBLE_FRAGMENT_POSE), NULL, 0 }, // THRESHOLD_DISTANCE_DESTRUCTIBLE_FRAGMENT_POSE +}; + + +bool DestructibleDebugRenderParams::mBuiltFlag = false; +NvParameterized::MutexType DestructibleDebugRenderParams::mBuiltFlagMutex; + +DestructibleDebugRenderParams::DestructibleDebugRenderParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) : + NvParameters(traits, buf, refCount) +{ + //mParameterizedTraits->registerFactory(className(), &DestructibleDebugRenderParamsFactoryInst); + + if (!buf) //Do not init data if it is inplace-deserialized + { + initDynamicArrays(); + initStrings(); + initReferences(); + initDefaults(); + } +} + +DestructibleDebugRenderParams::~DestructibleDebugRenderParams() +{ + freeStrings(); + freeReferences(); + freeDynamicArrays(); +} + +void DestructibleDebugRenderParams::destroy() +{ + // We cache these fields here to avoid overwrite in destructor + bool doDeallocateSelf = mDoDeallocateSelf; + NvParameterized::Traits* traits = mParameterizedTraits; + int32_t* refCount = mRefCount; + void* buf = mBuffer; + + this->~DestructibleDebugRenderParams(); + + NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf); +} + +const NvParameterized::DefinitionImpl* DestructibleDebugRenderParams::getParameterDefinitionTree(void) +{ + if (!mBuiltFlag) // Double-checked lock + { + NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex); + if (!mBuiltFlag) + { + buildTree(); + } + } + + return(&ParamDefTable[0]); +} + +const NvParameterized::DefinitionImpl* DestructibleDebugRenderParams::getParameterDefinitionTree(void) const +{ + DestructibleDebugRenderParams* tmpParam = const_cast<DestructibleDebugRenderParams*>(this); + + if (!mBuiltFlag) // Double-checked lock + { + NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex); + if (!mBuiltFlag) + { + tmpParam->buildTree(); + } + } + + return(&ParamDefTable[0]); +} + +NvParameterized::ErrorType DestructibleDebugRenderParams::getParameterHandle(const char* long_name, Handle& handle) const +{ + ErrorType Ret = NvParameters::getParameterHandle(long_name, handle); + if (Ret != ERROR_NONE) + { + return(Ret); + } + + size_t offset; + void* ptr; + + getVarPtr(handle, ptr, offset); + + if (ptr == NULL) + { + return(ERROR_INDEX_OUT_OF_RANGE); + } + + return(ERROR_NONE); +} + +NvParameterized::ErrorType DestructibleDebugRenderParams::getParameterHandle(const char* long_name, Handle& handle) +{ + ErrorType Ret = NvParameters::getParameterHandle(long_name, handle); + if (Ret != ERROR_NONE) + { + return(Ret); + } + + size_t offset; + void* ptr; + + getVarPtr(handle, ptr, offset); + + if (ptr == NULL) + { + return(ERROR_INDEX_OUT_OF_RANGE); + } + + return(ERROR_NONE); +} + +void DestructibleDebugRenderParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const +{ + ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<DestructibleDebugRenderParams::ParametersStruct*>(¶meters()), handle, offset); +} + + +/* Dynamic Handle Indices */ + +void DestructibleDebugRenderParams::freeParameterDefinitionTable(NvParameterized::Traits* traits) +{ + if (!traits) + { + return; + } + + if (!mBuiltFlag) // Double-checked lock + { + return; + } + + NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex); + + if (!mBuiltFlag) + { + return; + } + + for (uint32_t i = 0; i < NumParamDefs; ++i) + { + ParamDefTable[i].~DefinitionImpl(); + } + + traits->free(ParamDefTable); + + mBuiltFlag = false; +} + +#define PDEF_PTR(index) (&ParamDefTable[index]) + +void DestructibleDebugRenderParams::buildTree(void) +{ + + uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs; + ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize)); + memset(ParamDefTable, 0, allocSize); + + for (uint32_t i = 0; i < NumParamDefs; ++i) + { + NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits); + } + + // Initialize DefinitionImpl node: nodeIndex=0, longName="" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0]; + ParamDef->init("", TYPE_STRUCT, "STRUCT", true); + + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=1, longName="VISUALIZE_DESTRUCTIBLE_ACTOR" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1]; + ParamDef->init("VISUALIZE_DESTRUCTIBLE_ACTOR", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("shortDescription", "Module switch - whether or not to visualize destruction.", true); + ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=2, longName="VISUALIZE_DESTRUCTIBLE_BOUNDS" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2]; + ParamDef->init("VISUALIZE_DESTRUCTIBLE_BOUNDS", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("shortDescription", "Shows the axis-aligned bounding box which contains all chunks for each destructible actor.", true); + ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=3, longName="VISUALIZE_DESTRUCTIBLE_SUPPORT" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3]; + ParamDef->init("VISUALIZE_DESTRUCTIBLE_SUPPORT", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("shortDescription", "Shows the support graph as lines and support chunks' bounding boxes.", true); + ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=4, longName="VISUALIZE_DESTRUCTIBLE_ACTOR_POSE" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4]; + ParamDef->init("VISUALIZE_DESTRUCTIBLE_ACTOR_POSE", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("shortDescription", "Shows the coordinate frame representing the local origin for unfractured destructibles.", true); + ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=5, longName="THRESHOLD_DISTANCE_DESTRUCTIBLE_ACTOR_POSE" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5]; + ParamDef->init("THRESHOLD_DISTANCE_DESTRUCTIBLE_ACTOR_POSE", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("shortDescription", "If VISUALIZE_DESTRUCTIBLE_ACTOR_POSE is true, the maximum object-to-eye distance to draw the chunk poses.", true); + ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=6, longName="VISUALIZE_DESTRUCTIBLE_ACTOR_NAME" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[6]; + ParamDef->init("VISUALIZE_DESTRUCTIBLE_ACTOR_NAME", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("shortDescription", "Shows the name of each destructible.", true); + ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=7, longName="THRESHOLD_DISTANCE_DESTRUCTIBLE_ACTOR_NAME" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[7]; + ParamDef->init("THRESHOLD_DISTANCE_DESTRUCTIBLE_ACTOR_NAME", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("shortDescription", "If VISUALIZE_DESTRUCTIBLE_ACTOR_NAME is true, the maximum object-to-eye distance to draw the actor names.", true); + ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=8, longName="VISUALIZE_DESTRUCTIBLE_FRAGMENT_POSE" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[8]; + ParamDef->init("VISUALIZE_DESTRUCTIBLE_FRAGMENT_POSE", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("shortDescription", "Shows the coordinate frame representing the local origin for each chunk island.", true); + ParamDefTable[8].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=9, longName="THRESHOLD_DISTANCE_DESTRUCTIBLE_FRAGMENT_POSE" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[9]; + ParamDef->init("THRESHOLD_DISTANCE_DESTRUCTIBLE_FRAGMENT_POSE", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("shortDescription", "If VISUALIZE_DESTRUCTIBLE_FRAGMENT_POSE is true, the maximum object-to-eye distance to draw the fragment poses", true); + ParamDefTable[9].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // SetChildren for: nodeIndex=0, longName="" + { + static Definition* Children[9]; + Children[0] = PDEF_PTR(1); + Children[1] = PDEF_PTR(2); + Children[2] = PDEF_PTR(3); + Children[3] = PDEF_PTR(4); + Children[4] = PDEF_PTR(5); + Children[5] = PDEF_PTR(6); + Children[6] = PDEF_PTR(7); + Children[7] = PDEF_PTR(8); + Children[8] = PDEF_PTR(9); + + ParamDefTable[0].setChildren(Children, 9); + } + + mBuiltFlag = true; + +} +void DestructibleDebugRenderParams::initStrings(void) +{ +} + +void DestructibleDebugRenderParams::initDynamicArrays(void) +{ +} + +void DestructibleDebugRenderParams::initDefaults(void) +{ + + freeStrings(); + freeReferences(); + freeDynamicArrays(); + VISUALIZE_DESTRUCTIBLE_ACTOR = bool(true); + VISUALIZE_DESTRUCTIBLE_BOUNDS = float(0); + VISUALIZE_DESTRUCTIBLE_SUPPORT = float(0); + VISUALIZE_DESTRUCTIBLE_ACTOR_POSE = bool(true); + THRESHOLD_DISTANCE_DESTRUCTIBLE_ACTOR_POSE = float(3.402823466e+038); + VISUALIZE_DESTRUCTIBLE_ACTOR_NAME = bool(true); + THRESHOLD_DISTANCE_DESTRUCTIBLE_ACTOR_NAME = float(3.402823466e+038); + VISUALIZE_DESTRUCTIBLE_FRAGMENT_POSE = bool(true); + THRESHOLD_DISTANCE_DESTRUCTIBLE_FRAGMENT_POSE = float(3.402823466e+038); + + initDynamicArrays(); + initStrings(); + initReferences(); +} + +void DestructibleDebugRenderParams::initReferences(void) +{ +} + +void DestructibleDebugRenderParams::freeDynamicArrays(void) +{ +} + +void DestructibleDebugRenderParams::freeStrings(void) +{ +} + +void DestructibleDebugRenderParams::freeReferences(void) +{ +} + +} // namespace destructible +} // namespace nvidia diff --git a/APEX_1.4/module/destructible/src/autogen/DestructibleModuleParameters.cpp b/APEX_1.4/module/destructible/src/autogen/DestructibleModuleParameters.cpp new file mode 100644 index 00000000..ca5d7abc --- /dev/null +++ b/APEX_1.4/module/destructible/src/autogen/DestructibleModuleParameters.cpp @@ -0,0 +1,505 @@ +// 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-2015 NVIDIA Corporation. All rights reserved. + +// This file was generated by NvParameterized/scripts/GenParameterized.pl + + +#include "DestructibleModuleParameters.h" +#include <string.h> +#include <stdlib.h> + +using namespace NvParameterized; + +namespace nvidia +{ +namespace destructible +{ + +using namespace DestructibleModuleParametersNS; + +const char* const DestructibleModuleParametersFactory::vptr = + NvParameterized::getVptr<DestructibleModuleParameters, DestructibleModuleParameters::ClassAlignment>(); + +const uint32_t NumParamDefs = 9; +static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs]; + + +static const size_t ParamLookupChildrenTable[] = +{ + 1, 2, 3, 4, 5, 6, 7, 8, +}; + +#define TENUM(type) nvidia::##type +#define CHILDREN(index) &ParamLookupChildrenTable[index] +static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] = +{ + { TYPE_STRUCT, false, 0, CHILDREN(0), 8 }, + { TYPE_U32, false, (size_t)(&((ParametersStruct*)0)->maxDynamicChunkIslandCount), NULL, 0 }, // maxDynamicChunkIslandCount + { TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->sortFIFOByBenefit), NULL, 0 }, // sortFIFOByBenefit + { TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->validBoundsPadding), NULL, 0 }, // validBoundsPadding + { TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->maxChunkSeparationLOD), NULL, 0 }, // maxChunkSeparationLOD + { TYPE_U32, false, (size_t)(&((ParametersStruct*)0)->maxActorCreatesPerFrame), NULL, 0 }, // maxActorCreatesPerFrame + { TYPE_U32, false, (size_t)(&((ParametersStruct*)0)->maxChunkDepthOffset), NULL, 0 }, // maxChunkDepthOffset + { TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->massScale), NULL, 0 }, // massScale + { TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->scaledMassExponent), NULL, 0 }, // scaledMassExponent +}; + + +bool DestructibleModuleParameters::mBuiltFlag = false; +NvParameterized::MutexType DestructibleModuleParameters::mBuiltFlagMutex; + +DestructibleModuleParameters::DestructibleModuleParameters(NvParameterized::Traits* traits, void* buf, int32_t* refCount) : + NvParameters(traits, buf, refCount) +{ + //mParameterizedTraits->registerFactory(className(), &DestructibleModuleParametersFactoryInst); + + if (!buf) //Do not init data if it is inplace-deserialized + { + initDynamicArrays(); + initStrings(); + initReferences(); + initDefaults(); + } +} + +DestructibleModuleParameters::~DestructibleModuleParameters() +{ + freeStrings(); + freeReferences(); + freeDynamicArrays(); +} + +void DestructibleModuleParameters::destroy() +{ + // We cache these fields here to avoid overwrite in destructor + bool doDeallocateSelf = mDoDeallocateSelf; + NvParameterized::Traits* traits = mParameterizedTraits; + int32_t* refCount = mRefCount; + void* buf = mBuffer; + + this->~DestructibleModuleParameters(); + + NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf); +} + +const NvParameterized::DefinitionImpl* DestructibleModuleParameters::getParameterDefinitionTree(void) +{ + if (!mBuiltFlag) // Double-checked lock + { + NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex); + if (!mBuiltFlag) + { + buildTree(); + } + } + + return(&ParamDefTable[0]); +} + +const NvParameterized::DefinitionImpl* DestructibleModuleParameters::getParameterDefinitionTree(void) const +{ + DestructibleModuleParameters* tmpParam = const_cast<DestructibleModuleParameters*>(this); + + if (!mBuiltFlag) // Double-checked lock + { + NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex); + if (!mBuiltFlag) + { + tmpParam->buildTree(); + } + } + + return(&ParamDefTable[0]); +} + +NvParameterized::ErrorType DestructibleModuleParameters::getParameterHandle(const char* long_name, Handle& handle) const +{ + ErrorType Ret = NvParameters::getParameterHandle(long_name, handle); + if (Ret != ERROR_NONE) + { + return(Ret); + } + + size_t offset; + void* ptr; + + getVarPtr(handle, ptr, offset); + + if (ptr == NULL) + { + return(ERROR_INDEX_OUT_OF_RANGE); + } + + return(ERROR_NONE); +} + +NvParameterized::ErrorType DestructibleModuleParameters::getParameterHandle(const char* long_name, Handle& handle) +{ + ErrorType Ret = NvParameters::getParameterHandle(long_name, handle); + if (Ret != ERROR_NONE) + { + return(Ret); + } + + size_t offset; + void* ptr; + + getVarPtr(handle, ptr, offset); + + if (ptr == NULL) + { + return(ERROR_INDEX_OUT_OF_RANGE); + } + + return(ERROR_NONE); +} + +void DestructibleModuleParameters::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const +{ + ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<DestructibleModuleParameters::ParametersStruct*>(¶meters()), handle, offset); +} + + +/* Dynamic Handle Indices */ + +void DestructibleModuleParameters::freeParameterDefinitionTable(NvParameterized::Traits* traits) +{ + if (!traits) + { + return; + } + + if (!mBuiltFlag) // Double-checked lock + { + return; + } + + NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex); + + if (!mBuiltFlag) + { + return; + } + + for (uint32_t i = 0; i < NumParamDefs; ++i) + { + ParamDefTable[i].~DefinitionImpl(); + } + + traits->free(ParamDefTable); + + mBuiltFlag = false; +} + +#define PDEF_PTR(index) (&ParamDefTable[index]) + +void DestructibleModuleParameters::buildTree(void) +{ + + uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs; + ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize)); + memset(ParamDefTable, 0, allocSize); + + for (uint32_t i = 0; i < NumParamDefs; ++i) + { + NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits); + } + + // Initialize DefinitionImpl node: nodeIndex=0, longName="" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0]; + ParamDef->init("", TYPE_STRUCT, "STRUCT", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("shortDescription", "This class is used for initializing the ModuleDestructible.", true); + ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=1, longName="maxDynamicChunkIslandCount" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1]; + ParamDef->init("maxDynamicChunkIslandCount", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("shortDescription", "The maximum number of dynamic PxActors that will be allowed to be active per ApexScene. A value of 0 (the default) is interpreted as no limit.", true); + ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=2, longName="sortFIFOByBenefit" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2]; + ParamDef->init("sortFIFOByBenefit", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("shortDescription", "Instead of keeping the maxCount youngest, use maxCount largest benefit if this is true.", true); + ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=3, longName="validBoundsPadding" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3]; + ParamDef->init("validBoundsPadding", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("shortDescription", "The padding applied to the combined scene valid bounds and Destructible actor bounds. The final combined and passed bounds is used to cull PxActors", true); + ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=4, longName="maxChunkSeparationLOD" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4]; + ParamDef->init("maxChunkSeparationLOD", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("max", uint64_t(1), true); + HintTable[1].init("min", uint64_t(0), true); + ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#else + + static HintImpl HintTable[4]; + static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], }; + HintTable[0].init("longDescription", "Chunk islands are destroyed after this time or separation from their origins. This parameter sets the lifetimes and max separations within their min-max ranges. The valid range is [0,1]. Default is 0.5.", true); + HintTable[1].init("max", uint64_t(1), true); + HintTable[2].init("min", uint64_t(0), true); + HintTable[3].init("shortDescription", "Every destructible asset defines a min and max lifetime, and maximum separation distance for its chunks.", true); + ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 4); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=5, longName="maxActorCreatesPerFrame" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5]; + ParamDef->init("maxActorCreatesPerFrame", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("shortDescription", "Lets the user throttle the number of SDK actor creates per frame (per scene) due to destruction, as this can be quite costly. The default is 0xffffffff (unlimited).", true); + ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=6, longName="maxChunkDepthOffset" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[6]; + ParamDef->init("maxChunkDepthOffset", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If maxChunkDepthOffset = 0, all chunks can be fractured. If maxChunkDepthOffset = 1, the highest level (smallest) chunks are eliminated, etc. This prevents too many chunks from being formed. In other words, the higher maxChunkDepthOffset, the lower the LOD.", true); + HintTable[1].init("shortDescription", "Effectively eliminates the higher level (smaller) chunks from DestructibleAssets (see DestructibleAsset).", true); + ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=7, longName="massScale" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[7]; + ParamDef->init("massScale", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Used with scaledMassExponent for scaling dynamic chunk masses.\nThe 'real' mass m of a chunk is calculated by the destructible actor's density multiplied by\nthe total volume of the chunk's (scaled) collision shapes. The mass used in\nthe simulation is massScale*pow(m/massScale,scaledMassExponent). Values less than 1 have the\neffect of reducing the ratio of different masses. The closer scaledMassExponent is to zero, the\nmore the ratio will be 'flattened.' This helps PhysX converge when there is a very large number\nof interacting rigid bodies (such as a pile of destructible chunks).\nValid range: (0,infinity). Default = 1.0.\n", true); + HintTable[1].init("shortDescription", "Used with scaledMassExponent for scaling dynamic chunk masses.", true); + ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=8, longName="scaledMassExponent" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[8]; + ParamDef->init("scaledMassExponent", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Used with massScale for scaling dynamic chunk masses.\nThe 'real' mass m of a chunk is calculated by the destructible actor's density multiplied by\nthe total volume of the chunk's (scaled) collision shapes. The mass used in\nthe simulation is massScale*pow(m/massScale,scaledMassExponent). Values less than 1 have the\neffect of reducing the ratio of different masses. The closer scaledMassExponent is to zero, the\nmore the ratio will be 'flattened.' This helps PhysX converge when there is a very large number\nof interacting rigid bodies (such as a pile of destructible chunks).\nValid range: (0,1]. Default = 0.5.\n", true); + HintTable[1].init("shortDescription", "Used with massScale for scaling dynamic chunk masses.", true); + ParamDefTable[8].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // SetChildren for: nodeIndex=0, longName="" + { + static Definition* Children[8]; + Children[0] = PDEF_PTR(1); + Children[1] = PDEF_PTR(2); + Children[2] = PDEF_PTR(3); + Children[3] = PDEF_PTR(4); + Children[4] = PDEF_PTR(5); + Children[5] = PDEF_PTR(6); + Children[6] = PDEF_PTR(7); + Children[7] = PDEF_PTR(8); + + ParamDefTable[0].setChildren(Children, 8); + } + + mBuiltFlag = true; + +} +void DestructibleModuleParameters::initStrings(void) +{ +} + +void DestructibleModuleParameters::initDynamicArrays(void) +{ +} + +void DestructibleModuleParameters::initDefaults(void) +{ + + freeStrings(); + freeReferences(); + freeDynamicArrays(); + maxDynamicChunkIslandCount = uint32_t(0); + sortFIFOByBenefit = bool(false); + validBoundsPadding = float(0); + maxChunkSeparationLOD = float(0.5); + maxActorCreatesPerFrame = uint32_t(UINT32_MAX); + maxChunkDepthOffset = uint32_t(0); + massScale = float(1); + scaledMassExponent = float(0.5); + + initDynamicArrays(); + initStrings(); + initReferences(); +} + +void DestructibleModuleParameters::initReferences(void) +{ +} + +void DestructibleModuleParameters::freeDynamicArrays(void) +{ +} + +void DestructibleModuleParameters::freeStrings(void) +{ +} + +void DestructibleModuleParameters::freeReferences(void) +{ +} + +} // namespace destructible +} // namespace nvidia diff --git a/APEX_1.4/module/destructible/src/autogen/DestructiblePreviewParam.cpp b/APEX_1.4/module/destructible/src/autogen/DestructiblePreviewParam.cpp new file mode 100644 index 00000000..53055f9f --- /dev/null +++ b/APEX_1.4/module/destructible/src/autogen/DestructiblePreviewParam.cpp @@ -0,0 +1,572 @@ +// 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-2015 NVIDIA Corporation. All rights reserved. + +// This file was generated by NvParameterized/scripts/GenParameterized.pl + + +#include "DestructiblePreviewParam.h" +#include <string.h> +#include <stdlib.h> + +using namespace NvParameterized; + +namespace nvidia +{ +namespace destructible +{ + +using namespace DestructiblePreviewParamNS; + +const char* const DestructiblePreviewParamFactory::vptr = + NvParameterized::getVptr<DestructiblePreviewParam, DestructiblePreviewParam::ClassAlignment>(); + +const uint32_t NumParamDefs = 10; +static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs]; + + +static const size_t ParamLookupChildrenTable[] = +{ + 1, 2, 3, 4, 5, 7, 9, 6, 8, +}; + +#define TENUM(type) nvidia::##type +#define CHILDREN(index) &ParamLookupChildrenTable[index] +static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] = +{ + { TYPE_STRUCT, false, 0, CHILDREN(0), 7 }, + { TYPE_MAT44, false, (size_t)(&((ParametersStruct*)0)->globalPose), NULL, 0 }, // globalPose + { TYPE_U32, false, (size_t)(&((ParametersStruct*)0)->chunkDepth), NULL, 0 }, // chunkDepth + { TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->explodeAmount), NULL, 0 }, // explodeAmount + { TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->renderUnexplodedChunksStatically), NULL, 0 }, // renderUnexplodedChunksStatically + { TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->overrideSkinnedMaterialNames), CHILDREN(7), 1 }, // overrideSkinnedMaterialNames + { TYPE_STRING, false, 1 * sizeof(NvParameterized::DummyStringStruct), NULL, 0 }, // overrideSkinnedMaterialNames[] + { TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->overrideStaticMaterialNames), CHILDREN(8), 1 }, // overrideStaticMaterialNames + { TYPE_STRING, false, 1 * sizeof(NvParameterized::DummyStringStruct), NULL, 0 }, // overrideStaticMaterialNames[] + { TYPE_U64, false, (size_t)(&((ParametersStruct*)0)->userData), NULL, 0 }, // userData +}; + + +bool DestructiblePreviewParam::mBuiltFlag = false; +NvParameterized::MutexType DestructiblePreviewParam::mBuiltFlagMutex; + +DestructiblePreviewParam::DestructiblePreviewParam(NvParameterized::Traits* traits, void* buf, int32_t* refCount) : + NvParameters(traits, buf, refCount) +{ + //mParameterizedTraits->registerFactory(className(), &DestructiblePreviewParamFactoryInst); + + if (!buf) //Do not init data if it is inplace-deserialized + { + initDynamicArrays(); + initStrings(); + initReferences(); + initDefaults(); + } +} + +DestructiblePreviewParam::~DestructiblePreviewParam() +{ + freeStrings(); + freeReferences(); + freeDynamicArrays(); +} + +void DestructiblePreviewParam::destroy() +{ + // We cache these fields here to avoid overwrite in destructor + bool doDeallocateSelf = mDoDeallocateSelf; + NvParameterized::Traits* traits = mParameterizedTraits; + int32_t* refCount = mRefCount; + void* buf = mBuffer; + + this->~DestructiblePreviewParam(); + + NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf); +} + +const NvParameterized::DefinitionImpl* DestructiblePreviewParam::getParameterDefinitionTree(void) +{ + if (!mBuiltFlag) // Double-checked lock + { + NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex); + if (!mBuiltFlag) + { + buildTree(); + } + } + + return(&ParamDefTable[0]); +} + +const NvParameterized::DefinitionImpl* DestructiblePreviewParam::getParameterDefinitionTree(void) const +{ + DestructiblePreviewParam* tmpParam = const_cast<DestructiblePreviewParam*>(this); + + if (!mBuiltFlag) // Double-checked lock + { + NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex); + if (!mBuiltFlag) + { + tmpParam->buildTree(); + } + } + + return(&ParamDefTable[0]); +} + +NvParameterized::ErrorType DestructiblePreviewParam::getParameterHandle(const char* long_name, Handle& handle) const +{ + ErrorType Ret = NvParameters::getParameterHandle(long_name, handle); + if (Ret != ERROR_NONE) + { + return(Ret); + } + + size_t offset; + void* ptr; + + getVarPtr(handle, ptr, offset); + + if (ptr == NULL) + { + return(ERROR_INDEX_OUT_OF_RANGE); + } + + return(ERROR_NONE); +} + +NvParameterized::ErrorType DestructiblePreviewParam::getParameterHandle(const char* long_name, Handle& handle) +{ + ErrorType Ret = NvParameters::getParameterHandle(long_name, handle); + if (Ret != ERROR_NONE) + { + return(Ret); + } + + size_t offset; + void* ptr; + + getVarPtr(handle, ptr, offset); + + if (ptr == NULL) + { + return(ERROR_INDEX_OUT_OF_RANGE); + } + + return(ERROR_NONE); +} + +void DestructiblePreviewParam::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const +{ + ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<DestructiblePreviewParam::ParametersStruct*>(¶meters()), handle, offset); +} + + +/* Dynamic Handle Indices */ +/* [0] - overrideSkinnedMaterialNames (not an array of structs) */ +/* [0] - overrideStaticMaterialNames (not an array of structs) */ + +void DestructiblePreviewParam::freeParameterDefinitionTable(NvParameterized::Traits* traits) +{ + if (!traits) + { + return; + } + + if (!mBuiltFlag) // Double-checked lock + { + return; + } + + NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex); + + if (!mBuiltFlag) + { + return; + } + + for (uint32_t i = 0; i < NumParamDefs; ++i) + { + ParamDefTable[i].~DefinitionImpl(); + } + + traits->free(ParamDefTable); + + mBuiltFlag = false; +} + +#define PDEF_PTR(index) (&ParamDefTable[index]) + +void DestructiblePreviewParam::buildTree(void) +{ + + uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs; + ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize)); + memset(ParamDefTable, 0, allocSize); + + for (uint32_t i = 0; i < NumParamDefs; ++i) + { + NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits); + } + + // Initialize DefinitionImpl node: nodeIndex=0, longName="" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0]; + ParamDef->init("", TYPE_STRUCT, "STRUCT", true); + + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=1, longName="globalPose" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1]; + ParamDef->init("globalPose", TYPE_MAT44, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The pose for the destructible preview, including scaling.\n", true); + HintTable[1].init("shortDescription", "The pose for the destructible preview", true); + ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=2, longName="chunkDepth" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2]; + ParamDef->init("chunkDepth", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Which chunk depth to render.\n", true); + HintTable[1].init("shortDescription", "Which chunk depth to render.", true); + ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=3, longName="explodeAmount" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3]; + ParamDef->init("explodeAmount", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "How far apart to 'explode' the chunks rendered. The value is relative to the chunk's initial offset from the origin.\n", true); + HintTable[1].init("shortDescription", "How far apart to 'explode' the chunks rendered.", true); + ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=4, longName="renderUnexplodedChunksStatically" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4]; + ParamDef->init("renderUnexplodedChunksStatically", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "If true, unexploded chunks (see explodeAmount) will be renderered statically (without skinning).\nDefault value = false.\n", true); + HintTable[1].init("shortDescription", "Whether or not to render unexploded chunks statically (without skinning)", true); + ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=5, longName="overrideSkinnedMaterialNames" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5]; + ParamDef->init("overrideSkinnedMaterialNames", TYPE_ARRAY, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Per-actor material names, to override those in the asset, for skinned rendering.", true); + HintTable[1].init("shortDescription", "Per-actor material names, to override those in the asset, for skinned rendering", true); + ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + ParamDef->setArraySize(-1); + static const uint8_t dynHandleIndices[1] = { 0, }; + ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1); + + } + + // Initialize DefinitionImpl node: nodeIndex=6, longName="overrideSkinnedMaterialNames[]" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[6]; + ParamDef->init("overrideSkinnedMaterialNames", TYPE_STRING, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Per-actor material names, to override those in the asset, for skinned rendering.", true); + HintTable[1].init("shortDescription", "Per-actor material names, to override those in the asset, for skinned rendering", true); + ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=7, longName="overrideStaticMaterialNames" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[7]; + ParamDef->init("overrideStaticMaterialNames", TYPE_ARRAY, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Per-actor material names, to override those in the asset, for static rendering.", true); + HintTable[1].init("shortDescription", "Per-actor material names, to override those in the asset, for static rendering", true); + ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + ParamDef->setArraySize(-1); + static const uint8_t dynHandleIndices[1] = { 0, }; + ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1); + + } + + // Initialize DefinitionImpl node: nodeIndex=8, longName="overrideStaticMaterialNames[]" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[8]; + ParamDef->init("overrideStaticMaterialNames", TYPE_STRING, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Per-actor material names, to override those in the asset, for static rendering.", true); + HintTable[1].init("shortDescription", "Per-actor material names, to override those in the asset, for static rendering", true); + ParamDefTable[8].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=9, longName="userData" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[9]; + ParamDef->init("userData", TYPE_U64, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("editorDisplay", "false", true); + ParamDefTable[9].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("editorDisplay", "false", true); + HintTable[1].init("shortDescription", "Optional user data pointer associated with the destructible preview", true); + ParamDefTable[9].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // SetChildren for: nodeIndex=0, longName="" + { + static Definition* Children[7]; + Children[0] = PDEF_PTR(1); + Children[1] = PDEF_PTR(2); + Children[2] = PDEF_PTR(3); + Children[3] = PDEF_PTR(4); + Children[4] = PDEF_PTR(5); + Children[5] = PDEF_PTR(7); + Children[6] = PDEF_PTR(9); + + ParamDefTable[0].setChildren(Children, 7); + } + + // SetChildren for: nodeIndex=5, longName="overrideSkinnedMaterialNames" + { + static Definition* Children[1]; + Children[0] = PDEF_PTR(6); + + ParamDefTable[5].setChildren(Children, 1); + } + + // SetChildren for: nodeIndex=7, longName="overrideStaticMaterialNames" + { + static Definition* Children[1]; + Children[0] = PDEF_PTR(8); + + ParamDefTable[7].setChildren(Children, 1); + } + + mBuiltFlag = true; + +} +void DestructiblePreviewParam::initStrings(void) +{ +} + +void DestructiblePreviewParam::initDynamicArrays(void) +{ + overrideSkinnedMaterialNames.buf = NULL; + overrideSkinnedMaterialNames.isAllocated = true; + overrideSkinnedMaterialNames.elementSize = sizeof(NvParameterized::DummyStringStruct); + overrideSkinnedMaterialNames.arraySizes[0] = 0; + overrideStaticMaterialNames.buf = NULL; + overrideStaticMaterialNames.isAllocated = true; + overrideStaticMaterialNames.elementSize = sizeof(NvParameterized::DummyStringStruct); + overrideStaticMaterialNames.arraySizes[0] = 0; +} + +void DestructiblePreviewParam::initDefaults(void) +{ + + freeStrings(); + freeReferences(); + freeDynamicArrays(); + globalPose = physx::PxMat44(init(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1)); + chunkDepth = uint32_t(0); + explodeAmount = float(0); + renderUnexplodedChunksStatically = bool(false); + userData = uint64_t(0); + + initDynamicArrays(); + initStrings(); + initReferences(); +} + +void DestructiblePreviewParam::initReferences(void) +{ +} + +void DestructiblePreviewParam::freeDynamicArrays(void) +{ + if (overrideSkinnedMaterialNames.isAllocated && overrideSkinnedMaterialNames.buf) + { + mParameterizedTraits->free(overrideSkinnedMaterialNames.buf); + } + if (overrideStaticMaterialNames.isAllocated && overrideStaticMaterialNames.buf) + { + mParameterizedTraits->free(overrideStaticMaterialNames.buf); + } +} + +void DestructiblePreviewParam::freeStrings(void) +{ + + for (int i = 0; i < overrideSkinnedMaterialNames.arraySizes[0]; ++i) + { + if (overrideSkinnedMaterialNames.buf[i].isAllocated && overrideSkinnedMaterialNames.buf[i].buf) + { + mParameterizedTraits->strfree((char*)overrideSkinnedMaterialNames.buf[i].buf); + } + } + + for (int i = 0; i < overrideStaticMaterialNames.arraySizes[0]; ++i) + { + if (overrideStaticMaterialNames.buf[i].isAllocated && overrideStaticMaterialNames.buf[i].buf) + { + mParameterizedTraits->strfree((char*)overrideStaticMaterialNames.buf[i].buf); + } + } +} + +void DestructiblePreviewParam::freeReferences(void) +{ +} + +} // namespace destructible +} // namespace nvidia diff --git a/APEX_1.4/module/destructible/src/autogen/MeshCookedCollisionStream.cpp b/APEX_1.4/module/destructible/src/autogen/MeshCookedCollisionStream.cpp new file mode 100644 index 00000000..074c9531 --- /dev/null +++ b/APEX_1.4/module/destructible/src/autogen/MeshCookedCollisionStream.cpp @@ -0,0 +1,348 @@ +// 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-2015 NVIDIA Corporation. All rights reserved. + +// This file was generated by NvParameterized/scripts/GenParameterized.pl + + +#include "MeshCookedCollisionStream.h" +#include <string.h> +#include <stdlib.h> + +using namespace NvParameterized; + +namespace nvidia +{ +namespace destructible +{ + +using namespace MeshCookedCollisionStreamNS; + +const char* const MeshCookedCollisionStreamFactory::vptr = + NvParameterized::getVptr<MeshCookedCollisionStream, MeshCookedCollisionStream::ClassAlignment>(); + +const uint32_t NumParamDefs = 3; +static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs]; + + +static const size_t ParamLookupChildrenTable[] = +{ + 1, 2, +}; + +#define TENUM(type) nvidia::##type +#define CHILDREN(index) &ParamLookupChildrenTable[index] +static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] = +{ + { TYPE_STRUCT, false, 0, CHILDREN(0), 1 }, + { TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->bytes), CHILDREN(1), 1 }, // bytes + { TYPE_U8, false, 1 * sizeof(uint8_t), NULL, 0 }, // bytes[] +}; + + +bool MeshCookedCollisionStream::mBuiltFlag = false; +NvParameterized::MutexType MeshCookedCollisionStream::mBuiltFlagMutex; + +MeshCookedCollisionStream::MeshCookedCollisionStream(NvParameterized::Traits* traits, void* buf, int32_t* refCount) : + NvParameters(traits, buf, refCount) +{ + //mParameterizedTraits->registerFactory(className(), &MeshCookedCollisionStreamFactoryInst); + + if (!buf) //Do not init data if it is inplace-deserialized + { + initDynamicArrays(); + initStrings(); + initReferences(); + initDefaults(); + } +} + +MeshCookedCollisionStream::~MeshCookedCollisionStream() +{ + freeStrings(); + freeReferences(); + freeDynamicArrays(); +} + +void MeshCookedCollisionStream::destroy() +{ + // We cache these fields here to avoid overwrite in destructor + bool doDeallocateSelf = mDoDeallocateSelf; + NvParameterized::Traits* traits = mParameterizedTraits; + int32_t* refCount = mRefCount; + void* buf = mBuffer; + + this->~MeshCookedCollisionStream(); + + NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf); +} + +const NvParameterized::DefinitionImpl* MeshCookedCollisionStream::getParameterDefinitionTree(void) +{ + if (!mBuiltFlag) // Double-checked lock + { + NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex); + if (!mBuiltFlag) + { + buildTree(); + } + } + + return(&ParamDefTable[0]); +} + +const NvParameterized::DefinitionImpl* MeshCookedCollisionStream::getParameterDefinitionTree(void) const +{ + MeshCookedCollisionStream* tmpParam = const_cast<MeshCookedCollisionStream*>(this); + + if (!mBuiltFlag) // Double-checked lock + { + NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex); + if (!mBuiltFlag) + { + tmpParam->buildTree(); + } + } + + return(&ParamDefTable[0]); +} + +NvParameterized::ErrorType MeshCookedCollisionStream::getParameterHandle(const char* long_name, Handle& handle) const +{ + ErrorType Ret = NvParameters::getParameterHandle(long_name, handle); + if (Ret != ERROR_NONE) + { + return(Ret); + } + + size_t offset; + void* ptr; + + getVarPtr(handle, ptr, offset); + + if (ptr == NULL) + { + return(ERROR_INDEX_OUT_OF_RANGE); + } + + return(ERROR_NONE); +} + +NvParameterized::ErrorType MeshCookedCollisionStream::getParameterHandle(const char* long_name, Handle& handle) +{ + ErrorType Ret = NvParameters::getParameterHandle(long_name, handle); + if (Ret != ERROR_NONE) + { + return(Ret); + } + + size_t offset; + void* ptr; + + getVarPtr(handle, ptr, offset); + + if (ptr == NULL) + { + return(ERROR_INDEX_OUT_OF_RANGE); + } + + return(ERROR_NONE); +} + +void MeshCookedCollisionStream::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const +{ + ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<MeshCookedCollisionStream::ParametersStruct*>(¶meters()), handle, offset); +} + + +/* Dynamic Handle Indices */ + +void MeshCookedCollisionStream::freeParameterDefinitionTable(NvParameterized::Traits* traits) +{ + if (!traits) + { + return; + } + + if (!mBuiltFlag) // Double-checked lock + { + return; + } + + NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex); + + if (!mBuiltFlag) + { + return; + } + + for (uint32_t i = 0; i < NumParamDefs; ++i) + { + ParamDefTable[i].~DefinitionImpl(); + } + + traits->free(ParamDefTable); + + mBuiltFlag = false; +} + +#define PDEF_PTR(index) (&ParamDefTable[index]) + +void MeshCookedCollisionStream::buildTree(void) +{ + + uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs; + ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize)); + memset(ParamDefTable, 0, allocSize); + + for (uint32_t i = 0; i < NumParamDefs; ++i) + { + NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits); + } + + // Initialize DefinitionImpl node: nodeIndex=0, longName="" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0]; + ParamDef->init("", TYPE_STRUCT, "STRUCT", true); + + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=1, longName="bytes" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1]; + ParamDef->init("bytes", TYPE_ARRAY, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "A byte stream used to store cooked convex collision data. One\n is needed for every chunk at every scale which will be instanced.", true); + HintTable[1].init("shortDescription", "A byte stream used to store cooked convex collision data", true); + ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + ParamDef->setArraySize(-1); + } + + // Initialize DefinitionImpl node: nodeIndex=2, longName="bytes[]" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2]; + ParamDef->init("bytes", TYPE_U8, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "A byte stream used to store cooked convex collision data. One\n is needed for every chunk at every scale which will be instanced.", true); + HintTable[1].init("shortDescription", "A byte stream used to store cooked convex collision data", true); + ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // SetChildren for: nodeIndex=0, longName="" + { + static Definition* Children[1]; + Children[0] = PDEF_PTR(1); + + ParamDefTable[0].setChildren(Children, 1); + } + + // SetChildren for: nodeIndex=1, longName="bytes" + { + static Definition* Children[1]; + Children[0] = PDEF_PTR(2); + + ParamDefTable[1].setChildren(Children, 1); + } + + mBuiltFlag = true; + +} +void MeshCookedCollisionStream::initStrings(void) +{ +} + +void MeshCookedCollisionStream::initDynamicArrays(void) +{ + bytes.buf = NULL; + bytes.isAllocated = true; + bytes.elementSize = sizeof(uint8_t); + bytes.arraySizes[0] = 0; +} + +void MeshCookedCollisionStream::initDefaults(void) +{ + + freeStrings(); + freeReferences(); + freeDynamicArrays(); + + initDynamicArrays(); + initStrings(); + initReferences(); +} + +void MeshCookedCollisionStream::initReferences(void) +{ +} + +void MeshCookedCollisionStream::freeDynamicArrays(void) +{ + if (bytes.isAllocated && bytes.buf) + { + mParameterizedTraits->free(bytes.buf); + } +} + +void MeshCookedCollisionStream::freeStrings(void) +{ +} + +void MeshCookedCollisionStream::freeReferences(void) +{ +} + +} // namespace destructible +} // namespace nvidia diff --git a/APEX_1.4/module/destructible/src/autogen/MeshCookedCollisionStreamsAtScale.cpp b/APEX_1.4/module/destructible/src/autogen/MeshCookedCollisionStreamsAtScale.cpp new file mode 100644 index 00000000..c8693a9e --- /dev/null +++ b/APEX_1.4/module/destructible/src/autogen/MeshCookedCollisionStreamsAtScale.cpp @@ -0,0 +1,376 @@ +// 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-2015 NVIDIA Corporation. All rights reserved. + +// This file was generated by NvParameterized/scripts/GenParameterized.pl + + +#include "MeshCookedCollisionStreamsAtScale.h" +#include <string.h> +#include <stdlib.h> + +using namespace NvParameterized; + +namespace nvidia +{ +namespace destructible +{ + +using namespace MeshCookedCollisionStreamsAtScaleNS; + +const char* const MeshCookedCollisionStreamsAtScaleFactory::vptr = + NvParameterized::getVptr<MeshCookedCollisionStreamsAtScale, MeshCookedCollisionStreamsAtScale::ClassAlignment>(); + +const uint32_t NumParamDefs = 3; +static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs]; + + +static const size_t ParamLookupChildrenTable[] = +{ + 1, 2, +}; + +#define TENUM(type) nvidia::##type +#define CHILDREN(index) &ParamLookupChildrenTable[index] +static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] = +{ + { TYPE_STRUCT, false, 0, CHILDREN(0), 1 }, + { TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->meshCookedCollisionStreams), CHILDREN(1), 1 }, // meshCookedCollisionStreams + { TYPE_REF, false, 1 * sizeof(NvParameterized::Interface*), NULL, 0 }, // meshCookedCollisionStreams[] +}; + + +bool MeshCookedCollisionStreamsAtScale::mBuiltFlag = false; +NvParameterized::MutexType MeshCookedCollisionStreamsAtScale::mBuiltFlagMutex; + +MeshCookedCollisionStreamsAtScale::MeshCookedCollisionStreamsAtScale(NvParameterized::Traits* traits, void* buf, int32_t* refCount) : + NvParameters(traits, buf, refCount) +{ + //mParameterizedTraits->registerFactory(className(), &MeshCookedCollisionStreamsAtScaleFactoryInst); + + if (!buf) //Do not init data if it is inplace-deserialized + { + initDynamicArrays(); + initStrings(); + initReferences(); + initDefaults(); + } +} + +MeshCookedCollisionStreamsAtScale::~MeshCookedCollisionStreamsAtScale() +{ + freeStrings(); + freeReferences(); + freeDynamicArrays(); +} + +void MeshCookedCollisionStreamsAtScale::destroy() +{ + // We cache these fields here to avoid overwrite in destructor + bool doDeallocateSelf = mDoDeallocateSelf; + NvParameterized::Traits* traits = mParameterizedTraits; + int32_t* refCount = mRefCount; + void* buf = mBuffer; + + this->~MeshCookedCollisionStreamsAtScale(); + + NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf); +} + +const NvParameterized::DefinitionImpl* MeshCookedCollisionStreamsAtScale::getParameterDefinitionTree(void) +{ + if (!mBuiltFlag) // Double-checked lock + { + NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex); + if (!mBuiltFlag) + { + buildTree(); + } + } + + return(&ParamDefTable[0]); +} + +const NvParameterized::DefinitionImpl* MeshCookedCollisionStreamsAtScale::getParameterDefinitionTree(void) const +{ + MeshCookedCollisionStreamsAtScale* tmpParam = const_cast<MeshCookedCollisionStreamsAtScale*>(this); + + if (!mBuiltFlag) // Double-checked lock + { + NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex); + if (!mBuiltFlag) + { + tmpParam->buildTree(); + } + } + + return(&ParamDefTable[0]); +} + +NvParameterized::ErrorType MeshCookedCollisionStreamsAtScale::getParameterHandle(const char* long_name, Handle& handle) const +{ + ErrorType Ret = NvParameters::getParameterHandle(long_name, handle); + if (Ret != ERROR_NONE) + { + return(Ret); + } + + size_t offset; + void* ptr; + + getVarPtr(handle, ptr, offset); + + if (ptr == NULL) + { + return(ERROR_INDEX_OUT_OF_RANGE); + } + + return(ERROR_NONE); +} + +NvParameterized::ErrorType MeshCookedCollisionStreamsAtScale::getParameterHandle(const char* long_name, Handle& handle) +{ + ErrorType Ret = NvParameters::getParameterHandle(long_name, handle); + if (Ret != ERROR_NONE) + { + return(Ret); + } + + size_t offset; + void* ptr; + + getVarPtr(handle, ptr, offset); + + if (ptr == NULL) + { + return(ERROR_INDEX_OUT_OF_RANGE); + } + + return(ERROR_NONE); +} + +void MeshCookedCollisionStreamsAtScale::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const +{ + ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<MeshCookedCollisionStreamsAtScale::ParametersStruct*>(¶meters()), handle, offset); +} + + +/* Dynamic Handle Indices */ +/* [0] - meshCookedCollisionStreams (not an array of structs) */ + +void MeshCookedCollisionStreamsAtScale::freeParameterDefinitionTable(NvParameterized::Traits* traits) +{ + if (!traits) + { + return; + } + + if (!mBuiltFlag) // Double-checked lock + { + return; + } + + NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex); + + if (!mBuiltFlag) + { + return; + } + + for (uint32_t i = 0; i < NumParamDefs; ++i) + { + ParamDefTable[i].~DefinitionImpl(); + } + + traits->free(ParamDefTable); + + mBuiltFlag = false; +} + +#define PDEF_PTR(index) (&ParamDefTable[index]) + +void MeshCookedCollisionStreamsAtScale::buildTree(void) +{ + + uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs; + ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize)); + memset(ParamDefTable, 0, allocSize); + + for (uint32_t i = 0; i < NumParamDefs; ++i) + { + NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits); + } + + // Initialize DefinitionImpl node: nodeIndex=0, longName="" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0]; + ParamDef->init("", TYPE_STRUCT, "STRUCT", true); + + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=1, longName="meshCookedCollisionStreams" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1]; + ParamDef->init("meshCookedCollisionStreams", TYPE_ARRAY, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("INCLUDED", uint64_t(1), true); + ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("INCLUDED", uint64_t(1), true); + HintTable[1].init("longDescription", "An array of collision hull byte streams. These will be the convex\n hulls for all chunks at a particular scale.", true); + HintTable[2].init("shortDescription", "An array of collision hull byte streams", true); + ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + static const char* const RefVariantVals[] = { "MeshCookedCollisionStream" }; + ParamDefTable[1].setRefVariantVals((const char**)RefVariantVals, 1); + + + ParamDef->setArraySize(-1); + static const uint8_t dynHandleIndices[1] = { 0, }; + ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1); + + } + + // Initialize DefinitionImpl node: nodeIndex=2, longName="meshCookedCollisionStreams[]" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2]; + ParamDef->init("meshCookedCollisionStreams", TYPE_REF, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("INCLUDED", uint64_t(1), true); + ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("INCLUDED", uint64_t(1), true); + HintTable[1].init("longDescription", "An array of collision hull byte streams. These will be the convex\n hulls for all chunks at a particular scale.", true); + HintTable[2].init("shortDescription", "An array of collision hull byte streams", true); + ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + static const char* const RefVariantVals[] = { "MeshCookedCollisionStream" }; + ParamDefTable[2].setRefVariantVals((const char**)RefVariantVals, 1); + + + + } + + // SetChildren for: nodeIndex=0, longName="" + { + static Definition* Children[1]; + Children[0] = PDEF_PTR(1); + + ParamDefTable[0].setChildren(Children, 1); + } + + // SetChildren for: nodeIndex=1, longName="meshCookedCollisionStreams" + { + static Definition* Children[1]; + Children[0] = PDEF_PTR(2); + + ParamDefTable[1].setChildren(Children, 1); + } + + mBuiltFlag = true; + +} +void MeshCookedCollisionStreamsAtScale::initStrings(void) +{ +} + +void MeshCookedCollisionStreamsAtScale::initDynamicArrays(void) +{ + meshCookedCollisionStreams.buf = NULL; + meshCookedCollisionStreams.isAllocated = true; + meshCookedCollisionStreams.elementSize = sizeof(NvParameterized::Interface*); + meshCookedCollisionStreams.arraySizes[0] = 0; +} + +void MeshCookedCollisionStreamsAtScale::initDefaults(void) +{ + + freeStrings(); + freeReferences(); + freeDynamicArrays(); + + initDynamicArrays(); + initStrings(); + initReferences(); +} + +void MeshCookedCollisionStreamsAtScale::initReferences(void) +{ +} + +void MeshCookedCollisionStreamsAtScale::freeDynamicArrays(void) +{ + if (meshCookedCollisionStreams.isAllocated && meshCookedCollisionStreams.buf) + { + mParameterizedTraits->free(meshCookedCollisionStreams.buf); + } +} + +void MeshCookedCollisionStreamsAtScale::freeStrings(void) +{ +} + +void MeshCookedCollisionStreamsAtScale::freeReferences(void) +{ + + for (int i = 0; i < meshCookedCollisionStreams.arraySizes[0]; ++i) + { + if (meshCookedCollisionStreams.buf[i]) + { + meshCookedCollisionStreams.buf[i]->destroy(); + } + } +} + +} // namespace destructible +} // namespace nvidia diff --git a/APEX_1.4/module/destructible/src/autogen/SurfaceTraceParameters.cpp b/APEX_1.4/module/destructible/src/autogen/SurfaceTraceParameters.cpp new file mode 100644 index 00000000..7a4cfbef --- /dev/null +++ b/APEX_1.4/module/destructible/src/autogen/SurfaceTraceParameters.cpp @@ -0,0 +1,438 @@ +// 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-2015 NVIDIA Corporation. All rights reserved. + +// This file was generated by NvParameterized/scripts/GenParameterized.pl + + +#include "SurfaceTraceParameters.h" +#include <string.h> +#include <stdlib.h> + +using namespace NvParameterized; + +namespace nvidia +{ +namespace destructible +{ + +using namespace SurfaceTraceParametersNS; + +const char* const SurfaceTraceParametersFactory::vptr = + NvParameterized::getVptr<SurfaceTraceParameters, SurfaceTraceParameters::ClassAlignment>(); + +const uint32_t NumParamDefs = 6; +static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs]; + + +static const size_t ParamLookupChildrenTable[] = +{ + 1, 3, 5, 2, 4, +}; + +#define TENUM(type) nvidia::##type +#define CHILDREN(index) &ParamLookupChildrenTable[index] +static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] = +{ + { TYPE_STRUCT, false, 0, CHILDREN(0), 3 }, + { TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->submeshIndices), CHILDREN(3), 1 }, // submeshIndices + { TYPE_U8, false, 1 * sizeof(uint8_t), NULL, 0 }, // submeshIndices[] + { TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->vertexIndices), CHILDREN(4), 1 }, // vertexIndices + { TYPE_U32, false, 1 * sizeof(uint32_t), NULL, 0 }, // vertexIndices[] + { TYPE_VEC3, false, (size_t)(&((ParametersStruct*)0)->defaultNormal), NULL, 0 }, // defaultNormal +}; + + +bool SurfaceTraceParameters::mBuiltFlag = false; +NvParameterized::MutexType SurfaceTraceParameters::mBuiltFlagMutex; + +SurfaceTraceParameters::SurfaceTraceParameters(NvParameterized::Traits* traits, void* buf, int32_t* refCount) : + NvParameters(traits, buf, refCount) +{ + //mParameterizedTraits->registerFactory(className(), &SurfaceTraceParametersFactoryInst); + + if (!buf) //Do not init data if it is inplace-deserialized + { + initDynamicArrays(); + initStrings(); + initReferences(); + initDefaults(); + } +} + +SurfaceTraceParameters::~SurfaceTraceParameters() +{ + freeStrings(); + freeReferences(); + freeDynamicArrays(); +} + +void SurfaceTraceParameters::destroy() +{ + // We cache these fields here to avoid overwrite in destructor + bool doDeallocateSelf = mDoDeallocateSelf; + NvParameterized::Traits* traits = mParameterizedTraits; + int32_t* refCount = mRefCount; + void* buf = mBuffer; + + this->~SurfaceTraceParameters(); + + NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf); +} + +const NvParameterized::DefinitionImpl* SurfaceTraceParameters::getParameterDefinitionTree(void) +{ + if (!mBuiltFlag) // Double-checked lock + { + NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex); + if (!mBuiltFlag) + { + buildTree(); + } + } + + return(&ParamDefTable[0]); +} + +const NvParameterized::DefinitionImpl* SurfaceTraceParameters::getParameterDefinitionTree(void) const +{ + SurfaceTraceParameters* tmpParam = const_cast<SurfaceTraceParameters*>(this); + + if (!mBuiltFlag) // Double-checked lock + { + NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex); + if (!mBuiltFlag) + { + tmpParam->buildTree(); + } + } + + return(&ParamDefTable[0]); +} + +NvParameterized::ErrorType SurfaceTraceParameters::getParameterHandle(const char* long_name, Handle& handle) const +{ + ErrorType Ret = NvParameters::getParameterHandle(long_name, handle); + if (Ret != ERROR_NONE) + { + return(Ret); + } + + size_t offset; + void* ptr; + + getVarPtr(handle, ptr, offset); + + if (ptr == NULL) + { + return(ERROR_INDEX_OUT_OF_RANGE); + } + + return(ERROR_NONE); +} + +NvParameterized::ErrorType SurfaceTraceParameters::getParameterHandle(const char* long_name, Handle& handle) +{ + ErrorType Ret = NvParameters::getParameterHandle(long_name, handle); + if (Ret != ERROR_NONE) + { + return(Ret); + } + + size_t offset; + void* ptr; + + getVarPtr(handle, ptr, offset); + + if (ptr == NULL) + { + return(ERROR_INDEX_OUT_OF_RANGE); + } + + return(ERROR_NONE); +} + +void SurfaceTraceParameters::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const +{ + ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<SurfaceTraceParameters::ParametersStruct*>(¶meters()), handle, offset); +} + + +/* Dynamic Handle Indices */ + +void SurfaceTraceParameters::freeParameterDefinitionTable(NvParameterized::Traits* traits) +{ + if (!traits) + { + return; + } + + if (!mBuiltFlag) // Double-checked lock + { + return; + } + + NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex); + + if (!mBuiltFlag) + { + return; + } + + for (uint32_t i = 0; i < NumParamDefs; ++i) + { + ParamDefTable[i].~DefinitionImpl(); + } + + traits->free(ParamDefTable); + + mBuiltFlag = false; +} + +#define PDEF_PTR(index) (&ParamDefTable[index]) + +void SurfaceTraceParameters::buildTree(void) +{ + + uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs; + ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize)); + memset(ParamDefTable, 0, allocSize); + + for (uint32_t i = 0; i < NumParamDefs; ++i) + { + NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits); + } + + // Initialize DefinitionImpl node: nodeIndex=0, longName="" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0]; + ParamDef->init("", TYPE_STRUCT, "STRUCT", true); + + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=1, longName="submeshIndices" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1]; + ParamDef->init("submeshIndices", TYPE_ARRAY, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The submeshes to which the corresponding vertices (in vertexIndices) belong.\n The surface traces are defined as a set of vertex indices, but these indices are relative to\n a submesh. The size of submeshIndices must be equal to the size of vertexIndices.", true); + HintTable[1].init("shortDescription", "The submeshes to which the corresponding vertices (in vertexIndices) belong", true); + ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + ParamDef->setArraySize(-1); + } + + // Initialize DefinitionImpl node: nodeIndex=2, longName="submeshIndices[]" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2]; + ParamDef->init("submeshIndices", TYPE_U8, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The submeshes to which the corresponding vertices (in vertexIndices) belong.\n The surface traces are defined as a set of vertex indices, but these indices are relative to\n a submesh. The size of submeshIndices must be equal to the size of vertexIndices.", true); + HintTable[1].init("shortDescription", "The submeshes to which the corresponding vertices (in vertexIndices) belong", true); + ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=3, longName="vertexIndices" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3]; + ParamDef->init("vertexIndices", TYPE_ARRAY, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The vertex indices defining the surface trace. The surface traces are defined\n as a set of vertex indices, but these indices are relative to a submesh. The size of submeshIndices\n must be equal to the size of vertexIndices.", true); + HintTable[1].init("shortDescription", "The vertex indices defining the surface trace.", true); + ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + ParamDef->setArraySize(-1); + } + + // Initialize DefinitionImpl node: nodeIndex=4, longName="vertexIndices[]" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4]; + ParamDef->init("vertexIndices", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The vertex indices defining the surface trace. The surface traces are defined\n as a set of vertex indices, but these indices are relative to a submesh. The size of submeshIndices\n must be equal to the size of vertexIndices.", true); + HintTable[1].init("shortDescription", "The vertex indices defining the surface trace.", true); + ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=5, longName="defaultNormal" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5]; + ParamDef->init("defaultNormal", TYPE_VEC3, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "The average surface normal for this trace. A surface trace is a single closed loop\n on the surface of the mesh, along triangle boundaries. This normal is the normalized average of the\n surface triangles enclosed by the loop.", true); + HintTable[1].init("shortDescription", "The average surface normal for this trace", true); + ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // SetChildren for: nodeIndex=0, longName="" + { + static Definition* Children[3]; + Children[0] = PDEF_PTR(1); + Children[1] = PDEF_PTR(3); + Children[2] = PDEF_PTR(5); + + ParamDefTable[0].setChildren(Children, 3); + } + + // SetChildren for: nodeIndex=1, longName="submeshIndices" + { + static Definition* Children[1]; + Children[0] = PDEF_PTR(2); + + ParamDefTable[1].setChildren(Children, 1); + } + + // SetChildren for: nodeIndex=3, longName="vertexIndices" + { + static Definition* Children[1]; + Children[0] = PDEF_PTR(4); + + ParamDefTable[3].setChildren(Children, 1); + } + + mBuiltFlag = true; + +} +void SurfaceTraceParameters::initStrings(void) +{ +} + +void SurfaceTraceParameters::initDynamicArrays(void) +{ + submeshIndices.buf = NULL; + submeshIndices.isAllocated = true; + submeshIndices.elementSize = sizeof(uint8_t); + submeshIndices.arraySizes[0] = 0; + vertexIndices.buf = NULL; + vertexIndices.isAllocated = true; + vertexIndices.elementSize = sizeof(uint32_t); + vertexIndices.arraySizes[0] = 0; +} + +void SurfaceTraceParameters::initDefaults(void) +{ + + freeStrings(); + freeReferences(); + freeDynamicArrays(); + + initDynamicArrays(); + initStrings(); + initReferences(); +} + +void SurfaceTraceParameters::initReferences(void) +{ +} + +void SurfaceTraceParameters::freeDynamicArrays(void) +{ + if (submeshIndices.isAllocated && submeshIndices.buf) + { + mParameterizedTraits->free(submeshIndices.buf); + } + if (vertexIndices.isAllocated && vertexIndices.buf) + { + mParameterizedTraits->free(vertexIndices.buf); + } +} + +void SurfaceTraceParameters::freeStrings(void) +{ +} + +void SurfaceTraceParameters::freeReferences(void) +{ +} + +} // namespace destructible +} // namespace nvidia diff --git a/APEX_1.4/module/destructible/src/autogen/SurfaceTraceSetParameters.cpp b/APEX_1.4/module/destructible/src/autogen/SurfaceTraceSetParameters.cpp new file mode 100644 index 00000000..d5b35283 --- /dev/null +++ b/APEX_1.4/module/destructible/src/autogen/SurfaceTraceSetParameters.cpp @@ -0,0 +1,402 @@ +// 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-2015 NVIDIA Corporation. All rights reserved. + +// This file was generated by NvParameterized/scripts/GenParameterized.pl + + +#include "SurfaceTraceSetParameters.h" +#include <string.h> +#include <stdlib.h> + +using namespace NvParameterized; + +namespace nvidia +{ +namespace destructible +{ + +using namespace SurfaceTraceSetParametersNS; + +const char* const SurfaceTraceSetParametersFactory::vptr = + NvParameterized::getVptr<SurfaceTraceSetParameters, SurfaceTraceSetParameters::ClassAlignment>(); + +const uint32_t NumParamDefs = 4; +static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs]; + + +static const size_t ParamLookupChildrenTable[] = +{ + 1, 3, 2, +}; + +#define TENUM(type) nvidia::##type +#define CHILDREN(index) &ParamLookupChildrenTable[index] +static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] = +{ + { TYPE_STRUCT, false, 0, CHILDREN(0), 2 }, + { TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->traces), CHILDREN(2), 1 }, // traces + { TYPE_REF, false, 1 * sizeof(NvParameterized::Interface*), NULL, 0 }, // traces[] + { TYPE_VEC3, false, (size_t)(&((ParametersStruct*)0)->positionOffset), NULL, 0 }, // positionOffset +}; + + +bool SurfaceTraceSetParameters::mBuiltFlag = false; +NvParameterized::MutexType SurfaceTraceSetParameters::mBuiltFlagMutex; + +SurfaceTraceSetParameters::SurfaceTraceSetParameters(NvParameterized::Traits* traits, void* buf, int32_t* refCount) : + NvParameters(traits, buf, refCount) +{ + //mParameterizedTraits->registerFactory(className(), &SurfaceTraceSetParametersFactoryInst); + + if (!buf) //Do not init data if it is inplace-deserialized + { + initDynamicArrays(); + initStrings(); + initReferences(); + initDefaults(); + } +} + +SurfaceTraceSetParameters::~SurfaceTraceSetParameters() +{ + freeStrings(); + freeReferences(); + freeDynamicArrays(); +} + +void SurfaceTraceSetParameters::destroy() +{ + // We cache these fields here to avoid overwrite in destructor + bool doDeallocateSelf = mDoDeallocateSelf; + NvParameterized::Traits* traits = mParameterizedTraits; + int32_t* refCount = mRefCount; + void* buf = mBuffer; + + this->~SurfaceTraceSetParameters(); + + NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf); +} + +const NvParameterized::DefinitionImpl* SurfaceTraceSetParameters::getParameterDefinitionTree(void) +{ + if (!mBuiltFlag) // Double-checked lock + { + NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex); + if (!mBuiltFlag) + { + buildTree(); + } + } + + return(&ParamDefTable[0]); +} + +const NvParameterized::DefinitionImpl* SurfaceTraceSetParameters::getParameterDefinitionTree(void) const +{ + SurfaceTraceSetParameters* tmpParam = const_cast<SurfaceTraceSetParameters*>(this); + + if (!mBuiltFlag) // Double-checked lock + { + NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex); + if (!mBuiltFlag) + { + tmpParam->buildTree(); + } + } + + return(&ParamDefTable[0]); +} + +NvParameterized::ErrorType SurfaceTraceSetParameters::getParameterHandle(const char* long_name, Handle& handle) const +{ + ErrorType Ret = NvParameters::getParameterHandle(long_name, handle); + if (Ret != ERROR_NONE) + { + return(Ret); + } + + size_t offset; + void* ptr; + + getVarPtr(handle, ptr, offset); + + if (ptr == NULL) + { + return(ERROR_INDEX_OUT_OF_RANGE); + } + + return(ERROR_NONE); +} + +NvParameterized::ErrorType SurfaceTraceSetParameters::getParameterHandle(const char* long_name, Handle& handle) +{ + ErrorType Ret = NvParameters::getParameterHandle(long_name, handle); + if (Ret != ERROR_NONE) + { + return(Ret); + } + + size_t offset; + void* ptr; + + getVarPtr(handle, ptr, offset); + + if (ptr == NULL) + { + return(ERROR_INDEX_OUT_OF_RANGE); + } + + return(ERROR_NONE); +} + +void SurfaceTraceSetParameters::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const +{ + ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<SurfaceTraceSetParameters::ParametersStruct*>(¶meters()), handle, offset); +} + + +/* Dynamic Handle Indices */ +/* [0] - traces (not an array of structs) */ + +void SurfaceTraceSetParameters::freeParameterDefinitionTable(NvParameterized::Traits* traits) +{ + if (!traits) + { + return; + } + + if (!mBuiltFlag) // Double-checked lock + { + return; + } + + NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex); + + if (!mBuiltFlag) + { + return; + } + + for (uint32_t i = 0; i < NumParamDefs; ++i) + { + ParamDefTable[i].~DefinitionImpl(); + } + + traits->free(ParamDefTable); + + mBuiltFlag = false; +} + +#define PDEF_PTR(index) (&ParamDefTable[index]) + +void SurfaceTraceSetParameters::buildTree(void) +{ + + uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs; + ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize)); + memset(ParamDefTable, 0, allocSize); + + for (uint32_t i = 0; i < NumParamDefs; ++i) + { + NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits); + } + + // Initialize DefinitionImpl node: nodeIndex=0, longName="" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0]; + ParamDef->init("", TYPE_STRUCT, "STRUCT", true); + + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=1, longName="traces" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1]; + ParamDef->init("traces", TYPE_ARRAY, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("INCLUDED", uint64_t(1), true); + ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("INCLUDED", uint64_t(1), true); + HintTable[1].init("longDescription", "A set of surface traces belonging to a single chunk. Since chunks\n may have a complex shape, the triangles which are on the destructible's surface may not\n form a contiguous set. Therefore there may be more than one surface trace per chunk.", true); + HintTable[2].init("shortDescription", "A set of surface traces belonging to a single chunk", true); + ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + static const char* const RefVariantVals[] = { "SurfaceTraceParameters" }; + ParamDefTable[1].setRefVariantVals((const char**)RefVariantVals, 1); + + + ParamDef->setArraySize(-1); + static const uint8_t dynHandleIndices[1] = { 0, }; + ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1); + + } + + // Initialize DefinitionImpl node: nodeIndex=2, longName="traces[]" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2]; + ParamDef->init("traces", TYPE_REF, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("INCLUDED", uint64_t(1), true); + ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("INCLUDED", uint64_t(1), true); + HintTable[1].init("longDescription", "A set of surface traces belonging to a single chunk. Since chunks\n may have a complex shape, the triangles which are on the destructible's surface may not\n form a contiguous set. Therefore there may be more than one surface trace per chunk.", true); + HintTable[2].init("shortDescription", "A set of surface traces belonging to a single chunk", true); + ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + static const char* const RefVariantVals[] = { "SurfaceTraceParameters" }; + ParamDefTable[2].setRefVariantVals((const char**)RefVariantVals, 1); + + + + } + + // Initialize DefinitionImpl node: nodeIndex=3, longName="positionOffset" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3]; + ParamDef->init("positionOffset", TYPE_VEC3, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("longDescription", "Chunk-local offset for this trace, needed for instanced chunks.", true); + HintTable[1].init("shortDescription", "Chunk-local offset for this trace, needed for instanced chunks", true); + ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // SetChildren for: nodeIndex=0, longName="" + { + static Definition* Children[2]; + Children[0] = PDEF_PTR(1); + Children[1] = PDEF_PTR(3); + + ParamDefTable[0].setChildren(Children, 2); + } + + // SetChildren for: nodeIndex=1, longName="traces" + { + static Definition* Children[1]; + Children[0] = PDEF_PTR(2); + + ParamDefTable[1].setChildren(Children, 1); + } + + mBuiltFlag = true; + +} +void SurfaceTraceSetParameters::initStrings(void) +{ +} + +void SurfaceTraceSetParameters::initDynamicArrays(void) +{ + traces.buf = NULL; + traces.isAllocated = true; + traces.elementSize = sizeof(NvParameterized::Interface*); + traces.arraySizes[0] = 0; +} + +void SurfaceTraceSetParameters::initDefaults(void) +{ + + freeStrings(); + freeReferences(); + freeDynamicArrays(); + positionOffset = physx::PxVec3(physx::PxVec3(0.0f)); + + initDynamicArrays(); + initStrings(); + initReferences(); +} + +void SurfaceTraceSetParameters::initReferences(void) +{ +} + +void SurfaceTraceSetParameters::freeDynamicArrays(void) +{ + if (traces.isAllocated && traces.buf) + { + mParameterizedTraits->free(traces.buf); + } +} + +void SurfaceTraceSetParameters::freeStrings(void) +{ +} + +void SurfaceTraceSetParameters::freeReferences(void) +{ + + for (int i = 0; i < traces.arraySizes[0]; ++i) + { + if (traces.buf[i]) + { + traces.buf[i]->destroy(); + } + } +} + +} // namespace destructible +} // namespace nvidia |