diff options
Diffstat (limited to 'APEX_1.4/module/basicios_legacy/include')
32 files changed, 5828 insertions, 0 deletions
diff --git a/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p0_0p1.h b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p0_0p1.h new file mode 100644 index 00000000..817ce7a7 --- /dev/null +++ b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p0_0p1.h @@ -0,0 +1,53 @@ +/* + * 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_CONVERSIONBASICIOSASSETPARAM_0P0_0P1H_H +#define MODULE_CONVERSIONBASICIOSASSETPARAM_0P0_0P1H_H + +#include "NvParamConversionTemplate.h" +#include "BasicIOSAssetParam_0p0.h" +#include "BasicIOSAssetParam_0p1.h" + +namespace nvidia { +namespace apex { +namespace legacy { + + +typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::BasicIOSAssetParam_0p0, + nvidia::parameterized::BasicIOSAssetParam_0p1, + nvidia::parameterized::BasicIOSAssetParam_0p0::ClassVersion, + nvidia::parameterized::BasicIOSAssetParam_0p1::ClassVersion> + ConversionBasicIOSAssetParam_0p0_0p1Parent; + +class ConversionBasicIOSAssetParam_0p0_0p1: public ConversionBasicIOSAssetParam_0p0_0p1Parent +{ +public: + static NvParameterized::Conversion* Create(NvParameterized::Traits* t) + { + void* buf = t->alloc(sizeof(ConversionBasicIOSAssetParam_0p0_0p1)); + return buf ? PX_PLACEMENT_NEW(buf, ConversionBasicIOSAssetParam_0p0_0p1)(t) : 0; + } + +protected: + ConversionBasicIOSAssetParam_0p0_0p1(NvParameterized::Traits* t) : ConversionBasicIOSAssetParam_0p0_0p1Parent(t) {} + + bool convert() + { + // just take the default values (scaleSceneGravity = 1.0, externalAcceleration=0,0,0) + return true; + } +}; + +} +} +} //nvidia::apex::legacy + +#endif diff --git a/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p1_0p2.h b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p1_0p2.h new file mode 100644 index 00000000..247b1a1c --- /dev/null +++ b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p1_0p2.h @@ -0,0 +1,80 @@ +/* + * 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_CONVERSIONBASICIOSASSETPARAM_0P1_0P2H_H +#define MODULE_CONVERSIONBASICIOSASSETPARAM_0P1_0P2H_H + +#include "NvParamConversionTemplate.h" +#include "BasicIOSAssetParam_0p1.h" +#include "BasicIOSAssetParam_0p2.h" + +namespace nvidia { +namespace apex { +namespace legacy { + + +typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::BasicIOSAssetParam_0p1, + nvidia::parameterized::BasicIOSAssetParam_0p2, + nvidia::parameterized::BasicIOSAssetParam_0p1::ClassVersion, + nvidia::parameterized::BasicIOSAssetParam_0p2::ClassVersion> + ConversionBasicIOSAssetParam_0p1_0p2Parent; + +class ConversionBasicIOSAssetParam_0p1_0p2: public ConversionBasicIOSAssetParam_0p1_0p2Parent +{ +public: + static NvParameterized::Conversion* Create(NvParameterized::Traits* t) + { + void* buf = t->alloc(sizeof(ConversionBasicIOSAssetParam_0p1_0p2)); + return buf ? PX_PLACEMENT_NEW(buf, ConversionBasicIOSAssetParam_0p1_0p2)(t) : 0; + } + +protected: + ConversionBasicIOSAssetParam_0p1_0p2(NvParameterized::Traits* t) : ConversionBasicIOSAssetParam_0p1_0p2Parent(t) {} + + const NvParameterized::PrefVer* getPreferredVersions() const + { + static NvParameterized::PrefVer prefVers[] = + { + //TODO: + // Add your preferred versions for included references here. + // Entry format is + // { (const char*)longName, (uint32_t)preferredVersion } + + { 0, 0 } // Terminator (do not remove!) + }; + + return prefVers; + } + + bool convert() + { + //TODO: + // Write custom conversion code here using mNewData and mLegacyData members. + // + // Note that + // - mNewData has already been initialized with default values + // - same-named/same-typed members have already been copied + // from mLegacyData to mNewData + // - included references were moved to mNewData + // (and updated to preferred versions according to getPreferredVersions) + // + // For more info see the versioning wiki. + + return true; + } +}; + + +} +} +} //nvidia::apex::legacy + +#endif diff --git a/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p2_0p3.h b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p2_0p3.h new file mode 100644 index 00000000..1e8840b5 --- /dev/null +++ b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p2_0p3.h @@ -0,0 +1,56 @@ +/* + * 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_CONVERSIONBASICIOSASSETPARAM_0P2_0P3H_H +#define MODULE_CONVERSIONBASICIOSASSETPARAM_0P2_0P3H_H + +#include "NvParamConversionTemplate.h" +#include "BasicIOSAssetParam_0p2.h" +#include "BasicIOSAssetParam_0p3.h" + +namespace nvidia { +namespace apex { +namespace legacy { + + +typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::BasicIOSAssetParam_0p2, + nvidia::parameterized::BasicIOSAssetParam_0p3, + nvidia::parameterized::BasicIOSAssetParam_0p2::ClassVersion, + nvidia::parameterized::BasicIOSAssetParam_0p3::ClassVersion> + ConversionBasicIOSAssetParam_0p2_0p3Parent; + +class ConversionBasicIOSAssetParam_0p2_0p3: public ConversionBasicIOSAssetParam_0p2_0p3Parent +{ +public: + static NvParameterized::Conversion* Create(NvParameterized::Traits* t) + { + void* buf = t->alloc(sizeof(ConversionBasicIOSAssetParam_0p2_0p3)); + return buf ? PX_PLACEMENT_NEW(buf, ConversionBasicIOSAssetParam_0p2_0p3)(t) : 0; + } + +protected: + ConversionBasicIOSAssetParam_0p2_0p3(NvParameterized::Traits* t) : ConversionBasicIOSAssetParam_0p2_0p3Parent(t) {} + + bool convert() + { + // Inherit median from legacy asset + mNewData->particleMass.center = mLegacyData->particleMass; + + return true; + } +}; + + +} +} +} //nvidia::apex::legacy + +#endif diff --git a/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p3_0p4.h b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p3_0p4.h new file mode 100644 index 00000000..ff0e5d50 --- /dev/null +++ b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p3_0p4.h @@ -0,0 +1,72 @@ +/* + * 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_CONVERSIONBASICIOSASSETPARAM_0P3_0P4H_H +#define MODULE_CONVERSIONBASICIOSASSETPARAM_0P3_0P4H_H + +#include "NvParamConversionTemplate.h" +#include "BasicIOSAssetParam_0p3.h" +#include "BasicIOSAssetParam_0p4.h" + +namespace nvidia { +namespace apex { +namespace legacy { + + +typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::BasicIOSAssetParam_0p3, + nvidia::parameterized::BasicIOSAssetParam_0p4, + nvidia::parameterized::BasicIOSAssetParam_0p3::ClassVersion, + nvidia::parameterized::BasicIOSAssetParam_0p4::ClassVersion> + ConversionBasicIOSAssetParam_0p3_0p4Parent; + +class ConversionBasicIOSAssetParam_0p3_0p4: public ConversionBasicIOSAssetParam_0p3_0p4Parent +{ +public: + static NvParameterized::Conversion* Create(NvParameterized::Traits* t) + { + void* buf = t->alloc(sizeof(ConversionBasicIOSAssetParam_0p3_0p4)); + return buf ? PX_PLACEMENT_NEW(buf, ConversionBasicIOSAssetParam_0p3_0p4)(t) : 0; + } + +protected: + ConversionBasicIOSAssetParam_0p3_0p4(NvParameterized::Traits* t) : ConversionBasicIOSAssetParam_0p3_0p4Parent(t) {} + + const NvParameterized::PrefVer* getPreferredVersions() const + { + static NvParameterized::PrefVer prefVers[] = + { + //TODO: + // Add your preferred versions for included references here. + // Entry format is + // { (const char*)longName, (uint32_t)preferredVersion } + + { 0, 0 } // Terminator (do not remove!) + }; + + return prefVers; + } + + bool convert() + { + // copy 'collisionGroupMaskName' to 'collisionFilterDataName' + NvParameterized::Handle handle(*mNewData, "collisionFilterDataName"); + handle.setParamString(mLegacyData->collisionGroupMaskName); + + return true; + } +}; + + +} +} +} //nvidia::apex::legacy + +#endif diff --git a/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p4_0p5.h b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p4_0p5.h new file mode 100644 index 00000000..3131e3a2 --- /dev/null +++ b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p4_0p5.h @@ -0,0 +1,80 @@ +/* + * 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_CONVERSIONBASICIOSASSETPARAM_0P4_0P5H_H +#define MODULE_CONVERSIONBASICIOSASSETPARAM_0P4_0P5H_H + +#include "NvParamConversionTemplate.h" +#include "BasicIOSAssetParam_0p4.h" +#include "BasicIOSAssetParam_0p5.h" + +namespace nvidia { +namespace apex { +namespace legacy { + + +typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::BasicIOSAssetParam_0p4, + nvidia::parameterized::BasicIOSAssetParam_0p5, + nvidia::parameterized::BasicIOSAssetParam_0p4::ClassVersion, + nvidia::parameterized::BasicIOSAssetParam_0p5::ClassVersion> + ConversionBasicIOSAssetParam_0p4_0p5Parent; + +class ConversionBasicIOSAssetParam_0p4_0p5: public ConversionBasicIOSAssetParam_0p4_0p5Parent +{ +public: + static NvParameterized::Conversion* Create(NvParameterized::Traits* t) + { + void* buf = t->alloc(sizeof(ConversionBasicIOSAssetParam_0p4_0p5)); + return buf ? PX_PLACEMENT_NEW(buf, ConversionBasicIOSAssetParam_0p4_0p5)(t) : 0; + } + +protected: + ConversionBasicIOSAssetParam_0p4_0p5(NvParameterized::Traits* t) : ConversionBasicIOSAssetParam_0p4_0p5Parent(t) {} + + const NvParameterized::PrefVer* getPreferredVersions() const + { + static NvParameterized::PrefVer prefVers[] = + { + //TODO: + // Add your preferred versions for included references here. + // Entry format is + // { (const char*)longName, (uint32_t)preferredVersion } + + { 0, 0 } // Terminator (do not remove!) + }; + + return prefVers; + } + + bool convert() + { + //TODO: + // Write custom conversion code here using mNewData and mLegacyData members. + // + // Note that + // - mNewData has already been initialized with default values + // - same-named/same-typed members have already been copied + // from mLegacyData to mNewData + // - included references were moved to mNewData + // (and updated to preferred versions according to getPreferredVersions) + // + // For more info see the versioning wiki. + + return true; + } +}; + + +} +} +} //nvidia::apex::legacy + +#endif diff --git a/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p5_0p6.h b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p5_0p6.h new file mode 100644 index 00000000..35966e61 --- /dev/null +++ b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p5_0p6.h @@ -0,0 +1,80 @@ +/* + * 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_CONVERSIONBASICIOSASSETPARAM_0P5_0P6H_H +#define MODULE_CONVERSIONBASICIOSASSETPARAM_0P5_0P6H_H + +#include "NvParamConversionTemplate.h" +#include "BasicIOSAssetParam_0p5.h" +#include "BasicIOSAssetParam_0p6.h" + +namespace nvidia { +namespace apex { +namespace legacy { + + +typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::BasicIOSAssetParam_0p5, + nvidia::parameterized::BasicIOSAssetParam_0p6, + nvidia::parameterized::BasicIOSAssetParam_0p5::ClassVersion, + nvidia::parameterized::BasicIOSAssetParam_0p6::ClassVersion> + ConversionBasicIOSAssetParam_0p5_0p6Parent; + +class ConversionBasicIOSAssetParam_0p5_0p6: public ConversionBasicIOSAssetParam_0p5_0p6Parent +{ +public: + static NvParameterized::Conversion* Create(NvParameterized::Traits* t) + { + void* buf = t->alloc(sizeof(ConversionBasicIOSAssetParam_0p5_0p6)); + return buf ? PX_PLACEMENT_NEW(buf, ConversionBasicIOSAssetParam_0p5_0p6)(t) : 0; + } + +protected: + ConversionBasicIOSAssetParam_0p5_0p6(NvParameterized::Traits* t) : ConversionBasicIOSAssetParam_0p5_0p6Parent(t) {} + + const NvParameterized::PrefVer* getPreferredVersions() const + { + static NvParameterized::PrefVer prefVers[] = + { + //TODO: + // Add your preferred versions for included references here. + // Entry format is + // { (const char*)longName, (uint32_t)preferredVersion } + + { 0, 0 } // Terminator (do not remove!) + }; + + return prefVers; + } + + bool convert() + { + //TODO: + // Write custom conversion code here using mNewData and mLegacyData members. + // + // Note that + // - mNewData has already been initialized with default values + // - same-named/same-typed members have already been copied + // from mLegacyData to mNewData + // - included references were moved to mNewData + // (and updated to preferred versions according to getPreferredVersions) + // + // For more info see the versioning wiki. + + return true; + } +}; + + +} +} +} //nvidia::apex::legacy + +#endif diff --git a/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p6_0p7.h b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p6_0p7.h new file mode 100644 index 00000000..5f808e89 --- /dev/null +++ b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p6_0p7.h @@ -0,0 +1,80 @@ +/* + * 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_CONVERSIONBASICIOSASSETPARAM_0P6_0P7H_H +#define MODULE_CONVERSIONBASICIOSASSETPARAM_0P6_0P7H_H + +#include "NvParamConversionTemplate.h" +#include "BasicIOSAssetParam_0p6.h" +#include "BasicIOSAssetParam_0p7.h" + +namespace nvidia { +namespace apex { +namespace legacy { + + +typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::BasicIOSAssetParam_0p6, + nvidia::parameterized::BasicIOSAssetParam_0p7, + nvidia::parameterized::BasicIOSAssetParam_0p6::ClassVersion, + nvidia::parameterized::BasicIOSAssetParam_0p7::ClassVersion> + ConversionBasicIOSAssetParam_0p6_0p7Parent; + +class ConversionBasicIOSAssetParam_0p6_0p7: public ConversionBasicIOSAssetParam_0p6_0p7Parent +{ +public: + static NvParameterized::Conversion* Create(NvParameterized::Traits* t) + { + void* buf = t->alloc(sizeof(ConversionBasicIOSAssetParam_0p6_0p7)); + return buf ? PX_PLACEMENT_NEW(buf, ConversionBasicIOSAssetParam_0p6_0p7)(t) : 0; + } + +protected: + ConversionBasicIOSAssetParam_0p6_0p7(NvParameterized::Traits* t) : ConversionBasicIOSAssetParam_0p6_0p7Parent(t) {} + + const NvParameterized::PrefVer* getPreferredVersions() const + { + static NvParameterized::PrefVer prefVers[] = + { + //TODO: + // Add your preferred versions for included references here. + // Entry format is + // { (const char*)longName, (uint32_t)preferredVersion } + + { 0, 0 } // Terminator (do not remove!) + }; + + return prefVers; + } + + bool convert() + { + //TODO: + // Write custom conversion code here using mNewData and mLegacyData members. + // + // Note that + // - mNewData has already been initialized with default values + // - same-named/same-typed members have already been copied + // from mLegacyData to mNewData + // - included references were moved to mNewData + // (and updated to preferred versions according to getPreferredVersions) + // + // For more info see the versioning wiki. + + return true; + } +}; + + +} +} +} //nvidia::apex::legacy + +#endif diff --git a/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p7_0p8.h b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p7_0p8.h new file mode 100644 index 00000000..78af5db2 --- /dev/null +++ b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p7_0p8.h @@ -0,0 +1,80 @@ +/* + * 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_CONVERSIONBASICIOSASSETPARAM_0P7_0P8H_H +#define MODULE_CONVERSIONBASICIOSASSETPARAM_0P7_0P8H_H + +#include "NvParamConversionTemplate.h" +#include "BasicIOSAssetParam_0p7.h" +#include "BasicIOSAssetParam_0p8.h" + +namespace nvidia { +namespace apex { +namespace legacy { + + +typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::BasicIOSAssetParam_0p7, + nvidia::parameterized::BasicIOSAssetParam_0p8, + nvidia::parameterized::BasicIOSAssetParam_0p7::ClassVersion, + nvidia::parameterized::BasicIOSAssetParam_0p8::ClassVersion> + ConversionBasicIOSAssetParam_0p7_0p8Parent; + +class ConversionBasicIOSAssetParam_0p7_0p8: public ConversionBasicIOSAssetParam_0p7_0p8Parent +{ +public: + static NvParameterized::Conversion* Create(NvParameterized::Traits* t) + { + void* buf = t->alloc(sizeof(ConversionBasicIOSAssetParam_0p7_0p8)); + return buf ? PX_PLACEMENT_NEW(buf, ConversionBasicIOSAssetParam_0p7_0p8)(t) : 0; + } + +protected: + ConversionBasicIOSAssetParam_0p7_0p8(NvParameterized::Traits* t) : ConversionBasicIOSAssetParam_0p7_0p8Parent(t) {} + + const NvParameterized::PrefVer* getPreferredVersions() const + { + static NvParameterized::PrefVer prefVers[] = + { + //TODO: + // Add your preferred versions for included references here. + // Entry format is + // { (const char*)longName, (uint32_t)preferredVersion } + + { 0, 0 } // Terminator (do not remove!) + }; + + return prefVers; + } + + bool convert() + { + //TODO: + // Write custom conversion code here using mNewData and mLegacyData members. + // + // Note that + // - mNewData has already been initialized with default values + // - same-named/same-typed members have already been copied + // from mLegacyData to mNewData + // - included references were moved to mNewData + // (and updated to preferred versions according to getPreferredVersions) + // + // For more info see the versioning wiki. + + return true; + } +}; + + +} +} +} //nvidia::apex::legacy + +#endif diff --git a/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p8_0p9.h b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p8_0p9.h new file mode 100644 index 00000000..58cadf7b --- /dev/null +++ b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p8_0p9.h @@ -0,0 +1,98 @@ +/* + * 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_CONVERSIONBASICIOSASSETPARAM_0P8_0P9H_H +#define MODULE_CONVERSIONBASICIOSASSETPARAM_0P8_0P9H_H + +#include "NvParamConversionTemplate.h" +#include "BasicIOSAssetParam_0p8.h" +#include "BasicIOSAssetParam_0p9.h" + +namespace nvidia { +namespace apex { +namespace legacy { + + +typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::BasicIOSAssetParam_0p8, + nvidia::parameterized::BasicIOSAssetParam_0p9, + nvidia::parameterized::BasicIOSAssetParam_0p8::ClassVersion, + nvidia::parameterized::BasicIOSAssetParam_0p9::ClassVersion> + ConversionBasicIOSAssetParam_0p8_0p9Parent; + +class ConversionBasicIOSAssetParam_0p8_0p9: public ConversionBasicIOSAssetParam_0p8_0p9Parent +{ +public: + static NvParameterized::Conversion* Create(NvParameterized::Traits* t) + { + void* buf = t->alloc(sizeof(ConversionBasicIOSAssetParam_0p8_0p9)); + return buf ? PX_PLACEMENT_NEW(buf, ConversionBasicIOSAssetParam_0p8_0p9)(t) : 0; + } + +protected: + ConversionBasicIOSAssetParam_0p8_0p9(NvParameterized::Traits* t) : ConversionBasicIOSAssetParam_0p8_0p9Parent(t) {} + + const NvParameterized::PrefVer* getPreferredVersions() const + { + static NvParameterized::PrefVer prefVers[] = + { + //TODO: + // Add your preferred versions for included references here. + // Entry format is + // { (const char*)longName, (uint32_t)preferredVersion } + + { 0, 0 } // Terminator (do not remove!) + }; + + return prefVers; + } + + bool convert() + { + //TODO: + // Write custom conversion code here using mNewData and mLegacyData members. + // + // Note that + // - mNewData has already been initialized with default values + // - same-named/same-typed members have already been copied + // from mLegacyData to mNewData + // - included references were moved to mNewData + // (and updated to preferred versions according to getPreferredVersions) + // + // For more info see the versioning wiki. + + // Old + // UseFakeDensityDistance + // FakeDensityDistance + // UseFakeDensityGrid + // FakeDensityGridSize + // FakeDensityGridMaxCellCount + // FakeDensityGridResolution + + // New + // FakeDensityGrid.Enabled + // FakeDensityGrid.FrustumMode + // FakeDensityGrid.GridResolution + // FakeDensityGrid.NormalParams.GridSize + // FakeDensityGrid.NormalParams.GridMaxCellCount + // FakeDensityGrid.FrustumParams.GridSize + // FakeDensityGrid.FrustumParams.GridMaxCellCount + + // Don't transfer anything. + return true; + } +}; + + +} +} +} //nvidia::apex::legacy + +#endif diff --git a/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p9_1p0.h b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p9_1p0.h new file mode 100644 index 00000000..066602f8 --- /dev/null +++ b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p9_1p0.h @@ -0,0 +1,97 @@ +/* + * 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_CONVERSIONBASICIOSASSETPARAM_0P9_1P0H_H +#define MODULE_CONVERSIONBASICIOSASSETPARAM_0P9_1P0H_H + +#include "NvParamConversionTemplate.h" +#include "BasicIOSAssetParam_0p9.h" +#include "BasicIOSAssetParam_1p0.h" + +namespace nvidia { +namespace apex { +namespace legacy { + + +typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::BasicIOSAssetParam_0p9, + nvidia::parameterized::BasicIOSAssetParam_1p0, + nvidia::parameterized::BasicIOSAssetParam_0p9::ClassVersion, + nvidia::parameterized::BasicIOSAssetParam_1p0::ClassVersion> + ConversionBasicIOSAssetParam_0p9_1p0Parent; + +class ConversionBasicIOSAssetParam_0p9_1p0: public ConversionBasicIOSAssetParam_0p9_1p0Parent +{ +public: + static NvParameterized::Conversion* Create(NvParameterized::Traits* t) + { + void* buf = t->alloc(sizeof(ConversionBasicIOSAssetParam_0p9_1p0)); + return buf ? PX_PLACEMENT_NEW(buf, ConversionBasicIOSAssetParam_0p9_1p0)(t) : 0; + } + +protected: + ConversionBasicIOSAssetParam_0p9_1p0(NvParameterized::Traits* t) : ConversionBasicIOSAssetParam_0p9_1p0Parent(t) {} + + const NvParameterized::PrefVer* getPreferredVersions() const + { + static NvParameterized::PrefVer prefVers[] = + { + //TODO: + // Add your preferred versions for included references here. + // Entry format is + // { (const char*)longName, (uint32_t)preferredVersion } + + { 0, 0 } // Terminator (do not remove!) + }; + + return prefVers; + } + + bool convert() + { + //TODO: + // Write custom conversion code here using mNewData and mLegacyData members. + // + // Note that + // - mNewData has already been initialized with default values + // - same-named/same-typed members have already been copied + // from mLegacyData to mNewData + // - included references were moved to mNewData + // (and updated to preferred versions according to getPreferredVersions) + // + // For more info see the versioning wiki. + + mNewData->GridDensityGrid.Enabled = mLegacyData->FakeDensityGrid.Enabled; + mNewData->GridDensityGrid.FrustumParams.GridMaxCellCount = mLegacyData->FakeDensityGrid.FrustumParams.GridMaxCellCount; + mNewData->GridDensityGrid.FrustumParams.GridSize = mLegacyData->FakeDensityGrid.FrustumParams.GridSize; + + NvParameterized::Handle hEnumNew(*mNewData, "GridDensityGrid.GridResolution"); //convert FDG -> GDG + NvParameterized::Handle hEnumOld(*mLegacyData, "FakeDensityGrid.GridResolution"); + PX_ASSERT(hEnumNew.isValid()); + PX_ASSERT(hEnumOld.isValid()); + + const NvParameterized::Definition* paramDefOld; + paramDefOld = hEnumOld.parameterDefinition(); + int32_t index = paramDefOld->enumValIndex(mLegacyData->FakeDensityGrid.GridResolution); + + const NvParameterized::Definition* paramDefNew; + paramDefNew = hEnumNew.parameterDefinition(); + hEnumNew.setParamEnum(paramDefNew->enumVal(index)); + + return true; + } +}; + + +} +} +} //nvidia::apex::legacy + +#endif diff --git a/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_1p0_1p1.h b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_1p0_1p1.h new file mode 100644 index 00000000..81a0a723 --- /dev/null +++ b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_1p0_1p1.h @@ -0,0 +1,87 @@ +/* + * 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_CONVERSIONBASICIOSASSETPARAM_1P0_1P1H_H +#define MODULE_CONVERSIONBASICIOSASSETPARAM_1P0_1P1H_H + +#include "NvParamConversionTemplate.h" +#include "BasicIOSAssetParam_1p0.h" +#include "BasicIOSAssetParam_1p1.h" + +namespace nvidia { +namespace apex { +namespace legacy { + + +typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::BasicIOSAssetParam_1p0, + nvidia::parameterized::BasicIOSAssetParam_1p1, + nvidia::parameterized::BasicIOSAssetParam_1p0::ClassVersion, + nvidia::parameterized::BasicIOSAssetParam_1p1::ClassVersion> + ConversionBasicIOSAssetParam_1p0_1p1Parent; + +class ConversionBasicIOSAssetParam_1p0_1p1: public ConversionBasicIOSAssetParam_1p0_1p1Parent +{ +public: + static NvParameterized::Conversion* Create(NvParameterized::Traits* t) + { + void* buf = t->alloc(sizeof(ConversionBasicIOSAssetParam_1p0_1p1)); + return buf ? PX_PLACEMENT_NEW(buf, ConversionBasicIOSAssetParam_1p0_1p1)(t) : 0; + } + +protected: + ConversionBasicIOSAssetParam_1p0_1p1(NvParameterized::Traits* t) : ConversionBasicIOSAssetParam_1p0_1p1Parent(t) {} + + const NvParameterized::PrefVer* getPreferredVersions() const + { + static NvParameterized::PrefVer prefVers[] = + { + //TODO: + // Add your preferred versions for included references here. + // Entry format is + // { (const char*)longName, (uint32_t)preferredVersion } + + { 0, 0 } // Terminator (do not remove!) + }; + + return prefVers; + } + + bool convert() + { + mNewData->GridDensity.Enabled = mLegacyData->GridDensityGrid.Enabled; + // mNewData->GridDensity.Resolution = mLegacyData->GridDensityGrid.GridResolution; + mNewData->GridDensity.GridSize = mLegacyData->GridDensityGrid.FrustumParams.GridSize; + mNewData->GridDensity.MaxCellCount = mLegacyData->GridDensityGrid.FrustumParams.GridMaxCellCount; + + // enums are strings, better do it the safe way + NvParameterized::Handle hEnumNew(*mNewData, "GridDensity.Resolution"); + NvParameterized::Handle hEnumOld(*mLegacyData, "GridDensityGrid.GridResolution"); + PX_ASSERT(hEnumNew.isValid()); + PX_ASSERT(hEnumOld.isValid()); + + const NvParameterized::Definition* paramDefOld; + paramDefOld = hEnumOld.parameterDefinition(); + int32_t index = paramDefOld->enumValIndex(mLegacyData->GridDensityGrid.GridResolution); + + const NvParameterized::Definition* paramDefNew; + paramDefNew = hEnumNew.parameterDefinition(); + hEnumNew.setParamEnum(paramDefNew->enumVal(index)); + + return true; + } +}; + + +} +} +} //nvidia::apex::legacy + +#endif diff --git a/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_1p1_1p2.h b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_1p1_1p2.h new file mode 100644 index 00000000..b576ff30 --- /dev/null +++ b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_1p1_1p2.h @@ -0,0 +1,80 @@ +/* + * 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_CONVERSIONBASICIOSASSETPARAM_1P1_1P2H_H +#define MODULE_CONVERSIONBASICIOSASSETPARAM_1P1_1P2H_H + +#include "NvParamConversionTemplate.h" +#include "BasicIOSAssetParam_1p1.h" +#include "BasicIOSAssetParam_1p2.h" + +namespace nvidia { +namespace apex { +namespace legacy { + + +typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::BasicIOSAssetParam_1p1, + nvidia::parameterized::BasicIOSAssetParam_1p2, + nvidia::parameterized::BasicIOSAssetParam_1p1::ClassVersion, + nvidia::parameterized::BasicIOSAssetParam_1p2::ClassVersion> + ConversionBasicIOSAssetParam_1p1_1p2Parent; + +class ConversionBasicIOSAssetParam_1p1_1p2: public ConversionBasicIOSAssetParam_1p1_1p2Parent +{ +public: + static NvParameterized::Conversion* Create(NvParameterized::Traits* t) + { + void* buf = t->alloc(sizeof(ConversionBasicIOSAssetParam_1p1_1p2)); + return buf ? PX_PLACEMENT_NEW(buf, ConversionBasicIOSAssetParam_1p1_1p2)(t) : 0; + } + +protected: + ConversionBasicIOSAssetParam_1p1_1p2(NvParameterized::Traits* t) : ConversionBasicIOSAssetParam_1p1_1p2Parent(t) {} + + const NvParameterized::PrefVer* getPreferredVersions() const + { + static NvParameterized::PrefVer prefVers[] = + { + //TODO: + // Add your preferred versions for included references here. + // Entry format is + // { (const char*)longName, (uint32_t)preferredVersion } + + { 0, 0 } // Terminator (do not remove!) + }; + + return prefVers; + } + + bool convert() + { + //TODO: + // Write custom conversion code here using mNewData and mLegacyData members. + // + // Note that + // - mNewData has already been initialized with default values + // - same-named/same-typed members have already been copied + // from mLegacyData to mNewData + // - included references were moved to mNewData + // (and updated to preferred versions according to getPreferredVersions) + // + // For more info see the versioning wiki. + + return true; + } +}; + + +} +} +} //nvidia::apex::legacy + +#endif diff --git a/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_1p2_1p3.h b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_1p2_1p3.h new file mode 100644 index 00000000..2eac6ef3 --- /dev/null +++ b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_1p2_1p3.h @@ -0,0 +1,80 @@ +/* + * 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_CONVERSIONBASICIOSASSETPARAM_1P2_1P3H_H +#define MODULE_CONVERSIONBASICIOSASSETPARAM_1P2_1P3H_H + +#include "NvParamConversionTemplate.h" +#include "BasicIOSAssetParam_1p2.h" +#include "BasicIOSAssetParam_1p3.h" + +namespace nvidia { +namespace apex { +namespace legacy { + + +typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::BasicIOSAssetParam_1p2, + nvidia::parameterized::BasicIOSAssetParam_1p3, + nvidia::parameterized::BasicIOSAssetParam_1p2::ClassVersion, + nvidia::parameterized::BasicIOSAssetParam_1p3::ClassVersion> + ConversionBasicIOSAssetParam_1p2_1p3Parent; + +class ConversionBasicIOSAssetParam_1p2_1p3: public ConversionBasicIOSAssetParam_1p2_1p3Parent +{ +public: + static NvParameterized::Conversion* Create(NvParameterized::Traits* t) + { + void* buf = t->alloc(sizeof(ConversionBasicIOSAssetParam_1p2_1p3)); + return buf ? PX_PLACEMENT_NEW(buf, ConversionBasicIOSAssetParam_1p2_1p3)(t) : 0; + } + +protected: + ConversionBasicIOSAssetParam_1p2_1p3(NvParameterized::Traits* t) : ConversionBasicIOSAssetParam_1p2_1p3Parent(t) {} + + const NvParameterized::PrefVer* getPreferredVersions() const + { + static NvParameterized::PrefVer prefVers[] = + { + //TODO: + // Add your preferred versions for included references here. + // Entry format is + // { (const char*)longName, (uint32_t)preferredVersion } + + { 0, 0 } // Terminator (do not remove!) + }; + + return prefVers; + } + + bool convert() + { + //TODO: + // Write custom conversion code here using mNewData and mLegacyData members. + // + // Note that + // - mNewData has already been initialized with default values + // - same-named/same-typed members have already been copied + // from mLegacyData to mNewData + // - included references were moved to mNewData + // (and updated to preferred versions according to getPreferredVersions) + // + // For more info see the versioning wiki. + + return true; + } +}; + + +} +} +} //nvidia::apex::legacy + +#endif diff --git a/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_1p3_1p4.h b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_1p3_1p4.h new file mode 100644 index 00000000..56368e3b --- /dev/null +++ b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_1p3_1p4.h @@ -0,0 +1,80 @@ +/* + * 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_CONVERSIONBASICIOSASSETPARAM_1P3_1P4H_H +#define MODULE_CONVERSIONBASICIOSASSETPARAM_1P3_1P4H_H + +#include "NvParamConversionTemplate.h" +#include "BasicIOSAssetParam_1p3.h" +#include "BasicIOSAssetParam_1p4.h" + +namespace nvidia { +namespace apex { +namespace legacy { + + +typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::BasicIOSAssetParam_1p3, + nvidia::parameterized::BasicIOSAssetParam_1p4, + nvidia::parameterized::BasicIOSAssetParam_1p3::ClassVersion, + nvidia::parameterized::BasicIOSAssetParam_1p4::ClassVersion> + ConversionBasicIOSAssetParam_1p3_1p4Parent; + +class ConversionBasicIOSAssetParam_1p3_1p4: public ConversionBasicIOSAssetParam_1p3_1p4Parent +{ +public: + static NvParameterized::Conversion* Create(NvParameterized::Traits* t) + { + void* buf = t->alloc(sizeof(ConversionBasicIOSAssetParam_1p3_1p4)); + return buf ? PX_PLACEMENT_NEW(buf, ConversionBasicIOSAssetParam_1p3_1p4)(t) : 0; + } + +protected: + ConversionBasicIOSAssetParam_1p3_1p4(NvParameterized::Traits* t) : ConversionBasicIOSAssetParam_1p3_1p4Parent(t) {} + + const NvParameterized::PrefVer* getPreferredVersions() const + { + static NvParameterized::PrefVer prefVers[] = + { + //TODO: + // Add your preferred versions for included references here. + // Entry format is + // { (const char*)longName, (uint32_t)preferredVersion } + + { 0, 0 } // Terminator (do not remove!) + }; + + return prefVers; + } + + bool convert() + { + //TODO: + // Write custom conversion code here using mNewData and mLegacyData members. + // + // Note that + // - mNewData has already been initialized with default values + // - same-named/same-typed members have already been copied + // from mLegacyData to mNewData + // - included references were moved to mNewData + // (and updated to preferred versions according to getPreferredVersions) + // + // For more info see the versioning wiki. + + return true; + } +}; + + +} +} +} //nvidia::apex::legacy + +#endif 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 |