diff options
Diffstat (limited to 'APEX_1.4/module/particles/src/autogen/EffectPackageAssetParams.cpp')
| -rw-r--r-- | APEX_1.4/module/particles/src/autogen/EffectPackageAssetParams.cpp | 1613 |
1 files changed, 1613 insertions, 0 deletions
diff --git a/APEX_1.4/module/particles/src/autogen/EffectPackageAssetParams.cpp b/APEX_1.4/module/particles/src/autogen/EffectPackageAssetParams.cpp new file mode 100644 index 00000000..1c36c949 --- /dev/null +++ b/APEX_1.4/module/particles/src/autogen/EffectPackageAssetParams.cpp @@ -0,0 +1,1613 @@ +// 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 "EffectPackageAssetParams.h" +#include <string.h> +#include <stdlib.h> + +using namespace NvParameterized; + +namespace nvidia +{ +namespace particles +{ + +using namespace EffectPackageAssetParamsNS; + +const char* const EffectPackageAssetParamsFactory::vptr = + NvParameterized::getVptr<EffectPackageAssetParams, EffectPackageAssetParams::ClassAlignment>(); + +const uint32_t NumParamDefs = 40; +static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs]; + + +static const size_t ParamLookupChildrenTable[] = +{ + 1, 23, 37, 39, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 24, 25, 26, 27, 29, 33, 28, 30, 31, 32, 34, 35, 36, 38, +}; + +#define TENUM(type) nvidia::##type +#define CHILDREN(index) &ParamLookupChildrenTable[index] +static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] = +{ + { TYPE_STRUCT, false, 0, CHILDREN(0), 4 }, + { TYPE_STRUCT, false, (size_t)(&((ParametersStruct*)0)->LODSettings), CHILDREN(4), 21 }, // LODSettings + { TYPE_BOOL, false, (size_t)(&((LevelOfDetailSettings_Type*)0)->UniqueRenderVolume), NULL, 0 }, // LODSettings.UniqueRenderVolume + { TYPE_F32, false, (size_t)(&((LevelOfDetailSettings_Type*)0)->FadeDistanceBegin), NULL, 0 }, // LODSettings.FadeDistanceBegin + { TYPE_F32, false, (size_t)(&((LevelOfDetailSettings_Type*)0)->FadeDistanceEnd), NULL, 0 }, // LODSettings.FadeDistanceEnd + { TYPE_BOOL, false, (size_t)(&((LevelOfDetailSettings_Type*)0)->RandomizeEmitterRate), NULL, 0 }, // LODSettings.RandomizeEmitterRate + { TYPE_F32, false, (size_t)(&((LevelOfDetailSettings_Type*)0)->FadeOutRate), NULL, 0 }, // LODSettings.FadeOutRate + { TYPE_BOOL, false, (size_t)(&((LevelOfDetailSettings_Type*)0)->CullByDistance), NULL, 0 }, // LODSettings.CullByDistance + { TYPE_BOOL, false, (size_t)(&((LevelOfDetailSettings_Type*)0)->CullOffScreen), NULL, 0 }, // LODSettings.CullOffScreen + { TYPE_F32, false, (size_t)(&((LevelOfDetailSettings_Type*)0)->OffScreenCullTime), NULL, 0 }, // LODSettings.OffScreenCullTime + { TYPE_F32, false, (size_t)(&((LevelOfDetailSettings_Type*)0)->NonVisibleDeleteTime), NULL, 0 }, // LODSettings.NonVisibleDeleteTime + { TYPE_F32, false, (size_t)(&((LevelOfDetailSettings_Type*)0)->ScreenCullSize), NULL, 0 }, // LODSettings.ScreenCullSize + { TYPE_F32, false, (size_t)(&((LevelOfDetailSettings_Type*)0)->ScreenCullDistance), NULL, 0 }, // LODSettings.ScreenCullDistance + { TYPE_BOOL, false, (size_t)(&((LevelOfDetailSettings_Type*)0)->FadeEmitterRate), NULL, 0 }, // LODSettings.FadeEmitterRate + { TYPE_BOOL, false, (size_t)(&((LevelOfDetailSettings_Type*)0)->FadeAttractorFieldStrength), NULL, 0 }, // LODSettings.FadeAttractorFieldStrength + { TYPE_BOOL, false, (size_t)(&((LevelOfDetailSettings_Type*)0)->FadeJetFieldStrength), NULL, 0 }, // LODSettings.FadeJetFieldStrength + { TYPE_BOOL, false, (size_t)(&((LevelOfDetailSettings_Type*)0)->FadeTurbulenceVelocity), NULL, 0 }, // LODSettings.FadeTurbulenceVelocity + { TYPE_BOOL, false, (size_t)(&((LevelOfDetailSettings_Type*)0)->FadeTurbulenceNoise), NULL, 0 }, // LODSettings.FadeTurbulenceNoise + { TYPE_BOOL, false, (size_t)(&((LevelOfDetailSettings_Type*)0)->FadeTurbulenceExternalVelocity), NULL, 0 }, // LODSettings.FadeTurbulenceExternalVelocity + { TYPE_BOOL, false, (size_t)(&((LevelOfDetailSettings_Type*)0)->FadeTurbulenceVelocityWeight), NULL, 0 }, // LODSettings.FadeTurbulenceVelocityWeight + { TYPE_BOOL, false, (size_t)(&((LevelOfDetailSettings_Type*)0)->FadeHeatSourceTemperature), NULL, 0 }, // LODSettings.FadeHeatSourceTemperature + { TYPE_BOOL, false, (size_t)(&((LevelOfDetailSettings_Type*)0)->FadeForceFieldStrength), NULL, 0 }, // LODSettings.FadeForceFieldStrength + { TYPE_BOOL, false, (size_t)(&((LevelOfDetailSettings_Type*)0)->FadeForceFieldScale), NULL, 0 }, // LODSettings.FadeForceFieldScale + { TYPE_STRUCT, false, (size_t)(&((ParametersStruct*)0)->Path), CHILDREN(25), 6 }, // Path + { TYPE_ENUM, false, (size_t)(&((EffectPath_Type*)0)->PlaybackMode), NULL, 0 }, // Path.PlaybackMode + { TYPE_F32, false, (size_t)(&((EffectPath_Type*)0)->PathDuration), NULL, 0 }, // Path.PathDuration + { TYPE_U32, false, (size_t)(&((EffectPath_Type*)0)->LoopIndex), NULL, 0 }, // Path.LoopIndex + { TYPE_ARRAY, true, (size_t)(&((EffectPath_Type*)0)->ControlPoints), CHILDREN(31), 1 }, // Path.ControlPoints + { TYPE_TRANSFORM, false, 1 * sizeof(physx::PxTransform), NULL, 0 }, // Path.ControlPoints[] + { TYPE_ARRAY, true, (size_t)(&((EffectPath_Type*)0)->Scale), CHILDREN(32), 1 }, // Path.Scale + { TYPE_STRUCT, false, 1 * sizeof(ControlPoint_Type), CHILDREN(33), 2 }, // Path.Scale[] + { TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->x), NULL, 0 }, // Path.Scale[].x + { TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->y), NULL, 0 }, // Path.Scale[].y + { TYPE_ARRAY, true, (size_t)(&((EffectPath_Type*)0)->Speed), CHILDREN(35), 1 }, // Path.Speed + { TYPE_STRUCT, false, 1 * sizeof(ControlPoint_Type), CHILDREN(36), 2 }, // Path.Speed[] + { TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->x), NULL, 0 }, // Path.Speed[].x + { TYPE_F32, false, (size_t)(&((ControlPoint_Type*)0)->y), NULL, 0 }, // Path.Speed[].y + { TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->Effects), CHILDREN(38), 1 }, // Effects + { TYPE_REF, false, 1 * sizeof(NvParameterized::Interface*), NULL, 0 }, // Effects[] + { TYPE_STRING, false, (size_t)(&((ParametersStruct*)0)->toolString), NULL, 0 }, // toolString +}; + + +bool EffectPackageAssetParams::mBuiltFlag = false; +NvParameterized::MutexType EffectPackageAssetParams::mBuiltFlagMutex; + +EffectPackageAssetParams::EffectPackageAssetParams(NvParameterized::Traits* traits, void* buf, int32_t* refCount) : + NvParameters(traits, buf, refCount) +{ + //mParameterizedTraits->registerFactory(className(), &EffectPackageAssetParamsFactoryInst); + + if (!buf) //Do not init data if it is inplace-deserialized + { + initDynamicArrays(); + initStrings(); + initReferences(); + initDefaults(); + } +} + +EffectPackageAssetParams::~EffectPackageAssetParams() +{ + freeStrings(); + freeReferences(); + freeDynamicArrays(); +} + +void EffectPackageAssetParams::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->~EffectPackageAssetParams(); + + NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf); +} + +const NvParameterized::DefinitionImpl* EffectPackageAssetParams::getParameterDefinitionTree(void) +{ + if (!mBuiltFlag) // Double-checked lock + { + NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex); + if (!mBuiltFlag) + { + buildTree(); + } + } + + return(&ParamDefTable[0]); +} + +const NvParameterized::DefinitionImpl* EffectPackageAssetParams::getParameterDefinitionTree(void) const +{ + EffectPackageAssetParams* tmpParam = const_cast<EffectPackageAssetParams*>(this); + + if (!mBuiltFlag) // Double-checked lock + { + NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex); + if (!mBuiltFlag) + { + tmpParam->buildTree(); + } + } + + return(&ParamDefTable[0]); +} + +NvParameterized::ErrorType EffectPackageAssetParams::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 EffectPackageAssetParams::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 EffectPackageAssetParams::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const +{ + ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<EffectPackageAssetParams::ParametersStruct*>(¶meters()), handle, offset); +} + + +/* Dynamic Handle Indices */ +/* [0] - Effects (not an array of structs) */ + +void EffectPackageAssetParams::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 EffectPackageAssetParams::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", "The effect package asset", true); + ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=1, longName="LODSettings" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1]; + ParamDef->init("LODSettings", TYPE_STRUCT, "LevelOfDetailSettings", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("shortDescription", "LOD Settings for this effect package", true); + ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=2, longName="LODSettings.UniqueRenderVolume" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2]; + ParamDef->init("UniqueRenderVolume", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("shortDescription", "Set to true if this effect should have a unique render volume; to get a separate draw call from all other instances of this effect", true); + ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=3, longName="LODSettings.FadeDistanceBegin" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3]; + ParamDef->init("FadeDistanceBegin", 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", double(5000.000000000), true); + HintTable[1].init("min", double(0.100000001), true); + ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#else + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("max", double(5000.000000000), true); + HintTable[1].init("min", double(0.100000001), true); + HintTable[2].init("shortDescription", "Distance to begin fading out the effect", true); + ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=4, longName="LODSettings.FadeDistanceEnd" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4]; + ParamDef->init("FadeDistanceEnd", 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", double(5000.000000000), true); + HintTable[1].init("min", double(0.100000001), true); + ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#else + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("max", double(5000.000000000), true); + HintTable[1].init("min", double(0.100000001), true); + HintTable[2].init("shortDescription", "Distance to finish fading out the effect", true); + ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=5, longName="LODSettings.RandomizeEmitterRate" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5]; + ParamDef->init("RandomizeEmitterRate", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("shortDescription", "If true the emitter rate is randomized from the min to max values", true); + ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=6, longName="LODSettings.FadeOutRate" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[6]; + ParamDef->init("FadeOutRate", 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", double(10.000000000), true); + HintTable[1].init("min", double(0.000000000), true); + ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#else + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("max", double(10.000000000), true); + HintTable[1].init("min", double(0.000000000), true); + HintTable[2].init("shortDescription", "Time over which to fade out effect completely", true); + ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=7, longName="LODSettings.CullByDistance" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[7]; + ParamDef->init("CullByDistance", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("shortDescription", "Whether or not to cull effects based on their distance from the camera; requires a valid view matrix", true); + ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=8, longName="LODSettings.CullOffScreen" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[8]; + ParamDef->init("CullOffScreen", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("shortDescription", "Whether or not to cull this effect if it is off screen", true); + ParamDefTable[8].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=9, longName="LODSettings.OffScreenCullTime" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[9]; + ParamDef->init("OffScreenCullTime", 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", double(99.000000000), true); + HintTable[1].init("min", double(0.000000000), true); + ParamDefTable[9].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#else + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("max", double(99.000000000), true); + HintTable[1].init("min", double(0.000000000), true); + HintTable[2].init("shortDescription", "Time the effect should be offscreen before it is disabled", true); + ParamDefTable[9].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=10, longName="LODSettings.NonVisibleDeleteTime" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[10]; + ParamDef->init("NonVisibleDeleteTime", 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", double(99.000000000), true); + HintTable[1].init("min", double(0.000000000), true); + ParamDefTable[10].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#else + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("max", double(99.000000000), true); + HintTable[1].init("min", double(0.000000000), true); + HintTable[2].init("shortDescription", "The time an effect is non-visible before we delete it, rathern than just disabling it's state", true); + ParamDefTable[10].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=11, longName="LODSettings.ScreenCullSize" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[11]; + ParamDef->init("ScreenCullSize", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("DISPLAY_NAME", "ScreenCullingSize", true); + HintTable[1].init("max", double(1.000000000), true); + HintTable[2].init("min", double(0.010000000), true); + ParamDefTable[11].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#else + + static HintImpl HintTable[4]; + static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], }; + HintTable[0].init("DISPLAY_NAME", "ScreenCullingSize", true); + HintTable[1].init("max", double(1.000000000), true); + HintTable[2].init("min", double(0.010000000), true); + HintTable[3].init("shortDescription", "Bounding volme to cull the effect when near the edge of the screen", true); + ParamDefTable[11].setHints((const NvParameterized::Hint**)HintPtrTable, 4); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=12, longName="LODSettings.ScreenCullDistance" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[12]; + ParamDef->init("ScreenCullDistance", TYPE_F32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("min", double(0.000000000), true); + ParamDefTable[12].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("min", double(0.000000000), true); + HintTable[1].init("shortDescription", "Radius to camera that we bypass screen culling entirely because the effect is too close to the screen; default is 3 meters", true); + ParamDefTable[12].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=13, longName="LODSettings.FadeEmitterRate" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[13]; + ParamDef->init("FadeEmitterRate", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("shortDescription", "Control the emitter rate with Fade Distance LOD setting", true); + ParamDefTable[13].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=14, longName="LODSettings.FadeAttractorFieldStrength" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[14]; + ParamDef->init("FadeAttractorFieldStrength", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("HIDDEN", uint64_t(1), true); + ParamDefTable[14].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("HIDDEN", uint64_t(1), true); + HintTable[1].init("shortDescription", "Helpful tooltip information goes here", true); + ParamDefTable[14].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=15, longName="LODSettings.FadeJetFieldStrength" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[15]; + ParamDef->init("FadeJetFieldStrength", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("HIDDEN", uint64_t(1), true); + ParamDefTable[15].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("HIDDEN", uint64_t(1), true); + HintTable[1].init("shortDescription", "Helpful tooltip information goes here", true); + ParamDefTable[15].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=16, longName="LODSettings.FadeTurbulenceVelocity" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[16]; + ParamDef->init("FadeTurbulenceVelocity", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("HIDDEN", uint64_t(1), true); + ParamDefTable[16].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("HIDDEN", uint64_t(1), true); + HintTable[1].init("shortDescription", "Helpful tooltip information goes here", true); + ParamDefTable[16].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=17, longName="LODSettings.FadeTurbulenceNoise" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[17]; + ParamDef->init("FadeTurbulenceNoise", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("HIDDEN", uint64_t(1), true); + ParamDefTable[17].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("HIDDEN", uint64_t(1), true); + HintTable[1].init("shortDescription", "Helpful tooltip information goes here", true); + ParamDefTable[17].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=18, longName="LODSettings.FadeTurbulenceExternalVelocity" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[18]; + ParamDef->init("FadeTurbulenceExternalVelocity", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("HIDDEN", uint64_t(1), true); + ParamDefTable[18].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("HIDDEN", uint64_t(1), true); + HintTable[1].init("shortDescription", "Helpful tooltip information goes here", true); + ParamDefTable[18].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=19, longName="LODSettings.FadeTurbulenceVelocityWeight" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[19]; + ParamDef->init("FadeTurbulenceVelocityWeight", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("HIDDEN", uint64_t(1), true); + ParamDefTable[19].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("HIDDEN", uint64_t(1), true); + HintTable[1].init("shortDescription", "Helpful tooltip information goes here", true); + ParamDefTable[19].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=20, longName="LODSettings.FadeHeatSourceTemperature" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[20]; + ParamDef->init("FadeHeatSourceTemperature", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("HIDDEN", uint64_t(1), true); + ParamDefTable[20].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("HIDDEN", uint64_t(1), true); + HintTable[1].init("shortDescription", "Helpful tooltip information goes here", true); + ParamDefTable[20].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=21, longName="LODSettings.FadeForceFieldStrength" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[21]; + ParamDef->init("FadeForceFieldStrength", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("HIDDEN", uint64_t(1), true); + ParamDefTable[21].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("HIDDEN", uint64_t(1), true); + HintTable[1].init("shortDescription", "Helpful tooltip information goes here", true); + ParamDefTable[21].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=22, longName="LODSettings.FadeForceFieldScale" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[22]; + ParamDef->init("FadeForceFieldScale", TYPE_BOOL, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("HIDDEN", uint64_t(1), true); + ParamDefTable[22].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("HIDDEN", uint64_t(1), true); + HintTable[1].init("shortDescription", "Helpful tooltip information goes here", true); + ParamDefTable[22].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=23, longName="Path" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[23]; + ParamDef->init("Path", TYPE_STRUCT, "EffectPath", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("shortDescription", "An optional path for this effect to travel on", true); + ParamDefTable[23].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=24, longName="Path.PlaybackMode" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[24]; + ParamDef->init("PlaybackMode", TYPE_ENUM, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + +#else + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("shortDescription", "The mode to play back the path", true); + ParamDefTable[24].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + static const char* const EnumVals[] = { "LOOP", "PLAY_ONCE", "PING_PONG" }; + ParamDefTable[24].setEnumVals((const char**)EnumVals, 3); + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=25, longName="Path.PathDuration" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[25]; + ParamDef->init("PathDuration", 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", double(1000.000000000), true); + HintTable[1].init("min", double(0.000010000), true); + ParamDefTable[25].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#else + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("max", double(1000.000000000), true); + HintTable[1].init("min", double(0.000010000), true); + HintTable[2].init("shortDescription", "The duration of the path if one is not otherwise provided", true); + ParamDefTable[25].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=26, longName="Path.LoopIndex" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[26]; + ParamDef->init("LoopIndex", TYPE_U32, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("min", uint64_t(0), true); + ParamDefTable[26].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("min", uint64_t(0), true); + HintTable[1].init("shortDescription", "The array index to loop back to", true); + ParamDefTable[26].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=27, longName="Path.ControlPoints" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[27]; + ParamDef->init("ControlPoints", TYPE_ARRAY, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true); + HintTable[1].init("editorCurve", uint64_t(1), true); + HintTable[2].init("pathEditor", uint64_t(1), true); + ParamDefTable[27].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#else + + static HintImpl HintTable[4]; + static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], }; + HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true); + HintTable[1].init("editorCurve", uint64_t(1), true); + HintTable[2].init("pathEditor", uint64_t(1), true); + HintTable[3].init("shortDescription", "The array of control points to fit the curve to", true); + ParamDefTable[27].setHints((const NvParameterized::Hint**)HintPtrTable, 4); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + ParamDef->setArraySize(-1); + } + + // Initialize DefinitionImpl node: nodeIndex=28, longName="Path.ControlPoints[]" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[28]; + ParamDef->init("ControlPoints", TYPE_TRANSFORM, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true); + HintTable[1].init("editorCurve", uint64_t(1), true); + HintTable[2].init("pathEditor", uint64_t(1), true); + ParamDefTable[28].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#else + + static HintImpl HintTable[4]; + static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], }; + HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true); + HintTable[1].init("editorCurve", uint64_t(1), true); + HintTable[2].init("pathEditor", uint64_t(1), true); + HintTable[3].init("shortDescription", "The array of control points to fit the curve to", true); + ParamDefTable[28].setHints((const NvParameterized::Hint**)HintPtrTable, 4); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=29, longName="Path.Scale" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[29]; + ParamDef->init("Scale", TYPE_ARRAY, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[5]; + static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], }; + HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true); + HintTable[1].init("UseSpline", uint64_t(1), true); + HintTable[2].init("editorCurve", uint64_t(1), true); + HintTable[3].init("xAxisLabel", "Over Time", true); + HintTable[4].init("yAxisLabel", "Scale", true); + ParamDefTable[29].setHints((const NvParameterized::Hint**)HintPtrTable, 5); + +#else + + static HintImpl HintTable[6]; + static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], }; + HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true); + HintTable[1].init("UseSpline", uint64_t(1), true); + HintTable[2].init("editorCurve", uint64_t(1), true); + HintTable[3].init("shortDescription", "The array of scale values over time", true); + HintTable[4].init("xAxisLabel", "Over Time", true); + HintTable[5].init("yAxisLabel", "Scale", true); + ParamDefTable[29].setHints((const NvParameterized::Hint**)HintPtrTable, 6); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + ParamDef->setArraySize(-1); + } + + // Initialize DefinitionImpl node: nodeIndex=30, longName="Path.Scale[]" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[30]; + ParamDef->init("Scale", TYPE_STRUCT, "ControlPoint", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[5]; + static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], }; + HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true); + HintTable[1].init("UseSpline", uint64_t(1), true); + HintTable[2].init("editorCurve", uint64_t(1), true); + HintTable[3].init("xAxisLabel", "Over Time", true); + HintTable[4].init("yAxisLabel", "Scale", true); + ParamDefTable[30].setHints((const NvParameterized::Hint**)HintPtrTable, 5); + +#else + + static HintImpl HintTable[6]; + static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], }; + HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true); + HintTable[1].init("UseSpline", uint64_t(1), true); + HintTable[2].init("editorCurve", uint64_t(1), true); + HintTable[3].init("shortDescription", "The array of scale values over time", true); + HintTable[4].init("xAxisLabel", "Over Time", true); + HintTable[5].init("yAxisLabel", "Scale", true); + ParamDefTable[30].setHints((const NvParameterized::Hint**)HintPtrTable, 6); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=31, longName="Path.Scale[].x" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[31]; + ParamDef->init("x", 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", double(1.000000000), true); + HintTable[1].init("min", double(0.000000000), true); + ParamDefTable[31].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#else + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("max", double(1.000000000), true); + HintTable[1].init("min", double(0.000000000), true); + HintTable[2].init("shortDescription", "The x-axis value for this vector", true); + ParamDefTable[31].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=32, longName="Path.Scale[].y" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[32]; + ParamDef->init("y", 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 y-axis value for this vector", true); + ParamDefTable[32].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=33, longName="Path.Speed" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[33]; + ParamDef->init("Speed", TYPE_ARRAY, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[5]; + static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], }; + HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true); + HintTable[1].init("UseSpline", uint64_t(1), true); + HintTable[2].init("editorCurve", uint64_t(1), true); + HintTable[3].init("xAxisLabel", "Over Time", true); + HintTable[4].init("yAxisLabel", "Speed", true); + ParamDefTable[33].setHints((const NvParameterized::Hint**)HintPtrTable, 5); + +#else + + static HintImpl HintTable[6]; + static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], }; + HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true); + HintTable[1].init("UseSpline", uint64_t(1), true); + HintTable[2].init("editorCurve", uint64_t(1), true); + HintTable[3].init("shortDescription", "The array of speed values over time", true); + HintTable[4].init("xAxisLabel", "Over Time", true); + HintTable[5].init("yAxisLabel", "Speed", true); + ParamDefTable[33].setHints((const NvParameterized::Hint**)HintPtrTable, 6); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + ParamDef->setArraySize(-1); + } + + // Initialize DefinitionImpl node: nodeIndex=34, longName="Path.Speed[]" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[34]; + ParamDef->init("Speed", TYPE_STRUCT, "ControlPoint", true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[5]; + static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], }; + HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true); + HintTable[1].init("UseSpline", uint64_t(1), true); + HintTable[2].init("editorCurve", uint64_t(1), true); + HintTable[3].init("xAxisLabel", "Over Time", true); + HintTable[4].init("yAxisLabel", "Speed", true); + ParamDefTable[34].setHints((const NvParameterized::Hint**)HintPtrTable, 5); + +#else + + static HintImpl HintTable[6]; + static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], }; + HintTable[0].init("RIGHT_CLICK", "COPY_PATH PASTE_PATH CLEAR_PATH", true); + HintTable[1].init("UseSpline", uint64_t(1), true); + HintTable[2].init("editorCurve", uint64_t(1), true); + HintTable[3].init("shortDescription", "The array of speed values over time", true); + HintTable[4].init("xAxisLabel", "Over Time", true); + HintTable[5].init("yAxisLabel", "Speed", true); + ParamDefTable[34].setHints((const NvParameterized::Hint**)HintPtrTable, 6); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=35, longName="Path.Speed[].x" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[35]; + ParamDef->init("x", 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", double(1.000000000), true); + HintTable[1].init("min", double(0.000000000), true); + ParamDefTable[35].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#else + + static HintImpl HintTable[3]; + static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], }; + HintTable[0].init("max", double(1.000000000), true); + HintTable[1].init("min", double(0.000000000), true); + HintTable[2].init("shortDescription", "The x-axis value for this vector", true); + ParamDefTable[35].setHints((const NvParameterized::Hint**)HintPtrTable, 3); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=36, longName="Path.Speed[].y" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[36]; + ParamDef->init("y", 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 y-axis value for this vector", true); + ParamDefTable[36].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // Initialize DefinitionImpl node: nodeIndex=37, longName="Effects" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[37]; + ParamDef->init("Effects", TYPE_ARRAY, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[4]; + static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], }; + HintTable[0].init("DISABLE_SINGLE_CLICK_COLLAPSE", uint64_t(1), true); + HintTable[1].init("DISABLE_SINGLE_CLICK_EXPAND", uint64_t(1), true); + HintTable[2].init("INCLUDED", uint64_t(1), true); + HintTable[3].init("RIGHT_CLICK", "ENABLE_EFFECT DISABLE_EFFECT COPY_EFFECT_PROPERTIES PASTE_EFFECT_PROPERTIES", true); + ParamDefTable[37].setHints((const NvParameterized::Hint**)HintPtrTable, 4); + +#else + + static HintImpl HintTable[5]; + static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], }; + HintTable[0].init("DISABLE_SINGLE_CLICK_COLLAPSE", uint64_t(1), true); + HintTable[1].init("DISABLE_SINGLE_CLICK_EXPAND", uint64_t(1), true); + HintTable[2].init("INCLUDED", uint64_t(1), true); + HintTable[3].init("RIGHT_CLICK", "ENABLE_EFFECT DISABLE_EFFECT COPY_EFFECT_PROPERTIES PASTE_EFFECT_PROPERTIES", true); + HintTable[4].init("shortDescription", "Effect Setting", true); + ParamDefTable[37].setHints((const NvParameterized::Hint**)HintPtrTable, 5); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + static const char* const RefVariantVals[] = { "EmitterEffect", "HeatSourceEffect", "JetFieldSamplerEffect", "AttractorFieldSamplerEffect", "TurbulenceFieldSamplerEffect", "ForceFieldEffect", "NoiseFieldSamplerEffect", "VortexFieldSamplerEffect", "SubstanceSourceEffect", "WindFieldSamplerEffect", "RigidBodyEffect", "VelocitySourceEffect", "FlameEmitterEffect" }; + ParamDefTable[37].setRefVariantVals((const char**)RefVariantVals, 13); + + + ParamDef->setArraySize(-1); + static const uint8_t dynHandleIndices[1] = { 0, }; + ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1); + + } + + // Initialize DefinitionImpl node: nodeIndex=38, longName="Effects[]" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[38]; + ParamDef->init("Effects", TYPE_REF, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[4]; + static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], }; + HintTable[0].init("DISABLE_SINGLE_CLICK_COLLAPSE", uint64_t(1), true); + HintTable[1].init("DISABLE_SINGLE_CLICK_EXPAND", uint64_t(1), true); + HintTable[2].init("INCLUDED", uint64_t(1), true); + HintTable[3].init("RIGHT_CLICK", "ENABLE_EFFECT DISABLE_EFFECT COPY_EFFECT_PROPERTIES PASTE_EFFECT_PROPERTIES", true); + ParamDefTable[38].setHints((const NvParameterized::Hint**)HintPtrTable, 4); + +#else + + static HintImpl HintTable[5]; + static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], }; + HintTable[0].init("DISABLE_SINGLE_CLICK_COLLAPSE", uint64_t(1), true); + HintTable[1].init("DISABLE_SINGLE_CLICK_EXPAND", uint64_t(1), true); + HintTable[2].init("INCLUDED", uint64_t(1), true); + HintTable[3].init("RIGHT_CLICK", "ENABLE_EFFECT DISABLE_EFFECT COPY_EFFECT_PROPERTIES PASTE_EFFECT_PROPERTIES", true); + HintTable[4].init("shortDescription", "Effect Setting", true); + ParamDefTable[38].setHints((const NvParameterized::Hint**)HintPtrTable, 5); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + static const char* const RefVariantVals[] = { "EmitterEffect", "HeatSourceEffect", "JetFieldSamplerEffect", "AttractorFieldSamplerEffect", "TurbulenceFieldSamplerEffect", "ForceFieldEffect", "NoiseFieldSamplerEffect", "VortexFieldSamplerEffect", "SubstanceSourceEffect", "WindFieldSamplerEffect", "RigidBodyEffect", "VelocitySourceEffect", "FlameEmitterEffect" }; + ParamDefTable[38].setRefVariantVals((const char**)RefVariantVals, 13); + + + + } + + // Initialize DefinitionImpl node: nodeIndex=39, longName="toolString" + { + NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[39]; + ParamDef->init("toolString", TYPE_STRING, NULL, true); + +#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS + + static HintImpl HintTable[1]; + static Hint* HintPtrTable[1] = { &HintTable[0], }; + HintTable[0].init("READONLY", uint64_t(1), true); + ParamDefTable[39].setHints((const NvParameterized::Hint**)HintPtrTable, 1); + +#else + + static HintImpl HintTable[2]; + static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], }; + HintTable[0].init("READONLY", uint64_t(1), true); + HintTable[1].init("shortDescription", "Describes the authoring tool. Info about used tool and runtime during effect creation", true); + ParamDefTable[39].setHints((const NvParameterized::Hint**)HintPtrTable, 2); + +#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */ + + + + + + } + + // SetChildren for: nodeIndex=0, longName="" + { + static Definition* Children[4]; + Children[0] = PDEF_PTR(1); + Children[1] = PDEF_PTR(23); + Children[2] = PDEF_PTR(37); + Children[3] = PDEF_PTR(39); + + ParamDefTable[0].setChildren(Children, 4); + } + + // SetChildren for: nodeIndex=1, longName="LODSettings" + { + static Definition* Children[21]; + Children[0] = PDEF_PTR(2); + Children[1] = PDEF_PTR(3); + Children[2] = PDEF_PTR(4); + Children[3] = PDEF_PTR(5); + Children[4] = PDEF_PTR(6); + Children[5] = PDEF_PTR(7); + Children[6] = PDEF_PTR(8); + Children[7] = PDEF_PTR(9); + Children[8] = PDEF_PTR(10); + Children[9] = PDEF_PTR(11); + Children[10] = PDEF_PTR(12); + Children[11] = PDEF_PTR(13); + Children[12] = PDEF_PTR(14); + Children[13] = PDEF_PTR(15); + Children[14] = PDEF_PTR(16); + Children[15] = PDEF_PTR(17); + Children[16] = PDEF_PTR(18); + Children[17] = PDEF_PTR(19); + Children[18] = PDEF_PTR(20); + Children[19] = PDEF_PTR(21); + Children[20] = PDEF_PTR(22); + + ParamDefTable[1].setChildren(Children, 21); + } + + // SetChildren for: nodeIndex=23, longName="Path" + { + static Definition* Children[6]; + Children[0] = PDEF_PTR(24); + Children[1] = PDEF_PTR(25); + Children[2] = PDEF_PTR(26); + Children[3] = PDEF_PTR(27); + Children[4] = PDEF_PTR(29); + Children[5] = PDEF_PTR(33); + + ParamDefTable[23].setChildren(Children, 6); + } + + // SetChildren for: nodeIndex=27, longName="Path.ControlPoints" + { + static Definition* Children[1]; + Children[0] = PDEF_PTR(28); + + ParamDefTable[27].setChildren(Children, 1); + } + + // SetChildren for: nodeIndex=29, longName="Path.Scale" + { + static Definition* Children[1]; + Children[0] = PDEF_PTR(30); + + ParamDefTable[29].setChildren(Children, 1); + } + + // SetChildren for: nodeIndex=30, longName="Path.Scale[]" + { + static Definition* Children[2]; + Children[0] = PDEF_PTR(31); + Children[1] = PDEF_PTR(32); + + ParamDefTable[30].setChildren(Children, 2); + } + + // SetChildren for: nodeIndex=33, longName="Path.Speed" + { + static Definition* Children[1]; + Children[0] = PDEF_PTR(34); + + ParamDefTable[33].setChildren(Children, 1); + } + + // SetChildren for: nodeIndex=34, longName="Path.Speed[]" + { + static Definition* Children[2]; + Children[0] = PDEF_PTR(35); + Children[1] = PDEF_PTR(36); + + ParamDefTable[34].setChildren(Children, 2); + } + + // SetChildren for: nodeIndex=37, longName="Effects" + { + static Definition* Children[1]; + Children[0] = PDEF_PTR(38); + + ParamDefTable[37].setChildren(Children, 1); + } + + mBuiltFlag = true; + +} +void EffectPackageAssetParams::initStrings(void) +{ + toolString.isAllocated = true; + toolString.buf = NULL; +} + +void EffectPackageAssetParams::initDynamicArrays(void) +{ + Path.ControlPoints.buf = NULL; + Path.ControlPoints.isAllocated = true; + Path.ControlPoints.elementSize = sizeof(physx::PxTransform); + Path.ControlPoints.arraySizes[0] = 0; + Path.Scale.buf = NULL; + Path.Scale.isAllocated = true; + Path.Scale.elementSize = sizeof(ControlPoint_Type); + Path.Scale.arraySizes[0] = 0; + Path.Speed.buf = NULL; + Path.Speed.isAllocated = true; + Path.Speed.elementSize = sizeof(ControlPoint_Type); + Path.Speed.arraySizes[0] = 0; + Effects.buf = NULL; + Effects.isAllocated = true; + Effects.elementSize = sizeof(NvParameterized::Interface*); + Effects.arraySizes[0] = 0; +} + +void EffectPackageAssetParams::initDefaults(void) +{ + + freeStrings(); + freeReferences(); + freeDynamicArrays(); + LODSettings.UniqueRenderVolume = bool(0); + LODSettings.FadeDistanceBegin = float(50000.000000000); + LODSettings.FadeDistanceEnd = float(5000.000000000); + LODSettings.RandomizeEmitterRate = bool(0); + LODSettings.FadeOutRate = float(0.200000003); + LODSettings.CullByDistance = bool(0); + LODSettings.CullOffScreen = bool(0); + LODSettings.OffScreenCullTime = float(1.000000000); + LODSettings.NonVisibleDeleteTime = float(4.000000000); + LODSettings.ScreenCullSize = float(0.100000001); + LODSettings.ScreenCullDistance = float(3.000000000); + LODSettings.FadeEmitterRate = bool(1); + LODSettings.FadeAttractorFieldStrength = bool(1); + LODSettings.FadeJetFieldStrength = bool(1); + LODSettings.FadeTurbulenceVelocity = bool(0); + LODSettings.FadeTurbulenceNoise = bool(0); + LODSettings.FadeTurbulenceExternalVelocity = bool(0); + LODSettings.FadeTurbulenceVelocityWeight = bool(0); + LODSettings.FadeHeatSourceTemperature = bool(0); + LODSettings.FadeForceFieldStrength = bool(0); + LODSettings.FadeForceFieldScale = bool(0); + Path.PlaybackMode = (const char*)"LOOP"; + Path.PathDuration = float(4.000000000); + Path.LoopIndex = uint32_t(0); + + initDynamicArrays(); + initStrings(); + initReferences(); +} + +void EffectPackageAssetParams::initReferences(void) +{ +} + +void EffectPackageAssetParams::freeDynamicArrays(void) +{ + if (Path.ControlPoints.isAllocated && Path.ControlPoints.buf) + { + mParameterizedTraits->free(Path.ControlPoints.buf); + } + if (Path.Scale.isAllocated && Path.Scale.buf) + { + mParameterizedTraits->free(Path.Scale.buf); + } + if (Path.Speed.isAllocated && Path.Speed.buf) + { + mParameterizedTraits->free(Path.Speed.buf); + } + if (Effects.isAllocated && Effects.buf) + { + mParameterizedTraits->free(Effects.buf); + } +} + +void EffectPackageAssetParams::freeStrings(void) +{ + + if (toolString.isAllocated && toolString.buf) + { + mParameterizedTraits->strfree((char*)toolString.buf); + } +} + +void EffectPackageAssetParams::freeReferences(void) +{ + + for (int i = 0; i < Effects.arraySizes[0]; ++i) + { + if (Effects.buf[i]) + { + Effects.buf[i]->destroy(); + } + } +} + +} // namespace particles +} // namespace nvidia |