diff options
Diffstat (limited to 'APEX_1.4/module/basicios_legacy/include/autogen')
18 files changed, 4725 insertions, 0 deletions
diff --git a/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p0.h b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p0.h new file mode 100644 index 00000000..2c9f6c76 --- /dev/null +++ b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p0.h @@ -0,0 +1,233 @@ +// 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 + + +#ifndef HEADER_BasicIOSAssetParam_0p0_h +#define HEADER_BasicIOSAssetParam_0p0_h + +#include "NvParametersTypes.h" + +#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS +#include "nvparameterized/NvParameterized.h" +#include "nvparameterized/NvParameterizedTraits.h" +#include "NvParameters.h" +#include "NvTraitsInternal.h" +#endif + +namespace nvidia +{ +namespace parameterized +{ + +#if PX_VC +#pragma warning(push) +#pragma warning(disable: 4324) // structure was padded due to __declspec(align()) +#endif + +namespace BasicIOSAssetParam_0p0NS +{ + + + +struct ParametersStruct +{ + + float restDensity; + float particleRadius; + uint32_t maxParticleCount; + float maxInjectedParticleCount; + +}; + +static const uint32_t checksum[] = { 0x13e90d7d, 0x9644d70e, 0x92bd7f6c, 0xa4c80d68, }; + +} // namespace BasicIOSAssetParam_0p0NS + +#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS +class BasicIOSAssetParam_0p0 : public NvParameterized::NvParameters, public BasicIOSAssetParam_0p0NS::ParametersStruct +{ +public: + BasicIOSAssetParam_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0); + + virtual ~BasicIOSAssetParam_0p0(); + + virtual void destroy(); + + static const char* staticClassName(void) + { + return("BasicIOSAssetParam"); + } + + const char* className(void) const + { + return(staticClassName()); + } + + static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)0; + + static uint32_t staticVersion(void) + { + return ClassVersion; + } + + uint32_t version(void) const + { + return(staticVersion()); + } + + static const uint32_t ClassAlignment = 8; + + static const uint32_t* staticChecksum(uint32_t& bits) + { + bits = 8 * sizeof(BasicIOSAssetParam_0p0NS::checksum); + return BasicIOSAssetParam_0p0NS::checksum; + } + + static void freeParameterDefinitionTable(NvParameterized::Traits* traits); + + const uint32_t* checksum(uint32_t& bits) const + { + return staticChecksum(bits); + } + + const BasicIOSAssetParam_0p0NS::ParametersStruct& parameters(void) const + { + BasicIOSAssetParam_0p0* tmpThis = const_cast<BasicIOSAssetParam_0p0*>(this); + return *(static_cast<BasicIOSAssetParam_0p0NS::ParametersStruct*>(tmpThis)); + } + + BasicIOSAssetParam_0p0NS::ParametersStruct& parameters(void) + { + return *(static_cast<BasicIOSAssetParam_0p0NS::ParametersStruct*>(this)); + } + + virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const; + virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle); + + void initDefaults(void); + +protected: + + virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void); + virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const; + + + virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const; + +private: + + void buildTree(void); + void initDynamicArrays(void); + void initStrings(void); + void initReferences(void); + void freeDynamicArrays(void); + void freeStrings(void); + void freeReferences(void); + + static bool mBuiltFlag; + static NvParameterized::MutexType mBuiltFlagMutex; +}; + +class BasicIOSAssetParam_0p0Factory : public NvParameterized::Factory +{ + static const char* const vptr; + +public: + + virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits) + { + BasicIOSAssetParam_0p0::freeParameterDefinitionTable(traits); + } + + virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits) + { + // placement new on this class using mParameterizedTraits + + void* newPtr = paramTraits->alloc(sizeof(BasicIOSAssetParam_0p0), BasicIOSAssetParam_0p0::ClassAlignment); + if (!NvParameterized::IsAligned(newPtr, BasicIOSAssetParam_0p0::ClassAlignment)) + { + NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_0p0"); + paramTraits->free(newPtr); + return 0; + } + + memset(newPtr, 0, sizeof(BasicIOSAssetParam_0p0)); // always initialize memory allocated to zero for default values + return NV_PARAM_PLACEMENT_NEW(newPtr, BasicIOSAssetParam_0p0)(paramTraits); + } + + virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount) + { + if (!NvParameterized::IsAligned(bufObj, BasicIOSAssetParam_0p0::ClassAlignment) + || !NvParameterized::IsAligned(bufStart, BasicIOSAssetParam_0p0::ClassAlignment)) + { + NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_0p0"); + return 0; + } + + // Init NvParameters-part + // We used to call empty constructor of BasicIOSAssetParam_0p0 here + // but it may call default constructors of members and spoil the data + NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount); + + // Init vtable (everything else is already initialized) + *(const char**)bufObj = vptr; + + return (BasicIOSAssetParam_0p0*)bufObj; + } + + virtual const char* getClassName() + { + return (BasicIOSAssetParam_0p0::staticClassName()); + } + + virtual uint32_t getVersion() + { + return (BasicIOSAssetParam_0p0::staticVersion()); + } + + virtual uint32_t getAlignment() + { + return (BasicIOSAssetParam_0p0::ClassAlignment); + } + + virtual const uint32_t* getChecksum(uint32_t& bits) + { + return (BasicIOSAssetParam_0p0::staticChecksum(bits)); + } +}; +#endif // NV_PARAMETERIZED_ONLY_LAYOUTS + +} // namespace parameterized +} // namespace nvidia + +#if PX_VC +#pragma warning(pop) +#endif + +#endif diff --git a/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p1.h b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p1.h new file mode 100644 index 00000000..a65bf702 --- /dev/null +++ b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p1.h @@ -0,0 +1,235 @@ +// 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 + + +#ifndef HEADER_BasicIOSAssetParam_0p1_h +#define HEADER_BasicIOSAssetParam_0p1_h + +#include "NvParametersTypes.h" + +#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS +#include "nvparameterized/NvParameterized.h" +#include "nvparameterized/NvParameterizedTraits.h" +#include "NvParameters.h" +#include "NvTraitsInternal.h" +#endif + +namespace nvidia +{ +namespace parameterized +{ + +#if PX_VC +#pragma warning(push) +#pragma warning(disable: 4324) // structure was padded due to __declspec(align()) +#endif + +namespace BasicIOSAssetParam_0p1NS +{ + + + +struct ParametersStruct +{ + + float restDensity; + float particleRadius; + uint32_t maxParticleCount; + float maxInjectedParticleCount; + float sceneGravityScale; + physx::PxVec3 externalAcceleration; + +}; + +static const uint32_t checksum[] = { 0xfef11c54, 0x679c8a6e, 0xb38c2860, 0x9eb5ca69, }; + +} // namespace BasicIOSAssetParam_0p1NS + +#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS +class BasicIOSAssetParam_0p1 : public NvParameterized::NvParameters, public BasicIOSAssetParam_0p1NS::ParametersStruct +{ +public: + BasicIOSAssetParam_0p1(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0); + + virtual ~BasicIOSAssetParam_0p1(); + + virtual void destroy(); + + static const char* staticClassName(void) + { + return("BasicIOSAssetParam"); + } + + const char* className(void) const + { + return(staticClassName()); + } + + static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)1; + + static uint32_t staticVersion(void) + { + return ClassVersion; + } + + uint32_t version(void) const + { + return(staticVersion()); + } + + static const uint32_t ClassAlignment = 8; + + static const uint32_t* staticChecksum(uint32_t& bits) + { + bits = 8 * sizeof(BasicIOSAssetParam_0p1NS::checksum); + return BasicIOSAssetParam_0p1NS::checksum; + } + + static void freeParameterDefinitionTable(NvParameterized::Traits* traits); + + const uint32_t* checksum(uint32_t& bits) const + { + return staticChecksum(bits); + } + + const BasicIOSAssetParam_0p1NS::ParametersStruct& parameters(void) const + { + BasicIOSAssetParam_0p1* tmpThis = const_cast<BasicIOSAssetParam_0p1*>(this); + return *(static_cast<BasicIOSAssetParam_0p1NS::ParametersStruct*>(tmpThis)); + } + + BasicIOSAssetParam_0p1NS::ParametersStruct& parameters(void) + { + return *(static_cast<BasicIOSAssetParam_0p1NS::ParametersStruct*>(this)); + } + + virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const; + virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle); + + void initDefaults(void); + +protected: + + virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void); + virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const; + + + virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const; + +private: + + void buildTree(void); + void initDynamicArrays(void); + void initStrings(void); + void initReferences(void); + void freeDynamicArrays(void); + void freeStrings(void); + void freeReferences(void); + + static bool mBuiltFlag; + static NvParameterized::MutexType mBuiltFlagMutex; +}; + +class BasicIOSAssetParam_0p1Factory : public NvParameterized::Factory +{ + static const char* const vptr; + +public: + + virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits) + { + BasicIOSAssetParam_0p1::freeParameterDefinitionTable(traits); + } + + virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits) + { + // placement new on this class using mParameterizedTraits + + void* newPtr = paramTraits->alloc(sizeof(BasicIOSAssetParam_0p1), BasicIOSAssetParam_0p1::ClassAlignment); + if (!NvParameterized::IsAligned(newPtr, BasicIOSAssetParam_0p1::ClassAlignment)) + { + NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_0p1"); + paramTraits->free(newPtr); + return 0; + } + + memset(newPtr, 0, sizeof(BasicIOSAssetParam_0p1)); // always initialize memory allocated to zero for default values + return NV_PARAM_PLACEMENT_NEW(newPtr, BasicIOSAssetParam_0p1)(paramTraits); + } + + virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount) + { + if (!NvParameterized::IsAligned(bufObj, BasicIOSAssetParam_0p1::ClassAlignment) + || !NvParameterized::IsAligned(bufStart, BasicIOSAssetParam_0p1::ClassAlignment)) + { + NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_0p1"); + return 0; + } + + // Init NvParameters-part + // We used to call empty constructor of BasicIOSAssetParam_0p1 here + // but it may call default constructors of members and spoil the data + NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount); + + // Init vtable (everything else is already initialized) + *(const char**)bufObj = vptr; + + return (BasicIOSAssetParam_0p1*)bufObj; + } + + virtual const char* getClassName() + { + return (BasicIOSAssetParam_0p1::staticClassName()); + } + + virtual uint32_t getVersion() + { + return (BasicIOSAssetParam_0p1::staticVersion()); + } + + virtual uint32_t getAlignment() + { + return (BasicIOSAssetParam_0p1::ClassAlignment); + } + + virtual const uint32_t* getChecksum(uint32_t& bits) + { + return (BasicIOSAssetParam_0p1::staticChecksum(bits)); + } +}; +#endif // NV_PARAMETERIZED_ONLY_LAYOUTS + +} // namespace parameterized +} // namespace nvidia + +#if PX_VC +#pragma warning(pop) +#endif + +#endif diff --git a/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p2.h b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p2.h new file mode 100644 index 00000000..9d9325ac --- /dev/null +++ b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p2.h @@ -0,0 +1,238 @@ +// 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 + + +#ifndef HEADER_BasicIOSAssetParam_0p2_h +#define HEADER_BasicIOSAssetParam_0p2_h + +#include "NvParametersTypes.h" + +#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS +#include "nvparameterized/NvParameterized.h" +#include "nvparameterized/NvParameterizedTraits.h" +#include "NvParameters.h" +#include "NvTraitsInternal.h" +#endif + +namespace nvidia +{ +namespace parameterized +{ + +#if PX_VC +#pragma warning(push) +#pragma warning(disable: 4324) // structure was padded due to __declspec(align()) +#endif + +namespace BasicIOSAssetParam_0p2NS +{ + + + +struct ParametersStruct +{ + + float restDensity; + float particleRadius; + uint32_t maxParticleCount; + float maxInjectedParticleCount; + float sceneGravityScale; + physx::PxVec3 externalAcceleration; + NvParameterized::DummyStringStruct collisionGroupName; + NvParameterized::DummyStringStruct collisionGroupMaskName; + float particleMass; + +}; + +static const uint32_t checksum[] = { 0x76342808, 0xfd820291, 0xf3442960, 0x52c21a2a, }; + +} // namespace BasicIOSAssetParam_0p2NS + +#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS +class BasicIOSAssetParam_0p2 : public NvParameterized::NvParameters, public BasicIOSAssetParam_0p2NS::ParametersStruct +{ +public: + BasicIOSAssetParam_0p2(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0); + + virtual ~BasicIOSAssetParam_0p2(); + + virtual void destroy(); + + static const char* staticClassName(void) + { + return("BasicIOSAssetParam"); + } + + const char* className(void) const + { + return(staticClassName()); + } + + static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)2; + + static uint32_t staticVersion(void) + { + return ClassVersion; + } + + uint32_t version(void) const + { + return(staticVersion()); + } + + static const uint32_t ClassAlignment = 8; + + static const uint32_t* staticChecksum(uint32_t& bits) + { + bits = 8 * sizeof(BasicIOSAssetParam_0p2NS::checksum); + return BasicIOSAssetParam_0p2NS::checksum; + } + + static void freeParameterDefinitionTable(NvParameterized::Traits* traits); + + const uint32_t* checksum(uint32_t& bits) const + { + return staticChecksum(bits); + } + + const BasicIOSAssetParam_0p2NS::ParametersStruct& parameters(void) const + { + BasicIOSAssetParam_0p2* tmpThis = const_cast<BasicIOSAssetParam_0p2*>(this); + return *(static_cast<BasicIOSAssetParam_0p2NS::ParametersStruct*>(tmpThis)); + } + + BasicIOSAssetParam_0p2NS::ParametersStruct& parameters(void) + { + return *(static_cast<BasicIOSAssetParam_0p2NS::ParametersStruct*>(this)); + } + + virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const; + virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle); + + void initDefaults(void); + +protected: + + virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void); + virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const; + + + virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const; + +private: + + void buildTree(void); + void initDynamicArrays(void); + void initStrings(void); + void initReferences(void); + void freeDynamicArrays(void); + void freeStrings(void); + void freeReferences(void); + + static bool mBuiltFlag; + static NvParameterized::MutexType mBuiltFlagMutex; +}; + +class BasicIOSAssetParam_0p2Factory : public NvParameterized::Factory +{ + static const char* const vptr; + +public: + + virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits) + { + BasicIOSAssetParam_0p2::freeParameterDefinitionTable(traits); + } + + virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits) + { + // placement new on this class using mParameterizedTraits + + void* newPtr = paramTraits->alloc(sizeof(BasicIOSAssetParam_0p2), BasicIOSAssetParam_0p2::ClassAlignment); + if (!NvParameterized::IsAligned(newPtr, BasicIOSAssetParam_0p2::ClassAlignment)) + { + NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_0p2"); + paramTraits->free(newPtr); + return 0; + } + + memset(newPtr, 0, sizeof(BasicIOSAssetParam_0p2)); // always initialize memory allocated to zero for default values + return NV_PARAM_PLACEMENT_NEW(newPtr, BasicIOSAssetParam_0p2)(paramTraits); + } + + virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount) + { + if (!NvParameterized::IsAligned(bufObj, BasicIOSAssetParam_0p2::ClassAlignment) + || !NvParameterized::IsAligned(bufStart, BasicIOSAssetParam_0p2::ClassAlignment)) + { + NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_0p2"); + return 0; + } + + // Init NvParameters-part + // We used to call empty constructor of BasicIOSAssetParam_0p2 here + // but it may call default constructors of members and spoil the data + NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount); + + // Init vtable (everything else is already initialized) + *(const char**)bufObj = vptr; + + return (BasicIOSAssetParam_0p2*)bufObj; + } + + virtual const char* getClassName() + { + return (BasicIOSAssetParam_0p2::staticClassName()); + } + + virtual uint32_t getVersion() + { + return (BasicIOSAssetParam_0p2::staticVersion()); + } + + virtual uint32_t getAlignment() + { + return (BasicIOSAssetParam_0p2::ClassAlignment); + } + + virtual const uint32_t* getChecksum(uint32_t& bits) + { + return (BasicIOSAssetParam_0p2::staticChecksum(bits)); + } +}; +#endif // NV_PARAMETERIZED_ONLY_LAYOUTS + +} // namespace parameterized +} // namespace nvidia + +#if PX_VC +#pragma warning(pop) +#endif + +#endif diff --git a/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p3.h b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p3.h new file mode 100644 index 00000000..0bde55dc --- /dev/null +++ b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p3.h @@ -0,0 +1,245 @@ +// 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 + + +#ifndef HEADER_BasicIOSAssetParam_0p3_h +#define HEADER_BasicIOSAssetParam_0p3_h + +#include "NvParametersTypes.h" + +#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS +#include "nvparameterized/NvParameterized.h" +#include "nvparameterized/NvParameterizedTraits.h" +#include "NvParameters.h" +#include "NvTraitsInternal.h" +#endif + +namespace nvidia +{ +namespace parameterized +{ + +#if PX_VC +#pragma warning(push) +#pragma warning(disable: 4324) // structure was padded due to __declspec(align()) +#endif + +namespace BasicIOSAssetParam_0p3NS +{ + +struct RandomF32_Type; + +struct RandomF32_Type +{ + float center; + float spread; + const char* type; +}; + +struct ParametersStruct +{ + + float restDensity; + float particleRadius; + uint32_t maxParticleCount; + float maxInjectedParticleCount; + float sceneGravityScale; + physx::PxVec3 externalAcceleration; + NvParameterized::DummyStringStruct collisionGroupName; + NvParameterized::DummyStringStruct collisionGroupMaskName; + RandomF32_Type particleMass; + +}; + +static const uint32_t checksum[] = { 0x3b2fd8d7, 0x3393dc25, 0x6c4e302a, 0x80a29e81, }; + +} // namespace BasicIOSAssetParam_0p3NS + +#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS +class BasicIOSAssetParam_0p3 : public NvParameterized::NvParameters, public BasicIOSAssetParam_0p3NS::ParametersStruct +{ +public: + BasicIOSAssetParam_0p3(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0); + + virtual ~BasicIOSAssetParam_0p3(); + + virtual void destroy(); + + static const char* staticClassName(void) + { + return("BasicIOSAssetParam"); + } + + const char* className(void) const + { + return(staticClassName()); + } + + static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)3; + + static uint32_t staticVersion(void) + { + return ClassVersion; + } + + uint32_t version(void) const + { + return(staticVersion()); + } + + static const uint32_t ClassAlignment = 8; + + static const uint32_t* staticChecksum(uint32_t& bits) + { + bits = 8 * sizeof(BasicIOSAssetParam_0p3NS::checksum); + return BasicIOSAssetParam_0p3NS::checksum; + } + + static void freeParameterDefinitionTable(NvParameterized::Traits* traits); + + const uint32_t* checksum(uint32_t& bits) const + { + return staticChecksum(bits); + } + + const BasicIOSAssetParam_0p3NS::ParametersStruct& parameters(void) const + { + BasicIOSAssetParam_0p3* tmpThis = const_cast<BasicIOSAssetParam_0p3*>(this); + return *(static_cast<BasicIOSAssetParam_0p3NS::ParametersStruct*>(tmpThis)); + } + + BasicIOSAssetParam_0p3NS::ParametersStruct& parameters(void) + { + return *(static_cast<BasicIOSAssetParam_0p3NS::ParametersStruct*>(this)); + } + + virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const; + virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle); + + void initDefaults(void); + +protected: + + virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void); + virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const; + + + virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const; + +private: + + void buildTree(void); + void initDynamicArrays(void); + void initStrings(void); + void initReferences(void); + void freeDynamicArrays(void); + void freeStrings(void); + void freeReferences(void); + + static bool mBuiltFlag; + static NvParameterized::MutexType mBuiltFlagMutex; +}; + +class BasicIOSAssetParam_0p3Factory : public NvParameterized::Factory +{ + static const char* const vptr; + +public: + + virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits) + { + BasicIOSAssetParam_0p3::freeParameterDefinitionTable(traits); + } + + virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits) + { + // placement new on this class using mParameterizedTraits + + void* newPtr = paramTraits->alloc(sizeof(BasicIOSAssetParam_0p3), BasicIOSAssetParam_0p3::ClassAlignment); + if (!NvParameterized::IsAligned(newPtr, BasicIOSAssetParam_0p3::ClassAlignment)) + { + NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_0p3"); + paramTraits->free(newPtr); + return 0; + } + + memset(newPtr, 0, sizeof(BasicIOSAssetParam_0p3)); // always initialize memory allocated to zero for default values + return NV_PARAM_PLACEMENT_NEW(newPtr, BasicIOSAssetParam_0p3)(paramTraits); + } + + virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount) + { + if (!NvParameterized::IsAligned(bufObj, BasicIOSAssetParam_0p3::ClassAlignment) + || !NvParameterized::IsAligned(bufStart, BasicIOSAssetParam_0p3::ClassAlignment)) + { + NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_0p3"); + return 0; + } + + // Init NvParameters-part + // We used to call empty constructor of BasicIOSAssetParam_0p3 here + // but it may call default constructors of members and spoil the data + NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount); + + // Init vtable (everything else is already initialized) + *(const char**)bufObj = vptr; + + return (BasicIOSAssetParam_0p3*)bufObj; + } + + virtual const char* getClassName() + { + return (BasicIOSAssetParam_0p3::staticClassName()); + } + + virtual uint32_t getVersion() + { + return (BasicIOSAssetParam_0p3::staticVersion()); + } + + virtual uint32_t getAlignment() + { + return (BasicIOSAssetParam_0p3::ClassAlignment); + } + + virtual const uint32_t* getChecksum(uint32_t& bits) + { + return (BasicIOSAssetParam_0p3::staticChecksum(bits)); + } +}; +#endif // NV_PARAMETERIZED_ONLY_LAYOUTS + +} // namespace parameterized +} // namespace nvidia + +#if PX_VC +#pragma warning(pop) +#endif + +#endif diff --git a/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p4.h b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p4.h new file mode 100644 index 00000000..d3ca37da --- /dev/null +++ b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p4.h @@ -0,0 +1,250 @@ +// 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 + + +#ifndef HEADER_BasicIOSAssetParam_0p4_h +#define HEADER_BasicIOSAssetParam_0p4_h + +#include "NvParametersTypes.h" + +#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS +#include "nvparameterized/NvParameterized.h" +#include "nvparameterized/NvParameterizedTraits.h" +#include "NvParameters.h" +#include "NvTraitsInternal.h" +#endif + +namespace nvidia +{ +namespace parameterized +{ + +#if PX_VC +#pragma warning(push) +#pragma warning(disable: 4324) // structure was padded due to __declspec(align()) +#endif + +namespace BasicIOSAssetParam_0p4NS +{ + +struct RandomF32_Type; + +struct RandomF32_Type +{ + float center; + float spread; + const char* type; +}; + +struct ParametersStruct +{ + + float restDensity; + float particleRadius; + uint32_t maxParticleCount; + float maxInjectedParticleCount; + float sceneGravityScale; + physx::PxVec3 externalAcceleration; + RandomF32_Type particleMass; + NvParameterized::DummyStringStruct collisionFilterDataName; + NvParameterized::DummyStringStruct fieldSamplerFilterDataName; + bool staticCollision; + float restitutionForStaticShapes; + bool dynamicCollision; + float restitutionForDynamicShapes; + float collisionDistanceMultiplier; + +}; + +static const uint32_t checksum[] = { 0x0cb6a84c, 0x48e1978e, 0x961cee62, 0x01d7d95b, }; + +} // namespace BasicIOSAssetParam_0p4NS + +#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS +class BasicIOSAssetParam_0p4 : public NvParameterized::NvParameters, public BasicIOSAssetParam_0p4NS::ParametersStruct +{ +public: + BasicIOSAssetParam_0p4(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0); + + virtual ~BasicIOSAssetParam_0p4(); + + virtual void destroy(); + + static const char* staticClassName(void) + { + return("BasicIOSAssetParam"); + } + + const char* className(void) const + { + return(staticClassName()); + } + + static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)4; + + static uint32_t staticVersion(void) + { + return ClassVersion; + } + + uint32_t version(void) const + { + return(staticVersion()); + } + + static const uint32_t ClassAlignment = 8; + + static const uint32_t* staticChecksum(uint32_t& bits) + { + bits = 8 * sizeof(BasicIOSAssetParam_0p4NS::checksum); + return BasicIOSAssetParam_0p4NS::checksum; + } + + static void freeParameterDefinitionTable(NvParameterized::Traits* traits); + + const uint32_t* checksum(uint32_t& bits) const + { + return staticChecksum(bits); + } + + const BasicIOSAssetParam_0p4NS::ParametersStruct& parameters(void) const + { + BasicIOSAssetParam_0p4* tmpThis = const_cast<BasicIOSAssetParam_0p4*>(this); + return *(static_cast<BasicIOSAssetParam_0p4NS::ParametersStruct*>(tmpThis)); + } + + BasicIOSAssetParam_0p4NS::ParametersStruct& parameters(void) + { + return *(static_cast<BasicIOSAssetParam_0p4NS::ParametersStruct*>(this)); + } + + virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const; + virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle); + + void initDefaults(void); + +protected: + + virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void); + virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const; + + + virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const; + +private: + + void buildTree(void); + void initDynamicArrays(void); + void initStrings(void); + void initReferences(void); + void freeDynamicArrays(void); + void freeStrings(void); + void freeReferences(void); + + static bool mBuiltFlag; + static NvParameterized::MutexType mBuiltFlagMutex; +}; + +class BasicIOSAssetParam_0p4Factory : public NvParameterized::Factory +{ + static const char* const vptr; + +public: + + virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits) + { + BasicIOSAssetParam_0p4::freeParameterDefinitionTable(traits); + } + + virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits) + { + // placement new on this class using mParameterizedTraits + + void* newPtr = paramTraits->alloc(sizeof(BasicIOSAssetParam_0p4), BasicIOSAssetParam_0p4::ClassAlignment); + if (!NvParameterized::IsAligned(newPtr, BasicIOSAssetParam_0p4::ClassAlignment)) + { + NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_0p4"); + paramTraits->free(newPtr); + return 0; + } + + memset(newPtr, 0, sizeof(BasicIOSAssetParam_0p4)); // always initialize memory allocated to zero for default values + return NV_PARAM_PLACEMENT_NEW(newPtr, BasicIOSAssetParam_0p4)(paramTraits); + } + + virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount) + { + if (!NvParameterized::IsAligned(bufObj, BasicIOSAssetParam_0p4::ClassAlignment) + || !NvParameterized::IsAligned(bufStart, BasicIOSAssetParam_0p4::ClassAlignment)) + { + NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_0p4"); + return 0; + } + + // Init NvParameters-part + // We used to call empty constructor of BasicIOSAssetParam_0p4 here + // but it may call default constructors of members and spoil the data + NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount); + + // Init vtable (everything else is already initialized) + *(const char**)bufObj = vptr; + + return (BasicIOSAssetParam_0p4*)bufObj; + } + + virtual const char* getClassName() + { + return (BasicIOSAssetParam_0p4::staticClassName()); + } + + virtual uint32_t getVersion() + { + return (BasicIOSAssetParam_0p4::staticVersion()); + } + + virtual uint32_t getAlignment() + { + return (BasicIOSAssetParam_0p4::ClassAlignment); + } + + virtual const uint32_t* getChecksum(uint32_t& bits) + { + return (BasicIOSAssetParam_0p4::staticChecksum(bits)); + } +}; +#endif // NV_PARAMETERIZED_ONLY_LAYOUTS + +} // namespace parameterized +} // namespace nvidia + +#if PX_VC +#pragma warning(pop) +#endif + +#endif diff --git a/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p5.h b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p5.h new file mode 100644 index 00000000..fbb91543 --- /dev/null +++ b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p5.h @@ -0,0 +1,251 @@ +// 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 + + +#ifndef HEADER_BasicIOSAssetParam_0p5_h +#define HEADER_BasicIOSAssetParam_0p5_h + +#include "NvParametersTypes.h" + +#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS +#include "nvparameterized/NvParameterized.h" +#include "nvparameterized/NvParameterizedTraits.h" +#include "NvParameters.h" +#include "NvTraitsInternal.h" +#endif + +namespace nvidia +{ +namespace parameterized +{ + +#if PX_VC +#pragma warning(push) +#pragma warning(disable: 4324) // structure was padded due to __declspec(align()) +#endif + +namespace BasicIOSAssetParam_0p5NS +{ + +struct RandomF32_Type; + +struct RandomF32_Type +{ + float center; + float spread; + const char* type; +}; + +struct ParametersStruct +{ + + float restDensity; + float particleRadius; + uint32_t maxParticleCount; + float maxInjectedParticleCount; + float sceneGravityScale; + physx::PxVec3 externalAcceleration; + RandomF32_Type particleMass; + NvParameterized::DummyStringStruct collisionFilterDataName; + NvParameterized::DummyStringStruct fieldSamplerFilterDataName; + bool staticCollision; + float restitutionForStaticShapes; + bool dynamicCollision; + float restitutionForDynamicShapes; + float collisionDistanceMultiplier; + float collisionThreshold; + +}; + +static const uint32_t checksum[] = { 0x7af510ee, 0x7cf95f56, 0x5c6c9a11, 0xca6f7260, }; + +} // namespace BasicIOSAssetParam_0p5NS + +#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS +class BasicIOSAssetParam_0p5 : public NvParameterized::NvParameters, public BasicIOSAssetParam_0p5NS::ParametersStruct +{ +public: + BasicIOSAssetParam_0p5(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0); + + virtual ~BasicIOSAssetParam_0p5(); + + virtual void destroy(); + + static const char* staticClassName(void) + { + return("BasicIOSAssetParam"); + } + + const char* className(void) const + { + return(staticClassName()); + } + + static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)5; + + static uint32_t staticVersion(void) + { + return ClassVersion; + } + + uint32_t version(void) const + { + return(staticVersion()); + } + + static const uint32_t ClassAlignment = 8; + + static const uint32_t* staticChecksum(uint32_t& bits) + { + bits = 8 * sizeof(BasicIOSAssetParam_0p5NS::checksum); + return BasicIOSAssetParam_0p5NS::checksum; + } + + static void freeParameterDefinitionTable(NvParameterized::Traits* traits); + + const uint32_t* checksum(uint32_t& bits) const + { + return staticChecksum(bits); + } + + const BasicIOSAssetParam_0p5NS::ParametersStruct& parameters(void) const + { + BasicIOSAssetParam_0p5* tmpThis = const_cast<BasicIOSAssetParam_0p5*>(this); + return *(static_cast<BasicIOSAssetParam_0p5NS::ParametersStruct*>(tmpThis)); + } + + BasicIOSAssetParam_0p5NS::ParametersStruct& parameters(void) + { + return *(static_cast<BasicIOSAssetParam_0p5NS::ParametersStruct*>(this)); + } + + virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const; + virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle); + + void initDefaults(void); + +protected: + + virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void); + virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const; + + + virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const; + +private: + + void buildTree(void); + void initDynamicArrays(void); + void initStrings(void); + void initReferences(void); + void freeDynamicArrays(void); + void freeStrings(void); + void freeReferences(void); + + static bool mBuiltFlag; + static NvParameterized::MutexType mBuiltFlagMutex; +}; + +class BasicIOSAssetParam_0p5Factory : public NvParameterized::Factory +{ + static const char* const vptr; + +public: + + virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits) + { + BasicIOSAssetParam_0p5::freeParameterDefinitionTable(traits); + } + + virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits) + { + // placement new on this class using mParameterizedTraits + + void* newPtr = paramTraits->alloc(sizeof(BasicIOSAssetParam_0p5), BasicIOSAssetParam_0p5::ClassAlignment); + if (!NvParameterized::IsAligned(newPtr, BasicIOSAssetParam_0p5::ClassAlignment)) + { + NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_0p5"); + paramTraits->free(newPtr); + return 0; + } + + memset(newPtr, 0, sizeof(BasicIOSAssetParam_0p5)); // always initialize memory allocated to zero for default values + return NV_PARAM_PLACEMENT_NEW(newPtr, BasicIOSAssetParam_0p5)(paramTraits); + } + + virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount) + { + if (!NvParameterized::IsAligned(bufObj, BasicIOSAssetParam_0p5::ClassAlignment) + || !NvParameterized::IsAligned(bufStart, BasicIOSAssetParam_0p5::ClassAlignment)) + { + NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_0p5"); + return 0; + } + + // Init NvParameters-part + // We used to call empty constructor of BasicIOSAssetParam_0p5 here + // but it may call default constructors of members and spoil the data + NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount); + + // Init vtable (everything else is already initialized) + *(const char**)bufObj = vptr; + + return (BasicIOSAssetParam_0p5*)bufObj; + } + + virtual const char* getClassName() + { + return (BasicIOSAssetParam_0p5::staticClassName()); + } + + virtual uint32_t getVersion() + { + return (BasicIOSAssetParam_0p5::staticVersion()); + } + + virtual uint32_t getAlignment() + { + return (BasicIOSAssetParam_0p5::ClassAlignment); + } + + virtual const uint32_t* getChecksum(uint32_t& bits) + { + return (BasicIOSAssetParam_0p5::staticChecksum(bits)); + } +}; +#endif // NV_PARAMETERIZED_ONLY_LAYOUTS + +} // namespace parameterized +} // namespace nvidia + +#if PX_VC +#pragma warning(pop) +#endif + +#endif diff --git a/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p6.h b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p6.h new file mode 100644 index 00000000..3323fd4f --- /dev/null +++ b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p6.h @@ -0,0 +1,253 @@ +// 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 + + +#ifndef HEADER_BasicIOSAssetParam_0p6_h +#define HEADER_BasicIOSAssetParam_0p6_h + +#include "NvParametersTypes.h" + +#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS +#include "nvparameterized/NvParameterized.h" +#include "nvparameterized/NvParameterizedTraits.h" +#include "NvParameters.h" +#include "NvTraitsInternal.h" +#endif + +namespace nvidia +{ +namespace parameterized +{ + +#if PX_VC +#pragma warning(push) +#pragma warning(disable: 4324) // structure was padded due to __declspec(align()) +#endif + +namespace BasicIOSAssetParam_0p6NS +{ + +struct RandomF32_Type; + +struct RandomF32_Type +{ + float center; + float spread; + const char* type; +}; + +struct ParametersStruct +{ + + float restDensity; + float particleRadius; + uint32_t maxParticleCount; + float maxInjectedParticleCount; + float sceneGravityScale; + physx::PxVec3 externalAcceleration; + RandomF32_Type particleMass; + NvParameterized::DummyStringStruct collisionFilterDataName; + NvParameterized::DummyStringStruct fieldSamplerFilterDataName; + bool staticCollision; + float restitutionForStaticShapes; + bool dynamicCollision; + float restitutionForDynamicShapes; + float collisionDistanceMultiplier; + float collisionThreshold; + bool collisionWithConvex; + bool collisionWithTriangleMesh; + +}; + +static const uint32_t checksum[] = { 0xf6d69e51, 0x7edca183, 0xb8953089, 0xdd758d6f, }; + +} // namespace BasicIOSAssetParam_0p6NS + +#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS +class BasicIOSAssetParam_0p6 : public NvParameterized::NvParameters, public BasicIOSAssetParam_0p6NS::ParametersStruct +{ +public: + BasicIOSAssetParam_0p6(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0); + + virtual ~BasicIOSAssetParam_0p6(); + + virtual void destroy(); + + static const char* staticClassName(void) + { + return("BasicIOSAssetParam"); + } + + const char* className(void) const + { + return(staticClassName()); + } + + static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)6; + + static uint32_t staticVersion(void) + { + return ClassVersion; + } + + uint32_t version(void) const + { + return(staticVersion()); + } + + static const uint32_t ClassAlignment = 8; + + static const uint32_t* staticChecksum(uint32_t& bits) + { + bits = 8 * sizeof(BasicIOSAssetParam_0p6NS::checksum); + return BasicIOSAssetParam_0p6NS::checksum; + } + + static void freeParameterDefinitionTable(NvParameterized::Traits* traits); + + const uint32_t* checksum(uint32_t& bits) const + { + return staticChecksum(bits); + } + + const BasicIOSAssetParam_0p6NS::ParametersStruct& parameters(void) const + { + BasicIOSAssetParam_0p6* tmpThis = const_cast<BasicIOSAssetParam_0p6*>(this); + return *(static_cast<BasicIOSAssetParam_0p6NS::ParametersStruct*>(tmpThis)); + } + + BasicIOSAssetParam_0p6NS::ParametersStruct& parameters(void) + { + return *(static_cast<BasicIOSAssetParam_0p6NS::ParametersStruct*>(this)); + } + + virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const; + virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle); + + void initDefaults(void); + +protected: + + virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void); + virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const; + + + virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const; + +private: + + void buildTree(void); + void initDynamicArrays(void); + void initStrings(void); + void initReferences(void); + void freeDynamicArrays(void); + void freeStrings(void); + void freeReferences(void); + + static bool mBuiltFlag; + static NvParameterized::MutexType mBuiltFlagMutex; +}; + +class BasicIOSAssetParam_0p6Factory : public NvParameterized::Factory +{ + static const char* const vptr; + +public: + + virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits) + { + BasicIOSAssetParam_0p6::freeParameterDefinitionTable(traits); + } + + virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits) + { + // placement new on this class using mParameterizedTraits + + void* newPtr = paramTraits->alloc(sizeof(BasicIOSAssetParam_0p6), BasicIOSAssetParam_0p6::ClassAlignment); + if (!NvParameterized::IsAligned(newPtr, BasicIOSAssetParam_0p6::ClassAlignment)) + { + NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_0p6"); + paramTraits->free(newPtr); + return 0; + } + + memset(newPtr, 0, sizeof(BasicIOSAssetParam_0p6)); // always initialize memory allocated to zero for default values + return NV_PARAM_PLACEMENT_NEW(newPtr, BasicIOSAssetParam_0p6)(paramTraits); + } + + virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount) + { + if (!NvParameterized::IsAligned(bufObj, BasicIOSAssetParam_0p6::ClassAlignment) + || !NvParameterized::IsAligned(bufStart, BasicIOSAssetParam_0p6::ClassAlignment)) + { + NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_0p6"); + return 0; + } + + // Init NvParameters-part + // We used to call empty constructor of BasicIOSAssetParam_0p6 here + // but it may call default constructors of members and spoil the data + NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount); + + // Init vtable (everything else is already initialized) + *(const char**)bufObj = vptr; + + return (BasicIOSAssetParam_0p6*)bufObj; + } + + virtual const char* getClassName() + { + return (BasicIOSAssetParam_0p6::staticClassName()); + } + + virtual uint32_t getVersion() + { + return (BasicIOSAssetParam_0p6::staticVersion()); + } + + virtual uint32_t getAlignment() + { + return (BasicIOSAssetParam_0p6::ClassAlignment); + } + + virtual const uint32_t* getChecksum(uint32_t& bits) + { + return (BasicIOSAssetParam_0p6::staticChecksum(bits)); + } +}; +#endif // NV_PARAMETERIZED_ONLY_LAYOUTS + +} // namespace parameterized +} // namespace nvidia + +#if PX_VC +#pragma warning(pop) +#endif + +#endif diff --git a/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p7.h b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p7.h new file mode 100644 index 00000000..42e2fd6d --- /dev/null +++ b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p7.h @@ -0,0 +1,254 @@ +// 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 + + +#ifndef HEADER_BasicIOSAssetParam_0p7_h +#define HEADER_BasicIOSAssetParam_0p7_h + +#include "NvParametersTypes.h" + +#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS +#include "nvparameterized/NvParameterized.h" +#include "nvparameterized/NvParameterizedTraits.h" +#include "NvParameters.h" +#include "NvTraitsInternal.h" +#endif + +namespace nvidia +{ +namespace parameterized +{ + +#if PX_VC +#pragma warning(push) +#pragma warning(disable: 4324) // structure was padded due to __declspec(align()) +#endif + +namespace BasicIOSAssetParam_0p7NS +{ + +struct RandomF32_Type; + +struct RandomF32_Type +{ + float center; + float spread; + const char* type; +}; + +struct ParametersStruct +{ + + float restDensity; + float particleRadius; + uint32_t maxParticleCount; + float maxInjectedParticleCount; + uint32_t maxCollidingObjects; + float sceneGravityScale; + physx::PxVec3 externalAcceleration; + RandomF32_Type particleMass; + NvParameterized::DummyStringStruct collisionFilterDataName; + NvParameterized::DummyStringStruct fieldSamplerFilterDataName; + bool staticCollision; + float restitutionForStaticShapes; + bool dynamicCollision; + float restitutionForDynamicShapes; + float collisionDistanceMultiplier; + float collisionThreshold; + bool collisionWithConvex; + bool collisionWithTriangleMesh; + +}; + +static const uint32_t checksum[] = { 0xd08a68f8, 0xdfb2b2cb, 0x04b13ed2, 0x8ac33237, }; + +} // namespace BasicIOSAssetParam_0p7NS + +#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS +class BasicIOSAssetParam_0p7 : public NvParameterized::NvParameters, public BasicIOSAssetParam_0p7NS::ParametersStruct +{ +public: + BasicIOSAssetParam_0p7(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0); + + virtual ~BasicIOSAssetParam_0p7(); + + virtual void destroy(); + + static const char* staticClassName(void) + { + return("BasicIOSAssetParam"); + } + + const char* className(void) const + { + return(staticClassName()); + } + + static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)7; + + static uint32_t staticVersion(void) + { + return ClassVersion; + } + + uint32_t version(void) const + { + return(staticVersion()); + } + + static const uint32_t ClassAlignment = 8; + + static const uint32_t* staticChecksum(uint32_t& bits) + { + bits = 8 * sizeof(BasicIOSAssetParam_0p7NS::checksum); + return BasicIOSAssetParam_0p7NS::checksum; + } + + static void freeParameterDefinitionTable(NvParameterized::Traits* traits); + + const uint32_t* checksum(uint32_t& bits) const + { + return staticChecksum(bits); + } + + const BasicIOSAssetParam_0p7NS::ParametersStruct& parameters(void) const + { + BasicIOSAssetParam_0p7* tmpThis = const_cast<BasicIOSAssetParam_0p7*>(this); + return *(static_cast<BasicIOSAssetParam_0p7NS::ParametersStruct*>(tmpThis)); + } + + BasicIOSAssetParam_0p7NS::ParametersStruct& parameters(void) + { + return *(static_cast<BasicIOSAssetParam_0p7NS::ParametersStruct*>(this)); + } + + virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const; + virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle); + + void initDefaults(void); + +protected: + + virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void); + virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const; + + + virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const; + +private: + + void buildTree(void); + void initDynamicArrays(void); + void initStrings(void); + void initReferences(void); + void freeDynamicArrays(void); + void freeStrings(void); + void freeReferences(void); + + static bool mBuiltFlag; + static NvParameterized::MutexType mBuiltFlagMutex; +}; + +class BasicIOSAssetParam_0p7Factory : public NvParameterized::Factory +{ + static const char* const vptr; + +public: + + virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits) + { + BasicIOSAssetParam_0p7::freeParameterDefinitionTable(traits); + } + + virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits) + { + // placement new on this class using mParameterizedTraits + + void* newPtr = paramTraits->alloc(sizeof(BasicIOSAssetParam_0p7), BasicIOSAssetParam_0p7::ClassAlignment); + if (!NvParameterized::IsAligned(newPtr, BasicIOSAssetParam_0p7::ClassAlignment)) + { + NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_0p7"); + paramTraits->free(newPtr); + return 0; + } + + memset(newPtr, 0, sizeof(BasicIOSAssetParam_0p7)); // always initialize memory allocated to zero for default values + return NV_PARAM_PLACEMENT_NEW(newPtr, BasicIOSAssetParam_0p7)(paramTraits); + } + + virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount) + { + if (!NvParameterized::IsAligned(bufObj, BasicIOSAssetParam_0p7::ClassAlignment) + || !NvParameterized::IsAligned(bufStart, BasicIOSAssetParam_0p7::ClassAlignment)) + { + NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_0p7"); + return 0; + } + + // Init NvParameters-part + // We used to call empty constructor of BasicIOSAssetParam_0p7 here + // but it may call default constructors of members and spoil the data + NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount); + + // Init vtable (everything else is already initialized) + *(const char**)bufObj = vptr; + + return (BasicIOSAssetParam_0p7*)bufObj; + } + + virtual const char* getClassName() + { + return (BasicIOSAssetParam_0p7::staticClassName()); + } + + virtual uint32_t getVersion() + { + return (BasicIOSAssetParam_0p7::staticVersion()); + } + + virtual uint32_t getAlignment() + { + return (BasicIOSAssetParam_0p7::ClassAlignment); + } + + virtual const uint32_t* getChecksum(uint32_t& bits) + { + return (BasicIOSAssetParam_0p7::staticChecksum(bits)); + } +}; +#endif // NV_PARAMETERIZED_ONLY_LAYOUTS + +} // namespace parameterized +} // namespace nvidia + +#if PX_VC +#pragma warning(pop) +#endif + +#endif diff --git a/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p8.h b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p8.h new file mode 100644 index 00000000..dd139f24 --- /dev/null +++ b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p8.h @@ -0,0 +1,260 @@ +// 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 + + +#ifndef HEADER_BasicIOSAssetParam_0p8_h +#define HEADER_BasicIOSAssetParam_0p8_h + +#include "NvParametersTypes.h" + +#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS +#include "nvparameterized/NvParameterized.h" +#include "nvparameterized/NvParameterizedTraits.h" +#include "NvParameters.h" +#include "NvTraitsInternal.h" +#endif + +namespace nvidia +{ +namespace parameterized +{ + +#if PX_VC +#pragma warning(push) +#pragma warning(disable: 4324) // structure was padded due to __declspec(align()) +#endif + +namespace BasicIOSAssetParam_0p8NS +{ + +struct RandomF32_Type; + +struct RandomF32_Type +{ + float center; + float spread; + const char* type; +}; + +struct ParametersStruct +{ + + float restDensity; + float particleRadius; + uint32_t maxParticleCount; + float maxInjectedParticleCount; + uint32_t maxCollidingObjects; + float sceneGravityScale; + physx::PxVec3 externalAcceleration; + RandomF32_Type particleMass; + NvParameterized::DummyStringStruct collisionFilterDataName; + NvParameterized::DummyStringStruct fieldSamplerFilterDataName; + bool staticCollision; + float restitutionForStaticShapes; + bool dynamicCollision; + float restitutionForDynamicShapes; + float collisionDistanceMultiplier; + float collisionThreshold; + bool collisionWithConvex; + bool collisionWithTriangleMesh; + bool UseFakeDensityDistance; + float FakeDensityDistance; + bool UseFakeDensityGrid; + float FakeDensityGridSize; + uint32_t FakeDensityGridMaxCellCount; + const char* FakeDensityGridResolution; + +}; + +static const uint32_t checksum[] = { 0x200e5368, 0x7869390f, 0x538d6f82, 0xca3a948f, }; + +} // namespace BasicIOSAssetParam_0p8NS + +#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS +class BasicIOSAssetParam_0p8 : public NvParameterized::NvParameters, public BasicIOSAssetParam_0p8NS::ParametersStruct +{ +public: + BasicIOSAssetParam_0p8(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0); + + virtual ~BasicIOSAssetParam_0p8(); + + virtual void destroy(); + + static const char* staticClassName(void) + { + return("BasicIOSAssetParam"); + } + + const char* className(void) const + { + return(staticClassName()); + } + + static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)8; + + static uint32_t staticVersion(void) + { + return ClassVersion; + } + + uint32_t version(void) const + { + return(staticVersion()); + } + + static const uint32_t ClassAlignment = 8; + + static const uint32_t* staticChecksum(uint32_t& bits) + { + bits = 8 * sizeof(BasicIOSAssetParam_0p8NS::checksum); + return BasicIOSAssetParam_0p8NS::checksum; + } + + static void freeParameterDefinitionTable(NvParameterized::Traits* traits); + + const uint32_t* checksum(uint32_t& bits) const + { + return staticChecksum(bits); + } + + const BasicIOSAssetParam_0p8NS::ParametersStruct& parameters(void) const + { + BasicIOSAssetParam_0p8* tmpThis = const_cast<BasicIOSAssetParam_0p8*>(this); + return *(static_cast<BasicIOSAssetParam_0p8NS::ParametersStruct*>(tmpThis)); + } + + BasicIOSAssetParam_0p8NS::ParametersStruct& parameters(void) + { + return *(static_cast<BasicIOSAssetParam_0p8NS::ParametersStruct*>(this)); + } + + virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const; + virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle); + + void initDefaults(void); + +protected: + + virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void); + virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const; + + + virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const; + +private: + + void buildTree(void); + void initDynamicArrays(void); + void initStrings(void); + void initReferences(void); + void freeDynamicArrays(void); + void freeStrings(void); + void freeReferences(void); + + static bool mBuiltFlag; + static NvParameterized::MutexType mBuiltFlagMutex; +}; + +class BasicIOSAssetParam_0p8Factory : public NvParameterized::Factory +{ + static const char* const vptr; + +public: + + virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits) + { + BasicIOSAssetParam_0p8::freeParameterDefinitionTable(traits); + } + + virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits) + { + // placement new on this class using mParameterizedTraits + + void* newPtr = paramTraits->alloc(sizeof(BasicIOSAssetParam_0p8), BasicIOSAssetParam_0p8::ClassAlignment); + if (!NvParameterized::IsAligned(newPtr, BasicIOSAssetParam_0p8::ClassAlignment)) + { + NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_0p8"); + paramTraits->free(newPtr); + return 0; + } + + memset(newPtr, 0, sizeof(BasicIOSAssetParam_0p8)); // always initialize memory allocated to zero for default values + return NV_PARAM_PLACEMENT_NEW(newPtr, BasicIOSAssetParam_0p8)(paramTraits); + } + + virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount) + { + if (!NvParameterized::IsAligned(bufObj, BasicIOSAssetParam_0p8::ClassAlignment) + || !NvParameterized::IsAligned(bufStart, BasicIOSAssetParam_0p8::ClassAlignment)) + { + NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_0p8"); + return 0; + } + + // Init NvParameters-part + // We used to call empty constructor of BasicIOSAssetParam_0p8 here + // but it may call default constructors of members and spoil the data + NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount); + + // Init vtable (everything else is already initialized) + *(const char**)bufObj = vptr; + + return (BasicIOSAssetParam_0p8*)bufObj; + } + + virtual const char* getClassName() + { + return (BasicIOSAssetParam_0p8::staticClassName()); + } + + virtual uint32_t getVersion() + { + return (BasicIOSAssetParam_0p8::staticVersion()); + } + + virtual uint32_t getAlignment() + { + return (BasicIOSAssetParam_0p8::ClassAlignment); + } + + virtual const uint32_t* getChecksum(uint32_t& bits) + { + return (BasicIOSAssetParam_0p8::staticChecksum(bits)); + } +}; +#endif // NV_PARAMETERIZED_ONLY_LAYOUTS + +} // namespace parameterized +} // namespace nvidia + +#if PX_VC +#pragma warning(pop) +#endif + +#endif diff --git a/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p9.h b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p9.h new file mode 100644 index 00000000..29228940 --- /dev/null +++ b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p9.h @@ -0,0 +1,270 @@ +// 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 + + +#ifndef HEADER_BasicIOSAssetParam_0p9_h +#define HEADER_BasicIOSAssetParam_0p9_h + +#include "NvParametersTypes.h" + +#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS +#include "nvparameterized/NvParameterized.h" +#include "nvparameterized/NvParameterizedTraits.h" +#include "NvParameters.h" +#include "NvTraitsInternal.h" +#endif + +namespace nvidia +{ +namespace parameterized +{ + +#if PX_VC +#pragma warning(push) +#pragma warning(disable: 4324) // structure was padded due to __declspec(align()) +#endif + +namespace BasicIOSAssetParam_0p9NS +{ + +struct RandomF32_Type; +struct FakeDensityGridNonSharedParams_Type; +struct FakeDensityGridParams_Type; + +struct FakeDensityGridNonSharedParams_Type +{ + float GridSize; + uint32_t GridMaxCellCount; +}; +struct FakeDensityGridParams_Type +{ + bool Enabled; + bool FrustumMode; + const char* GridResolution; + FakeDensityGridNonSharedParams_Type NormalParams; + FakeDensityGridNonSharedParams_Type FrustumParams; +}; +struct RandomF32_Type +{ + float center; + float spread; + const char* type; +}; + +struct ParametersStruct +{ + + float restDensity; + float particleRadius; + uint32_t maxParticleCount; + float maxInjectedParticleCount; + uint32_t maxCollidingObjects; + float sceneGravityScale; + physx::PxVec3 externalAcceleration; + RandomF32_Type particleMass; + NvParameterized::DummyStringStruct collisionFilterDataName; + NvParameterized::DummyStringStruct fieldSamplerFilterDataName; + bool staticCollision; + float restitutionForStaticShapes; + bool dynamicCollision; + float restitutionForDynamicShapes; + float collisionDistanceMultiplier; + float collisionThreshold; + bool collisionWithConvex; + bool collisionWithTriangleMesh; + FakeDensityGridParams_Type FakeDensityGrid; + +}; + +static const uint32_t checksum[] = { 0x6e9af62c, 0x78c430f2, 0x556ec540, 0x264551cc, }; + +} // namespace BasicIOSAssetParam_0p9NS + +#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS +class BasicIOSAssetParam_0p9 : public NvParameterized::NvParameters, public BasicIOSAssetParam_0p9NS::ParametersStruct +{ +public: + BasicIOSAssetParam_0p9(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0); + + virtual ~BasicIOSAssetParam_0p9(); + + virtual void destroy(); + + static const char* staticClassName(void) + { + return("BasicIOSAssetParam"); + } + + const char* className(void) const + { + return(staticClassName()); + } + + static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)9; + + static uint32_t staticVersion(void) + { + return ClassVersion; + } + + uint32_t version(void) const + { + return(staticVersion()); + } + + static const uint32_t ClassAlignment = 8; + + static const uint32_t* staticChecksum(uint32_t& bits) + { + bits = 8 * sizeof(BasicIOSAssetParam_0p9NS::checksum); + return BasicIOSAssetParam_0p9NS::checksum; + } + + static void freeParameterDefinitionTable(NvParameterized::Traits* traits); + + const uint32_t* checksum(uint32_t& bits) const + { + return staticChecksum(bits); + } + + const BasicIOSAssetParam_0p9NS::ParametersStruct& parameters(void) const + { + BasicIOSAssetParam_0p9* tmpThis = const_cast<BasicIOSAssetParam_0p9*>(this); + return *(static_cast<BasicIOSAssetParam_0p9NS::ParametersStruct*>(tmpThis)); + } + + BasicIOSAssetParam_0p9NS::ParametersStruct& parameters(void) + { + return *(static_cast<BasicIOSAssetParam_0p9NS::ParametersStruct*>(this)); + } + + virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const; + virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle); + + void initDefaults(void); + +protected: + + virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void); + virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const; + + + virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const; + +private: + + void buildTree(void); + void initDynamicArrays(void); + void initStrings(void); + void initReferences(void); + void freeDynamicArrays(void); + void freeStrings(void); + void freeReferences(void); + + static bool mBuiltFlag; + static NvParameterized::MutexType mBuiltFlagMutex; +}; + +class BasicIOSAssetParam_0p9Factory : public NvParameterized::Factory +{ + static const char* const vptr; + +public: + + virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits) + { + BasicIOSAssetParam_0p9::freeParameterDefinitionTable(traits); + } + + virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits) + { + // placement new on this class using mParameterizedTraits + + void* newPtr = paramTraits->alloc(sizeof(BasicIOSAssetParam_0p9), BasicIOSAssetParam_0p9::ClassAlignment); + if (!NvParameterized::IsAligned(newPtr, BasicIOSAssetParam_0p9::ClassAlignment)) + { + NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_0p9"); + paramTraits->free(newPtr); + return 0; + } + + memset(newPtr, 0, sizeof(BasicIOSAssetParam_0p9)); // always initialize memory allocated to zero for default values + return NV_PARAM_PLACEMENT_NEW(newPtr, BasicIOSAssetParam_0p9)(paramTraits); + } + + virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount) + { + if (!NvParameterized::IsAligned(bufObj, BasicIOSAssetParam_0p9::ClassAlignment) + || !NvParameterized::IsAligned(bufStart, BasicIOSAssetParam_0p9::ClassAlignment)) + { + NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_0p9"); + return 0; + } + + // Init NvParameters-part + // We used to call empty constructor of BasicIOSAssetParam_0p9 here + // but it may call default constructors of members and spoil the data + NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount); + + // Init vtable (everything else is already initialized) + *(const char**)bufObj = vptr; + + return (BasicIOSAssetParam_0p9*)bufObj; + } + + virtual const char* getClassName() + { + return (BasicIOSAssetParam_0p9::staticClassName()); + } + + virtual uint32_t getVersion() + { + return (BasicIOSAssetParam_0p9::staticVersion()); + } + + virtual uint32_t getAlignment() + { + return (BasicIOSAssetParam_0p9::ClassAlignment); + } + + virtual const uint32_t* getChecksum(uint32_t& bits) + { + return (BasicIOSAssetParam_0p9::staticChecksum(bits)); + } +}; +#endif // NV_PARAMETERIZED_ONLY_LAYOUTS + +} // namespace parameterized +} // namespace nvidia + +#if PX_VC +#pragma warning(pop) +#endif + +#endif diff --git a/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_1p0.h b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_1p0.h new file mode 100644 index 00000000..516d30f2 --- /dev/null +++ b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_1p0.h @@ -0,0 +1,268 @@ +// 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 + + +#ifndef HEADER_BasicIOSAssetParam_1p0_h +#define HEADER_BasicIOSAssetParam_1p0_h + +#include "NvParametersTypes.h" + +#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS +#include "nvparameterized/NvParameterized.h" +#include "nvparameterized/NvParameterizedTraits.h" +#include "NvParameters.h" +#include "NvTraitsInternal.h" +#endif + +namespace nvidia +{ +namespace parameterized +{ + +#if PX_VC +#pragma warning(push) +#pragma warning(disable: 4324) // structure was padded due to __declspec(align()) +#endif + +namespace BasicIOSAssetParam_1p0NS +{ + +struct RandomF32_Type; +struct GridDensityGridNonSharedParams_Type; +struct GridDensityGridParams_Type; + +struct GridDensityGridNonSharedParams_Type +{ + float GridSize; + uint32_t GridMaxCellCount; +}; +struct GridDensityGridParams_Type +{ + bool Enabled; + const char* GridResolution; + GridDensityGridNonSharedParams_Type FrustumParams; +}; +struct RandomF32_Type +{ + float center; + float spread; + const char* type; +}; + +struct ParametersStruct +{ + + float restDensity; + float particleRadius; + uint32_t maxParticleCount; + float maxInjectedParticleCount; + uint32_t maxCollidingObjects; + float sceneGravityScale; + physx::PxVec3 externalAcceleration; + RandomF32_Type particleMass; + NvParameterized::DummyStringStruct collisionFilterDataName; + NvParameterized::DummyStringStruct fieldSamplerFilterDataName; + bool staticCollision; + float restitutionForStaticShapes; + bool dynamicCollision; + float restitutionForDynamicShapes; + float collisionDistanceMultiplier; + float collisionThreshold; + bool collisionWithConvex; + bool collisionWithTriangleMesh; + GridDensityGridParams_Type GridDensityGrid; + +}; + +static const uint32_t checksum[] = { 0x0ec8eaad, 0xe41b35e0, 0x0495591a, 0x41cce2f3, }; + +} // namespace BasicIOSAssetParam_1p0NS + +#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS +class BasicIOSAssetParam_1p0 : public NvParameterized::NvParameters, public BasicIOSAssetParam_1p0NS::ParametersStruct +{ +public: + BasicIOSAssetParam_1p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0); + + virtual ~BasicIOSAssetParam_1p0(); + + virtual void destroy(); + + static const char* staticClassName(void) + { + return("BasicIOSAssetParam"); + } + + const char* className(void) const + { + return(staticClassName()); + } + + static const uint32_t ClassVersion = ((uint32_t)1 << 16) + (uint32_t)0; + + static uint32_t staticVersion(void) + { + return ClassVersion; + } + + uint32_t version(void) const + { + return(staticVersion()); + } + + static const uint32_t ClassAlignment = 8; + + static const uint32_t* staticChecksum(uint32_t& bits) + { + bits = 8 * sizeof(BasicIOSAssetParam_1p0NS::checksum); + return BasicIOSAssetParam_1p0NS::checksum; + } + + static void freeParameterDefinitionTable(NvParameterized::Traits* traits); + + const uint32_t* checksum(uint32_t& bits) const + { + return staticChecksum(bits); + } + + const BasicIOSAssetParam_1p0NS::ParametersStruct& parameters(void) const + { + BasicIOSAssetParam_1p0* tmpThis = const_cast<BasicIOSAssetParam_1p0*>(this); + return *(static_cast<BasicIOSAssetParam_1p0NS::ParametersStruct*>(tmpThis)); + } + + BasicIOSAssetParam_1p0NS::ParametersStruct& parameters(void) + { + return *(static_cast<BasicIOSAssetParam_1p0NS::ParametersStruct*>(this)); + } + + virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const; + virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle); + + void initDefaults(void); + +protected: + + virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void); + virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const; + + + virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const; + +private: + + void buildTree(void); + void initDynamicArrays(void); + void initStrings(void); + void initReferences(void); + void freeDynamicArrays(void); + void freeStrings(void); + void freeReferences(void); + + static bool mBuiltFlag; + static NvParameterized::MutexType mBuiltFlagMutex; +}; + +class BasicIOSAssetParam_1p0Factory : public NvParameterized::Factory +{ + static const char* const vptr; + +public: + + virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits) + { + BasicIOSAssetParam_1p0::freeParameterDefinitionTable(traits); + } + + virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits) + { + // placement new on this class using mParameterizedTraits + + void* newPtr = paramTraits->alloc(sizeof(BasicIOSAssetParam_1p0), BasicIOSAssetParam_1p0::ClassAlignment); + if (!NvParameterized::IsAligned(newPtr, BasicIOSAssetParam_1p0::ClassAlignment)) + { + NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_1p0"); + paramTraits->free(newPtr); + return 0; + } + + memset(newPtr, 0, sizeof(BasicIOSAssetParam_1p0)); // always initialize memory allocated to zero for default values + return NV_PARAM_PLACEMENT_NEW(newPtr, BasicIOSAssetParam_1p0)(paramTraits); + } + + virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount) + { + if (!NvParameterized::IsAligned(bufObj, BasicIOSAssetParam_1p0::ClassAlignment) + || !NvParameterized::IsAligned(bufStart, BasicIOSAssetParam_1p0::ClassAlignment)) + { + NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_1p0"); + return 0; + } + + // Init NvParameters-part + // We used to call empty constructor of BasicIOSAssetParam_1p0 here + // but it may call default constructors of members and spoil the data + NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount); + + // Init vtable (everything else is already initialized) + *(const char**)bufObj = vptr; + + return (BasicIOSAssetParam_1p0*)bufObj; + } + + virtual const char* getClassName() + { + return (BasicIOSAssetParam_1p0::staticClassName()); + } + + virtual uint32_t getVersion() + { + return (BasicIOSAssetParam_1p0::staticVersion()); + } + + virtual uint32_t getAlignment() + { + return (BasicIOSAssetParam_1p0::ClassAlignment); + } + + virtual const uint32_t* getChecksum(uint32_t& bits) + { + return (BasicIOSAssetParam_1p0::staticChecksum(bits)); + } +}; +#endif // NV_PARAMETERIZED_ONLY_LAYOUTS + +} // namespace parameterized +} // namespace nvidia + +#if PX_VC +#pragma warning(pop) +#endif + +#endif diff --git a/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_1p1.h b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_1p1.h new file mode 100644 index 00000000..f87af5fe --- /dev/null +++ b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_1p1.h @@ -0,0 +1,263 @@ +// 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 + + +#ifndef HEADER_BasicIOSAssetParam_1p1_h +#define HEADER_BasicIOSAssetParam_1p1_h + +#include "NvParametersTypes.h" + +#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS +#include "nvparameterized/NvParameterized.h" +#include "nvparameterized/NvParameterizedTraits.h" +#include "NvParameters.h" +#include "NvTraitsInternal.h" +#endif + +namespace nvidia +{ +namespace parameterized +{ + +#if PX_VC +#pragma warning(push) +#pragma warning(disable: 4324) // structure was padded due to __declspec(align()) +#endif + +namespace BasicIOSAssetParam_1p1NS +{ + +struct RandomF32_Type; +struct GridDensityParams_Type; + +struct GridDensityParams_Type +{ + bool Enabled; + const char* Resolution; + float GridSize; + uint32_t MaxCellCount; +}; +struct RandomF32_Type +{ + float center; + float spread; + const char* type; +}; + +struct ParametersStruct +{ + + float restDensity; + float particleRadius; + uint32_t maxParticleCount; + float maxInjectedParticleCount; + uint32_t maxCollidingObjects; + float sceneGravityScale; + physx::PxVec3 externalAcceleration; + RandomF32_Type particleMass; + NvParameterized::DummyStringStruct collisionFilterDataName; + NvParameterized::DummyStringStruct fieldSamplerFilterDataName; + bool staticCollision; + float restitutionForStaticShapes; + bool dynamicCollision; + float restitutionForDynamicShapes; + float collisionDistanceMultiplier; + float collisionThreshold; + bool collisionWithConvex; + bool collisionWithTriangleMesh; + GridDensityParams_Type GridDensity; + +}; + +static const uint32_t checksum[] = { 0xb9cf2ef9, 0x026f63d8, 0xf432a6a2, 0x5405c67a, }; + +} // namespace BasicIOSAssetParam_1p1NS + +#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS +class BasicIOSAssetParam_1p1 : public NvParameterized::NvParameters, public BasicIOSAssetParam_1p1NS::ParametersStruct +{ +public: + BasicIOSAssetParam_1p1(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0); + + virtual ~BasicIOSAssetParam_1p1(); + + virtual void destroy(); + + static const char* staticClassName(void) + { + return("BasicIOSAssetParam"); + } + + const char* className(void) const + { + return(staticClassName()); + } + + static const uint32_t ClassVersion = ((uint32_t)1 << 16) + (uint32_t)1; + + static uint32_t staticVersion(void) + { + return ClassVersion; + } + + uint32_t version(void) const + { + return(staticVersion()); + } + + static const uint32_t ClassAlignment = 8; + + static const uint32_t* staticChecksum(uint32_t& bits) + { + bits = 8 * sizeof(BasicIOSAssetParam_1p1NS::checksum); + return BasicIOSAssetParam_1p1NS::checksum; + } + + static void freeParameterDefinitionTable(NvParameterized::Traits* traits); + + const uint32_t* checksum(uint32_t& bits) const + { + return staticChecksum(bits); + } + + const BasicIOSAssetParam_1p1NS::ParametersStruct& parameters(void) const + { + BasicIOSAssetParam_1p1* tmpThis = const_cast<BasicIOSAssetParam_1p1*>(this); + return *(static_cast<BasicIOSAssetParam_1p1NS::ParametersStruct*>(tmpThis)); + } + + BasicIOSAssetParam_1p1NS::ParametersStruct& parameters(void) + { + return *(static_cast<BasicIOSAssetParam_1p1NS::ParametersStruct*>(this)); + } + + virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const; + virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle); + + void initDefaults(void); + +protected: + + virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void); + virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const; + + + virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const; + +private: + + void buildTree(void); + void initDynamicArrays(void); + void initStrings(void); + void initReferences(void); + void freeDynamicArrays(void); + void freeStrings(void); + void freeReferences(void); + + static bool mBuiltFlag; + static NvParameterized::MutexType mBuiltFlagMutex; +}; + +class BasicIOSAssetParam_1p1Factory : public NvParameterized::Factory +{ + static const char* const vptr; + +public: + + virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits) + { + BasicIOSAssetParam_1p1::freeParameterDefinitionTable(traits); + } + + virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits) + { + // placement new on this class using mParameterizedTraits + + void* newPtr = paramTraits->alloc(sizeof(BasicIOSAssetParam_1p1), BasicIOSAssetParam_1p1::ClassAlignment); + if (!NvParameterized::IsAligned(newPtr, BasicIOSAssetParam_1p1::ClassAlignment)) + { + NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_1p1"); + paramTraits->free(newPtr); + return 0; + } + + memset(newPtr, 0, sizeof(BasicIOSAssetParam_1p1)); // always initialize memory allocated to zero for default values + return NV_PARAM_PLACEMENT_NEW(newPtr, BasicIOSAssetParam_1p1)(paramTraits); + } + + virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount) + { + if (!NvParameterized::IsAligned(bufObj, BasicIOSAssetParam_1p1::ClassAlignment) + || !NvParameterized::IsAligned(bufStart, BasicIOSAssetParam_1p1::ClassAlignment)) + { + NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_1p1"); + return 0; + } + + // Init NvParameters-part + // We used to call empty constructor of BasicIOSAssetParam_1p1 here + // but it may call default constructors of members and spoil the data + NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount); + + // Init vtable (everything else is already initialized) + *(const char**)bufObj = vptr; + + return (BasicIOSAssetParam_1p1*)bufObj; + } + + virtual const char* getClassName() + { + return (BasicIOSAssetParam_1p1::staticClassName()); + } + + virtual uint32_t getVersion() + { + return (BasicIOSAssetParam_1p1::staticVersion()); + } + + virtual uint32_t getAlignment() + { + return (BasicIOSAssetParam_1p1::ClassAlignment); + } + + virtual const uint32_t* getChecksum(uint32_t& bits) + { + return (BasicIOSAssetParam_1p1::staticChecksum(bits)); + } +}; +#endif // NV_PARAMETERIZED_ONLY_LAYOUTS + +} // namespace parameterized +} // namespace nvidia + +#if PX_VC +#pragma warning(pop) +#endif + +#endif diff --git a/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_1p2.h b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_1p2.h new file mode 100644 index 00000000..8422a370 --- /dev/null +++ b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_1p2.h @@ -0,0 +1,264 @@ +// 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 + + +#ifndef HEADER_BasicIOSAssetParam_1p2_h +#define HEADER_BasicIOSAssetParam_1p2_h + +#include "NvParametersTypes.h" + +#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS +#include "nvparameterized/NvParameterized.h" +#include "nvparameterized/NvParameterizedTraits.h" +#include "NvParameters.h" +#include "NvTraitsInternal.h" +#endif + +namespace nvidia +{ +namespace parameterized +{ + +#if PX_VC +#pragma warning(push) +#pragma warning(disable: 4324) // structure was padded due to __declspec(align()) +#endif + +namespace BasicIOSAssetParam_1p2NS +{ + +struct RandomF32_Type; +struct GridDensityParams_Type; + +struct GridDensityParams_Type +{ + bool Enabled; + const char* Resolution; + float GridSize; + uint32_t MaxCellCount; +}; +struct RandomF32_Type +{ + float center; + float spread; + const char* type; +}; + +struct ParametersStruct +{ + + float restDensity; + float particleRadius; + uint32_t maxParticleCount; + float maxInjectedParticleCount; + uint32_t maxCollidingObjects; + float sceneGravityScale; + physx::PxVec3 externalAcceleration; + RandomF32_Type particleMass; + NvParameterized::DummyStringStruct collisionFilterDataName; + NvParameterized::DummyStringStruct fieldSamplerFilterDataName; + bool staticCollision; + float restitutionForStaticShapes; + bool dynamicCollision; + float restitutionForDynamicShapes; + float collisionDistanceMultiplier; + float collisionThreshold; + bool collisionWithConvex; + bool collisionWithTriangleMesh; + GridDensityParams_Type GridDensity; + bool enableTemperatureBuffer; + +}; + +static const uint32_t checksum[] = { 0xc3985a5c, 0x2317e2e4, 0xb76060b8, 0x57d78da2, }; + +} // namespace BasicIOSAssetParam_1p2NS + +#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS +class BasicIOSAssetParam_1p2 : public NvParameterized::NvParameters, public BasicIOSAssetParam_1p2NS::ParametersStruct +{ +public: + BasicIOSAssetParam_1p2(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0); + + virtual ~BasicIOSAssetParam_1p2(); + + virtual void destroy(); + + static const char* staticClassName(void) + { + return("BasicIOSAssetParam"); + } + + const char* className(void) const + { + return(staticClassName()); + } + + static const uint32_t ClassVersion = ((uint32_t)1 << 16) + (uint32_t)2; + + static uint32_t staticVersion(void) + { + return ClassVersion; + } + + uint32_t version(void) const + { + return(staticVersion()); + } + + static const uint32_t ClassAlignment = 8; + + static const uint32_t* staticChecksum(uint32_t& bits) + { + bits = 8 * sizeof(BasicIOSAssetParam_1p2NS::checksum); + return BasicIOSAssetParam_1p2NS::checksum; + } + + static void freeParameterDefinitionTable(NvParameterized::Traits* traits); + + const uint32_t* checksum(uint32_t& bits) const + { + return staticChecksum(bits); + } + + const BasicIOSAssetParam_1p2NS::ParametersStruct& parameters(void) const + { + BasicIOSAssetParam_1p2* tmpThis = const_cast<BasicIOSAssetParam_1p2*>(this); + return *(static_cast<BasicIOSAssetParam_1p2NS::ParametersStruct*>(tmpThis)); + } + + BasicIOSAssetParam_1p2NS::ParametersStruct& parameters(void) + { + return *(static_cast<BasicIOSAssetParam_1p2NS::ParametersStruct*>(this)); + } + + virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const; + virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle); + + void initDefaults(void); + +protected: + + virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void); + virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const; + + + virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const; + +private: + + void buildTree(void); + void initDynamicArrays(void); + void initStrings(void); + void initReferences(void); + void freeDynamicArrays(void); + void freeStrings(void); + void freeReferences(void); + + static bool mBuiltFlag; + static NvParameterized::MutexType mBuiltFlagMutex; +}; + +class BasicIOSAssetParam_1p2Factory : public NvParameterized::Factory +{ + static const char* const vptr; + +public: + + virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits) + { + BasicIOSAssetParam_1p2::freeParameterDefinitionTable(traits); + } + + virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits) + { + // placement new on this class using mParameterizedTraits + + void* newPtr = paramTraits->alloc(sizeof(BasicIOSAssetParam_1p2), BasicIOSAssetParam_1p2::ClassAlignment); + if (!NvParameterized::IsAligned(newPtr, BasicIOSAssetParam_1p2::ClassAlignment)) + { + NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_1p2"); + paramTraits->free(newPtr); + return 0; + } + + memset(newPtr, 0, sizeof(BasicIOSAssetParam_1p2)); // always initialize memory allocated to zero for default values + return NV_PARAM_PLACEMENT_NEW(newPtr, BasicIOSAssetParam_1p2)(paramTraits); + } + + virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount) + { + if (!NvParameterized::IsAligned(bufObj, BasicIOSAssetParam_1p2::ClassAlignment) + || !NvParameterized::IsAligned(bufStart, BasicIOSAssetParam_1p2::ClassAlignment)) + { + NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_1p2"); + return 0; + } + + // Init NvParameters-part + // We used to call empty constructor of BasicIOSAssetParam_1p2 here + // but it may call default constructors of members and spoil the data + NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount); + + // Init vtable (everything else is already initialized) + *(const char**)bufObj = vptr; + + return (BasicIOSAssetParam_1p2*)bufObj; + } + + virtual const char* getClassName() + { + return (BasicIOSAssetParam_1p2::staticClassName()); + } + + virtual uint32_t getVersion() + { + return (BasicIOSAssetParam_1p2::staticVersion()); + } + + virtual uint32_t getAlignment() + { + return (BasicIOSAssetParam_1p2::ClassAlignment); + } + + virtual const uint32_t* getChecksum(uint32_t& bits) + { + return (BasicIOSAssetParam_1p2::staticChecksum(bits)); + } +}; +#endif // NV_PARAMETERIZED_ONLY_LAYOUTS + +} // namespace parameterized +} // namespace nvidia + +#if PX_VC +#pragma warning(pop) +#endif + +#endif diff --git a/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_1p3.h b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_1p3.h new file mode 100644 index 00000000..bdf71e5f --- /dev/null +++ b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_1p3.h @@ -0,0 +1,281 @@ +// 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 + + +#ifndef HEADER_BasicIOSAssetParam_1p3_h +#define HEADER_BasicIOSAssetParam_1p3_h + +#include "NvParametersTypes.h" + +#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS +#include "nvparameterized/NvParameterized.h" +#include "nvparameterized/NvParameterizedTraits.h" +#include "NvParameters.h" +#include "NvTraitsInternal.h" +#endif + +namespace nvidia +{ +namespace parameterized +{ + +#if PX_VC +#pragma warning(push) +#pragma warning(disable: 4324) // structure was padded due to __declspec(align()) +#endif + +namespace BasicIOSAssetParam_1p3NS +{ + +struct RandomF32_Type; +struct GridDensityParams_Type; +struct ParticleToGridCouplingParams_Type; +struct GridToParticleCouplingParams_Type; + +struct ParticleToGridCouplingParams_Type +{ + float accelTimeConstant; + float decelTimeConstant; + float thresholdMultiplier; +}; +struct GridDensityParams_Type +{ + bool Enabled; + const char* Resolution; + float GridSize; + uint32_t MaxCellCount; +}; +struct GridToParticleCouplingParams_Type +{ + float accelTimeConstant; + float decelTimeConstant; + float thresholdMultiplier; +}; +struct RandomF32_Type +{ + float center; + float spread; + const char* type; +}; + +struct ParametersStruct +{ + + float restDensity; + float particleRadius; + uint32_t maxParticleCount; + float maxInjectedParticleCount; + uint32_t maxCollidingObjects; + float sceneGravityScale; + physx::PxVec3 externalAcceleration; + RandomF32_Type particleMass; + NvParameterized::DummyStringStruct collisionFilterDataName; + NvParameterized::DummyStringStruct fieldSamplerFilterDataName; + bool staticCollision; + float restitutionForStaticShapes; + bool dynamicCollision; + float restitutionForDynamicShapes; + float collisionDistanceMultiplier; + float collisionThreshold; + bool collisionWithConvex; + bool collisionWithTriangleMesh; + GridDensityParams_Type GridDensity; + bool enableTemperatureBuffer; + bool enableCouplingOverride; + ParticleToGridCouplingParams_Type particleToGridCoupling; + GridToParticleCouplingParams_Type gridToParticleCoupling; + +}; + +static const uint32_t checksum[] = { 0xce8e2592, 0xae4fe7ed, 0x0e4024c0, 0x2142d36e, }; + +} // namespace BasicIOSAssetParam_1p3NS + +#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS +class BasicIOSAssetParam_1p3 : public NvParameterized::NvParameters, public BasicIOSAssetParam_1p3NS::ParametersStruct +{ +public: + BasicIOSAssetParam_1p3(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0); + + virtual ~BasicIOSAssetParam_1p3(); + + virtual void destroy(); + + static const char* staticClassName(void) + { + return("BasicIOSAssetParam"); + } + + const char* className(void) const + { + return(staticClassName()); + } + + static const uint32_t ClassVersion = ((uint32_t)1 << 16) + (uint32_t)3; + + static uint32_t staticVersion(void) + { + return ClassVersion; + } + + uint32_t version(void) const + { + return(staticVersion()); + } + + static const uint32_t ClassAlignment = 8; + + static const uint32_t* staticChecksum(uint32_t& bits) + { + bits = 8 * sizeof(BasicIOSAssetParam_1p3NS::checksum); + return BasicIOSAssetParam_1p3NS::checksum; + } + + static void freeParameterDefinitionTable(NvParameterized::Traits* traits); + + const uint32_t* checksum(uint32_t& bits) const + { + return staticChecksum(bits); + } + + const BasicIOSAssetParam_1p3NS::ParametersStruct& parameters(void) const + { + BasicIOSAssetParam_1p3* tmpThis = const_cast<BasicIOSAssetParam_1p3*>(this); + return *(static_cast<BasicIOSAssetParam_1p3NS::ParametersStruct*>(tmpThis)); + } + + BasicIOSAssetParam_1p3NS::ParametersStruct& parameters(void) + { + return *(static_cast<BasicIOSAssetParam_1p3NS::ParametersStruct*>(this)); + } + + virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const; + virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle); + + void initDefaults(void); + +protected: + + virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void); + virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const; + + + virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const; + +private: + + void buildTree(void); + void initDynamicArrays(void); + void initStrings(void); + void initReferences(void); + void freeDynamicArrays(void); + void freeStrings(void); + void freeReferences(void); + + static bool mBuiltFlag; + static NvParameterized::MutexType mBuiltFlagMutex; +}; + +class BasicIOSAssetParam_1p3Factory : public NvParameterized::Factory +{ + static const char* const vptr; + +public: + + virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits) + { + BasicIOSAssetParam_1p3::freeParameterDefinitionTable(traits); + } + + virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits) + { + // placement new on this class using mParameterizedTraits + + void* newPtr = paramTraits->alloc(sizeof(BasicIOSAssetParam_1p3), BasicIOSAssetParam_1p3::ClassAlignment); + if (!NvParameterized::IsAligned(newPtr, BasicIOSAssetParam_1p3::ClassAlignment)) + { + NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_1p3"); + paramTraits->free(newPtr); + return 0; + } + + memset(newPtr, 0, sizeof(BasicIOSAssetParam_1p3)); // always initialize memory allocated to zero for default values + return NV_PARAM_PLACEMENT_NEW(newPtr, BasicIOSAssetParam_1p3)(paramTraits); + } + + virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount) + { + if (!NvParameterized::IsAligned(bufObj, BasicIOSAssetParam_1p3::ClassAlignment) + || !NvParameterized::IsAligned(bufStart, BasicIOSAssetParam_1p3::ClassAlignment)) + { + NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_1p3"); + return 0; + } + + // Init NvParameters-part + // We used to call empty constructor of BasicIOSAssetParam_1p3 here + // but it may call default constructors of members and spoil the data + NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount); + + // Init vtable (everything else is already initialized) + *(const char**)bufObj = vptr; + + return (BasicIOSAssetParam_1p3*)bufObj; + } + + virtual const char* getClassName() + { + return (BasicIOSAssetParam_1p3::staticClassName()); + } + + virtual uint32_t getVersion() + { + return (BasicIOSAssetParam_1p3::staticVersion()); + } + + virtual uint32_t getAlignment() + { + return (BasicIOSAssetParam_1p3::ClassAlignment); + } + + virtual const uint32_t* getChecksum(uint32_t& bits) + { + return (BasicIOSAssetParam_1p3::staticChecksum(bits)); + } +}; +#endif // NV_PARAMETERIZED_ONLY_LAYOUTS + +} // namespace parameterized +} // namespace nvidia + +#if PX_VC +#pragma warning(pop) +#endif + +#endif diff --git a/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_1p4.h b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_1p4.h new file mode 100644 index 00000000..b1a9c607 --- /dev/null +++ b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_1p4.h @@ -0,0 +1,282 @@ +// 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 + + +#ifndef HEADER_BasicIOSAssetParam_1p4_h +#define HEADER_BasicIOSAssetParam_1p4_h + +#include "NvParametersTypes.h" + +#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS +#include "nvparameterized/NvParameterized.h" +#include "nvparameterized/NvParameterizedTraits.h" +#include "NvParameters.h" +#include "NvTraitsInternal.h" +#endif + +namespace nvidia +{ +namespace parameterized +{ + +#if PX_VC +#pragma warning(push) +#pragma warning(disable: 4324) // structure was padded due to __declspec(align()) +#endif + +namespace BasicIOSAssetParam_1p4NS +{ + +struct RandomF32_Type; +struct GridDensityParams_Type; +struct ParticleToGridCouplingParams_Type; +struct GridToParticleCouplingParams_Type; + +struct ParticleToGridCouplingParams_Type +{ + float accelTimeConstant; + float decelTimeConstant; + float thresholdMultiplier; +}; +struct GridDensityParams_Type +{ + bool Enabled; + const char* Resolution; + float GridSize; + uint32_t MaxCellCount; +}; +struct GridToParticleCouplingParams_Type +{ + float accelTimeConstant; + float decelTimeConstant; + float thresholdMultiplier; +}; +struct RandomF32_Type +{ + float center; + float spread; + const char* type; +}; + +struct ParametersStruct +{ + + float restDensity; + float particleRadius; + uint32_t maxParticleCount; + float maxInjectedParticleCount; + uint32_t maxCollidingObjects; + float sceneGravityScale; + physx::PxVec3 externalAcceleration; + RandomF32_Type particleMass; + NvParameterized::DummyStringStruct collisionFilterDataName; + NvParameterized::DummyStringStruct fieldSamplerFilterDataName; + bool staticCollision; + float restitutionForStaticShapes; + bool dynamicCollision; + float restitutionForDynamicShapes; + float collisionDistanceMultiplier; + float collisionThreshold; + bool collisionWithConvex; + bool collisionWithTriangleMesh; + GridDensityParams_Type GridDensity; + bool enableTemperatureBuffer; + bool enableDensityBuffer; + bool enableCouplingOverride; + ParticleToGridCouplingParams_Type particleToGridCoupling; + GridToParticleCouplingParams_Type gridToParticleCoupling; + +}; + +static const uint32_t checksum[] = { 0xd1ae20ca, 0xe79f585e, 0x9ab86d65, 0x9964607a, }; + +} // namespace BasicIOSAssetParam_1p4NS + +#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS +class BasicIOSAssetParam_1p4 : public NvParameterized::NvParameters, public BasicIOSAssetParam_1p4NS::ParametersStruct +{ +public: + BasicIOSAssetParam_1p4(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0); + + virtual ~BasicIOSAssetParam_1p4(); + + virtual void destroy(); + + static const char* staticClassName(void) + { + return("BasicIOSAssetParam"); + } + + const char* className(void) const + { + return(staticClassName()); + } + + static const uint32_t ClassVersion = ((uint32_t)1 << 16) + (uint32_t)4; + + static uint32_t staticVersion(void) + { + return ClassVersion; + } + + uint32_t version(void) const + { + return(staticVersion()); + } + + static const uint32_t ClassAlignment = 8; + + static const uint32_t* staticChecksum(uint32_t& bits) + { + bits = 8 * sizeof(BasicIOSAssetParam_1p4NS::checksum); + return BasicIOSAssetParam_1p4NS::checksum; + } + + static void freeParameterDefinitionTable(NvParameterized::Traits* traits); + + const uint32_t* checksum(uint32_t& bits) const + { + return staticChecksum(bits); + } + + const BasicIOSAssetParam_1p4NS::ParametersStruct& parameters(void) const + { + BasicIOSAssetParam_1p4* tmpThis = const_cast<BasicIOSAssetParam_1p4*>(this); + return *(static_cast<BasicIOSAssetParam_1p4NS::ParametersStruct*>(tmpThis)); + } + + BasicIOSAssetParam_1p4NS::ParametersStruct& parameters(void) + { + return *(static_cast<BasicIOSAssetParam_1p4NS::ParametersStruct*>(this)); + } + + virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const; + virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle); + + void initDefaults(void); + +protected: + + virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void); + virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const; + + + virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const; + +private: + + void buildTree(void); + void initDynamicArrays(void); + void initStrings(void); + void initReferences(void); + void freeDynamicArrays(void); + void freeStrings(void); + void freeReferences(void); + + static bool mBuiltFlag; + static NvParameterized::MutexType mBuiltFlagMutex; +}; + +class BasicIOSAssetParam_1p4Factory : public NvParameterized::Factory +{ + static const char* const vptr; + +public: + + virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits) + { + BasicIOSAssetParam_1p4::freeParameterDefinitionTable(traits); + } + + virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits) + { + // placement new on this class using mParameterizedTraits + + void* newPtr = paramTraits->alloc(sizeof(BasicIOSAssetParam_1p4), BasicIOSAssetParam_1p4::ClassAlignment); + if (!NvParameterized::IsAligned(newPtr, BasicIOSAssetParam_1p4::ClassAlignment)) + { + NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_1p4"); + paramTraits->free(newPtr); + return 0; + } + + memset(newPtr, 0, sizeof(BasicIOSAssetParam_1p4)); // always initialize memory allocated to zero for default values + return NV_PARAM_PLACEMENT_NEW(newPtr, BasicIOSAssetParam_1p4)(paramTraits); + } + + virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount) + { + if (!NvParameterized::IsAligned(bufObj, BasicIOSAssetParam_1p4::ClassAlignment) + || !NvParameterized::IsAligned(bufStart, BasicIOSAssetParam_1p4::ClassAlignment)) + { + NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_1p4"); + return 0; + } + + // Init NvParameters-part + // We used to call empty constructor of BasicIOSAssetParam_1p4 here + // but it may call default constructors of members and spoil the data + NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount); + + // Init vtable (everything else is already initialized) + *(const char**)bufObj = vptr; + + return (BasicIOSAssetParam_1p4*)bufObj; + } + + virtual const char* getClassName() + { + return (BasicIOSAssetParam_1p4::staticClassName()); + } + + virtual uint32_t getVersion() + { + return (BasicIOSAssetParam_1p4::staticVersion()); + } + + virtual uint32_t getAlignment() + { + return (BasicIOSAssetParam_1p4::ClassAlignment); + } + + virtual const uint32_t* getChecksum(uint32_t& bits) + { + return (BasicIOSAssetParam_1p4::staticChecksum(bits)); + } +}; +#endif // NV_PARAMETERIZED_ONLY_LAYOUTS + +} // namespace parameterized +} // namespace nvidia + +#if PX_VC +#pragma warning(pop) +#endif + +#endif diff --git a/APEX_1.4/module/basicios_legacy/include/autogen/BasicIosDebugRenderParams_0p0.h b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIosDebugRenderParams_0p0.h new file mode 100644 index 00000000..b3aed4cf --- /dev/null +++ b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIosDebugRenderParams_0p0.h @@ -0,0 +1,232 @@ +// 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 + + +#ifndef HEADER_BasicIosDebugRenderParams_0p0_h +#define HEADER_BasicIosDebugRenderParams_0p0_h + +#include "NvParametersTypes.h" + +#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS +#include "nvparameterized/NvParameterized.h" +#include "nvparameterized/NvParameterizedTraits.h" +#include "NvParameters.h" +#include "NvTraitsInternal.h" +#endif + +namespace nvidia +{ +namespace parameterized +{ + +#if PX_VC +#pragma warning(push) +#pragma warning(disable: 4324) // structure was padded due to __declspec(align()) +#endif + +namespace BasicIosDebugRenderParams_0p0NS +{ + + + +struct ParametersStruct +{ + + bool VISUALIZE_BASIC_IOS_ACTOR; + bool VISUALIZE_BASIC_IOS_COLLIDE_SHAPES; + bool VISUALIZE_BASIC_IOS_GRID_DENSITY; + +}; + +static const uint32_t checksum[] = { 0xfdf6893d, 0xf8944ef9, 0x2d74bc9a, 0x7fb067bf, }; + +} // namespace BasicIosDebugRenderParams_0p0NS + +#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS +class BasicIosDebugRenderParams_0p0 : public NvParameterized::NvParameters, public BasicIosDebugRenderParams_0p0NS::ParametersStruct +{ +public: + BasicIosDebugRenderParams_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0); + + virtual ~BasicIosDebugRenderParams_0p0(); + + virtual void destroy(); + + static const char* staticClassName(void) + { + return("BasicIosDebugRenderParams"); + } + + const char* className(void) const + { + return(staticClassName()); + } + + static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)0; + + static uint32_t staticVersion(void) + { + return ClassVersion; + } + + uint32_t version(void) const + { + return(staticVersion()); + } + + static const uint32_t ClassAlignment = 8; + + static const uint32_t* staticChecksum(uint32_t& bits) + { + bits = 8 * sizeof(BasicIosDebugRenderParams_0p0NS::checksum); + return BasicIosDebugRenderParams_0p0NS::checksum; + } + + static void freeParameterDefinitionTable(NvParameterized::Traits* traits); + + const uint32_t* checksum(uint32_t& bits) const + { + return staticChecksum(bits); + } + + const BasicIosDebugRenderParams_0p0NS::ParametersStruct& parameters(void) const + { + BasicIosDebugRenderParams_0p0* tmpThis = const_cast<BasicIosDebugRenderParams_0p0*>(this); + return *(static_cast<BasicIosDebugRenderParams_0p0NS::ParametersStruct*>(tmpThis)); + } + + BasicIosDebugRenderParams_0p0NS::ParametersStruct& parameters(void) + { + return *(static_cast<BasicIosDebugRenderParams_0p0NS::ParametersStruct*>(this)); + } + + virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const; + virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle); + + void initDefaults(void); + +protected: + + virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void); + virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const; + + + virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const; + +private: + + void buildTree(void); + void initDynamicArrays(void); + void initStrings(void); + void initReferences(void); + void freeDynamicArrays(void); + void freeStrings(void); + void freeReferences(void); + + static bool mBuiltFlag; + static NvParameterized::MutexType mBuiltFlagMutex; +}; + +class BasicIosDebugRenderParams_0p0Factory : public NvParameterized::Factory +{ + static const char* const vptr; + +public: + + virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits) + { + BasicIosDebugRenderParams_0p0::freeParameterDefinitionTable(traits); + } + + virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits) + { + // placement new on this class using mParameterizedTraits + + void* newPtr = paramTraits->alloc(sizeof(BasicIosDebugRenderParams_0p0), BasicIosDebugRenderParams_0p0::ClassAlignment); + if (!NvParameterized::IsAligned(newPtr, BasicIosDebugRenderParams_0p0::ClassAlignment)) + { + NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIosDebugRenderParams_0p0"); + paramTraits->free(newPtr); + return 0; + } + + memset(newPtr, 0, sizeof(BasicIosDebugRenderParams_0p0)); // always initialize memory allocated to zero for default values + return NV_PARAM_PLACEMENT_NEW(newPtr, BasicIosDebugRenderParams_0p0)(paramTraits); + } + + virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount) + { + if (!NvParameterized::IsAligned(bufObj, BasicIosDebugRenderParams_0p0::ClassAlignment) + || !NvParameterized::IsAligned(bufStart, BasicIosDebugRenderParams_0p0::ClassAlignment)) + { + NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIosDebugRenderParams_0p0"); + return 0; + } + + // Init NvParameters-part + // We used to call empty constructor of BasicIosDebugRenderParams_0p0 here + // but it may call default constructors of members and spoil the data + NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount); + + // Init vtable (everything else is already initialized) + *(const char**)bufObj = vptr; + + return (BasicIosDebugRenderParams_0p0*)bufObj; + } + + virtual const char* getClassName() + { + return (BasicIosDebugRenderParams_0p0::staticClassName()); + } + + virtual uint32_t getVersion() + { + return (BasicIosDebugRenderParams_0p0::staticVersion()); + } + + virtual uint32_t getAlignment() + { + return (BasicIosDebugRenderParams_0p0::ClassAlignment); + } + + virtual const uint32_t* getChecksum(uint32_t& bits) + { + return (BasicIosDebugRenderParams_0p0::staticChecksum(bits)); + } +}; +#endif // NV_PARAMETERIZED_ONLY_LAYOUTS + +} // namespace parameterized +} // namespace nvidia + +#if PX_VC +#pragma warning(pop) +#endif + +#endif diff --git a/APEX_1.4/module/basicios_legacy/include/autogen/BasicIosModuleParameters_0p0.h b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIosModuleParameters_0p0.h new file mode 100644 index 00000000..051a3103 --- /dev/null +++ b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIosModuleParameters_0p0.h @@ -0,0 +1,230 @@ +// 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 + + +#ifndef HEADER_BasicIosModuleParameters_0p0_h +#define HEADER_BasicIosModuleParameters_0p0_h + +#include "NvParametersTypes.h" + +#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS +#include "nvparameterized/NvParameterized.h" +#include "nvparameterized/NvParameterizedTraits.h" +#include "NvParameters.h" +#include "NvTraitsInternal.h" +#endif + +namespace nvidia +{ +namespace parameterized +{ + +#if PX_VC +#pragma warning(push) +#pragma warning(disable: 4324) // structure was padded due to __declspec(align()) +#endif + +namespace BasicIosModuleParameters_0p0NS +{ + + + +struct ParametersStruct +{ + + uint32_t unused; + +}; + +static const uint32_t checksum[] = { 0x3fbae874, 0x2a648c69, 0x7ac9c757, 0x46be4dcd, }; + +} // namespace BasicIosModuleParameters_0p0NS + +#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS +class BasicIosModuleParameters_0p0 : public NvParameterized::NvParameters, public BasicIosModuleParameters_0p0NS::ParametersStruct +{ +public: + BasicIosModuleParameters_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0); + + virtual ~BasicIosModuleParameters_0p0(); + + virtual void destroy(); + + static const char* staticClassName(void) + { + return("BasicIosModuleParameters"); + } + + const char* className(void) const + { + return(staticClassName()); + } + + static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)0; + + static uint32_t staticVersion(void) + { + return ClassVersion; + } + + uint32_t version(void) const + { + return(staticVersion()); + } + + static const uint32_t ClassAlignment = 8; + + static const uint32_t* staticChecksum(uint32_t& bits) + { + bits = 8 * sizeof(BasicIosModuleParameters_0p0NS::checksum); + return BasicIosModuleParameters_0p0NS::checksum; + } + + static void freeParameterDefinitionTable(NvParameterized::Traits* traits); + + const uint32_t* checksum(uint32_t& bits) const + { + return staticChecksum(bits); + } + + const BasicIosModuleParameters_0p0NS::ParametersStruct& parameters(void) const + { + BasicIosModuleParameters_0p0* tmpThis = const_cast<BasicIosModuleParameters_0p0*>(this); + return *(static_cast<BasicIosModuleParameters_0p0NS::ParametersStruct*>(tmpThis)); + } + + BasicIosModuleParameters_0p0NS::ParametersStruct& parameters(void) + { + return *(static_cast<BasicIosModuleParameters_0p0NS::ParametersStruct*>(this)); + } + + virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const; + virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle); + + void initDefaults(void); + +protected: + + virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void); + virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const; + + + virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const; + +private: + + void buildTree(void); + void initDynamicArrays(void); + void initStrings(void); + void initReferences(void); + void freeDynamicArrays(void); + void freeStrings(void); + void freeReferences(void); + + static bool mBuiltFlag; + static NvParameterized::MutexType mBuiltFlagMutex; +}; + +class BasicIosModuleParameters_0p0Factory : public NvParameterized::Factory +{ + static const char* const vptr; + +public: + + virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits) + { + BasicIosModuleParameters_0p0::freeParameterDefinitionTable(traits); + } + + virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits) + { + // placement new on this class using mParameterizedTraits + + void* newPtr = paramTraits->alloc(sizeof(BasicIosModuleParameters_0p0), BasicIosModuleParameters_0p0::ClassAlignment); + if (!NvParameterized::IsAligned(newPtr, BasicIosModuleParameters_0p0::ClassAlignment)) + { + NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIosModuleParameters_0p0"); + paramTraits->free(newPtr); + return 0; + } + + memset(newPtr, 0, sizeof(BasicIosModuleParameters_0p0)); // always initialize memory allocated to zero for default values + return NV_PARAM_PLACEMENT_NEW(newPtr, BasicIosModuleParameters_0p0)(paramTraits); + } + + virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount) + { + if (!NvParameterized::IsAligned(bufObj, BasicIosModuleParameters_0p0::ClassAlignment) + || !NvParameterized::IsAligned(bufStart, BasicIosModuleParameters_0p0::ClassAlignment)) + { + NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIosModuleParameters_0p0"); + return 0; + } + + // Init NvParameters-part + // We used to call empty constructor of BasicIosModuleParameters_0p0 here + // but it may call default constructors of members and spoil the data + NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount); + + // Init vtable (everything else is already initialized) + *(const char**)bufObj = vptr; + + return (BasicIosModuleParameters_0p0*)bufObj; + } + + virtual const char* getClassName() + { + return (BasicIosModuleParameters_0p0::staticClassName()); + } + + virtual uint32_t getVersion() + { + return (BasicIosModuleParameters_0p0::staticVersion()); + } + + virtual uint32_t getAlignment() + { + return (BasicIosModuleParameters_0p0::ClassAlignment); + } + + virtual const uint32_t* getChecksum(uint32_t& bits) + { + return (BasicIosModuleParameters_0p0::staticChecksum(bits)); + } +}; +#endif // NV_PARAMETERIZED_ONLY_LAYOUTS + +} // namespace parameterized +} // namespace nvidia + +#if PX_VC +#pragma warning(pop) +#endif + +#endif diff --git a/APEX_1.4/module/basicios_legacy/include/autogen/ModuleBasicIOSLegacyRegistration.h b/APEX_1.4/module/basicios_legacy/include/autogen/ModuleBasicIOSLegacyRegistration.h new file mode 100644 index 00000000..ca1002c7 --- /dev/null +++ b/APEX_1.4/module/basicios_legacy/include/autogen/ModuleBasicIOSLegacyRegistration.h @@ -0,0 +1,416 @@ +/* + * Copyright (c) 2008-2015, NVIDIA CORPORATION. All rights reserved. + * + * NVIDIA CORPORATION and its licensors retain all intellectual property + * and proprietary rights in and to this software, 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. + */ + +#ifndef MODULE_MODULEBASICIOSLEGACYREGISTRATIONH_H +#define MODULE_MODULEBASICIOSLEGACYREGISTRATIONH_H + +#include "PsAllocator.h" +#include "NvRegistrationsForTraitsBase.h" +#include "nvparameterized/NvParameterizedTraits.h" +#include "PxAssert.h" +#include <stdint.h> + +// INCLUDE GENERATED FACTORIES +#include "BasicIOSAssetParam_0p0.h" +#include "BasicIOSAssetParam_0p1.h" +#include "BasicIOSAssetParam_0p2.h" +#include "BasicIOSAssetParam_0p3.h" +#include "BasicIOSAssetParam_0p4.h" +#include "BasicIOSAssetParam_0p5.h" +#include "BasicIOSAssetParam_0p6.h" +#include "BasicIOSAssetParam_0p7.h" +#include "BasicIOSAssetParam_0p8.h" +#include "BasicIOSAssetParam_0p9.h" +#include "BasicIOSAssetParam_1p0.h" +#include "BasicIOSAssetParam_1p1.h" +#include "BasicIOSAssetParam_1p2.h" +#include "BasicIOSAssetParam_1p3.h" +#include "BasicIOSAssetParam_1p4.h" +#include "BasicIosDebugRenderParams_0p0.h" +#include "BasicIosModuleParameters_0p0.h" + + +// INCLUDE GENERATED CONVERSION +#include "ConversionBasicIOSAssetParam_0p0_0p1.h" +#include "ConversionBasicIOSAssetParam_0p1_0p2.h" +#include "ConversionBasicIOSAssetParam_0p2_0p3.h" +#include "ConversionBasicIOSAssetParam_0p3_0p4.h" +#include "ConversionBasicIOSAssetParam_0p4_0p5.h" +#include "ConversionBasicIOSAssetParam_0p5_0p6.h" +#include "ConversionBasicIOSAssetParam_0p6_0p7.h" +#include "ConversionBasicIOSAssetParam_0p7_0p8.h" +#include "ConversionBasicIOSAssetParam_0p8_0p9.h" +#include "ConversionBasicIOSAssetParam_0p9_1p0.h" +#include "ConversionBasicIOSAssetParam_1p0_1p1.h" +#include "ConversionBasicIOSAssetParam_1p1_1p2.h" +#include "ConversionBasicIOSAssetParam_1p2_1p3.h" +#include "ConversionBasicIOSAssetParam_1p3_1p4.h" + + +// global namespace + +class ModuleBasicIOSLegacyRegistration : public NvParameterized::RegistrationsForTraitsBase +{ +public: + static void invokeRegistration(NvParameterized::Traits* parameterizedTraits) + { + if (parameterizedTraits) + { + ModuleBasicIOSLegacyRegistration().registerAll(*parameterizedTraits); + } + } + + static void invokeUnregistration(NvParameterized::Traits* parameterizedTraits) + { + if (parameterizedTraits) + { + ModuleBasicIOSLegacyRegistration().unregisterAll(*parameterizedTraits); + } + } + + void registerAvailableFactories(NvParameterized::Traits& parameterizedTraits) + { + ::NvParameterized::Factory* factoriesToRegister[] = { +// REGISTER GENERATED FACTORIES + new nvidia::parameterized::BasicIOSAssetParam_0p0Factory(), + new nvidia::parameterized::BasicIOSAssetParam_0p1Factory(), + new nvidia::parameterized::BasicIOSAssetParam_0p2Factory(), + new nvidia::parameterized::BasicIOSAssetParam_0p3Factory(), + new nvidia::parameterized::BasicIOSAssetParam_0p4Factory(), + new nvidia::parameterized::BasicIOSAssetParam_0p5Factory(), + new nvidia::parameterized::BasicIOSAssetParam_0p6Factory(), + new nvidia::parameterized::BasicIOSAssetParam_0p7Factory(), + new nvidia::parameterized::BasicIOSAssetParam_0p8Factory(), + new nvidia::parameterized::BasicIOSAssetParam_0p9Factory(), + new nvidia::parameterized::BasicIOSAssetParam_1p0Factory(), + new nvidia::parameterized::BasicIOSAssetParam_1p1Factory(), + new nvidia::parameterized::BasicIOSAssetParam_1p2Factory(), + new nvidia::parameterized::BasicIOSAssetParam_1p3Factory(), + + }; + + for (size_t i = 0; i < sizeof(factoriesToRegister)/sizeof(factoriesToRegister[0]); ++i) + { + parameterizedTraits.registerFactory(*factoriesToRegister[i]); + } + } + + virtual void registerAvailableConverters(NvParameterized::Traits& parameterizedTraits) + { +// REGISTER GENERATED CONVERSION + { + typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_0p0_0p1 ConverterToRegister; + parameterizedTraits.registerConversion(ConverterToRegister::TOldClass::staticClassName(), + ConverterToRegister::TOldClass::ClassVersion, + ConverterToRegister::TNewClass::ClassVersion, + *(ConverterToRegister::Create(¶meterizedTraits))); + } + { + typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_0p1_0p2 ConverterToRegister; + parameterizedTraits.registerConversion(ConverterToRegister::TOldClass::staticClassName(), + ConverterToRegister::TOldClass::ClassVersion, + ConverterToRegister::TNewClass::ClassVersion, + *(ConverterToRegister::Create(¶meterizedTraits))); + } + { + typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_0p2_0p3 ConverterToRegister; + parameterizedTraits.registerConversion(ConverterToRegister::TOldClass::staticClassName(), + ConverterToRegister::TOldClass::ClassVersion, + ConverterToRegister::TNewClass::ClassVersion, + *(ConverterToRegister::Create(¶meterizedTraits))); + } + { + typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_0p3_0p4 ConverterToRegister; + parameterizedTraits.registerConversion(ConverterToRegister::TOldClass::staticClassName(), + ConverterToRegister::TOldClass::ClassVersion, + ConverterToRegister::TNewClass::ClassVersion, + *(ConverterToRegister::Create(¶meterizedTraits))); + } + { + typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_0p4_0p5 ConverterToRegister; + parameterizedTraits.registerConversion(ConverterToRegister::TOldClass::staticClassName(), + ConverterToRegister::TOldClass::ClassVersion, + ConverterToRegister::TNewClass::ClassVersion, + *(ConverterToRegister::Create(¶meterizedTraits))); + } + { + typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_0p5_0p6 ConverterToRegister; + parameterizedTraits.registerConversion(ConverterToRegister::TOldClass::staticClassName(), + ConverterToRegister::TOldClass::ClassVersion, + ConverterToRegister::TNewClass::ClassVersion, + *(ConverterToRegister::Create(¶meterizedTraits))); + } + { + typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_0p6_0p7 ConverterToRegister; + parameterizedTraits.registerConversion(ConverterToRegister::TOldClass::staticClassName(), + ConverterToRegister::TOldClass::ClassVersion, + ConverterToRegister::TNewClass::ClassVersion, + *(ConverterToRegister::Create(¶meterizedTraits))); + } + { + typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_0p7_0p8 ConverterToRegister; + parameterizedTraits.registerConversion(ConverterToRegister::TOldClass::staticClassName(), + ConverterToRegister::TOldClass::ClassVersion, + ConverterToRegister::TNewClass::ClassVersion, + *(ConverterToRegister::Create(¶meterizedTraits))); + } + { + typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_0p8_0p9 ConverterToRegister; + parameterizedTraits.registerConversion(ConverterToRegister::TOldClass::staticClassName(), + ConverterToRegister::TOldClass::ClassVersion, + ConverterToRegister::TNewClass::ClassVersion, + *(ConverterToRegister::Create(¶meterizedTraits))); + } + { + typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_0p9_1p0 ConverterToRegister; + parameterizedTraits.registerConversion(ConverterToRegister::TOldClass::staticClassName(), + ConverterToRegister::TOldClass::ClassVersion, + ConverterToRegister::TNewClass::ClassVersion, + *(ConverterToRegister::Create(¶meterizedTraits))); + } + { + typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_1p0_1p1 ConverterToRegister; + parameterizedTraits.registerConversion(ConverterToRegister::TOldClass::staticClassName(), + ConverterToRegister::TOldClass::ClassVersion, + ConverterToRegister::TNewClass::ClassVersion, + *(ConverterToRegister::Create(¶meterizedTraits))); + } + { + typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_1p1_1p2 ConverterToRegister; + parameterizedTraits.registerConversion(ConverterToRegister::TOldClass::staticClassName(), + ConverterToRegister::TOldClass::ClassVersion, + ConverterToRegister::TNewClass::ClassVersion, + *(ConverterToRegister::Create(¶meterizedTraits))); + } + { + typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_1p2_1p3 ConverterToRegister; + parameterizedTraits.registerConversion(ConverterToRegister::TOldClass::staticClassName(), + ConverterToRegister::TOldClass::ClassVersion, + ConverterToRegister::TNewClass::ClassVersion, + *(ConverterToRegister::Create(¶meterizedTraits))); + } + { + typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_1p3_1p4 ConverterToRegister; + parameterizedTraits.registerConversion(ConverterToRegister::TOldClass::staticClassName(), + ConverterToRegister::TOldClass::ClassVersion, + ConverterToRegister::TNewClass::ClassVersion, + *(ConverterToRegister::Create(¶meterizedTraits))); + } + + } + + void unregisterAvailableFactories(NvParameterized::Traits& parameterizedTraits) + { + struct FactoryDesc + { + const char* name; + uint32_t version; + }; + + ::NvParameterized::Factory* factoriesToUnregister[] = { +// UNREGISTER GENERATED FACTORIES + new nvidia::parameterized::BasicIOSAssetParam_0p0Factory(), + new nvidia::parameterized::BasicIOSAssetParam_0p1Factory(), + new nvidia::parameterized::BasicIOSAssetParam_0p2Factory(), + new nvidia::parameterized::BasicIOSAssetParam_0p3Factory(), + new nvidia::parameterized::BasicIOSAssetParam_0p4Factory(), + new nvidia::parameterized::BasicIOSAssetParam_0p5Factory(), + new nvidia::parameterized::BasicIOSAssetParam_0p6Factory(), + new nvidia::parameterized::BasicIOSAssetParam_0p7Factory(), + new nvidia::parameterized::BasicIOSAssetParam_0p8Factory(), + new nvidia::parameterized::BasicIOSAssetParam_0p9Factory(), + new nvidia::parameterized::BasicIOSAssetParam_1p0Factory(), + new nvidia::parameterized::BasicIOSAssetParam_1p1Factory(), + new nvidia::parameterized::BasicIOSAssetParam_1p2Factory(), + new nvidia::parameterized::BasicIOSAssetParam_1p3Factory(), + + }; + + for (size_t i = 0; i < sizeof(factoriesToUnregister)/sizeof(factoriesToUnregister[0]); ++i) + { + ::NvParameterized::Factory* removedFactory = parameterizedTraits.removeFactory(factoriesToUnregister[i]->getClassName(), factoriesToUnregister[i]->getVersion()); + if (!removedFactory) + { + PX_ASSERT_WITH_MESSAGE(0, "Factory can not be removed!"); + } + else + { + removedFactory->freeParameterDefinitionTable(¶meterizedTraits); + delete removedFactory; + delete factoriesToUnregister[i]; + } + } + } + + virtual void unregisterAvailableConverters(NvParameterized::Traits& parameterizedTraits) + { +// UNREGISTER GENERATED CONVERSION + { + typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_0p0_0p1 ConverterToUnregister; + ::NvParameterized::Conversion* removedConv = parameterizedTraits.removeConversion(ConverterToUnregister::TOldClass::staticClassName(), + ConverterToUnregister::TOldClass::ClassVersion, + ConverterToUnregister::TNewClass::ClassVersion); + if (removedConv) { + removedConv->~Conversion(); parameterizedTraits.free(removedConv); // PLACEMENT DELETE + } else { + // assert("Conversion was not found"); + } + } + { + typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_0p1_0p2 ConverterToUnregister; + ::NvParameterized::Conversion* removedConv = parameterizedTraits.removeConversion(ConverterToUnregister::TOldClass::staticClassName(), + ConverterToUnregister::TOldClass::ClassVersion, + ConverterToUnregister::TNewClass::ClassVersion); + if (removedConv) { + removedConv->~Conversion(); parameterizedTraits.free(removedConv); // PLACEMENT DELETE + } else { + // assert("Conversion was not found"); + } + } + { + typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_0p2_0p3 ConverterToUnregister; + ::NvParameterized::Conversion* removedConv = parameterizedTraits.removeConversion(ConverterToUnregister::TOldClass::staticClassName(), + ConverterToUnregister::TOldClass::ClassVersion, + ConverterToUnregister::TNewClass::ClassVersion); + if (removedConv) { + removedConv->~Conversion(); parameterizedTraits.free(removedConv); // PLACEMENT DELETE + } else { + // assert("Conversion was not found"); + } + } + { + typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_0p3_0p4 ConverterToUnregister; + ::NvParameterized::Conversion* removedConv = parameterizedTraits.removeConversion(ConverterToUnregister::TOldClass::staticClassName(), + ConverterToUnregister::TOldClass::ClassVersion, + ConverterToUnregister::TNewClass::ClassVersion); + if (removedConv) { + removedConv->~Conversion(); parameterizedTraits.free(removedConv); // PLACEMENT DELETE + } else { + // assert("Conversion was not found"); + } + } + { + typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_0p4_0p5 ConverterToUnregister; + ::NvParameterized::Conversion* removedConv = parameterizedTraits.removeConversion(ConverterToUnregister::TOldClass::staticClassName(), + ConverterToUnregister::TOldClass::ClassVersion, + ConverterToUnregister::TNewClass::ClassVersion); + if (removedConv) { + removedConv->~Conversion(); parameterizedTraits.free(removedConv); // PLACEMENT DELETE + } else { + // assert("Conversion was not found"); + } + } + { + typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_0p5_0p6 ConverterToUnregister; + ::NvParameterized::Conversion* removedConv = parameterizedTraits.removeConversion(ConverterToUnregister::TOldClass::staticClassName(), + ConverterToUnregister::TOldClass::ClassVersion, + ConverterToUnregister::TNewClass::ClassVersion); + if (removedConv) { + removedConv->~Conversion(); parameterizedTraits.free(removedConv); // PLACEMENT DELETE + } else { + // assert("Conversion was not found"); + } + } + { + typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_0p6_0p7 ConverterToUnregister; + ::NvParameterized::Conversion* removedConv = parameterizedTraits.removeConversion(ConverterToUnregister::TOldClass::staticClassName(), + ConverterToUnregister::TOldClass::ClassVersion, + ConverterToUnregister::TNewClass::ClassVersion); + if (removedConv) { + removedConv->~Conversion(); parameterizedTraits.free(removedConv); // PLACEMENT DELETE + } else { + // assert("Conversion was not found"); + } + } + { + typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_0p7_0p8 ConverterToUnregister; + ::NvParameterized::Conversion* removedConv = parameterizedTraits.removeConversion(ConverterToUnregister::TOldClass::staticClassName(), + ConverterToUnregister::TOldClass::ClassVersion, + ConverterToUnregister::TNewClass::ClassVersion); + if (removedConv) { + removedConv->~Conversion(); parameterizedTraits.free(removedConv); // PLACEMENT DELETE + } else { + // assert("Conversion was not found"); + } + } + { + typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_0p8_0p9 ConverterToUnregister; + ::NvParameterized::Conversion* removedConv = parameterizedTraits.removeConversion(ConverterToUnregister::TOldClass::staticClassName(), + ConverterToUnregister::TOldClass::ClassVersion, + ConverterToUnregister::TNewClass::ClassVersion); + if (removedConv) { + removedConv->~Conversion(); parameterizedTraits.free(removedConv); // PLACEMENT DELETE + } else { + // assert("Conversion was not found"); + } + } + { + typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_0p9_1p0 ConverterToUnregister; + ::NvParameterized::Conversion* removedConv = parameterizedTraits.removeConversion(ConverterToUnregister::TOldClass::staticClassName(), + ConverterToUnregister::TOldClass::ClassVersion, + ConverterToUnregister::TNewClass::ClassVersion); + if (removedConv) { + removedConv->~Conversion(); parameterizedTraits.free(removedConv); // PLACEMENT DELETE + } else { + // assert("Conversion was not found"); + } + } + { + typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_1p0_1p1 ConverterToUnregister; + ::NvParameterized::Conversion* removedConv = parameterizedTraits.removeConversion(ConverterToUnregister::TOldClass::staticClassName(), + ConverterToUnregister::TOldClass::ClassVersion, + ConverterToUnregister::TNewClass::ClassVersion); + if (removedConv) { + removedConv->~Conversion(); parameterizedTraits.free(removedConv); // PLACEMENT DELETE + } else { + // assert("Conversion was not found"); + } + } + { + typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_1p1_1p2 ConverterToUnregister; + ::NvParameterized::Conversion* removedConv = parameterizedTraits.removeConversion(ConverterToUnregister::TOldClass::staticClassName(), + ConverterToUnregister::TOldClass::ClassVersion, + ConverterToUnregister::TNewClass::ClassVersion); + if (removedConv) { + removedConv->~Conversion(); parameterizedTraits.free(removedConv); // PLACEMENT DELETE + } else { + // assert("Conversion was not found"); + } + } + { + typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_1p2_1p3 ConverterToUnregister; + ::NvParameterized::Conversion* removedConv = parameterizedTraits.removeConversion(ConverterToUnregister::TOldClass::staticClassName(), + ConverterToUnregister::TOldClass::ClassVersion, + ConverterToUnregister::TNewClass::ClassVersion); + if (removedConv) { + removedConv->~Conversion(); parameterizedTraits.free(removedConv); // PLACEMENT DELETE + } else { + // assert("Conversion was not found"); + } + } + { + typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_1p3_1p4 ConverterToUnregister; + ::NvParameterized::Conversion* removedConv = parameterizedTraits.removeConversion(ConverterToUnregister::TOldClass::staticClassName(), + ConverterToUnregister::TOldClass::ClassVersion, + ConverterToUnregister::TNewClass::ClassVersion); + if (removedConv) { + removedConv->~Conversion(); parameterizedTraits.free(removedConv); // PLACEMENT DELETE + } else { + // assert("Conversion was not found"); + } + } + + } + +}; + +// global namespace + +#endif |