diff options
Diffstat (limited to 'APEX_1.4/module/particles/src/ModuleParticlesImpl.cpp')
| -rw-r--r-- | APEX_1.4/module/particles/src/ModuleParticlesImpl.cpp | 4341 |
1 files changed, 4341 insertions, 0 deletions
diff --git a/APEX_1.4/module/particles/src/ModuleParticlesImpl.cpp b/APEX_1.4/module/particles/src/ModuleParticlesImpl.cpp new file mode 100644 index 00000000..79f2024a --- /dev/null +++ b/APEX_1.4/module/particles/src/ModuleParticlesImpl.cpp @@ -0,0 +1,4341 @@ +/* + * 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. + */ + + + +#include "ApexDefs.h" + +#define SAFE_MODULE_RELEASE(x) if ( x ) { ModuleIntl *m = mSdk->getInternalModule(x); PX_ASSERT(m); m->setParent(NULL); x->release(); x = NULL; } + +/* === ModuleParticlesImpl DLL Setup === */ + +#pragma warning(disable:4505) + +#include "ModuleParticlesImpl.h" +#include "ModuleParticlesRegistration.h" +#include "ModulePerfScope.h" +#include "ParticlesScene.h" +#include "SceneIntl.h" +#include "PxMaterial.h" +#include "ModuleTurbulenceFS.h" +#include "PsMemoryBuffer.h" + +#include "ApexSDKIntl.h" +#include "ApexUsingNamespace.h" +#include "Apex.h" +#include "nvparameterized/NvParamUtils.h" +#include "ApexEmitterAssetParameters.h" +#include "EmitterGeomSphereParams.h" +#include "IofxAssetParameters.h" +#include "SpriteIofxParameters.h" +#include "ViewDirectionSortingModifierParams.h" +#include "SimpleScaleModifierParams.h" +#include "InitialColorModifierParams.h" +#include "TurbulenceFSAssetParams.h" +#include "BasicIOSAssetParam.h" +#include "EmitterAsset.h" +#include "GroundEmitterAsset.h" +#include "ImpactEmitterAsset.h" +#include "IofxAsset.h" +#include "BasicIosAsset.h" +#include "ParticleIosAsset.h" +#include "TurbulenceFSAsset.h" +#include "EmitterGeomBoxParams.h" +#include "RandomScaleModifierParams.h" +#include "RandomRotationModifierParams.h" +#include "ColorVsLifeCompositeModifierParams.h" +#include "ScaleVsLife2DModifierParams.h" +#include "FloatMath.h" +#include "JetFSActor.h" +#include "WindFSActor.h" +#include "AttractorFSActor.h" +#include "BasicFSAsset.h" +#include "JetFSAssetParams.h" +#include "WindFSAssetParams.h" +#include "NoiseFSAssetParams.h" +#include "VortexFSAssetParams.h" +#include "OrientScaleAlongScreenVelocityModifierParams.h" +#include "RandomRotationModifierParams.h" +#include "RotationRateModifierParams.h" +#include "RotationRateVsLifeModifierParams.h" +#include "EffectPackageActorImpl.h" +#include "AttractorFSAssetParams.h" +#include "FluidParticleSystemParams.h" +#include "ModuleParticleIosRegistration.h" +#include "MeshIofxParameters.h" +#include "SimpleScaleModifierParams.h" +#include "RotationModifierParams.h" +#include "ScaleVsLife3DModifierParams.h" +#include "ForceFieldAssetParams.h" +#include "RadialForceFieldKernelParams.h" +#include "ForceFieldFalloffParams.h" +#include "ForceFieldNoiseParams.h" +#include "HeatSourceAsset.h" +#include "SubstanceSourceAsset.h" +#include "VelocitySourceAsset.h" +#include "ForceFieldAsset.h" +#include "EffectPackageAssetParams.h" +#include "FlameEmitterAsset.h" +#include "FlameEmitterAssetParams.h" + +#include "ViewDirectionSortingModifierParams.h" +#include "RandomSubtextureModifierParams.h" +#include "UserOpaqueMesh.h" +#include "HeatSourceAssetParams.h" +#include "HeatSourceGeomSphereParams.h" +#include "SubstanceSourceAssetParams.h" +#include "VelocitySourceAssetParams.h" +#include "PxPhysics.h" +#include "EffectPackageData.h" + +#define SAFE_DESTROY(x) if ( x ) { x->destroy(); x = NULL; } + + +#if PX_X86 + +#define LINK_KERNEL(name) "/include:_"#name +#define LINK_S2_KERNEL(name) "/include:_"#name"_templ$0 /include:_"#name"_templ$1" + +#elif PX_X64 + +#define LINK_KERNEL(name) "/include:"#name +#define LINK_S2_KERNEL(name) "/include:"#name"_templ$0 /include:"#name"_templ$1" + +#endif + +#if APEX_CUDA_SUPPORT + +#pragma comment(linker, LINK_S2_KERNEL(BasicFS_fieldSamplerGridKernel)) +#pragma comment(linker, LINK_S2_KERNEL(BasicFS_fieldSamplerPointsKernel)) + +#pragma comment(linker, LINK_KERNEL(BasicIOS_compactKernel)) +#pragma comment(linker, LINK_KERNEL(BasicIOS_histogramKernel)) +#pragma comment(linker, LINK_KERNEL(BasicIOS_mergeHistogramKernel)) +#pragma comment(linker, LINK_KERNEL(BasicIOS_reduceKernel)) +#pragma comment(linker, LINK_KERNEL(BasicIOS_scanKernel)) +#pragma comment(linker, LINK_S2_KERNEL(BasicIOS_simulateApplyFieldKernel)) +#pragma comment(linker, LINK_S2_KERNEL(BasicIOS_simulateKernel)) +#pragma comment(linker, LINK_KERNEL(BasicIOS_stateKernel)) + +#pragma comment(linker, LINK_KERNEL(FieldSampler_applyParticlesKernel)) +#pragma comment(linker, LINK_KERNEL(FieldSampler_clearGridKernel)) +#pragma comment(linker, LINK_KERNEL(FieldSampler_clearKernel)) +#pragma comment(linker, LINK_KERNEL(FieldSampler_composeKernel)) + +#pragma comment(linker, LINK_S2_KERNEL(ForceField_fieldSamplerGridKernel)) +#pragma comment(linker, LINK_S2_KERNEL(ForceField_fieldSamplerPointsKernel)) + +#pragma comment(linker, LINK_KERNEL(IOFX_actorRangeKernel)) +#pragma comment(linker, LINK_KERNEL(IOFX_bboxKernel)) +#pragma comment(linker, LINK_S2_KERNEL(IOFX_meshModifiersKernel)) +#pragma comment(linker, LINK_KERNEL(IOFX_newRadixSortBlockKernel)) +#pragma comment(linker, LINK_KERNEL(IOFX_newRadixSortStepKernel)) +#pragma comment(linker, LINK_KERNEL(IOFX_radixSortStepKernel)) +#pragma comment(linker, LINK_S2_KERNEL(IOFX_makeSortKeys)) +#pragma comment(linker, LINK_S2_KERNEL(IOFX_remapKernel)) +#pragma comment(linker, LINK_S2_KERNEL(IOFX_spriteModifiersKernel)) +#pragma comment(linker, LINK_S2_KERNEL(IOFX_spriteTextureModifiersKernel)) +#pragma comment(linker, LINK_S2_KERNEL(IOFX_volumeMigrationKernel)) + +#pragma comment(linker, LINK_KERNEL(ParticleIOS_compactKernel)) +#pragma comment(linker, LINK_KERNEL(ParticleIOS_histogramKernel)) +#pragma comment(linker, LINK_KERNEL(ParticleIOS_mergeHistogramKernel)) +#pragma comment(linker, LINK_KERNEL(ParticleIOS_reduceKernel)) +#pragma comment(linker, LINK_KERNEL(ParticleIOS_scanKernel)) +#pragma comment(linker, LINK_S2_KERNEL(ParticleIOS_simulateApplyFieldKernel)) +#pragma comment(linker, LINK_S2_KERNEL(ParticleIOS_simulateKernel)) +#pragma comment(linker, LINK_KERNEL(ParticleIOS_stateKernel)) + +#endif + +namespace nvidia +{ +namespace apex +{ + + +void instantiateModuleBasicIos(); +void instantiateModuleEmitter(); +void instantiateModuleIofx(); +void instantiateModuleFieldSampler(); +void instantiateModuleParticleIos(); +void instantiateModuleForceField(); +void instantiateModuleBasicFS(); + +static const char* getAuthoringTypeName(const char* className) +{ + const char* ret = NULL; + + if (nvidia::strcmp(className, "BasicIOSAssetParam") == 0) + { + ret = BASIC_IOS_AUTHORING_TYPE_NAME; + } + else if (nvidia::strcmp(className, "IofxAssetParameters") == 0) + { + ret = IOFX_AUTHORING_TYPE_NAME; + } + else if (nvidia::strcmp(className, "ParticleIosAssetParam") == 0) + { + ret = PARTICLE_IOS_AUTHORING_TYPE_NAME; + } + + + PX_ASSERT(ret); + return ret; +} + +#if defined(_USRDLL) + +/* Modules don't have to link against the framework, they keep their own */ +ApexSDKIntl* gApexSdk = 0; +ApexSDK* GetApexSDK() +{ + return gApexSdk; +} +ApexSDKIntl* GetInternalApexSDK() +{ + return gApexSdk; +} + +static PxTransform getPose(float x, float y, float z, float rotX, float rotY, float rotZ) +{ + PxTransform ret; + ret.p = PxVec3(x, y, z); + fm_eulerToQuat(rotX * FM_DEG_TO_RAD, rotY * FM_DEG_TO_RAD, rotZ * FM_DEG_TO_RAD, &ret.q.x); + return ret; +} + +APEX_API Module* CALL_CONV createModule( + ApexSDKIntl* inSdk, + ModuleIntl** niRef, + uint32_t APEXsdkVersion, + uint32_t PhysXsdkVersion, + ApexCreateError* errorCode) +{ + if (APEXsdkVersion != APEX_SDK_VERSION) + { + if (errorCode) + { + *errorCode = APEX_CE_WRONG_VERSION; + } + return NULL; + } + + if (PhysXsdkVersion != PX_PHYSICS_VERSION) + { + if (errorCode) + { + *errorCode = APEX_CE_WRONG_VERSION; + } + return NULL; + } + + /* Setup common module global variables */ + gApexSdk = inSdk; + particles::ModuleParticlesImpl* impl = PX_NEW(particles::ModuleParticlesImpl)(inSdk); + *niRef = (ModuleIntl*) impl; + return (Module*) impl; +} + +#else +/* Statically linking entry function */ +void instantiateModuleParticles() +{ + ApexSDKIntl* sdk = GetInternalApexSDK(); + particles::ModuleParticlesImpl* impl = PX_NEW(particles::ModuleParticlesImpl)(sdk); + sdk->registerExternalModule((Module*) impl, (ModuleIntl*) impl); +} +#endif // `defined(_USRDLL) + +} + +namespace particles +{ + +/* === ModuleParticlesImpl Implementation === */ + +#ifdef WITHOUT_APEX_AUTHORING + +class ParticlesAssetDummyAuthoring : public AssetAuthoring, public UserAllocated +{ +public: + ParticlesAssetDummyAuthoring(ModuleParticlesImpl* module, ResourceList& list, NvParameterized::Interface* params, const char* name) + { + PX_UNUSED(module); + PX_UNUSED(list); + PX_UNUSED(params); + PX_UNUSED(name); + } + + ParticlesAssetDummyAuthoring(ModuleParticlesImpl* module, ResourceList& list, const char* name) + { + PX_UNUSED(module); + PX_UNUSED(list); + PX_UNUSED(name); + } + + ParticlesAssetDummyAuthoring(ModuleParticlesImpl* module, ResourceList& list) + { + PX_UNUSED(module); + PX_UNUSED(list); + } + + virtual void release() + { + destroy(); + } + + // internal + void destroy() + { + delete this; + } + + const char* getName(void) const + { + return NULL; + } + + + /** + * \brief Prepares a fully authored Asset Authoring object for a specified platform + */ + virtual bool prepareForPlatform(nvidia::apex::PlatformTag) + { + PX_ASSERT(0); + return false; + } + + /** + * \brief Save asset's NvParameterized interface, may return NULL + */ + virtual NvParameterized::Interface* getNvParameterized() + { + PX_ASSERT(0); + return NULL; + } + + virtual NvParameterized::Interface* releaseAndReturnNvParameterizedInterface(void) + { + PX_ALWAYS_ASSERT(); + return NULL; + } + + virtual void setToolString(const char* toolName, const char* toolVersion, uint32_t toolChangelist) + { + PX_ALWAYS_ASSERT(); + PX_UNUSED(toolName); + PX_UNUSED(toolVersion); + PX_UNUSED(toolChangelist); + } +}; + +typedef ApexAuthorableObject<ModuleParticlesImpl, ParticlesAsset, ParticlesAssetDummyAuthoring> ParticlesAO; + +#else +typedef ApexAuthorableObject<ModuleParticlesImpl, ParticlesAsset, ParticlesAssetAuthoring> ParticlesAO; +#endif + + +AuthObjTypeID EffectPackageAssetImpl::mAssetTypeID; // Static class member of ParticlesAsset + +#ifdef WITHOUT_APEX_AUTHORING + +class EffectPackageAssetDummyAuthoring : public AssetAuthoring, public UserAllocated +{ +public: + EffectPackageAssetDummyAuthoring(ModuleParticlesImpl* module, ResourceList& list, NvParameterized::Interface* params, const char* name) + { + PX_UNUSED(module); + PX_UNUSED(list); + PX_UNUSED(params); + PX_UNUSED(name); + } + + EffectPackageAssetDummyAuthoring(ModuleParticlesImpl* module, ResourceList& list, const char* name) + { + PX_UNUSED(module); + PX_UNUSED(list); + PX_UNUSED(name); + } + + EffectPackageAssetDummyAuthoring(ModuleParticlesImpl* module, ResourceList& list) + { + PX_UNUSED(module); + PX_UNUSED(list); + } + + virtual void release() + { + destroy(); + } + + // internal + void destroy() + { + delete this; + } + + const char* getName(void) const + { + return NULL; + } + + /** + * \brief Returns the name of this APEX authorable object type + */ + virtual const char* getObjTypeName() const + { + return EffectPackageAssetImpl::getClassName(); + } + + /** + * \brief Prepares a fully authored Asset Authoring object for a specified platform + */ + virtual bool prepareForPlatform(nvidia::apex::PlatformTag) + { + PX_ASSERT(0); + return false; + } + + /** + * \brief Save asset's NvParameterized interface, may return NULL + */ + virtual NvParameterized::Interface* getNvParameterized() + { + PX_ASSERT(0); + return NULL; + } + + virtual NvParameterized::Interface* releaseAndReturnNvParameterizedInterface(void) + { + PX_ALWAYS_ASSERT(); + return NULL; + } + + virtual void setToolString(const char* toolName, const char* toolVersion, uint32_t toolChangelist) + { + PX_ALWAYS_ASSERT(); + PX_UNUSED(toolName); + PX_UNUSED(toolVersion); + PX_UNUSED(toolChangelist); + } +}; + +typedef ApexAuthorableObject<ModuleParticlesImpl, EffectPackageAssetImpl, EffectPackageAssetDummyAuthoring> EffectPackageAO; + +#else +typedef ApexAuthorableObject<ModuleParticlesImpl, EffectPackageAssetImpl, EffectPackageAssetAuthoringImpl> EffectPackageAO; +#endif + + +//******************************************************************** + +#define MODULE_PARENT(x) if ( x ) { ModuleIntl *m = mSdk->getInternalModule(x); PX_ASSERT(m); m->setParent(this); m->setCreateOk(false); } + +ModuleParticlesImpl::ModuleParticlesImpl(ApexSDKIntl* inSdk) +{ + mSdk = inSdk; + + PxPhysics *sdk = mSdk->getPhysXSDK(); + mDefaultMaterial = sdk->createMaterial(1, 1, 1); + + instantiateModuleBasicIos(); // Instantiate the BasicIOS module statically + mModuleBasicIos = mSdk->createModule("BasicIOS"); + PX_ASSERT(mModuleBasicIos); + MODULE_PARENT(mModuleBasicIos); + + instantiateModuleEmitter(); // Instantiate the Emitter module statically + mModuleEmitter = mSdk->createModule("Emitter"); + PX_ASSERT(mModuleEmitter); + MODULE_PARENT(mModuleEmitter); + + instantiateModuleIofx(); // Instantiate the IOFX module statically + mModuleIofx = mSdk->createModule("IOFX"); + PX_ASSERT(mModuleIofx); + MODULE_PARENT(mModuleIofx); + + instantiateModuleFieldSampler(); // Instantiate the field sampler module statically + mModuleFieldSampler = mSdk->createModule("FieldSampler"); + PX_ASSERT(mModuleFieldSampler); + MODULE_PARENT(mModuleFieldSampler); + + instantiateModuleBasicFS(); // Instantiate the BasicFS module statically + mModuleBasicFS = mSdk->createModule("BasicFS"); + PX_ASSERT(mModuleBasicFS); + MODULE_PARENT(mModuleBasicFS); + + instantiateModuleParticleIos(); // PhysX 3.x only : Instantiate the ParticleIOS module + mModuleParticleIos = mSdk->createModule("ParticleIOS"); + PX_ASSERT(mModuleParticleIos); + MODULE_PARENT(mModuleParticleIos); + + instantiateModuleForceField(); // PhysX 3.x only : Instantiate the ForceField module + mModuleForceField = mSdk->createModule("ForceField"); + PX_ASSERT(mModuleForceField); + MODULE_PARENT(mModuleForceField); + + + mName = "Particles"; + mApiProxy = this; + mModuleParams = NULL; + mTurbulenceModule = NULL; + mGraphicsMaterialsDatabase = NULL; + mEnableScreenCulling = false; + mZnegative = false; + mUseEmitterPool = false; + + mEffectPackageIOSDatabaseParams = NULL; + mEffectPackageIOFXDatabaseParams = NULL; + mEffectPackageEmitterDatabaseParams = NULL; + mEffectPackageDatabaseParams = NULL; + mEffectPackageFieldSamplerDatabaseParams = NULL; + + { + /* Register asset type and create a namespace for it's assets */ + const char* pName = EffectPackageAssetParams::staticClassName(); + EffectPackageAO* eAO = PX_NEW(EffectPackageAO)(this, mEffectPackageAuthorableObjects, pName); + EffectPackageAssetImpl::mAssetTypeID = eAO->getResID(); + } + + /* Register the NvParameterized factories */ + NvParameterized::Traits* traits = mSdk->getParameterizedTraits(); + ModuleParticlesRegistration::invokeRegistration(traits); + + { + uint32_t count = mSdk->getNbModules(); + Module** modules = mSdk->getModules(); + for (uint32_t i = 0; i < count; i++) + { + Module* m = modules[i]; + const char* name = m->getName(); + if (nvidia::strcmp(name, "TurbulenceFS") == 0) + { + mTurbulenceModule = static_cast< ModuleTurbulenceFS*>(m); + break; + } + } + } +} + +ModuleParticlesImpl::~ModuleParticlesImpl() +{ + if ( mDefaultMaterial ) + { + mDefaultMaterial->release(); + } +} + +void ModuleParticlesImpl::destroy() +{ + // release the NvParameterized factory + NvParameterized::Traits* traits = mSdk->getParameterizedTraits(); + + if (mModuleParams) + { + mModuleParams->destroy(); + mModuleParams = NULL; + } + + SAFE_DESTROY(mEffectPackageIOSDatabaseParams); + SAFE_DESTROY(mEffectPackageIOFXDatabaseParams); + SAFE_DESTROY(mEffectPackageEmitterDatabaseParams); + SAFE_DESTROY(mEffectPackageDatabaseParams); + SAFE_DESTROY(mEffectPackageFieldSamplerDatabaseParams); + SAFE_DESTROY(mGraphicsMaterialsDatabase); + + ModuleBase::destroy(); + + if (traits) + { + /* Remove the NvParameterized factories */ + ModuleParticlesRegistration::invokeUnregistration(traits); + } + + SAFE_MODULE_RELEASE(mModuleBasicIos); + SAFE_MODULE_RELEASE(mModuleEmitter); + SAFE_MODULE_RELEASE(mModuleIofx); + SAFE_MODULE_RELEASE(mModuleFieldSampler); + SAFE_MODULE_RELEASE(mModuleBasicFS); + SAFE_MODULE_RELEASE(mModuleParticleIos); // PhysX 3.x only : Instantiate the ParticleIOS module + SAFE_MODULE_RELEASE(mModuleForceField); // PhysX 3.x only : Instantiate the ForceField module + + // clear before deletion, so that we don't call back into releaseModuleSceneIntl during "delete this" + mParticlesScenes.clear(); + + delete this; + + +} + +NvParameterized::Interface* ModuleParticlesImpl::getDefaultModuleDesc() +{ + WRITE_ZONE(); + NvParameterized::Traits* traits = mSdk->getParameterizedTraits(); + + if (!mModuleParams) + { + mModuleParams = DYNAMIC_CAST(ParticlesModuleParameters*) + (traits->createNvParameterized("ParticlesModuleParameters")); + PX_ASSERT(mModuleParams); + } + else + { + mModuleParams->initDefaults(); + } + + return mModuleParams; +} + +void ModuleParticlesImpl::init(const ModuleParticlesDesc& expDesc) +{ + WRITE_ZONE(); + mModuleValue = expDesc.moduleValue; +} + +AuthObjTypeID ModuleParticlesImpl::getParticlesAssetTypeID() const +{ +// TODO return ParticlesAsset::mAssetTypeID; + return 0; +} +AuthObjTypeID ModuleParticlesImpl::getModuleID() const +{ + READ_ZONE(); +// return ParticlesAsset::mAssetTypeID; +// TODO + return 0; +} + + +/* == Particles Scene methods == */ +ModuleSceneIntl* ModuleParticlesImpl::createInternalModuleScene(SceneIntl& scene, RenderDebugInterface* renderDebug) +{ + ModuleSceneIntl* ret = PX_NEW(ParticlesScene)(*this, scene, renderDebug, mParticlesScenes); + mScenes.pushBack(ret); + + return ret; +} + +void ModuleParticlesImpl::releaseModuleSceneIntl(ModuleSceneIntl& scene) +{ + for (uint32_t i = 0; i < mScenes.size(); ++i) + { + if (mScenes[i] == &scene) + { + mScenes.remove(i); + break; + } + } + ParticlesScene* es = DYNAMIC_CAST(ParticlesScene*)(&scene); + es->destroy(); + +} + +uint32_t ModuleParticlesImpl::forceLoadAssets() +{ + uint32_t loadedAssetCount = 0; + + for (uint32_t i = 0; i < mAuthorableObjects.getSize(); i++) + { + AuthorableObjectIntl* ao = static_cast<AuthorableObjectIntl*>(mAuthorableObjects.getResource(i)); + loadedAssetCount += ao->forceLoadAssets(); + } + + for (uint32_t i = 0; i < mEffectPackageAuthorableObjects.getSize(); i++) + { + AuthorableObjectIntl* ao = static_cast<AuthorableObjectIntl*>(mEffectPackageAuthorableObjects.getResource(i)); + loadedAssetCount += ao->forceLoadAssets(); + } + + + return loadedAssetCount; +} + +ParticlesScene* ModuleParticlesImpl::getParticlesScene(const Scene& apexScene) +{ + for (uint32_t i = 0 ; i < mParticlesScenes.getSize() ; i++) + { + ParticlesScene* es = DYNAMIC_CAST(ParticlesScene*)(mParticlesScenes.getResource(i)); + if (es->mApexScene == &apexScene) + { + return es; + } + } + + PX_ASSERT(!"Unable to locate an appropriate ParticlesScene"); + return NULL; +} + +RenderableIterator* ModuleParticlesImpl::createRenderableIterator(const Scene& apexScene) +{ + WRITE_ZONE(); + ParticlesScene* es = getParticlesScene(apexScene); + if (es) + { + return es->createRenderableIterator(); + } + + return NULL; +} + +const NvParameterized::Interface* ModuleParticlesImpl::locateVolumeRenderMaterialData(const char* name) const +{ + const NvParameterized::Interface* ret = NULL; + + if (mGraphicsMaterialsDatabase) + { + EffectPackageGraphicsMaterialsParams* d = static_cast< EffectPackageGraphicsMaterialsParams*>(mGraphicsMaterialsDatabase); + for (int32_t i = 0; i < d->GraphicsMaterials.arraySizes[0]; i++) + { + NvParameterized::Interface *ei = d->GraphicsMaterials.buf[i]; + if ( ei && nvidia::strcmp(ei->className(),"VolumeRenderMaterialData") == 0 ) + { + VolumeRenderMaterialData* e = static_cast< VolumeRenderMaterialData*>(ei); + if (e) + { + if (e->Name && nvidia::stricmp(e->Name, name) == 0) + { + ret = e; + break; + } + } + } + } + } + return ret; +} + + + +const NvParameterized::Interface* ModuleParticlesImpl::locateGraphicsMaterialData(const char* name) const +{ + READ_ZONE(); + const NvParameterized::Interface* ret = NULL; + + if (mGraphicsMaterialsDatabase) + { + EffectPackageGraphicsMaterialsParams* d = static_cast< EffectPackageGraphicsMaterialsParams*>(mGraphicsMaterialsDatabase); + for (int32_t i = 0; i < d->GraphicsMaterials.arraySizes[0]; i++) + { + NvParameterized::Interface *ei = d->GraphicsMaterials.buf[i]; + if ( ei && nvidia::strcmp(ei->className(),"GraphicsMaterialData") == 0 || nvidia::strcmp(ei->className(),"VolumeRenderMaterialData") == 0 ) + { + GraphicsMaterialData* e = static_cast< GraphicsMaterialData*>(ei); + if (e) + { + if (e->Name && nvidia::stricmp(e->Name, name) == 0) + { + ret = e; + break; + } + } + } + } + } + return ret; +} + +static bool isUnique(Array< const char* > &nameList, const char* baseName) +{ + bool ret = true; + for (uint32_t i = 0; i < nameList.size(); i++) + { + if (nvidia::stricmp(baseName, nameList[i]) == 0) + { + ret = false; + break; + } + } + return ret; +} + +static const char* getUniqueName(Array< const char* > &nameList, const char* baseName) +{ + const char* ret = baseName; + + if (baseName == NULL || strlen(baseName) == 0) + { + baseName = "default"; + } + if (!isUnique(nameList, baseName)) + { + static char uniqueName[512]; + strncpy(uniqueName, baseName, 512); + for (uint32_t i = 1; i < 1000; i++) + { + sprintf_s(uniqueName, 512, "%s%d", baseName, i); + if (isUnique(nameList, uniqueName)) + { + ret = uniqueName; + break; + } + } + } + return ret; +} + + +bool ModuleParticlesImpl::setEffectPackageGraphicsMaterialsDatabase(const NvParameterized::Interface* dataBase) +{ + WRITE_ZONE(); + bool ret = false; + if (dataBase) + { + NvParameterized::Traits* traits = mSdk->getParameterizedTraits(); + if (nvidia::strcmp(dataBase->className(), EffectPackageGraphicsMaterialsParams::staticClassName()) == 0 && dataBase != mGraphicsMaterialsDatabase) + { + if (mGraphicsMaterialsDatabase) + { + mGraphicsMaterialsDatabase->destroy(); + mGraphicsMaterialsDatabase = NULL; + } + dataBase->clone(mGraphicsMaterialsDatabase); + if ( mGraphicsMaterialsDatabase == NULL ) + { + APEX_DEBUG_WARNING("Failed to clone asset."); + mGraphicsMaterialsDatabase = traits->createNvParameterized(EffectPackageGraphicsMaterialsParams::staticClassName()); + } + ret = true; + } + else + { + // add it to the end of the existing array.. + if (nvidia::strcmp(dataBase->className(), GraphicsMaterialData::staticClassName()) == 0 || nvidia::strcmp(dataBase->className(), VolumeRenderMaterialData::staticClassName()) == 0 ) + { + bool revised = false; + const char* itemName = dataBase->name(); + EffectPackageGraphicsMaterialsParams* d = static_cast< EffectPackageGraphicsMaterialsParams*>(mGraphicsMaterialsDatabase); + if ( d ) + { + for (uint32_t i = 0; i < (uint32_t)d->GraphicsMaterials.arraySizes[0]; i++) + { + NvParameterized::Interface* ei = d->GraphicsMaterials.buf[i]; + if (!ei) + { + continue; + } + const char *materialName=NULL; + if ( nvidia::strcmp(ei->className(),"GraphicsMaterialData") == 0 ) + { + GraphicsMaterialData* ed = static_cast< GraphicsMaterialData*>(ei); + materialName = ed->Name.buf; + } + else if ( nvidia::strcmp(ei->className(),"VolumeRenderMaterialData") == 0 ) + { + VolumeRenderMaterialData* ed = static_cast< VolumeRenderMaterialData*>(ei); + materialName = ed->Name.buf; + } + else + { + PX_ALWAYS_ASSERT(); + } + if ( materialName && nvidia::stricmp(materialName, itemName) == 0) + { + ei->copy(*dataBase); + revised = true; + ret = true; + break; + } + } + if (!revised && mGraphicsMaterialsDatabase) + { + int32_t arraySize = d->GraphicsMaterials.arraySizes[0]; + NvParameterized::Handle handle(mGraphicsMaterialsDatabase); + NvParameterized::ErrorType err = handle.getParameter("GraphicsMaterials"); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + err = handle.resizeArray(arraySize + 1); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + if (err == NvParameterized::ERROR_NONE) + { + NvParameterized::Interface* ei = NULL; + NvParameterized::ErrorType err = dataBase->clone(ei); + if ( err != NvParameterized::ERROR_NONE || ei == NULL ) + { + APEX_DEBUG_WARNING("Failed to clone asset."); + } + else + { + NvParameterized::Handle item(ei); + err = item.getParameter("Name"); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + item.setParamString(itemName); + ei->setName(itemName); + d->GraphicsMaterials.buf[arraySize] = ei; + } + ret = true; + } + } + } + } + } + + if (mGraphicsMaterialsDatabase) + { + EffectPackageGraphicsMaterialsParams* ds = static_cast< EffectPackageGraphicsMaterialsParams*>(mGraphicsMaterialsDatabase); + if (ds->GraphicsMaterials.arraySizes[0] == 0) + { + NvParameterized::Handle handle(mGraphicsMaterialsDatabase); + NvParameterized::ErrorType err = handle.getParameter("GraphicsMaterials"); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + err = handle.resizeArray(2); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + NvParameterized::Interface* ei; + if (err == NvParameterized::ERROR_NONE) + { + ei = traits->createNvParameterized(GraphicsMaterialData::staticClassName()); + ds->GraphicsMaterials.buf[0] = ei; + ei = traits->createNvParameterized(VolumeRenderMaterialData::staticClassName()); + ds->GraphicsMaterials.buf[1] = ei; + } + } + + Array< const char* > nameList; + for (int32_t i = 0; i < ds->GraphicsMaterials.arraySizes[0]; i++) + { + NvParameterized::Interface *ei = ds->GraphicsMaterials.buf[i]; + if ( !ei ) + continue; + const char *materialName=NULL; + if ( nvidia::strcmp(ei->className(),"GraphicsMaterialData") == 0 ) + { + GraphicsMaterialData* e = static_cast< GraphicsMaterialData*>(ei); + if (e) + { + materialName = e->Name; + } + } + else if ( nvidia::strcmp(ei->className(),"VolumeRenderMaterialData") == 0 ) + { + VolumeRenderMaterialData* e = static_cast< VolumeRenderMaterialData*>(ei); + if (e) + { + materialName = e->Name.buf; + } + } + else + { + PX_ALWAYS_ASSERT(); + } + if ( materialName ) + { + for (uint32_t j = 0; j < nameList.size(); j++) + { + if (nvidia::stricmp(nameList[j], materialName) == 0) + { + NvParameterized::Handle handle(ei); + NvParameterized::ErrorType err = handle.getParameter("Name"); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + if (err == NvParameterized::ERROR_NONE) + { + materialName = getUniqueName(nameList, materialName); + handle.setParamString(materialName); + ret = true; + break; + } + } + } + nameList.pushBack(materialName); + } + } + } + } + return ret; +} + + +const NvParameterized::Interface* ModuleParticlesImpl::getEffectPackageGraphicsMaterialsDatabase(void) const +{ + READ_ZONE(); + return mGraphicsMaterialsDatabase; +} + + +NvParameterized::Interface* ModuleParticlesImpl::locateResource(const char* resourceName, const char* nameSpace) +{ + WRITE_ZONE(); + NvParameterized::Interface* ret = NULL; + + if (mEffectPackageDatabaseParams == NULL) + { + return NULL; + } + + if (nvidia::strcmp(nameSpace, PARTICLES_EFFECT_PACKAGE_AUTHORING_TYPE_NAME) == 0) + { + EffectPackageDatabaseParams* d = static_cast< EffectPackageDatabaseParams*>(mEffectPackageDatabaseParams); + if ( d ) + { + for (uint32_t i = 0; i < (uint32_t)d->EffectPackages.arraySizes[0]; i++) + { + NvParameterized::Interface* ei = d->EffectPackages.buf[i]; + if (!ei) + { + continue; + } + EffectPackageData* ed = static_cast< EffectPackageData*>(ei); + if (nvidia::stricmp(ed->Name, resourceName) == 0) + { + ret = ed->EffectPackage; + break; + } + } + } + } + else if (nvidia::strcmp(nameSpace, APEX_MATERIALS_NAME_SPACE) == 0 || nvidia::strcmp(nameSpace,"GraphicsMaterialData") == 0 ) + { + EffectPackageGraphicsMaterialsParams* d = static_cast< EffectPackageGraphicsMaterialsParams*>(mGraphicsMaterialsDatabase); + if ( d ) + { + for (uint32_t i = 0; i < (uint32_t)d->GraphicsMaterials.arraySizes[0]; i++) + { + NvParameterized::Interface* ei = d->GraphicsMaterials.buf[i]; + if (!ei) + { + continue; + } + if ( nvidia::strcmp(ei->className(),"GraphicsMaterialData") == 0 ) + { + GraphicsMaterialData* ed = static_cast< GraphicsMaterialData*>(ei); + if ( nvidia::strcmp(ed->Name,resourceName) == 0 ) + { + ret = ei; + break; + } + } + } + } + } + else if (nvidia::strcmp(nameSpace, APEX_VOLUME_RENDER_MATERIALS_NAME_SPACE) == 0 || nvidia::strcmp(nameSpace,"VolumeRenderMaterialData") == 0 ) + { + EffectPackageGraphicsMaterialsParams* d = static_cast< EffectPackageGraphicsMaterialsParams*>(mGraphicsMaterialsDatabase); + if ( d ) + { + for (uint32_t i = 0; i < (uint32_t)d->GraphicsMaterials.arraySizes[0]; i++) + { + NvParameterized::Interface* ei = d->GraphicsMaterials.buf[i]; + if (!ei) + { + continue; + } + if ( nvidia::strcmp(ei->className(),"VolumeRenderMaterialData") == 0 ) + { + VolumeRenderMaterialData* ed = static_cast< VolumeRenderMaterialData*>(ei); + if ( nvidia::strcmp(ed->Name,resourceName) == 0 ) + { + ret = ei; + break; + } + } + } + } + } + else if (nvidia::strcmp(nameSpace, IOFX_AUTHORING_TYPE_NAME) == 0 || nvidia::strcmp(nameSpace, "GraphicsEffectData") == 0 ) + { + EffectPackageIOFXDatabaseParams* d = static_cast< EffectPackageIOFXDatabaseParams*>(mEffectPackageIOFXDatabaseParams); + if ( d ) + { + for (uint32_t i = 0; i < (uint32_t)d->GraphicsEffects.arraySizes[0]; i++) + { + NvParameterized::Interface* ei = d->GraphicsEffects.buf[i]; + if (!ei) + { + continue; + } + GraphicsEffectData* ed = static_cast< GraphicsEffectData*>(ei); + if (nvidia::stricmp(resourceName, ed->Name) == 0) + { + if (nvidia::strcmp(nameSpace, IOFX_AUTHORING_TYPE_NAME) == 0 ) + { + ret = ed->IOFX; + } + else + { + ret = ed; + } + break; + } + } + } + } + else if (nvidia::strcmp(nameSpace, "ParticleSimulationData") == 0) + { + EffectPackageIOSDatabaseParams* d = static_cast< EffectPackageIOSDatabaseParams*>(mEffectPackageIOSDatabaseParams); + if ( d ) + { + for (uint32_t i = 0; i < (uint32_t)d->ParticleSimulations.arraySizes[0]; i++) + { + NvParameterized::Interface* ei = d->ParticleSimulations.buf[i]; + if (!ei) + { + continue; + } + ParticleSimulationData* ed = static_cast< ParticleSimulationData*>(ei); + if (nvidia::stricmp(ed->Name, resourceName) == 0) + { + ret = ei; + break; + } + } + } + } + else if (nvidia::strcmp(nameSpace, BASIC_IOS_AUTHORING_TYPE_NAME) == 0) + { + EffectPackageIOSDatabaseParams* d = static_cast< EffectPackageIOSDatabaseParams*>(mEffectPackageIOSDatabaseParams); + if ( d ) + { + for (uint32_t i = 0; i < (uint32_t)d->ParticleSimulations.arraySizes[0]; i++) + { + NvParameterized::Interface* ei = d->ParticleSimulations.buf[i]; + if (!ei) + { + continue; + } + ParticleSimulationData* ed = static_cast< ParticleSimulationData*>(ei); + if (nvidia::strcmp(ed->IOS->className(), basicios::BasicIOSAssetParam::staticClassName()) == 0) + { + if (nvidia::stricmp(ed->Name, resourceName) == 0) + { + ret = ed->IOS; + break; + } + } + } + } + } + else if (nvidia::strcmp(nameSpace, PARTICLE_IOS_AUTHORING_TYPE_NAME) == 0) + { + EffectPackageIOSDatabaseParams* d = static_cast< EffectPackageIOSDatabaseParams*>(mEffectPackageIOSDatabaseParams); + if ( d ) + { + for (uint32_t i = 0; i < (uint32_t)d->ParticleSimulations.arraySizes[0]; i++) + { + NvParameterized::Interface* ei = d->ParticleSimulations.buf[i]; + if (!ei) + { + continue; + } + ParticleSimulationData* ed = static_cast< ParticleSimulationData*>(ei); + if (nvidia::strcmp(ed->IOS->className(), pxparticleios::ParticleIosAssetParam::staticClassName()) == 0) + { + if (nvidia::stricmp(ed->Name, resourceName) == 0) + { + ret = ed->IOS; + break; + } + } + } + } + } + else if (nvidia::strcmp(nameSpace, EMITTER_AUTHORING_TYPE_NAME) == 0 || nvidia::strcmp(nameSpace,"EmitterData") == 0 ) + { + EffectPackageEmitterDatabaseParams* d = static_cast< EffectPackageEmitterDatabaseParams*>(mEffectPackageEmitterDatabaseParams); + if ( d ) + { + for (uint32_t i = 0; i < (uint32_t)d->Emitters.arraySizes[0]; i++) + { + NvParameterized::Interface* ei = d->Emitters.buf[i]; + if (!ei) + { + continue; + } + EmitterData* ed = static_cast< EmitterData*>(ei); + if (nvidia::stricmp(resourceName, ed->Name) == 0) + { + if ( nvidia::strcmp(nameSpace, EMITTER_AUTHORING_TYPE_NAME) == 0 ) + { + ret = ed->Emitter; + } + else + { + ret = ed; + } + break; + } + } + } + } + else if (nvidia::strcmp(nameSpace, HEAT_SOURCE_AUTHORING_TYPE_NAME) == 0 || nvidia::strcmp(nameSpace, "HeatSourceData") == 0 ) + { + EffectPackageFieldSamplerDatabaseParams* d = static_cast< EffectPackageFieldSamplerDatabaseParams*>(mEffectPackageFieldSamplerDatabaseParams); + if ( d ) + { + for (uint32_t i = 0; i < (uint32_t)d->FieldSamplers.arraySizes[0]; i++) + { + NvParameterized::Interface* ei = d->FieldSamplers.buf[i]; + if (!ei) + { + continue; + } + if (nvidia::strcmp(ei->className(), HeatSourceData::staticClassName()) != 0) + { + continue; + } + HeatSourceData* ed = static_cast< HeatSourceData*>(ei); + if (nvidia::stricmp(ed->Name, resourceName) == 0) + { + if (nvidia::strcmp(nameSpace, HEAT_SOURCE_AUTHORING_TYPE_NAME) == 0 ) + { + ret = ed->HeatSource; + } + else + { + ret = ed; + } + break; + } + } + } + } + else if (nvidia::strcmp(nameSpace, SUBSTANCE_SOURCE_AUTHORING_TYPE_NAME) == 0 || nvidia::strcmp(nameSpace, "SubstanceSourceData") == 0 ) + { + EffectPackageFieldSamplerDatabaseParams* d = static_cast< EffectPackageFieldSamplerDatabaseParams*>(mEffectPackageFieldSamplerDatabaseParams); + if ( d ) + { + for (uint32_t i = 0; i < (uint32_t)d->FieldSamplers.arraySizes[0]; i++) + { + NvParameterized::Interface* ei = d->FieldSamplers.buf[i]; + if (!ei) + { + continue; + } + if (nvidia::strcmp(ei->className(), SubstanceSourceData::staticClassName()) != 0) + { + continue; + } + SubstanceSourceData* ed = static_cast< SubstanceSourceData*>(ei); + if (nvidia::stricmp(ed->Name, resourceName) == 0) + { + if (nvidia::strcmp(nameSpace, SUBSTANCE_SOURCE_AUTHORING_TYPE_NAME) == 0 ) + { + ret = ed->SubstanceSource; + } + else + { + ret = ed; + } + break; + } + } + } + } + else if (nvidia::strcmp(nameSpace, VELOCITY_SOURCE_AUTHORING_TYPE_NAME) == 0 || nvidia::strcmp(nameSpace, "VelocitySourceData") == 0 ) + { + EffectPackageFieldSamplerDatabaseParams* d = static_cast< EffectPackageFieldSamplerDatabaseParams*>(mEffectPackageFieldSamplerDatabaseParams); + if ( d ) + { + for (uint32_t i = 0; i < (uint32_t)d->FieldSamplers.arraySizes[0]; i++) + { + NvParameterized::Interface* ei = d->FieldSamplers.buf[i]; + if (!ei) + { + continue; + } + if (nvidia::strcmp(ei->className(), VelocitySourceData::staticClassName()) != 0) + { + continue; + } + VelocitySourceData* ed = static_cast< VelocitySourceData*>(ei); + if (nvidia::stricmp(ed->Name, resourceName) == 0) + { + if (nvidia::strcmp(nameSpace, VELOCITY_SOURCE_AUTHORING_TYPE_NAME) == 0 ) + { + ret = ed->VelocitySource; + } + else + { + ret = ed; + } + break; + } + } + } + } + else if (nvidia::strcmp(nameSpace, JET_FS_AUTHORING_TYPE_NAME) == 0 || nvidia::strcmp(nameSpace, "JetFieldSamplerData") == 0 ) + { + EffectPackageFieldSamplerDatabaseParams* d = static_cast< EffectPackageFieldSamplerDatabaseParams*>(mEffectPackageFieldSamplerDatabaseParams); + if ( d ) + { + for (uint32_t i = 0; i < (uint32_t)d->FieldSamplers.arraySizes[0]; i++) + { + NvParameterized::Interface* ei = d->FieldSamplers.buf[i]; + if (!ei) + { + continue; + } + if (nvidia::strcmp(ei->className(), JetFieldSamplerData::staticClassName()) != 0) + { + continue; + } + JetFieldSamplerData* ed = static_cast< JetFieldSamplerData*>(ei); + if (nvidia::stricmp(ed->Name, resourceName) == 0) + { + if (nvidia::strcmp(nameSpace, JET_FS_AUTHORING_TYPE_NAME) == 0 ) + { + ret = ed->JetFieldSampler; + } + else + { + ret = ed; + } + break; + } + } + } + } + else if (nvidia::strcmp(nameSpace, WIND_FS_AUTHORING_TYPE_NAME) == 0 || nvidia::strcmp(nameSpace, "WindFieldSamplerData") == 0 ) + { + EffectPackageFieldSamplerDatabaseParams* d = static_cast< EffectPackageFieldSamplerDatabaseParams*>(mEffectPackageFieldSamplerDatabaseParams); + if ( d ) + { + for (uint32_t i = 0; i < (uint32_t)d->FieldSamplers.arraySizes[0]; i++) + { + NvParameterized::Interface* ei = d->FieldSamplers.buf[i]; + if (!ei) + { + continue; + } + if (nvidia::strcmp(ei->className(), WindFieldSamplerData::staticClassName()) != 0) + { + continue; + } + WindFieldSamplerData* ed = static_cast< WindFieldSamplerData*>(ei); + if (nvidia::stricmp(ed->Name, resourceName) == 0) + { + if (nvidia::strcmp(nameSpace, WIND_FS_AUTHORING_TYPE_NAME) == 0 ) + { + ret = ed->WindFieldSampler; + } + else + { + ret = ed; + } + break; + } + } + } + } + else if (nvidia::strcmp(nameSpace, VORTEX_FS_AUTHORING_TYPE_NAME) == 0 || nvidia::strcmp(nameSpace, "VortexFieldSamplerData") == 0 ) + { + EffectPackageFieldSamplerDatabaseParams* d = static_cast< EffectPackageFieldSamplerDatabaseParams*>(mEffectPackageFieldSamplerDatabaseParams); + if ( d ) + { + for (uint32_t i = 0; i < (uint32_t)d->FieldSamplers.arraySizes[0]; i++) + { + NvParameterized::Interface* ei = d->FieldSamplers.buf[i]; + if (!ei) + { + continue; + } + if (nvidia::strcmp(ei->className(), VortexFieldSamplerData::staticClassName()) != 0) + { + continue; + } + VortexFieldSamplerData* ed = static_cast< VortexFieldSamplerData*>(ei); + if (nvidia::stricmp(ed->Name, resourceName) == 0) + { + if (nvidia::strcmp(nameSpace, VORTEX_FS_AUTHORING_TYPE_NAME) == 0 ) + { + ret = ed->VortexFieldSampler; + } + else + { + ret = ed; + } + break; + } + } + } + } + else if (nvidia::strcmp(nameSpace, NOISE_FS_AUTHORING_TYPE_NAME) == 0 || nvidia::strcmp(nameSpace, "NoiseFieldSamplerData") == 0 ) + { + EffectPackageFieldSamplerDatabaseParams* d = static_cast< EffectPackageFieldSamplerDatabaseParams*>(mEffectPackageFieldSamplerDatabaseParams); + if ( d ) + { + for (uint32_t i = 0; i < (uint32_t)d->FieldSamplers.arraySizes[0]; i++) + { + NvParameterized::Interface* ei = d->FieldSamplers.buf[i]; + if (!ei) + { + continue; + } + if (nvidia::strcmp(ei->className(), NoiseFieldSamplerData::staticClassName()) != 0) + { + continue; + } + NoiseFieldSamplerData* ed = static_cast< NoiseFieldSamplerData*>(ei); + if (nvidia::stricmp(ed->Name, resourceName) == 0) + { + if (nvidia::strcmp(nameSpace, NOISE_FS_AUTHORING_TYPE_NAME) == 0 ) + { + ret = ed->NoiseFieldSampler; + } + else + { + ret = ed; + } + break; + } + } + } + } + else if (nvidia::strcmp(nameSpace, ATTRACTOR_FS_AUTHORING_TYPE_NAME) == 0 || nvidia::strcmp(nameSpace, "AttractorFieldSamplerData") == 0 ) + { + EffectPackageFieldSamplerDatabaseParams* d = static_cast< EffectPackageFieldSamplerDatabaseParams*>(mEffectPackageFieldSamplerDatabaseParams); + if ( d ) + { + for (uint32_t i = 0; i < (uint32_t)d->FieldSamplers.arraySizes[0]; i++) + { + NvParameterized::Interface* ei = d->FieldSamplers.buf[i]; + if (!ei) + { + continue; + } + if (nvidia::strcmp(ei->className(), AttractorFieldSamplerData::staticClassName()) != 0) + { + continue; + } + AttractorFieldSamplerData* ed = static_cast< AttractorFieldSamplerData*>(ei); + if (nvidia::stricmp(ed->Name, resourceName) == 0) + { + if (nvidia::strcmp(nameSpace, ATTRACTOR_FS_AUTHORING_TYPE_NAME) == 0 ) + { + ret = ed->AttractorFieldSampler; + } + else + { + ret = ed; + } + break; + } + } + } + } + else if (nvidia::strcmp(nameSpace, TURBULENCE_FS_AUTHORING_TYPE_NAME) == 0 || nvidia::strcmp(nameSpace, "TurbulenceFieldSamplerData") == 0) + { + EffectPackageFieldSamplerDatabaseParams* d = static_cast< EffectPackageFieldSamplerDatabaseParams*>(mEffectPackageFieldSamplerDatabaseParams); + if ( d ) + { + for (uint32_t i = 0; i < (uint32_t)d->FieldSamplers.arraySizes[0]; i++) + { + NvParameterized::Interface* ei = d->FieldSamplers.buf[i]; + if (!ei) + { + continue; + } + if (nvidia::strcmp(ei->className(), TurbulenceFieldSamplerData::staticClassName()) != 0) + { + continue; + } + TurbulenceFieldSamplerData* ed = static_cast< TurbulenceFieldSamplerData*>(ei); + if (nvidia::stricmp(ed->Name, resourceName) == 0) + { + if (nvidia::strcmp(nameSpace, TURBULENCE_FS_AUTHORING_TYPE_NAME) == 0 ) + { + ret = ed->TurbulenceFieldSampler; + } + else + { + ret = ed; + } + break; + } + } + } + } + else if (nvidia::strcmp(nameSpace, FORCEFIELD_AUTHORING_TYPE_NAME) == 0 || nvidia::strcmp(nameSpace, "ForceFieldData") == 0) + { + EffectPackageFieldSamplerDatabaseParams* d = static_cast< EffectPackageFieldSamplerDatabaseParams*>(mEffectPackageFieldSamplerDatabaseParams); + if ( d ) + { + for (uint32_t i = 0; i < (uint32_t)d->FieldSamplers.arraySizes[0]; i++) + { + NvParameterized::Interface* ei = d->FieldSamplers.buf[i]; + if (!ei) + { + continue; + } + if (nvidia::strcmp(ei->className(), ForceFieldData::staticClassName()) != 0) + { + continue; + } + ForceFieldData* ed = static_cast< ForceFieldData*>(ei); + if (nvidia::stricmp(ed->Name, resourceName) == 0) + { + if (nvidia::strcmp(nameSpace, FORCEFIELD_AUTHORING_TYPE_NAME) == 0 ) + { + ret = ed->ForceField; + } + else + { + ret = ed; + } + break; + } + } + } + } + else if (nvidia::strcmp(nameSpace, FLAME_EMITTER_AUTHORING_TYPE_NAME) == 0 || nvidia::strcmp(nameSpace, "FlameEmitterData") == 0) + { + EffectPackageFieldSamplerDatabaseParams* d = static_cast< EffectPackageFieldSamplerDatabaseParams*>(mEffectPackageFieldSamplerDatabaseParams); + if ( d ) + { + for (uint32_t i = 0; i < (uint32_t)d->FieldSamplers.arraySizes[0]; i++) + { + NvParameterized::Interface* ei = d->FieldSamplers.buf[i]; + if (!ei) + { + continue; + } + if (nvidia::strcmp(ei->className(), FlameEmitterData::staticClassName()) != 0) + { + continue; + } + FlameEmitterData* ed = static_cast< FlameEmitterData*>(ei); + if (nvidia::stricmp(ed->Name, resourceName) == 0) + { + if (nvidia::strcmp(nameSpace, FLAME_EMITTER_AUTHORING_TYPE_NAME) == 0 ) + { + ret = ed->FlameEmitter; + } + else + { + ret = ed; + } + break; + } + } + } + } + + return ret; +} + + + + +const char** ModuleParticlesImpl::getResourceNames(const char* nameSpace, uint32_t& nameCount, const char** &variants) +{ + READ_ZONE(); + const char** ret = NULL; + + variants = NULL; + mTempNames.clear(); + mTempVariantNames.clear(); + + if (nvidia::strcmp(nameSpace, IOFX_AUTHORING_TYPE_NAME) == 0) + { + EffectPackageIOFXDatabaseParams* d = static_cast< EffectPackageIOFXDatabaseParams*>(mEffectPackageIOFXDatabaseParams); + if ( d ) + { + for (uint32_t i = 0; i < (uint32_t)d->GraphicsEffects.arraySizes[0]; i++) + { + NvParameterized::Interface* ei = d->GraphicsEffects.buf[i]; + if (!ei) + { + continue; + } + GraphicsEffectData* ed = static_cast< GraphicsEffectData*>(ei); + mTempNames.pushBack(ed->Name); + mTempVariantNames.pushBack(IOFX_AUTHORING_TYPE_NAME); + } + } + } + else if (nvidia::strcmp(nameSpace, APEX_MATERIALS_NAME_SPACE) == 0) + { + EffectPackageGraphicsMaterialsParams* d = static_cast< EffectPackageGraphicsMaterialsParams*>(mGraphicsMaterialsDatabase); + if ( d ) + { + for (uint32_t i = 0; i < (uint32_t)d->GraphicsMaterials.arraySizes[0]; i++) + { + NvParameterized::Interface* ei = d->GraphicsMaterials.buf[i]; + if (!ei) + { + continue; + } + if ( nvidia::strcmp(ei->className(),"GraphicsMaterialData") == 0 ) + { + GraphicsMaterialData* ed = static_cast< GraphicsMaterialData*>(ei); + mTempNames.pushBack(ed->Name); + mTempVariantNames.pushBack(APEX_MATERIALS_NAME_SPACE); + } + } + } + } + else if (nvidia::strcmp(nameSpace, APEX_VOLUME_RENDER_MATERIALS_NAME_SPACE) == 0) + { + EffectPackageGraphicsMaterialsParams* d = static_cast< EffectPackageGraphicsMaterialsParams*>(mGraphicsMaterialsDatabase); + if ( d ) + { + for (uint32_t i = 0; i < (uint32_t)d->GraphicsMaterials.arraySizes[0]; i++) + { + NvParameterized::Interface* ei = d->GraphicsMaterials.buf[i]; + if (!ei) + { + continue; + } + if ( nvidia::strcmp(ei->className(),"VolumeRenderMaterialData") == 0 ) + { + VolumeRenderMaterialData* ed = static_cast< VolumeRenderMaterialData*>(ei); + mTempNames.pushBack(ed->Name); + mTempVariantNames.pushBack(APEX_VOLUME_RENDER_MATERIALS_NAME_SPACE); + } + } + } + } + else if (nvidia::strcmp(nameSpace, BASIC_IOS_AUTHORING_TYPE_NAME) == 0 || nvidia::strcmp(nameSpace, PARTICLE_IOS_AUTHORING_TYPE_NAME) == 0) + { + EffectPackageIOSDatabaseParams* d = static_cast< EffectPackageIOSDatabaseParams*>(mEffectPackageIOSDatabaseParams); + if ( d ) + { + for (uint32_t i = 0; i < (uint32_t)d->ParticleSimulations.arraySizes[0]; i++) + { + NvParameterized::Interface* ei = d->ParticleSimulations.buf[i]; + if (!ei) + { + continue; + } + ParticleSimulationData* ed = static_cast< ParticleSimulationData*>(ei); + mTempNames.pushBack(ed->Name); + if (nvidia::strcmp(ed->IOS->className(), basicios::BasicIOSAssetParam::staticClassName()) == 0) + { + mTempVariantNames.pushBack(BASIC_IOS_AUTHORING_TYPE_NAME); + } + else + { + mTempVariantNames.pushBack(PARTICLE_IOS_AUTHORING_TYPE_NAME); + } + } + } + } + else if (nvidia::strcmp(nameSpace, EMITTER_AUTHORING_TYPE_NAME) == 0) + { + EffectPackageEmitterDatabaseParams* d = static_cast< EffectPackageEmitterDatabaseParams*>(mEffectPackageEmitterDatabaseParams); + if ( d ) + { + for (uint32_t i = 0; i < (uint32_t)d->Emitters.arraySizes[0]; i++) + { + NvParameterized::Interface* ei = d->Emitters.buf[i]; + if (!ei) + { + continue; + } + EmitterData* ed = static_cast< EmitterData*>(ei); + mTempNames.pushBack(ed->Name); + mTempVariantNames.pushBack(EMITTER_AUTHORING_TYPE_NAME); + } + } + } + else if (nvidia::strcmp(nameSpace, HEAT_SOURCE_AUTHORING_TYPE_NAME) == 0) + { + EffectPackageFieldSamplerDatabaseParams* d = static_cast< EffectPackageFieldSamplerDatabaseParams*>(mEffectPackageFieldSamplerDatabaseParams); + if ( d ) + { + for (uint32_t i = 0; i < (uint32_t)d->FieldSamplers.arraySizes[0]; i++) + { + NvParameterized::Interface* ei = d->FieldSamplers.buf[i]; + if (!ei) + { + continue; + } + if (nvidia::strcmp(ei->className(), HeatSourceData::staticClassName()) != 0) + { + continue; + } + HeatSourceData* ed = static_cast< HeatSourceData*>(ei); + mTempNames.pushBack(ed->Name); + mTempVariantNames.pushBack(HEAT_SOURCE_AUTHORING_TYPE_NAME); + } + } + } + else if (nvidia::strcmp(nameSpace, SUBSTANCE_SOURCE_AUTHORING_TYPE_NAME) == 0) + { + EffectPackageFieldSamplerDatabaseParams* d = static_cast< EffectPackageFieldSamplerDatabaseParams*>(mEffectPackageFieldSamplerDatabaseParams); + if ( d ) + { + for (uint32_t i = 0; i < (uint32_t)d->FieldSamplers.arraySizes[0]; i++) + { + NvParameterized::Interface* ei = d->FieldSamplers.buf[i]; + if (!ei) + { + continue; + } + if (nvidia::strcmp(ei->className(), SubstanceSourceData::staticClassName()) != 0) + { + continue; + } + SubstanceSourceData* ed = static_cast< SubstanceSourceData*>(ei); + mTempNames.pushBack(ed->Name); + mTempVariantNames.pushBack(SUBSTANCE_SOURCE_AUTHORING_TYPE_NAME); + } + } + } + else if (nvidia::strcmp(nameSpace, VELOCITY_SOURCE_AUTHORING_TYPE_NAME) == 0) + { + EffectPackageFieldSamplerDatabaseParams* d = static_cast< EffectPackageFieldSamplerDatabaseParams*>(mEffectPackageFieldSamplerDatabaseParams); + if ( d ) + { + for (uint32_t i = 0; i < (uint32_t)d->FieldSamplers.arraySizes[0]; i++) + { + NvParameterized::Interface* ei = d->FieldSamplers.buf[i]; + if (!ei) + { + continue; + } + if (nvidia::strcmp(ei->className(), VelocitySourceData::staticClassName()) != 0) + { + continue; + } + VelocitySourceData* ed = static_cast< VelocitySourceData*>(ei); + mTempNames.pushBack(ed->Name); + mTempVariantNames.pushBack(SUBSTANCE_SOURCE_AUTHORING_TYPE_NAME); + } + } + } + else if (nvidia::strcmp(nameSpace, JET_FS_AUTHORING_TYPE_NAME) == 0) + { + EffectPackageFieldSamplerDatabaseParams* d = static_cast< EffectPackageFieldSamplerDatabaseParams*>(mEffectPackageFieldSamplerDatabaseParams); + if ( d ) + { + for (uint32_t i = 0; i < (uint32_t)d->FieldSamplers.arraySizes[0]; i++) + { + NvParameterized::Interface* ei = d->FieldSamplers.buf[i]; + if (!ei) + { + continue; + } + if (nvidia::strcmp(ei->className(), JetFieldSamplerData::staticClassName()) != 0) + { + continue; + } + JetFieldSamplerData* ed = static_cast< JetFieldSamplerData*>(ei); + mTempNames.pushBack(ed->Name); + mTempVariantNames.pushBack(JET_FS_AUTHORING_TYPE_NAME); + } + } + } + else if (nvidia::strcmp(nameSpace, WIND_FS_AUTHORING_TYPE_NAME) == 0) + { + EffectPackageFieldSamplerDatabaseParams* d = static_cast< EffectPackageFieldSamplerDatabaseParams*>(mEffectPackageFieldSamplerDatabaseParams); + if ( d ) + { + for (uint32_t i = 0; i < (uint32_t)d->FieldSamplers.arraySizes[0]; i++) + { + NvParameterized::Interface* ei = d->FieldSamplers.buf[i]; + if (!ei) + { + continue; + } + if (nvidia::strcmp(ei->className(), WindFieldSamplerData::staticClassName()) != 0) + { + continue; + } + WindFieldSamplerData* ed = static_cast< WindFieldSamplerData*>(ei); + mTempNames.pushBack(ed->Name); + mTempVariantNames.pushBack(WIND_FS_AUTHORING_TYPE_NAME); + } + } + } + else if (nvidia::strcmp(nameSpace, NOISE_FS_AUTHORING_TYPE_NAME) == 0) + { + EffectPackageFieldSamplerDatabaseParams* d = static_cast< EffectPackageFieldSamplerDatabaseParams*>(mEffectPackageFieldSamplerDatabaseParams); + if ( d ) + { + for (uint32_t i = 0; i < (uint32_t)d->FieldSamplers.arraySizes[0]; i++) + { + NvParameterized::Interface* ei = d->FieldSamplers.buf[i]; + if (!ei) + { + continue; + } + if (nvidia::strcmp(ei->className(), NoiseFieldSamplerData::staticClassName()) != 0) + { + continue; + } + NoiseFieldSamplerData* ed = static_cast< NoiseFieldSamplerData*>(ei); + mTempNames.pushBack(ed->Name); + mTempVariantNames.pushBack(NOISE_FS_AUTHORING_TYPE_NAME); + } + } + } + else if (nvidia::strcmp(nameSpace, VORTEX_FS_AUTHORING_TYPE_NAME) == 0) + { + EffectPackageFieldSamplerDatabaseParams* d = static_cast< EffectPackageFieldSamplerDatabaseParams*>(mEffectPackageFieldSamplerDatabaseParams); + if ( d ) + { + for (uint32_t i = 0; i < (uint32_t)d->FieldSamplers.arraySizes[0]; i++) + { + NvParameterized::Interface* ei = d->FieldSamplers.buf[i]; + if (!ei) + { + continue; + } + if (nvidia::strcmp(ei->className(), VortexFieldSamplerData::staticClassName()) != 0) + { + continue; + } + VortexFieldSamplerData* ed = static_cast< VortexFieldSamplerData*>(ei); + mTempNames.pushBack(ed->Name); + mTempVariantNames.pushBack(VORTEX_FS_AUTHORING_TYPE_NAME); + } + } + } + else if (nvidia::strcmp(nameSpace, ATTRACTOR_FS_AUTHORING_TYPE_NAME) == 0) + { + EffectPackageFieldSamplerDatabaseParams* d = static_cast< EffectPackageFieldSamplerDatabaseParams*>(mEffectPackageFieldSamplerDatabaseParams); + if ( d ) + { + for (uint32_t i = 0; i < (uint32_t)d->FieldSamplers.arraySizes[0]; i++) + { + NvParameterized::Interface* ei = d->FieldSamplers.buf[i]; + if (!ei) + { + continue; + } + if (nvidia::strcmp(ei->className(), AttractorFieldSamplerData::staticClassName()) != 0) + { + continue; + } + AttractorFieldSamplerData* ed = static_cast< AttractorFieldSamplerData*>(ei); + mTempNames.pushBack(ed->Name); + mTempVariantNames.pushBack(ATTRACTOR_FS_AUTHORING_TYPE_NAME); + } + } + } + else if (nvidia::strcmp(nameSpace, TURBULENCE_FS_AUTHORING_TYPE_NAME) == 0) + { + EffectPackageFieldSamplerDatabaseParams* d = static_cast< EffectPackageFieldSamplerDatabaseParams*>(mEffectPackageFieldSamplerDatabaseParams); + if ( d ) + { + for (uint32_t i = 0; i < (uint32_t)d->FieldSamplers.arraySizes[0]; i++) + { + NvParameterized::Interface* ei = d->FieldSamplers.buf[i]; + if (!ei) + { + continue; + } + if (nvidia::strcmp(ei->className(), TurbulenceFieldSamplerData::staticClassName()) != 0) + { + continue; + } + TurbulenceFieldSamplerData* ed = static_cast< TurbulenceFieldSamplerData*>(ei); + mTempNames.pushBack(ed->Name); + mTempVariantNames.pushBack(TURBULENCE_FS_AUTHORING_TYPE_NAME); + } + } + } + else if (nvidia::strcmp(nameSpace, FORCEFIELD_AUTHORING_TYPE_NAME) == 0) + { + EffectPackageFieldSamplerDatabaseParams* d = static_cast< EffectPackageFieldSamplerDatabaseParams*>(mEffectPackageFieldSamplerDatabaseParams); + if ( d ) + { + for (uint32_t i = 0; i < (uint32_t)d->FieldSamplers.arraySizes[0]; i++) + { + NvParameterized::Interface* ei = d->FieldSamplers.buf[i]; + if (!ei) + { + continue; + } + if (nvidia::strcmp(ei->className(), ForceFieldData::staticClassName()) != 0) + { + continue; + } + ForceFieldData* ed = static_cast< ForceFieldData*>(ei); + mTempNames.pushBack(ed->Name); + mTempVariantNames.pushBack(FORCEFIELD_AUTHORING_TYPE_NAME); + } + } + } + else if (nvidia::strcmp(nameSpace, FLAME_EMITTER_AUTHORING_TYPE_NAME) == 0) + { + EffectPackageFieldSamplerDatabaseParams* d = static_cast< EffectPackageFieldSamplerDatabaseParams*>(mEffectPackageFieldSamplerDatabaseParams); + if ( d ) + { + for (uint32_t i = 0; i < (uint32_t)d->FieldSamplers.arraySizes[0]; i++) + { + NvParameterized::Interface* ei = d->FieldSamplers.buf[i]; + if (!ei) + { + continue; + } + if (nvidia::strcmp(ei->className(), FlameEmitterData::staticClassName()) != 0) + { + continue; + } + FlameEmitterData* ed = static_cast< FlameEmitterData*>(ei); + mTempNames.pushBack(ed->Name); + mTempVariantNames.pushBack(FLAME_EMITTER_AUTHORING_TYPE_NAME); + } + } + } + else + { + PX_ALWAYS_ASSERT(); + } + + nameCount = mTempNames.size(); + if (nameCount) + { + ret = &mTempNames[0]; + variants = &mTempVariantNames[0]; + } + + return ret; +} + + +bool ModuleParticlesImpl::setEffectPackageIOSDatabase(const NvParameterized::Interface* dataBase) +{ + WRITE_ZONE(); + bool ret = false; + + if (dataBase) + { + NvParameterized::Traits* traits = mSdk->getParameterizedTraits(); + const char* className = dataBase->className(); + if (nvidia::strcmp(className, basicios::BasicIOSAssetParam::staticClassName()) == 0 || nvidia::strcmp(className, pxparticleios::ParticleIosAssetParam::staticClassName()) == 0) + { + bool revised = false; + const char* itemName = dataBase->name() ? dataBase->name() : "defaultBasicIOS"; + EffectPackageIOSDatabaseParams* d = static_cast< EffectPackageIOSDatabaseParams*>(mEffectPackageIOSDatabaseParams); + if ( d ) + { + for (uint32_t i = 0; i < (uint32_t)d->ParticleSimulations.arraySizes[0]; i++) + { + NvParameterized::Interface* ei = d->ParticleSimulations.buf[i]; + if (!ei) + { + continue; + } + ParticleSimulationData* ed = static_cast< ParticleSimulationData*>(ei); + if (nvidia::stricmp(ed->Name.buf, itemName) == 0) + { + ed->IOS->copy(*dataBase); + initParticleSimulationData(ed); + revised = true; + ret = true; + break; + } + } + } + if (!revised && mEffectPackageIOSDatabaseParams) + { + int32_t arraySize = d->ParticleSimulations.arraySizes[0]; + NvParameterized::Handle handle(mEffectPackageIOSDatabaseParams); + NvParameterized::ErrorType err = handle.getParameter("ParticleSimulations"); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + err = handle.resizeArray(arraySize + 1); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + if (err == NvParameterized::ERROR_NONE) + { + NvParameterized::Interface* ei = traits->createNvParameterized(ParticleSimulationData::staticClassName()); + if (ei) + { + ParticleSimulationData* ed = static_cast< ParticleSimulationData*>(ei); + NvParameterized::Handle item(ei); + err = item.getParameter("Name"); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + item.setParamString(itemName); + ei->setName(itemName); + d->ParticleSimulations.buf[arraySize] = ei; + ed->IOS = NULL; + NvParameterized::ErrorType err = dataBase->clone(ed->IOS); + if ( err != NvParameterized::ERROR_NONE || ed->IOS == NULL ) + { + APEX_DEBUG_WARNING("Failed to clone asset."); + } + else + { + initParticleSimulationData(ed); + } + } + ret = true; + } + } + } + else if (nvidia::strcmp(dataBase->className(), EffectPackageIOSDatabaseParams::staticClassName()) == 0) + { + if (mEffectPackageIOSDatabaseParams && mEffectPackageIOSDatabaseParams != dataBase) + { + mEffectPackageIOSDatabaseParams->destroy(); + mEffectPackageIOSDatabaseParams = NULL; + } + if (mEffectPackageIOSDatabaseParams == NULL) + { + dataBase->clone(mEffectPackageIOSDatabaseParams); + if ( mEffectPackageIOSDatabaseParams == NULL) + { + APEX_DEBUG_WARNING("Failed to clone asset."); + mEffectPackageIOSDatabaseParams = traits->createNvParameterized(EffectPackageIOSDatabaseParams::staticClassName()); + } + } + + EffectPackageIOSDatabaseParams* d = static_cast< EffectPackageIOSDatabaseParams*>(mEffectPackageIOSDatabaseParams); + if ( d ) + { + if (d->ParticleSimulations.arraySizes[0] == 0) + { + NvParameterized::Handle handle(mEffectPackageIOSDatabaseParams); + NvParameterized::ErrorType err = handle.getParameter("ParticleSimulations"); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + err = handle.resizeArray(3); + + PX_ASSERT(err == NvParameterized::ERROR_NONE); + if (err == NvParameterized::ERROR_NONE) + { + // create the default BasicIOS + { + NvParameterized::Interface* ei = traits->createNvParameterized(ParticleSimulationData::staticClassName()); + d->ParticleSimulations.buf[0] = ei; + ParticleSimulationData* psd = static_cast< ParticleSimulationData*>(ei); + if (psd) + { + NvParameterized::setParamString(*ei, "Name", "defaultBasicIOS"); + psd->IOS = traits->createNvParameterized(basicios::BasicIOSAssetParam::staticClassName()); + } + } + // create the default SimpleParticleIOS + { + NvParameterized::Interface* ei = traits->createNvParameterized(ParticleSimulationData::staticClassName()); + d->ParticleSimulations.buf[1] = ei; + ParticleSimulationData* psd = static_cast< ParticleSimulationData*>(ei); + if (psd) + { + NvParameterized::setParamString(*ei, "Name", "defaultSimpleParticleIOS"); + psd->IOS = traits->createNvParameterized(pxparticleios::ParticleIosAssetParam::staticClassName()); + pxparticleios::ParticleIosAssetParam* pia = static_cast< pxparticleios::ParticleIosAssetParam*>(psd->IOS); + if (pia) + { + pia->particleType = traits->createNvParameterized(pxparticleios::SimpleParticleSystemParams::staticClassName()); + } + } + } + // create the default FluidParticleIOS + { + NvParameterized::Interface* ei = traits->createNvParameterized(ParticleSimulationData::staticClassName()); + d->ParticleSimulations.buf[2] = ei; + ParticleSimulationData* psd = static_cast< ParticleSimulationData*>(ei); + + if (psd) + { + NvParameterized::setParamString(*ei, "Name", "defaultFluidParticleIOS"); + psd->IOS = traits->createNvParameterized(pxparticleios::ParticleIosAssetParam::staticClassName()); + pxparticleios::ParticleIosAssetParam* pia = static_cast< pxparticleios::ParticleIosAssetParam*>(psd->IOS); + + if (pia) + { + pia->particleType = traits->createNvParameterized(pxparticleios::FluidParticleSystemParams::staticClassName()); + pxparticleios::FluidParticleSystemParams* fp = static_cast< pxparticleios::FluidParticleSystemParams*>(pia->particleType); + if (fp) + { + fp->restParticleDistance = 0.1f; + fp->stiffness = 8; + fp->viscosity = 5; + } + pia->maxParticleCount = 200000; + pia->particleRadius = 1; + pia->maxInjectedParticleCount = 0.1f; + pia->maxMotionDistance = 0.2; + pia->contactOffset = 0.008f; + pia->restOffset = 0.004f; + pia->gridSize = 1.5f; + pia->damping = 0; + pia->externalAcceleration = PxVec3(0, 0, 0); + pia->projectionPlaneNormal = PxVec3(0, 1, 0); + pia->projectionPlaneDistance = 0; + pia->particleMass = 0.1f; + pia->restitution = 0.15f; + pia->dynamicFriction = 0.008f; + pia->staticFriction = 0.1f; + pia->CollisionTwoway = false; + pia->CollisionWithDynamicActors = true; + pia->Enable = true; + pia->ProjectToPlane = false; + pia->PerParticleRestOffset = false; + pia->PerParticleCollisionCacheHint = false; + } + } + } + ret = true; + } + } + + Array< const char* > nameList; + for (int32_t i = 0; i < d->ParticleSimulations.arraySizes[0]; i++) + { + ParticleSimulationData* e = static_cast< ParticleSimulationData*>(d->ParticleSimulations.buf[i]); + if (e) + { + for (uint32_t j = 0; j < nameList.size(); j++) + { + if (nvidia::stricmp(nameList[j], e->Name) == 0) + { + NvParameterized::Handle handle(e); + NvParameterized::ErrorType err = handle.getParameter("Name"); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + if (err == NvParameterized::ERROR_NONE) + { + handle.setParamString(getUniqueName(nameList, e->Name)); + ret = true; + break; + } + } + } + nameList.pushBack(e->Name); + } + } + + + for (uint32_t i = 0; i < (uint32_t)d->ParticleSimulations.arraySizes[0]; i++) + { + ParticleSimulationData* ed = static_cast< ParticleSimulationData* >(d->ParticleSimulations.buf[i]); + PX_ASSERT(ed); + if (ed && initParticleSimulationData(ed)) + { + ret = true; + } + } + } + } + else + { + PX_ALWAYS_ASSERT(); // not a valid NvParameterized interface + } + if (fixupNamedReferences()) + { + ret = true; + } + } + return ret; +} + +static void initColor(iofx::ColorVsLifeCompositeModifierParamsNS::colorLifeStruct_Type& c, float lifeRemaining, float red, float green, float blue, float alpha) +{ + c.lifeRemaining = lifeRemaining; + c.color.x = red; + c.color.y = green; + c.color.z = blue; + c.color.w = alpha; +} + +static void initScale(iofx::ScaleVsLife2DModifierParamsNS::scaleLifeStruct_Type& s, float lifetime, float scalex, float scaley) +{ + s.lifeRemaining = lifetime; + s.scale.x = scalex; + s.scale.y = scaley; +} + + +bool ModuleParticlesImpl::setEffectPackageIOFXDatabase(const NvParameterized::Interface* dataBase) +{ + WRITE_ZONE(); + bool ret = false; + + if (dataBase) + { + NvParameterized::Traits* traits = mSdk->getParameterizedTraits(); + const char* className = dataBase->className(); + if (nvidia::strcmp(className, iofx::IofxAssetParameters::staticClassName()) == 0) + { + bool revised = false; + const char* itemName = dataBase->name(); + EffectPackageIOFXDatabaseParams* d = static_cast< EffectPackageIOFXDatabaseParams*>(mEffectPackageIOFXDatabaseParams); + if ( d ) + { + for (uint32_t i = 0; i < (uint32_t)d->GraphicsEffects.arraySizes[0]; i++) + { + NvParameterized::Interface* ei = d->GraphicsEffects.buf[i]; + if (!ei) + { + continue; + } + GraphicsEffectData* ed = static_cast< GraphicsEffectData*>(ei); + if (nvidia::stricmp(ed->Name.buf, itemName) == 0) + { + ed->IOFX->copy(*dataBase); + revised = true; + ret = true; + break; + } + } + } + if (!revised && mEffectPackageIOFXDatabaseParams) + { + int32_t arraySize = d->GraphicsEffects.arraySizes[0]; + NvParameterized::Handle handle(mEffectPackageIOFXDatabaseParams); + NvParameterized::ErrorType err = handle.getParameter("GraphicsEffects"); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + err = handle.resizeArray(arraySize + 1); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + if (err == NvParameterized::ERROR_NONE) + { + NvParameterized::Interface* ei = traits->createNvParameterized(GraphicsEffectData::staticClassName()); + if (ei) + { + GraphicsEffectData* ed = static_cast< GraphicsEffectData*>(ei); + NvParameterized::Handle item(ei); + err = item.getParameter("Name"); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + item.setParamString(itemName); + ei->setName(itemName); + d->GraphicsEffects.buf[arraySize] = ei; + ed->IOFX = NULL; + dataBase->clone(ed->IOFX); + if ( ed->IOFX == NULL ) + { + APEX_DEBUG_WARNING("Failed to clone asset."); + } + } + ret = true; + } + } + } + else if (nvidia::strcmp(dataBase->className(), EffectPackageIOFXDatabaseParams::staticClassName()) == 0) + { + if (mEffectPackageIOFXDatabaseParams && mEffectPackageIOFXDatabaseParams != dataBase) + { + mEffectPackageIOFXDatabaseParams->destroy(); + mEffectPackageIOFXDatabaseParams = NULL; + } + if (mEffectPackageIOFXDatabaseParams == NULL) + { + dataBase->clone(mEffectPackageIOFXDatabaseParams); + if ( mEffectPackageIOFXDatabaseParams == NULL ) + { + APEX_DEBUG_WARNING("Failed to clone asset."); + mEffectPackageIOFXDatabaseParams = traits->createNvParameterized(EffectPackageIOFXDatabaseParams::staticClassName()); + } + } + EffectPackageIOFXDatabaseParams* d = static_cast< EffectPackageIOFXDatabaseParams*>(mEffectPackageIOFXDatabaseParams); + if ( d ) + { + if (d->GraphicsEffects.arraySizes[0] == 0) + { + NvParameterized::Handle handle(mEffectPackageIOFXDatabaseParams); + NvParameterized::ErrorType err = handle.getParameter("GraphicsEffects"); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + err = handle.resizeArray(2); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + if (err == NvParameterized::ERROR_NONE) + { + { + NvParameterized::Interface* ei = traits->createNvParameterized(GraphicsEffectData::staticClassName()); + d->GraphicsEffects.buf[0] = ei; + if (ei) + { + GraphicsEffectData* ged = static_cast< GraphicsEffectData*>(ei); + if (ged) + { + NvParameterized::setParamString(*ei, "Name", "defaultSpriteIOFX"); + ged->IOFX = traits->createNvParameterized(iofx::IofxAssetParameters::staticClassName()); + iofx::IofxAssetParameters* iofx = static_cast< iofx::IofxAssetParameters*>(ged->IOFX); + if (iofx) + { + iofx->iofxType = traits->createNvParameterized(iofx::SpriteIofxParameters::staticClassName()); + iofx->renderOutput.useFloat4Color = true; + } + } + } + } + { + NvParameterized::Interface* ei = traits->createNvParameterized(GraphicsEffectData::staticClassName()); + d->GraphicsEffects.buf[1] = ei; + if (ei) + { + GraphicsEffectData* ged = static_cast< GraphicsEffectData*>(ei); + if (ged) + { + NvParameterized::setParamString(*ei, "Name", "defaultMeshIOFX"); + ged->IOFX = traits->createNvParameterized(iofx::IofxAssetParameters::staticClassName()); + iofx::IofxAssetParameters* iofx = static_cast< iofx::IofxAssetParameters*>(ged->IOFX); + if (iofx) + { + iofx->iofxType = traits->createNvParameterized(iofx::MeshIofxParameters::staticClassName()); + iofx->renderOutput.useFloat4Color = true; + } + } + } + } + + ret = true; + } + } + + + Array< const char* > nameList; + for (int32_t i = 0; i < d->GraphicsEffects.arraySizes[0]; i++) + { + GraphicsEffectData* e = static_cast< GraphicsEffectData*>(d->GraphicsEffects.buf[i]); + if (e) + { + for (uint32_t j = 0; j < nameList.size(); j++) + { + if (nvidia::stricmp(nameList[j], e->Name) == 0) + { + NvParameterized::Handle handle(e); + NvParameterized::ErrorType err = handle.getParameter("Name"); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + if (err == NvParameterized::ERROR_NONE) + { + handle.setParamString(getUniqueName(nameList, e->Name)); + ret = true; + break; + } + } + } + nameList.pushBack(e->Name); + } + } + + + for (uint32_t i = 0; i < (uint32_t)d->GraphicsEffects.arraySizes[0]; i++) + { + GraphicsEffectData* ed = static_cast< GraphicsEffectData*>(d->GraphicsEffects.buf[i]); + // first, see if it's assigned to a sprite IOFX without valid default values... + { + iofx::IofxAssetParameters* ae = static_cast< iofx::IofxAssetParameters*>(ed->IOFX); + if (ae) + { + if (nvidia::strcmp(ae->iofxType->className(), iofx::SpriteIofxParameters::staticClassName()) == 0) + { + iofx::SpriteIofxParameters* iofxP = static_cast< iofx::SpriteIofxParameters*>(ae->iofxType); + if (iofxP->spawnModifierList.arraySizes[0] == 0 && iofxP->continuousModifierList.arraySizes[0] == 0) + { + ed->IOFX->destroy(); + ed->IOFX = NULL; + ret = true; + } + } + } + } + + if (ed->IOFX == NULL) + { + ed->IOFX = traits->createNvParameterized(iofx::IofxAssetParameters::staticClassName()); + iofx::IofxAssetParameters* ae = static_cast< iofx::IofxAssetParameters*>(ed->IOFX); + if (ae) + { + ae->renderOutput.useFloat4Color = true; + NvParameterized::Interface* iofx = traits->createNvParameterized(iofx::SpriteIofxParameters::staticClassName()); + ae->iofxType = iofx; + iofx::SpriteIofxParameters* iofxP = static_cast< iofx::SpriteIofxParameters*>(iofx); + if (iofxP) + { + { + NvParameterized::Handle handle(iofx); + NvParameterized::ErrorType err = handle.getParameter("spriteMaterialName"); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + if (err == NvParameterized::ERROR_NONE) + { + err = handle.initParamRef(APEX_MATERIALS_NAME_SPACE, true); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + if (err == NvParameterized::ERROR_NONE) + { + iofxP->spriteMaterialName->setName("defaultGraphicsMaterial"); + } + } + } + + { + NvParameterized::Handle handle(iofx); + NvParameterized::ErrorType err = handle.getParameter("spawnModifierList"); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + err = handle.resizeArray(4); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + if (err == NvParameterized::ERROR_NONE) + { + iofxP->spawnModifierList.buf[0] = traits->createNvParameterized(iofx::InitialColorModifierParams::staticClassName()); + iofxP->spawnModifierList.buf[1] = traits->createNvParameterized(iofx::RandomRotationModifierParams::staticClassName()); + iofxP->spawnModifierList.buf[2] = traits->createNvParameterized(iofx::RandomSubtextureModifierParams::staticClassName()); + iofxP->spawnModifierList.buf[3] = traits->createNvParameterized(iofx::RandomScaleModifierParams::staticClassName()); + } + } + + { + NvParameterized::Handle handle(iofx); + NvParameterized::ErrorType err = handle.getParameter("continuousModifierList"); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + err = handle.resizeArray(1); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + if (err == NvParameterized::ERROR_NONE) + { + iofxP->continuousModifierList.buf[0] = traits->createNvParameterized(iofx::ViewDirectionSortingModifierParams::staticClassName()); + } + } + } + } + ret = true; + } + if (ed->IOFX) + { + iofx::IofxAssetParameters* ae = static_cast< iofx::IofxAssetParameters*>(ed->IOFX); + if (ae->iofxType) + { + ae->renderOutput.useFloat4Color = true; + const char* c = ae->iofxType->className(); + if (c && nvidia::strcmp(c, "MeshIofxParameters") == 0) + { + iofx::MeshIofxParameters* m = static_cast< iofx::MeshIofxParameters*>(ae->iofxType); + if (m->renderMeshList.arraySizes[0] == 0) + { + ret = true; + NvParameterized::Handle handle(m); + NvParameterized::ErrorType err = handle.getParameter("renderMeshList"); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + err = handle.resizeArray(1); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + if (err == NvParameterized::ERROR_NONE) + { + iofx::MeshIofxParametersNS::meshProperties_Type& t = m->renderMeshList.buf[0]; + t.weight = 1; + NvParameterized::Handle elementHandle(m); + err = handle.getChildHandle(0, elementHandle); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + NvParameterized::Handle item(*elementHandle.getInterface()); + NvParameterized::ErrorType err = elementHandle.getChildHandle(elementHandle.getInterface(), "meshAssetName", item); + PX_ASSERT(err == NvParameterized:: ERROR_NONE); + if (err == NvParameterized::ERROR_NONE) + { + err = item.initParamRef(APEX_OPAQUE_MESH_NAME_SPACE,true); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + if (err == NvParameterized::ERROR_NONE) + { + t.meshAssetName->setName("SampleMesh.apx"); + } + } + } + // initialize the spawn modifier list + { + NvParameterized::Handle handle(m); + NvParameterized::ErrorType err = handle.getParameter("spawnModifierList"); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + err = handle.resizeArray(2); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + if (err == NvParameterized::ERROR_NONE) + { + m->spawnModifierList.buf[0] = traits->createNvParameterized(iofx::SimpleScaleModifierParams::staticClassName()); + iofx::SimpleScaleModifierParams* ss = static_cast< iofx::SimpleScaleModifierParams*>(m->spawnModifierList.buf[0]); + if (ss) + { + ss->scaleFactor = PxVec3(1, 1, 1); + m->spawnModifierList.buf[1] = traits->createNvParameterized(iofx::RotationModifierParams::staticClassName()); + NvParameterized::setParamEnum(*m->spawnModifierList.buf[1], "rollType", "SPHERICAL"); + } + } + } + // initialize the continuous modifier list + { + NvParameterized::Handle handle(m); + NvParameterized::ErrorType err = handle.getParameter("continuousModifierList"); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + err = handle.resizeArray(2); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + if (err == NvParameterized::ERROR_NONE) + { + // init RotationModifierParams + { + m->continuousModifierList.buf[0] = traits->createNvParameterized(iofx::RotationModifierParams::staticClassName()); + if (m->continuousModifierList.buf[0]) + { + NvParameterized::setParamEnum(*m->continuousModifierList.buf[0], "rollType", "SPHERICAL"); + iofx::RotationModifierParams* rmp = static_cast< iofx::RotationModifierParams*>(m->continuousModifierList.buf[0]); + rmp->maxRotationRatePerSec = 0; + rmp->maxSettleRatePerSec = 1; + rmp->collisionRotationMultiplier = 1; + rmp->inAirRotationMultiplier = 1; + } + } + { + m->continuousModifierList.buf[1] = traits->createNvParameterized(iofx::ScaleVsLife3DModifierParams::staticClassName()); + if (m->continuousModifierList.buf[1]) + { + NvParameterized::Handle h(m->continuousModifierList.buf[1]); + err = h.getParameter("controlPoints"); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + err = h.resizeArray(3); + iofx::ScaleVsLife3DModifierParams& svl = *(static_cast< iofx::ScaleVsLife3DModifierParams*>(m->continuousModifierList.buf[1])); + svl.controlPoints.buf[0].lifeRemaining = 0; + svl.controlPoints.buf[0].scale = PxVec3(0, 0, 0); + + svl.controlPoints.buf[1].lifeRemaining = 0.5f; + svl.controlPoints.buf[1].scale = PxVec3(1, 1, 1); + + svl.controlPoints.buf[2].lifeRemaining = 1; + svl.controlPoints.buf[2].scale = PxVec3(0, 0, 0); + + } + } + } + + } + } + } + } + } + } + } + } + else + { + PX_ALWAYS_ASSERT(); + } + } + + + return ret; + +} + +bool ModuleParticlesImpl::setEffectPackageEmitterDatabase(const NvParameterized::Interface* dataBase) +{ + WRITE_ZONE(); + bool ret = false; + + if (dataBase) + { + NvParameterized::Traits* traits = mSdk->getParameterizedTraits(); + const char* className = dataBase->className(); + if (nvidia::strcmp(className, emitter::ApexEmitterAssetParameters::staticClassName()) == 0) + { + bool revised = false; + const char* itemName = dataBase->name(); + EffectPackageEmitterDatabaseParams* d = static_cast< EffectPackageEmitterDatabaseParams*>(mEffectPackageEmitterDatabaseParams); + if ( d ) + { + for (uint32_t i = 0; i < (uint32_t)d->Emitters.arraySizes[0]; i++) + { + NvParameterized::Interface* ei = d->Emitters.buf[i]; + if (!ei) + { + continue; + } + EmitterData* ed = static_cast< EmitterData*>(ei); + if (nvidia::stricmp(ed->Name.buf, itemName) == 0) + { + ed->Emitter->copy(*dataBase); + revised = true; + ret = true; + break; + } + } + } + if (!revised && mEffectPackageEmitterDatabaseParams) + { + int32_t arraySize = d->Emitters.arraySizes[0]; + NvParameterized::Handle handle(mEffectPackageEmitterDatabaseParams); + NvParameterized::ErrorType err = handle.getParameter("Emitters"); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + err = handle.resizeArray(arraySize + 1); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + if (err == NvParameterized::ERROR_NONE) + { + NvParameterized::Interface* ei = traits->createNvParameterized(EmitterData::staticClassName()); + if (ei) + { + EmitterData* ed = static_cast< EmitterData*>(ei); + NvParameterized::Handle item(ei); + err = item.getParameter("Name"); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + item.setParamString(itemName); + ei->setName(itemName); + d->Emitters.buf[arraySize] = ei; + ed->Emitter = NULL; + dataBase->clone(ed->Emitter); + if ( ed->Emitter == NULL ) + { + APEX_DEBUG_WARNING("Failed to clone asset."); + } + } + ret = true; + } + } + } + else if (nvidia::strcmp(dataBase->className(), EffectPackageEmitterDatabaseParams::staticClassName()) == 0) + { + if (mEffectPackageEmitterDatabaseParams && mEffectPackageEmitterDatabaseParams != dataBase) + { + mEffectPackageEmitterDatabaseParams->destroy(); + mEffectPackageEmitterDatabaseParams = NULL; + } + if (mEffectPackageEmitterDatabaseParams == NULL) + { + dataBase->clone(mEffectPackageEmitterDatabaseParams); + if ( mEffectPackageEmitterDatabaseParams == NULL ) + { + APEX_DEBUG_WARNING("Failed to clone asset."); + mEffectPackageEmitterDatabaseParams = traits->createNvParameterized(EffectPackageEmitterDatabaseParams::staticClassName()); + } + } + + EffectPackageEmitterDatabaseParams* d = static_cast< EffectPackageEmitterDatabaseParams*>(mEffectPackageEmitterDatabaseParams); + if ( d ) + { + if (d->Emitters.arraySizes[0] == 0) + { + NvParameterized::Handle handle(mEffectPackageEmitterDatabaseParams); + NvParameterized::ErrorType err = handle.getParameter("Emitters"); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + err = handle.resizeArray(1); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + if (err == NvParameterized::ERROR_NONE) + { + NvParameterized::Interface* ei = traits->createNvParameterized(EmitterData::staticClassName()); + d->Emitters.buf[0] = ei; + ret = true; + } + } + + + Array< const char* > nameList; + for (int32_t i = 0; i < d->Emitters.arraySizes[0]; i++) + { + EmitterData* e = static_cast< EmitterData*>(d->Emitters.buf[i]); + if (e) + { + for (uint32_t j = 0; j < nameList.size(); j++) + { + if (nvidia::stricmp(nameList[j], e->Name) == 0) + { + NvParameterized::Handle handle(e); + NvParameterized::ErrorType err = handle.getParameter("Name"); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + if (err == NvParameterized::ERROR_NONE) + { + handle.setParamString(getUniqueName(nameList, e->Name)); + ret = true; + break; + } + } + } + nameList.pushBack(e->Name); + } + } + + for (uint32_t i = 0; i < (uint32_t)d->Emitters.arraySizes[0]; i++) + { + EmitterData* ed = static_cast< EmitterData*>(d->Emitters.buf[i]); + if (ed->Emitter == NULL) + { + ed->Emitter = traits->createNvParameterized(emitter::ApexEmitterAssetParameters::staticClassName()); + // Modify "static_cast<emitter::ApexEmitterAssetParameters*>(ed->Emitter)" if default ApexEmitterAssetParameters initialisation is insufficiently + ret = true; + } + if (ed->Emitter) + { + emitter::ApexEmitterAssetParameters* ae = static_cast< emitter::ApexEmitterAssetParameters*>(ed->Emitter); + NvParameterized::Handle handle(ed->Emitter); + NvParameterized::ErrorType err = ed->Emitter->getParameterHandle("iofxAssetName", handle); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + if (err == NvParameterized::ERROR_NONE) + { + NvParameterized::Interface* val = NULL; + err = handle.getParamRef(val); + if (val == NULL) + { + err = handle.initParamRef(IOFX_AUTHORING_TYPE_NAME,true); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + if (err == NvParameterized::ERROR_NONE) + { + char scratch[512]; + sprintf_s(scratch, 512, "defaultSpriteIOFX"); + ae->iofxAssetName->setName(scratch); + } + } + } + } + if (ed->Emitter) + { + emitter::ApexEmitterAssetParameters* ae = static_cast< emitter::ApexEmitterAssetParameters*>(ed->Emitter); + NvParameterized::Handle handle(ed->Emitter); + NvParameterized::ErrorType err = ed->Emitter->getParameterHandle("iosAssetName", handle); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + if (err == NvParameterized::ERROR_NONE) + { + NvParameterized::Interface* val = NULL; + err = handle.getParamRef(val); + if (val == NULL) + { + err = handle.initParamRef(BASIC_IOS_AUTHORING_TYPE_NAME,true); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + if (err == NvParameterized::ERROR_NONE) + { + char scratch[512]; + sprintf_s(scratch, 512, "defaultBasicIOS"); + ae->iosAssetName->setName(scratch); + } + } + } + } + } + } + } + else + { + PX_ALWAYS_ASSERT(); // invalid NvParameterized::Interface passed in + } + } + + + return ret; +} + +enum FieldSamplerType +{ + FST_NONE, + FST_FORCE_FIELD, + FST_HEAT_SOURCE, + FST_SUBSTANCE_SOURCE, + FST_JET, + FST_ATTRACTOR, + FST_TURBULENCE, + FST_NOISE, + FST_VORTEX, + FST_WIND, + FST_VELOCITY_SOURCE, + FST_FLAME_EMITTER, + FST_LAST +}; + +static FieldSamplerType getFieldSamplerType(const NvParameterized::Interface* iface) +{ + FieldSamplerType ret = FST_NONE; + + if (iface) + { + const char* className = iface->className(); + if (nvidia::strcmp(className, forcefield::ForceFieldAssetParams::staticClassName()) == 0) + { + ret = FST_FORCE_FIELD; + } + else if (nvidia::strcmp(className, turbulencefs::HeatSourceAssetParams::staticClassName()) == 0) + { + ret = FST_HEAT_SOURCE; + } + else if (nvidia::strcmp(className, turbulencefs::SubstanceSourceAssetParams::staticClassName()) == 0) + { + ret = FST_SUBSTANCE_SOURCE; + } + else if (nvidia::strcmp(className, turbulencefs::VelocitySourceAssetParams::staticClassName()) == 0) + { + ret = FST_VELOCITY_SOURCE; + } + else if (nvidia::strcmp(className, basicfs::JetFSAssetParams::staticClassName()) == 0) + { + ret = FST_JET; + } + else if (nvidia::strcmp(className, basicfs::WindFSAssetParams::staticClassName()) == 0) + { + ret = FST_WIND; + } + else if (nvidia::strcmp(className, basicfs::NoiseFSAssetParams::staticClassName()) == 0) + { + ret = FST_NOISE; + } + else if (nvidia::strcmp(className, basicfs::VortexFSAssetParams::staticClassName()) == 0) + { + ret = FST_VORTEX; + } + else if (nvidia::strcmp(className, basicfs::AttractorFSAssetParams::staticClassName()) == 0) + { + ret = FST_ATTRACTOR; + } + else if (nvidia::strcmp(className, turbulencefs::TurbulenceFSAssetParams::staticClassName()) == 0) + { + ret = FST_TURBULENCE; + } + else if (nvidia::strcmp(className, turbulencefs::FlameEmitterAssetParams::staticClassName()) == 0) + { + ret = FST_FLAME_EMITTER; + } + else if (nvidia::strcmp(className, particles::ForceFieldData::staticClassName()) == 0) + { + ret = FST_FORCE_FIELD; + } + else if (nvidia::strcmp(className, particles::HeatSourceData::staticClassName()) == 0) + { + ret = FST_HEAT_SOURCE; + } + else if (nvidia::strcmp(className, particles::SubstanceSourceData::staticClassName()) == 0) + { + ret = FST_SUBSTANCE_SOURCE; + } + else if (nvidia::strcmp(className, particles::VelocitySourceData::staticClassName()) == 0) + { + ret = FST_VELOCITY_SOURCE; + } + else if (nvidia::strcmp(className, particles::AttractorFieldSamplerData::staticClassName()) == 0) + { + ret = FST_ATTRACTOR; + } + else if (nvidia::strcmp(className, particles::JetFieldSamplerData::staticClassName()) == 0) + { + ret = FST_JET; + } + else if (nvidia::strcmp(className, particles::WindFieldSamplerData::staticClassName()) == 0) + { + ret = FST_WIND; + } + else if (nvidia::strcmp(className, particles::NoiseFieldSamplerData::staticClassName()) == 0) + { + ret = FST_NOISE; + } + else if (nvidia::strcmp(className, particles::TurbulenceFieldSamplerData::staticClassName()) == 0) + { + ret = FST_TURBULENCE; + } + else if (nvidia::strcmp(className, particles::VortexFieldSamplerData::staticClassName()) == 0) + { + ret = FST_VORTEX; + } + else if (nvidia::strcmp(className, particles::FlameEmitterData::staticClassName()) == 0) + { + ret = FST_FLAME_EMITTER; + } + } + + return ret; +} + +static NvParameterized::Interface* getFieldSamplerData(FieldSamplerType fst, NvParameterized::Traits* traits, const NvParameterized::Interface* dataBase) +{ + NvParameterized::Interface* ret = NULL; + + const char* itemName = dataBase->name(); + NvParameterized::ErrorType err; + + switch (fst) + { + case FST_FORCE_FIELD: + { + NvParameterized::Interface* ei = traits->createNvParameterized(ForceFieldData::staticClassName()); + ForceFieldData* ed = static_cast< ForceFieldData*>(ei); + if (ed) + { + NvParameterized::Handle item(ei); + err = item.getParameter("Name"); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + item.setParamString(itemName); + ei->setName(itemName); + ret = ei; + ed->ForceField = NULL; + dataBase->clone(ed->ForceField); + if ( ed->ForceField == NULL ) + { + APEX_DEBUG_WARNING("Failed to clone asset."); + } + } + } + break; + case FST_HEAT_SOURCE: + { + NvParameterized::Interface* ei = traits->createNvParameterized(HeatSourceData::staticClassName()); + HeatSourceData* ed = static_cast< HeatSourceData*>(ei); + if (ed) + { + NvParameterized::Handle item(ei); + err = item.getParameter("Name"); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + item.setParamString(itemName); + ei->setName(itemName); + ret = ei; + ed->HeatSource = NULL; + dataBase->clone(ed->HeatSource); + if ( ed->HeatSource == NULL ) + { + APEX_DEBUG_WARNING("Failed to clone asset."); + } + } + } + break; + case FST_SUBSTANCE_SOURCE: + { + NvParameterized::Interface* ei = traits->createNvParameterized(SubstanceSourceData::staticClassName()); + SubstanceSourceData* ed = static_cast< SubstanceSourceData*>(ei); + if (ed) + { + NvParameterized::Handle item(ei); + err = item.getParameter("Name"); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + item.setParamString(itemName); + ei->setName(itemName); + ret = ei; + ed->SubstanceSource = NULL; + dataBase->clone(ed->SubstanceSource); + if ( ed->SubstanceSource == NULL ) + { + APEX_DEBUG_WARNING("Failed to clone asset."); + } + } + } + break; + case FST_VELOCITY_SOURCE: + { + NvParameterized::Interface* ei = traits->createNvParameterized(VelocitySourceData::staticClassName()); + VelocitySourceData* ed = static_cast< VelocitySourceData*>(ei); + if (ed) + { + NvParameterized::Handle item(ei); + err = item.getParameter("Name"); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + item.setParamString(itemName); + ei->setName(itemName); + ret = ei; + ed->VelocitySource = NULL; + dataBase->clone(ed->VelocitySource); + if ( ed->VelocitySource == NULL ) + { + APEX_DEBUG_WARNING("Failed to clone asset."); + } + } + } + break; + case FST_ATTRACTOR: + { + NvParameterized::Interface* ei = traits->createNvParameterized(AttractorFieldSamplerData::staticClassName()); + AttractorFieldSamplerData* ed = static_cast< AttractorFieldSamplerData*>(ei); + if (ed) + { + NvParameterized::Handle item(ei); + err = item.getParameter("Name"); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + item.setParamString(itemName); + ei->setName(itemName); + ret = ei; + ed->AttractorFieldSampler = NULL; + dataBase->clone(ed->AttractorFieldSampler); + if ( ed->AttractorFieldSampler == NULL ) + { + APEX_DEBUG_WARNING("Failed to clone asset."); + } + } + } + break; + case FST_VORTEX: + { + NvParameterized::Interface* ei = traits->createNvParameterized(VortexFieldSamplerData::staticClassName()); + VortexFieldSamplerData* ed = static_cast< VortexFieldSamplerData*>(ei); + if (ed) + { + NvParameterized::Handle item(ei); + err = item.getParameter("Name"); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + item.setParamString(itemName); + ei->setName(itemName); + ret = ei; + ed->VortexFieldSampler = NULL; + dataBase->clone(ed->VortexFieldSampler); + if ( ed->VortexFieldSampler == NULL ) + { + APEX_DEBUG_WARNING("Failed to clone asset."); + } + } + } + break; + case FST_NOISE: + { + NvParameterized::Interface* ei = traits->createNvParameterized(NoiseFieldSamplerData::staticClassName()); + NoiseFieldSamplerData* ed = static_cast< NoiseFieldSamplerData*>(ei); + if (ed) + { + NvParameterized::Handle item(ei); + err = item.getParameter("Name"); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + item.setParamString(itemName); + ei->setName(itemName); + ret = ei; + ed->NoiseFieldSampler = NULL; + dataBase->clone(ed->NoiseFieldSampler); + if ( ed->NoiseFieldSampler == NULL ) + { + APEX_DEBUG_WARNING("Failed to clone asset."); + } + } + } + break; + case FST_JET: + { + NvParameterized::Interface* ei = traits->createNvParameterized(JetFieldSamplerData::staticClassName()); + JetFieldSamplerData* ed = static_cast< JetFieldSamplerData*>(ei); + if (ed) + { + NvParameterized::Handle item(ei); + err = item.getParameter("Name"); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + item.setParamString(itemName); + ei->setName(itemName); + ret = ei; + ed->JetFieldSampler = NULL; + dataBase->clone(ed->JetFieldSampler); + if ( ed->JetFieldSampler == NULL ) + { + APEX_DEBUG_WARNING("Failed to clone asset."); + } + } + } + break; + case FST_WIND: + { + NvParameterized::Interface* ei = traits->createNvParameterized(WindFieldSamplerData::staticClassName()); + WindFieldSamplerData* ed = static_cast< WindFieldSamplerData*>(ei); + if (ed) + { + NvParameterized::Handle item(ei); + err = item.getParameter("Name"); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + item.setParamString(itemName); + ei->setName(itemName); + ret = ei; + ed->WindFieldSampler = NULL; + dataBase->clone(ed->WindFieldSampler); + if ( ed->WindFieldSampler == NULL ) + { + APEX_DEBUG_WARNING("Failed to clone asset."); + } + } + } + break; + case FST_TURBULENCE: + { + NvParameterized::Interface* ei = traits->createNvParameterized(TurbulenceFieldSamplerData::staticClassName()); + TurbulenceFieldSamplerData* ed = static_cast< TurbulenceFieldSamplerData*>(ei); + if (ed) + { + NvParameterized::Handle item(ei); + err = item.getParameter("Name"); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + item.setParamString(itemName); + ei->setName(itemName); + ret = ei; + ed->TurbulenceFieldSampler = NULL; + dataBase->clone(ed->TurbulenceFieldSampler); + if ( ed->TurbulenceFieldSampler == NULL ) + { + APEX_DEBUG_WARNING("Failed to clone asset."); + } + } + } + break; + case FST_FLAME_EMITTER: + { + NvParameterized::Interface* ei = traits->createNvParameterized(FlameEmitterData::staticClassName()); + FlameEmitterData* ed = static_cast< FlameEmitterData*>(ei); + if (ed) + { + NvParameterized::Handle item(ei); + err = item.getParameter("Name"); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + item.setParamString(itemName); + ei->setName(itemName); + ret = ei; + ed->FlameEmitter = NULL; + dataBase->clone(ed->FlameEmitter); + if ( ed->FlameEmitter == NULL ) + { + APEX_DEBUG_WARNING("Failed to clone asset."); + } + } + } + break; + + default: + PX_ALWAYS_ASSERT(); // not yet implemented! + break; + } + + return ret; +} + +bool ModuleParticlesImpl::fixFieldSamplerCollisionFilterNames(NvParameterized::Interface *iface) +{ + bool ret = false; + + FieldSamplerType fst = getFieldSamplerType(iface); + NvParameterized::Interface *asset = NULL; + + const char *filterName=NULL; + + switch (fst) + { + case FST_FORCE_FIELD: + { + ForceFieldData* ed = static_cast< ForceFieldData*>(iface); + asset = ed->ForceField; + filterName = "ForceFieldFS=all"; + } + break; + case FST_HEAT_SOURCE: + { + HeatSourceData *ed = static_cast< HeatSourceData *>(iface); + asset = ed->HeatSource; + filterName = "HeatSource=all"; + } + break; + case FST_SUBSTANCE_SOURCE: + { + SubstanceSourceData *ed = static_cast< SubstanceSourceData *>(iface); + asset = ed->SubstanceSource; + filterName = "SubstanceSource=all"; + } + break; + case FST_VELOCITY_SOURCE: + { + VelocitySourceData *ed = static_cast< VelocitySourceData *>(iface); + asset = ed->VelocitySource; + filterName = "VelocitySource=all"; + } + break; + case FST_ATTRACTOR: + { + AttractorFieldSamplerData* ed = static_cast< AttractorFieldSamplerData*>(iface); + asset = ed->AttractorFieldSampler; + filterName = "AttractorFS=all"; + } + break; + case FST_VORTEX: + { + VortexFieldSamplerData* ed = static_cast< VortexFieldSamplerData*>(iface); + asset = ed->VortexFieldSampler; + filterName = "VortexFS=all"; + } + break; + case FST_NOISE: + { + NoiseFieldSamplerData* ed = static_cast< NoiseFieldSamplerData*>(iface); + asset = ed->NoiseFieldSampler; + filterName = "NoiseFS=all"; + } + break; + case FST_JET: + { + JetFieldSamplerData* ed = static_cast< JetFieldSamplerData*>(iface); + asset = ed->JetFieldSampler; + filterName = "JetFS=all"; + } + break; + case FST_WIND: + { + WindFieldSamplerData* ed = static_cast< WindFieldSamplerData*>(iface); + asset = ed->WindFieldSampler; + filterName = "WindFS=all"; + } + break; + case FST_TURBULENCE: + { + TurbulenceFieldSamplerData* ed = static_cast< TurbulenceFieldSamplerData*>(iface); + asset = ed->TurbulenceFieldSampler; + filterName = "TurbulenceFS=all"; + } + break; + case FST_FLAME_EMITTER: + { + FlameEmitterData *ed = static_cast< FlameEmitterData *>(iface); + asset = ed->FlameEmitter; + filterName = "FlameEmitter=all"; + } + break; + default: + //PX_ASSERT(0); + break; + } + if ( asset && filterName ) + { + const char *fieldBoundaryFilterDataName=NULL; + const char *fieldSamplerFilterDataName=NULL; + bool ok = NvParameterized::getParamString(*asset,"fieldSamplerFilterDataName",fieldSamplerFilterDataName); + PX_ASSERT( ok ); + ok = NvParameterized::getParamString(*asset,"fieldBoundaryFilterDataName",fieldBoundaryFilterDataName); + if ( ok ) + { + if ( fieldBoundaryFilterDataName == NULL || fieldBoundaryFilterDataName[0] == 0 || nvidia::strcmp(fieldBoundaryFilterDataName,"defaultFieldBoundaryFilterDataName") == 0 ) + { + NvParameterized::setParamString(*asset,"fieldBoundaryFilterDataName",filterName); + ret = true; + } + } + if ( fieldSamplerFilterDataName == NULL || fieldSamplerFilterDataName[0] == 0 || nvidia::strcmp(fieldSamplerFilterDataName,"defaultFieldSamplerFilterDataName") == 0 ) + { + NvParameterized::setParamString(*asset,"fieldSamplerFilterDataName",filterName); + ret = true; + } + if ( fst == FST_TURBULENCE ) + { + const char *collisionFilterDataName=NULL; + bool ok = NvParameterized::getParamString(*asset,"collisionFilterDataName",collisionFilterDataName); + PX_UNUSED( ok ); + PX_ASSERT( ok ); + if ( collisionFilterDataName == NULL || collisionFilterDataName[0] == 0 || nvidia::strcmp(collisionFilterDataName,"defaultTurbulenceCollisionFilterDataName") == 0 ) + { + NvParameterized::setParamString(*asset,"collisionFilterDataName",filterName); + ret = true; + } + } + } + return ret; +} + +static void setNamedReference(NvParameterized::Interface* parentInterface, const char* parentName, const char* authoringTypeName) +{ + NvParameterized::Handle handle(parentInterface); + NvParameterized::ErrorType err = parentInterface->getParameterHandle(parentName, handle); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + if (err == NvParameterized::ERROR_NONE) + { + err = handle.initParamRef(authoringTypeName,true); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + } +} + + + +bool ModuleParticlesImpl::setEffectPackageFieldSamplerDatabase(const NvParameterized::Interface* dataBase) +{ + WRITE_ZONE(); + bool ret = false; + + if (dataBase) + { + NvParameterized::Traits* traits = mSdk->getParameterizedTraits(); + FieldSamplerType fst = getFieldSamplerType(dataBase); + if (fst != FST_NONE) + { + bool revised = false; + const char* itemName = dataBase->name(); + EffectPackageFieldSamplerDatabaseParams* d = static_cast< EffectPackageFieldSamplerDatabaseParams*>(mEffectPackageFieldSamplerDatabaseParams); + if ( d ) + { + for (uint32_t i = 0; i < (uint32_t)d->FieldSamplers.arraySizes[0]; i++) + { + NvParameterized::Interface* ei = d->FieldSamplers.buf[i]; + if (!ei) + { + continue; + } + const char* dataName; + NvParameterized::getParamString(*ei, "Name", dataName); + if (nvidia::stricmp(dataName, itemName) == 0) + { + ei->destroy(); + d->FieldSamplers.buf[i] = getFieldSamplerData(fst, traits, dataBase); + fixFieldSamplerCollisionFilterNames( d->FieldSamplers.buf[i] ); + revised = true; + ret = true; + break; + } + } + } + if (!revised && mEffectPackageFieldSamplerDatabaseParams) + { + int32_t arraySize = d->FieldSamplers.arraySizes[0]; + NvParameterized::Handle handle(mEffectPackageFieldSamplerDatabaseParams); + NvParameterized::ErrorType err = handle.getParameter("FieldSamplers"); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + err = handle.resizeArray(arraySize + 1); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + if (err == NvParameterized::ERROR_NONE) + { + d->FieldSamplers.buf[arraySize] = getFieldSamplerData(fst, traits, dataBase); + fixFieldSamplerCollisionFilterNames( d->FieldSamplers.buf[arraySize] ); + } + } + } + else if (nvidia::strcmp(dataBase->className(), EffectPackageFieldSamplerDatabaseParams::staticClassName()) == 0) + { + if (mEffectPackageFieldSamplerDatabaseParams && mEffectPackageFieldSamplerDatabaseParams != dataBase) + { + mEffectPackageFieldSamplerDatabaseParams->destroy(); + mEffectPackageFieldSamplerDatabaseParams = NULL; + } + + if (mEffectPackageFieldSamplerDatabaseParams == NULL) + { + dataBase->clone(mEffectPackageFieldSamplerDatabaseParams); + if ( mEffectPackageFieldSamplerDatabaseParams == NULL ) + { + APEX_DEBUG_WARNING("Failed to clone asset."); + mEffectPackageFieldSamplerDatabaseParams = traits->createNvParameterized(EffectPackageFieldSamplerDatabaseParams::staticClassName()); + } + } + + EffectPackageFieldSamplerDatabaseParams* d = static_cast< EffectPackageFieldSamplerDatabaseParams*>(mEffectPackageFieldSamplerDatabaseParams); + if ( d ) + { + if (d->FieldSamplers.arraySizes[0] == 0) + { + NvParameterized::Handle handle(mEffectPackageFieldSamplerDatabaseParams); + NvParameterized::ErrorType err = handle.getParameter("FieldSamplers"); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + err = handle.resizeArray(11); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + NvParameterized::Interface* ei; + if (err == NvParameterized::ERROR_NONE) + { + ei = traits->createNvParameterized(AttractorFieldSamplerData::staticClassName()); + d->FieldSamplers.buf[0] = ei; + + ei = traits->createNvParameterized(ForceFieldData::staticClassName()); + d->FieldSamplers.buf[1] = ei; + + ei = traits->createNvParameterized(HeatSourceData::staticClassName()); + d->FieldSamplers.buf[2] = ei; + + ei = traits->createNvParameterized(JetFieldSamplerData::staticClassName()); + d->FieldSamplers.buf[3] = ei; + + ei = traits->createNvParameterized(TurbulenceFieldSamplerData::staticClassName()); + d->FieldSamplers.buf[4] = ei; + + ei = traits->createNvParameterized(VortexFieldSamplerData::staticClassName()); + d->FieldSamplers.buf[5] = ei; + + ei = traits->createNvParameterized(NoiseFieldSamplerData::staticClassName()); + d->FieldSamplers.buf[6] = ei; + + ei = traits->createNvParameterized(SubstanceSourceData::staticClassName()); + d->FieldSamplers.buf[7] = ei; + + ei = traits->createNvParameterized(WindFieldSamplerData::staticClassName()); + d->FieldSamplers.buf[8] = ei; + + ei = traits->createNvParameterized(VelocitySourceData::staticClassName()); + d->FieldSamplers.buf[9] = ei; + + ei = traits->createNvParameterized(FlameEmitterData::staticClassName()); + d->FieldSamplers.buf[10] = ei; + + ret = true; + } + } + + + Array< const char* > nameList; + for (int32_t i = 0; i < d->FieldSamplers.arraySizes[0]; i++) + { + ForceFieldData* e = static_cast< ForceFieldData*>(d->FieldSamplers.buf[i]); + if (e) + { + for (uint32_t j = 0; j < nameList.size(); j++) + { + if (nvidia::stricmp(nameList[j], e->Name) == 0) + { + NvParameterized::Handle handle(e); + NvParameterized::ErrorType err = handle.getParameter("Name"); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + if (err == NvParameterized::ERROR_NONE) + { + handle.setParamString(getUniqueName(nameList, e->Name)); + ret = true; + break; + } + } + } + nameList.pushBack(e->Name); + } + } + + + for (uint32_t i = 0; i < (uint32_t)d->FieldSamplers.arraySizes[0]; i++) + { + NvParameterized::Interface* iface = d->FieldSamplers.buf[i]; + FieldSamplerType fst = getFieldSamplerType(iface); + switch (fst) + { + case FST_FORCE_FIELD: + { + ForceFieldData* ed = static_cast< ForceFieldData*>(d->FieldSamplers.buf[i]); + if (ed->ForceField == NULL) + { + ed->ForceField = traits->createNvParameterized(forcefield::ForceFieldAssetParams::staticClassName()); + ret = true; + } + forcefield::ForceFieldAssetParams* fap = static_cast< forcefield::ForceFieldAssetParams*>(ed->ForceField); + if (fap && fap->strength == 0 && fap->lifetime == 0) // initialize the forcefield to reasonable values; if lifetime is zero, then the force field is not considered initalized. + { + ret = true; + fap->defScale = 1; + fap->strength = 20.0f; + fap->lifetime = 1000; + + fap->includeShapeParameters.dimensions = PxVec3(5, 5, 5); + + //TODO: Verify correctness of changes, add case for GenericForceFieldKernelType + if (fap->forceFieldKernelType == NULL) + { + fap->forceFieldKernelType = traits->createNvParameterized(forcefield::RadialForceFieldKernelParams::staticClassName()); + forcefield::RadialForceFieldKernelParams* rfap = static_cast< forcefield::RadialForceFieldKernelParams*>(fap->forceFieldKernelType); + if (rfap) + { + rfap->falloffParameters = traits->createNvParameterized(forcefield::ForceFieldFalloffParams::staticClassName()); + forcefield::ForceFieldFalloffParams* ffp = static_cast< forcefield::ForceFieldFalloffParams*>(rfap->falloffParameters); + rfap->noiseParameters = traits->createNvParameterized(forcefield::ForceFieldNoiseParams::staticClassName()); + forcefield::ForceFieldNoiseParams* fnp = static_cast< forcefield::ForceFieldNoiseParams*>(rfap->noiseParameters); + + ffp->multiplier = 0.5f; + ffp->start = 100; + ffp->end = 0; + + fnp->strength = 0.01f; + fnp->spaceScale = 8; + fnp->timeScale = 1; + fnp->octaves = 3; + } + } + } + } + break; + case FST_HEAT_SOURCE: + { + HeatSourceData* ed = static_cast< HeatSourceData*>(d->FieldSamplers.buf[i]); + if (ed->HeatSource == NULL) + { + ed->HeatSource = traits->createNvParameterized(turbulencefs::HeatSourceAssetParams::staticClassName()); + ret = true; + } + turbulencefs::HeatSourceAssetParams* ap = static_cast< turbulencefs::HeatSourceAssetParams*>(ed->HeatSource); + if (ap && ap->geometryType == NULL) + { + ap->averageTemperature = 4; + ap->stdTemperature = 2; + ap->geometryType = traits->createNvParameterized(turbulencefs::HeatSourceGeomSphereParams::staticClassName()); + ret = true; + } + } + break; + case FST_SUBSTANCE_SOURCE: + { + SubstanceSourceData* ed = static_cast< SubstanceSourceData*>(d->FieldSamplers.buf[i]); + if (ed->SubstanceSource == NULL) + { + ed->SubstanceSource = traits->createNvParameterized(turbulencefs::SubstanceSourceAssetParams::staticClassName()); + ret = true; + } + turbulencefs::SubstanceSourceAssetParams* ap = static_cast< turbulencefs::SubstanceSourceAssetParams*>(ed->SubstanceSource); + if (ap && ap->geometryType == NULL) + { + ap->averageDensity = 32; + ap->stdDensity = 16; + ap->geometryType = traits->createNvParameterized(turbulencefs::HeatSourceGeomSphereParams::staticClassName()); + ret = true; + } + } + break; + case FST_VELOCITY_SOURCE: + { + VelocitySourceData* ed = static_cast< VelocitySourceData*>(d->FieldSamplers.buf[i]); + if (ed->VelocitySource == NULL) + { + ed->VelocitySource = traits->createNvParameterized(turbulencefs::VelocitySourceAssetParams::staticClassName()); + ret = true; + } + turbulencefs::VelocitySourceAssetParams* ap = static_cast< turbulencefs::VelocitySourceAssetParams*>(ed->VelocitySource); + if (ap && ap->geometryType == NULL) + { + ap->geometryType = traits->createNvParameterized(turbulencefs::HeatSourceGeomSphereParams::staticClassName()); + ret = true; + } + } + break; + case FST_ATTRACTOR: + { + AttractorFieldSamplerData* ed = static_cast< AttractorFieldSamplerData*>(d->FieldSamplers.buf[i]); + if (ed->AttractorFieldSampler == NULL) + { + ed->AttractorFieldSampler = traits->createNvParameterized(basicfs::AttractorFSAssetParams::staticClassName()); + basicfs::AttractorFSAssetParams* a = static_cast< basicfs::AttractorFSAssetParams*>(ed->AttractorFieldSampler); + if (a) + { + a->boundaryFadePercentage = 0.3f; + a->radius = 2; + a->constFieldStrength = 20; + a->variableFieldStrength = 1; + } + ret = true; + } + } + break; + case FST_VORTEX: + { + VortexFieldSamplerData* ed = static_cast< VortexFieldSamplerData*>(d->FieldSamplers.buf[i]); + if (ed->VortexFieldSampler == NULL) + { + ed->VortexFieldSampler = traits->createNvParameterized(basicfs::VortexFSAssetParams::staticClassName()); + basicfs::VortexFSAssetParams* j = static_cast< basicfs::VortexFSAssetParams*>(ed->VortexFieldSampler); + if (j) + { + j->boundaryFadePercentage = 0.1f; + j->height = 1; + j->bottomRadius = 1; + j->topRadius = 1; + j->rotationalStrength = 4; + j->radialStrength = 4; + j->liftStrength = 1; + } + ret = true; + } + } + break; + case FST_NOISE: + { + NoiseFieldSamplerData* ed = static_cast< NoiseFieldSamplerData*>(d->FieldSamplers.buf[i]); + if (ed->NoiseFieldSampler == NULL) + { + ed->NoiseFieldSampler = traits->createNvParameterized(basicfs::NoiseFSAssetParams::staticClassName()); + ret = true; + } + } + break; + case FST_JET: + { + JetFieldSamplerData* ed = static_cast< JetFieldSamplerData*>(d->FieldSamplers.buf[i]); + if (ed->JetFieldSampler == NULL) + { + ed->JetFieldSampler = traits->createNvParameterized(basicfs::JetFSAssetParams::staticClassName()); + basicfs::JetFSAssetParams* j = static_cast< basicfs::JetFSAssetParams*>(ed->JetFieldSampler); + if (j) + { + j->defaultScale = 1; + j->boundaryFadePercentage = 0.3f; + j->fieldDirection = PxVec3(1, 0, 0); + j->fieldDirectionDeviationAngle = 0; + j->fieldDirectionOscillationPeriod = 0; + j->fieldStrength = 10; + j->fieldStrengthDeviationPercentage = 0; + j->fieldStrengthOscillationPeriod = 0; + j->gridShapeRadius = 2; + j->gridShapeHeight = 2; + j->gridBoundaryFadePercentage = 0.01f; + j->nearRadius = 0.1f; + j->pivotRadius = 0.2f; + j->farRadius = 4; + j->directionalStretch = 1; + j->averageStartDistance = 1; + j->averageEndDistance = 5; + j->noisePercentage = 0.1f; + j->noiseTimeScale = 1; + j->noiseOctaves = 1; + } + ret = true; + } + } + break; + case FST_WIND: + { + WindFieldSamplerData* ed = static_cast< WindFieldSamplerData*>(d->FieldSamplers.buf[i]); + if (ed->WindFieldSampler == NULL) + { + ed->WindFieldSampler = traits->createNvParameterized(basicfs::WindFSAssetParams::staticClassName()); + basicfs::WindFSAssetParams* j = static_cast< basicfs::WindFSAssetParams*>(ed->WindFieldSampler); + if (j) + { + // TODO initialize to reasonable default values + } + ret = true; + } + } + break; + case FST_TURBULENCE: + { + TurbulenceFieldSamplerData* ed = static_cast< TurbulenceFieldSamplerData*>(d->FieldSamplers.buf[i]); + if (ed->TurbulenceFieldSampler == NULL) + { + ed->TurbulenceFieldSampler = traits->createNvParameterized(turbulencefs::TurbulenceFSAssetParams::staticClassName()); + turbulencefs::TurbulenceFSAssetParams* fs = static_cast< turbulencefs::TurbulenceFSAssetParams*>(ed->TurbulenceFieldSampler); + if (fs) + { + fs->gridSizeWorld = PxVec3(15, 15, 15); + fs->updatesPerFrame = 1; + fs->angularVelocityMultiplier = 1; + fs->angularVelocityClamp = 100000; + fs->linearVelocityMultiplier = 1; + fs->linearVelocityClamp = 100000; + fs->boundaryFadePercentage = 0.3f; + fs->boundarySizePercentage = 1; + fs->maxCollidingObjects = 32; + fs->maxHeatSources = 8; + fs->dragCoeff = 0; + fs->externalVelocity = PxVec3(0, 0, 0); + fs->fieldVelocityMultiplier = 1; + fs->fieldVelocityWeight = 0.75; + fs->useHeat = true; + fs->heatParams.temperatureBasedForceMultiplier = 0.02f; + fs->heatParams.ambientTemperature = 0; + fs->heatParams.heatForceDirection = PxVec3(0, 1, 0); + fs->isEnabledOptimizedLOD = false; + fs->updatesPerFrame = 1.f; + fs->noiseParams.noiseStrength = 0; + fs->noiseParams.noiseSpacePeriod = PxVec3(0.9f, 0.9f, 0.9f); + fs->noiseParams.noiseTimePeriod = 10; + fs->noiseParams.noiseOctaves = 1; + fs->dragCoeffForRigidBody = 0; + fs->fluidViscosity = 0; + } + + ret = true; + } + } + break; + case FST_FLAME_EMITTER: + { + FlameEmitterData* ed = static_cast< FlameEmitterData*>(d->FieldSamplers.buf[i]); + if (ed->FlameEmitter == NULL) + { + ed->FlameEmitter = traits->createNvParameterized(turbulencefs::FlameEmitterAssetParams::staticClassName()); + ret = true; + } + } + break; + default: + PX_ALWAYS_ASSERT(); // not yet implemented + break; + } + if ( fixFieldSamplerCollisionFilterNames( iface ) ) + { + ret = true; + } + } + } + } + else + { + PX_ALWAYS_ASSERT(); // invalid NvParameterized::Interface passed in + } + } + + + return ret; +} + + +static void initPathData(NvParameterized::Interface *ei,RigidBodyEffectNS::EffectProperties_Type &ep,bool &ret) +{ + if ( ep.Path.Scale.arraySizes[0] == 0 ) + { + NvParameterized::Handle handle(ei); + NvParameterized::ErrorType err = handle.getParameter("EffectProperties.Path.Scale"); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + err = handle.resizeArray(2); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + if (err == NvParameterized::ERROR_NONE) + { + RigidBodyEffectNS::ControlPoint_Type &c1 = ep.Path.Scale.buf[0]; + RigidBodyEffectNS::ControlPoint_Type &c2 = ep.Path.Scale.buf[1]; + + c1.x = 0; + c1.y = 1; + + c2.x = 1; + c2.y = 1; + ret = true; + } + } + if ( ep.Path.Speed.arraySizes[0] == 0 ) + { + NvParameterized::Handle handle(ei); + NvParameterized::ErrorType err = handle.getParameter("EffectProperties.Path.Speed"); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + err = handle.resizeArray(2); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + if (err == NvParameterized::ERROR_NONE) + { + RigidBodyEffectNS::ControlPoint_Type &c1 = ep.Path.Speed.buf[0]; + RigidBodyEffectNS::ControlPoint_Type &c2 = ep.Path.Speed.buf[1]; + + c1.x = 0; + c1.y = 1; + + c2.x = 1; + c2.y = 1; + ret = true; + } + } +} + +static void initPathData(NvParameterized::Interface *ei,RigidBodyEffectNS::EffectPath_Type &Path,bool &ret) +{ + if ( Path.Scale.arraySizes[0] == 0 ) + { + NvParameterized::Handle handle(ei); + NvParameterized::ErrorType err = handle.getParameter("Path.Scale"); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + err = handle.resizeArray(2); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + if (err == NvParameterized::ERROR_NONE) + { + RigidBodyEffectNS::ControlPoint_Type &c1 = Path.Scale.buf[0]; + RigidBodyEffectNS::ControlPoint_Type &c2 = Path.Scale.buf[1]; + + c1.x = 0; + c1.y = 1; + + c2.x = 1; + c2.y = 1; + ret = true; + } + } + if ( Path.Speed.arraySizes[0] == 0 ) + { + NvParameterized::Handle handle(ei); + NvParameterized::ErrorType err = handle.getParameter("Path.Speed"); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + err = handle.resizeArray(2); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + if (err == NvParameterized::ERROR_NONE) + { + RigidBodyEffectNS::ControlPoint_Type &c1 = Path.Speed.buf[0]; + RigidBodyEffectNS::ControlPoint_Type &c2 = Path.Speed.buf[1]; + + c1.x = 0; + c1.y = 1; + + c2.x = 1; + c2.y = 1; + ret = true; + } + } +} + + +bool ModuleParticlesImpl::setEffectPackageDatabase(const NvParameterized::Interface* dataBase) +{ + WRITE_ZONE(); + bool ret = false; + + if (dataBase) + { + NvParameterized::Traits* traits = mSdk->getParameterizedTraits(); + const char* className = dataBase->className(); + if (nvidia::strcmp(className, EffectPackageAssetParams::staticClassName()) == 0) + { + bool revised = false; + const char* itemName = dataBase->name(); + EffectPackageDatabaseParams* d = static_cast< EffectPackageDatabaseParams*>(mEffectPackageDatabaseParams); + for (uint32_t i = 0; i < (uint32_t)d->EffectPackages.arraySizes[0]; i++) + { + NvParameterized::Interface* ei = d->EffectPackages.buf[i]; + EffectPackageData* ed = static_cast< EffectPackageData*>(ei); + if (nvidia::stricmp(ed->Name.buf, itemName) == 0) + { + ed->EffectPackage->copy(*dataBase); + revised = true; + ret = true; + break; + } + } + if (!revised && mEffectPackageDatabaseParams) + { + int32_t arraySize = d->EffectPackages.arraySizes[0]; + NvParameterized::Handle handle(mEffectPackageDatabaseParams); + NvParameterized::ErrorType err = handle.getParameter("EffectPackages"); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + err = handle.resizeArray(arraySize + 1); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + if (err == NvParameterized::ERROR_NONE) + { + NvParameterized::Interface* ei = traits->createNvParameterized(EffectPackageData::staticClassName()); + EffectPackageData* ed = static_cast< EffectPackageData*>(ei); + if (ed) + { + NvParameterized::Handle item(ei); + err = item.getParameter("Name"); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + item.setParamString(itemName); + ei->setName(itemName); + d->EffectPackages.buf[arraySize] = ei; + dataBase->clone(ed->EffectPackage); + if ( ed->EffectPackage == NULL ) + { + APEX_DEBUG_WARNING("Failed to clone asset."); + } + } + ret = true; + } + } + } + else if (nvidia::strcmp(className, EffectPackageDatabaseParams::staticClassName()) == 0) + { + if (mEffectPackageDatabaseParams && mEffectPackageDatabaseParams != dataBase) + { + mEffectPackageDatabaseParams->destroy(); + mEffectPackageDatabaseParams = NULL; + } + if (mEffectPackageDatabaseParams == NULL) + { + dataBase->clone(mEffectPackageDatabaseParams); + if ( mEffectPackageDatabaseParams == NULL ) + { + APEX_DEBUG_WARNING("Failed to clone asset."); + mEffectPackageDatabaseParams = traits->createNvParameterized(EffectPackageDatabaseParams::staticClassName()); + } + } + } + // initialize anything which needs default values assigned... + if ( mEffectPackageDatabaseParams ) + { + EffectPackageDatabaseParams* d = static_cast< EffectPackageDatabaseParams*>(mEffectPackageDatabaseParams); + + { + if (d->EffectPackages.arraySizes[0] == 0) + { + NvParameterized::Handle handle(mEffectPackageDatabaseParams); + NvParameterized::ErrorType err = handle.getParameter("EffectPackages"); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + err = handle.resizeArray(1); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + if (err == NvParameterized::ERROR_NONE) + { + NvParameterized::Interface* ei = traits->createNvParameterized(EffectPackageData::staticClassName()); + EffectPackageData* ed = static_cast< EffectPackageData*>(ei); + d->EffectPackages.buf[0] = ei; + if (ed) + { + ed->EffectPackage = traits->createNvParameterized(EffectPackageAssetParams::staticClassName()); + EffectPackageAssetParams* p = static_cast< EffectPackageAssetParams*>(ed->EffectPackage); + if (p->Effects.arraySizes[0] == 0 && p) + { + NvParameterized::Handle handle(p); + NvParameterized::ErrorType err = handle.getParameter("Effects"); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + err = handle.resizeArray(1); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + if (err == NvParameterized::ERROR_NONE) + { + NvParameterized::Interface* ei = traits->createNvParameterized(EmitterEffect::staticClassName()); + p->Effects.buf[0] = ei; + ret = true; + } + } + } + ret = true; + } + } + Array< const char* > nameList; + for (int32_t i = 0; i < d->EffectPackages.arraySizes[0]; i++) + { + EffectPackageData* e = static_cast< EffectPackageData*>(d->EffectPackages.buf[i]); + if (e) + { + for (uint32_t j = 0; j < nameList.size(); j++) + { + if (nvidia::stricmp(nameList[j], e->Name) == 0) + { + NvParameterized::Handle handle(e); + NvParameterized::ErrorType err = handle.getParameter("Name"); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + if (err == NvParameterized::ERROR_NONE) + { + handle.setParamString(getUniqueName(nameList, e->Name)); + ret = true; + break; + } + } + } + nameList.pushBack(e->Name); + } + } + + + + for (uint32_t i = 0; i < (uint32_t)d->EffectPackages.arraySizes[0]; i++) + { + NvParameterized::Interface* ei = d->EffectPackages.buf[i]; + EffectPackageData* d = static_cast< EffectPackageData*>(ei); + + + EffectPackageAssetParams* p = static_cast< EffectPackageAssetParams*>(d->EffectPackage); + if (p == NULL) + { + NvParameterized::Interface* ep = traits->createNvParameterized(EffectPackageAssetParams::staticClassName()); + p = static_cast< EffectPackageAssetParams*>(ep); + d->EffectPackage = ep; + } + + { + RigidBodyEffectNS::EffectPath_Type &path = *(RigidBodyEffectNS::EffectPath_Type *)&p->Path; + initPathData(d->EffectPackage,path,ret); + } + + + + for (uint32_t i = 0; i < (uint32_t)p->Effects.arraySizes[0]; i++) + { + NvParameterized::Interface* ei = p->Effects.buf[i]; + if (!ei) + { + continue; + } + if (nvidia::strcmp(ei->className(), EmitterEffect::staticClassName()) == 0) + { + EmitterEffect* e = static_cast< EmitterEffect*>(ei); + RigidBodyEffectNS::EffectProperties_Type &ep = *(RigidBodyEffectNS::EffectProperties_Type *)&e->EffectProperties; + initPathData(ei,ep,ret); + if (e->Emitter == NULL) + { + setNamedReference(ei, "Emitter", EMITTER_AUTHORING_TYPE_NAME); + PX_ASSERT(e->Emitter); + e->Emitter->setName("defaultEmitter"); + ret = true; + } + } + else if (nvidia::strcmp(ei->className(), RigidBodyEffect::staticClassName()) == 0) + { + RigidBodyEffect* e = static_cast< RigidBodyEffect*>(ei); + RigidBodyEffectNS::EffectProperties_Type &ep = e->EffectProperties; + initPathData(ei,ep,ret); + } + else if (nvidia::strcmp(ei->className(), HeatSourceEffect::staticClassName()) == 0) + { + HeatSourceEffect* e = static_cast< HeatSourceEffect*>(ei); + RigidBodyEffectNS::EffectProperties_Type &ep = *(RigidBodyEffectNS::EffectProperties_Type *)&e->EffectProperties; + initPathData(ei,ep,ret); + if (e->HeatSource == NULL) + { + setNamedReference(ei, "HeatSource", HEAT_SOURCE_AUTHORING_TYPE_NAME); + PX_ASSERT(e->HeatSource); + e->HeatSource->setName("defaultHeatSource"); + ret = true; + } + } + else if (nvidia::strcmp(ei->className(), SubstanceSourceEffect::staticClassName()) == 0) + { + SubstanceSourceEffect* e = static_cast< SubstanceSourceEffect*>(ei); + RigidBodyEffectNS::EffectProperties_Type &ep = *(RigidBodyEffectNS::EffectProperties_Type *)&e->EffectProperties; + initPathData(ei,ep,ret); + if (e->SubstanceSource == NULL) + { + setNamedReference(ei, "SubstanceSource", SUBSTANCE_SOURCE_AUTHORING_TYPE_NAME); + PX_ASSERT(e->SubstanceSource); + e->SubstanceSource->setName("defaultSubstanceSource"); + ret = true; + } + } + else if (nvidia::strcmp(ei->className(), VelocitySourceEffect::staticClassName()) == 0) + { + VelocitySourceEffect* e = static_cast< VelocitySourceEffect*>(ei); + RigidBodyEffectNS::EffectProperties_Type &ep = *(RigidBodyEffectNS::EffectProperties_Type *)&e->EffectProperties; + initPathData(ei,ep,ret); + if (e->VelocitySource == NULL) + { + setNamedReference(ei, "VelocitySource", VELOCITY_SOURCE_AUTHORING_TYPE_NAME); + PX_ASSERT(e->VelocitySource); + e->VelocitySource->setName("defaultVelocitySource"); + ret = true; + } + } + else if (nvidia::strcmp(ei->className(), JetFieldSamplerEffect::staticClassName()) == 0) + { + JetFieldSamplerEffect* e = static_cast< JetFieldSamplerEffect*>(ei); + RigidBodyEffectNS::EffectProperties_Type &ep = *(RigidBodyEffectNS::EffectProperties_Type *)&e->EffectProperties; + initPathData(ei,ep,ret); + if (e->JetFieldSampler == NULL) + { + setNamedReference(ei, "JetFieldSampler", JET_FS_AUTHORING_TYPE_NAME); + PX_ASSERT(e->JetFieldSampler); + e->JetFieldSampler->setName("defaultJetFieldSampler"); + ret = true; + } + } + else if (nvidia::strcmp(ei->className(), WindFieldSamplerEffect::staticClassName()) == 0) + { + WindFieldSamplerEffect* e = static_cast< WindFieldSamplerEffect*>(ei); + RigidBodyEffectNS::EffectProperties_Type &ep = *(RigidBodyEffectNS::EffectProperties_Type *)&e->EffectProperties; + initPathData(ei,ep,ret); + if (e->WindFieldSampler == NULL) + { + setNamedReference(ei, "WindFieldSampler", WIND_FS_AUTHORING_TYPE_NAME); + PX_ASSERT(e->WindFieldSampler); + e->WindFieldSampler->setName("defaultWindFieldSampler"); + ret = true; + } + } + else if (nvidia::strcmp(ei->className(), NoiseFieldSamplerEffect::staticClassName()) == 0) + { + NoiseFieldSamplerEffect* e = static_cast< NoiseFieldSamplerEffect*>(ei); + RigidBodyEffectNS::EffectProperties_Type &ep = *(RigidBodyEffectNS::EffectProperties_Type *)&e->EffectProperties; + initPathData(ei,ep,ret); + if (e->NoiseFieldSampler == NULL) + { + setNamedReference(ei, "NoiseFieldSampler", NOISE_FS_AUTHORING_TYPE_NAME); + PX_ASSERT(e->NoiseFieldSampler); + e->NoiseFieldSampler->setName("defaultNoiseFieldSampler"); + ret = true; + } + } + else if (nvidia::strcmp(ei->className(), VortexFieldSamplerEffect::staticClassName()) == 0) + { + VortexFieldSamplerEffect* e = static_cast< VortexFieldSamplerEffect*>(ei); + RigidBodyEffectNS::EffectProperties_Type &ep = *(RigidBodyEffectNS::EffectProperties_Type *)&e->EffectProperties; + initPathData(ei,ep,ret); + if (e->VortexFieldSampler == NULL) + { + setNamedReference(ei, "VortexFieldSampler", VORTEX_FS_AUTHORING_TYPE_NAME); + PX_ASSERT(e->VortexFieldSampler); + e->VortexFieldSampler->setName("defaultVortexFieldSampler"); + ret = true; + } + } + else if (nvidia::strcmp(ei->className(), AttractorFieldSamplerEffect::staticClassName()) == 0) + { + AttractorFieldSamplerEffect* e = static_cast< AttractorFieldSamplerEffect*>(ei); + RigidBodyEffectNS::EffectProperties_Type &ep = *(RigidBodyEffectNS::EffectProperties_Type *)&e->EffectProperties; + initPathData(ei,ep,ret); + if (e->AttractorFieldSampler == NULL) + { + setNamedReference(ei, "AttractorFieldSampler", ATTRACTOR_FS_AUTHORING_TYPE_NAME); + PX_ASSERT(e->AttractorFieldSampler); + e->AttractorFieldSampler->setName("defaultAttractorFieldSampler"); + ret = true; + } + } + else if (nvidia::strcmp(ei->className(), TurbulenceFieldSamplerEffect::staticClassName()) == 0) + { + TurbulenceFieldSamplerEffect* e = static_cast< TurbulenceFieldSamplerEffect*>(ei); + RigidBodyEffectNS::EffectProperties_Type &ep = *(RigidBodyEffectNS::EffectProperties_Type *)&e->EffectProperties; + initPathData(ei,ep,ret); + if (e->TurbulenceFieldSampler == NULL) + { + setNamedReference(ei, "TurbulenceFieldSampler", TURBULENCE_FS_AUTHORING_TYPE_NAME); + PX_ASSERT(e->TurbulenceFieldSampler); + e->TurbulenceFieldSampler->setName("defaultTurbulenceFieldSampler"); + ret = true; + } + } + else if (nvidia::strcmp(ei->className(), ForceFieldEffect::staticClassName()) == 0) + { + ForceFieldEffect* e = static_cast< ForceFieldEffect*>(ei); + RigidBodyEffectNS::EffectProperties_Type &ep = *(RigidBodyEffectNS::EffectProperties_Type *)&e->EffectProperties; + initPathData(ei,ep,ret); + if (e->ForceField == NULL) + { + setNamedReference(ei, "ForceField", FORCEFIELD_AUTHORING_TYPE_NAME); + PX_ASSERT(e->ForceField); + e->ForceField->setName("defaultForceField"); + ret = true; + } + } + else if (nvidia::strcmp(ei->className(), FlameEmitterEffect::staticClassName()) == 0) + { + FlameEmitterEffect* e = static_cast< FlameEmitterEffect*>(ei); + RigidBodyEffectNS::EffectProperties_Type &ep = *(RigidBodyEffectNS::EffectProperties_Type *)&e->EffectProperties; + initPathData(ei,ep,ret); + if (e->FlameEmitter == NULL) + { + setNamedReference(ei, "FlameEmitter", FLAME_EMITTER_AUTHORING_TYPE_NAME); + PX_ASSERT(e->FlameEmitter); + e->FlameEmitter->setName("defaultFlameEmitter"); + ret = true; + } + } + + } + } + } + } + } + + + return ret; +} + + +bool ModuleParticlesImpl::fixupNamedReferences(void) +{ + bool ret = false; + + if (mEffectPackageEmitterDatabaseParams) + { + EffectPackageEmitterDatabaseParams* d = static_cast< EffectPackageEmitterDatabaseParams*>(mEffectPackageEmitterDatabaseParams); + + for (int32_t i = 0; i < d->Emitters.arraySizes[0]; i++) + { + EmitterData* ed = static_cast< EmitterData*>(d->Emitters.buf[i]); + + if (ed->Emitter) + { + NvParameterized::Handle handle(ed->Emitter); + NvParameterized::ErrorType err = ed->Emitter->getParameterHandle("iosAssetName", handle); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + if (err == NvParameterized::ERROR_NONE) + { + NvParameterized::Interface* val = NULL; + err = handle.getParamRef(val); + // ok..need to see if it has changed! + if (val) + { + const char* refName = val->name(); + EffectPackageIOSDatabaseParams* d = static_cast< EffectPackageIOSDatabaseParams*>(mEffectPackageIOSDatabaseParams); + for (uint32_t i = 0; i < (uint32_t)d->ParticleSimulations.arraySizes[0]; i++) + { + NvParameterized::Interface* ei = d->ParticleSimulations.buf[i]; + emitter::ApexEmitterAssetParameters* ae = static_cast< emitter::ApexEmitterAssetParameters*>(ed->Emitter); + ParticleSimulationData* ed = static_cast< ParticleSimulationData*>(ei); + if (nvidia::stricmp(ed->Name.buf, refName) == 0) + { + NvParameterized::Interface* ios = ed->IOS; + if ( ios ) + { + const char* paramRef = getAuthoringTypeName(ios->className()); + err = handle.initParamRef(paramRef,true); + PX_ASSERT(err == NvParameterized::ERROR_NONE); + if (err == NvParameterized::ERROR_NONE) + { + ae->iosAssetName->setName(ed->Name.buf); + } + } + break; + } + } + } + } + } + } + } + return ret; +} + +bool ModuleParticlesImpl::initParticleSimulationData(ParticleSimulationData* ed) +{ + bool ret = false; + + NvParameterized::Traits* traits = mSdk->getParameterizedTraits(); + + if (ed->IOS == NULL) + { + ed->IOS = traits->createNvParameterized(basicios::BasicIOSAssetParam::staticClassName()); + basicios::BasicIOSAssetParam* ios = static_cast< basicios::BasicIOSAssetParam*>(ed->IOS); + if (ios) + { + ios->restDensity = 1; + ios->particleRadius = 0.1f; + ios->maxParticleCount = 16384; + ios->maxInjectedParticleCount = 0.05; + ios->sceneGravityScale = 1; + ios->externalAcceleration.x = 0; + ios->externalAcceleration.y = 0; + ios->externalAcceleration.z = 0; + ios->particleMass.center = 1; + ios->particleMass.spread = 0; + ios->staticCollision = true; + ios->restitutionForStaticShapes = 0.2f; + ios->dynamicCollision = true; + ios->restitutionForDynamicShapes = 0.2f; + ios->collisionDistanceMultiplier = 1; + ios->collisionThreshold = 0.001f; + ios->collisionWithConvex = true; + ios->collisionWithTriangleMesh = false; + } + ret = true; + } + + if (ed->IOS && nvidia::strcmp(ed->IOS->className(), "ParticleIosAssetParam") == 0) + { + pxparticleios::ParticleIosAssetParam* p = static_cast< pxparticleios::ParticleIosAssetParam*>(ed->IOS); + if (p->particleType == NULL) + { + p->particleType = traits->createNvParameterized(pxparticleios::FluidParticleSystemParams::staticClassName()); + ret = true; + } + } + + if ( ed->IOS ) + { + if ( nvidia::strcmp(ed->IOS->className(), "ParticleIosAssetParam") == 0 ) + { + const char *filterName = "ParticlesSimple=all"; + pxparticleios::ParticleIosAssetParam* p = static_cast< pxparticleios::ParticleIosAssetParam*>(ed->IOS); + if (p->particleType && nvidia::strcmp(p->particleType->className(), pxparticleios::FluidParticleSystemParams::staticClassName()) == 0 ) + { + filterName = "ParticlesFluid=all"; + } + + { + const char *value=NULL; + NvParameterized::getParamString(*ed->IOS,"simulationFilterData",value); + if ( value == NULL || value[0] == 0 ) + { + NvParameterized::setParamString(*ed->IOS,"simulationFilterData",filterName); + ret = true; + } + } + { + const char *value=NULL; + NvParameterized::getParamString(*ed->IOS,"fieldSamplerFilterData",value); + if ( value == NULL || value[0] == 0 ) + { + NvParameterized::setParamString(*ed->IOS,"fieldSamplerFilterData",filterName); + ret = true; + } + } + } + else + { + const char *filterName = "ParticlesBasicIOS=all"; + { + const char *value=NULL; + NvParameterized::getParamString(*ed->IOS,"collisionFilterDataName",value); + if ( value == NULL || value[0] == 0 ) + { + NvParameterized::setParamString(*ed->IOS,"collisionFilterDataName",filterName); + ret = true; + } + } + { + const char *value=NULL; + NvParameterized::getParamString(*ed->IOS,"fieldSamplerFilterDataName",value); + if ( value == NULL || value[0] == 0 ) + { + NvParameterized::setParamString(*ed->IOS,"fieldSamplerFilterDataName",filterName); + ret = true; + } + } + + } + } + return ret; +} + +void ModuleParticlesImpl::resetEmitterPool(void) +{ + WRITE_ZONE(); + for (uint32_t i = 0; i < mScenes.size(); i++) + { + ParticlesScene* ds = static_cast< ParticlesScene*>(mScenes[i]); + ds->resetEmitterPool(); + } +} + +#define MODULE_CHECK(x) if ( x == module ) { x = NULL; } + +/** +Notification from ApexSDK when a module has been released +*/ +void ModuleParticlesImpl::notifyChildGone(ModuleIntl* imodule) +{ + Module* module = mSdk->getModule(imodule); + PX_ASSERT(module); + MODULE_CHECK(mModuleBasicIos); + MODULE_CHECK(mModuleEmitter); + MODULE_CHECK(mModuleIofx); + MODULE_CHECK(mModuleFieldSampler); + MODULE_CHECK(mModuleBasicFS); + MODULE_CHECK(mModuleParticleIos); // PhysX 3.x only : Instantiate the ParticleIOS module + MODULE_CHECK(mModuleForceField); // PhysX 3.x only : Instantiate the ForceField module +}; + +// This is a notification that the ApexSDK is being released. During the shutdown process +// the APEX SDK will automatically release all currently registered modules; therefore we are no longer +// responsible for releasing these modules ourselves. + +#define SAFE_MODULE_NULL(x) if ( x ) { ModuleIntl *m = mSdk->getInternalModule(x); PX_ASSERT(m); m->setParent(NULL); x = NULL; } + +void ModuleParticlesImpl::notifyReleaseSDK(void) +{ + SAFE_MODULE_NULL(mModuleBasicIos); + SAFE_MODULE_NULL(mModuleEmitter); + SAFE_MODULE_NULL(mModuleIofx); + SAFE_MODULE_NULL(mModuleFieldSampler); + SAFE_MODULE_NULL(mModuleBasicFS); + SAFE_MODULE_NULL(mModuleParticleIos); // PhysX 3.x only : Instantiate the ParticleIOS module + SAFE_MODULE_NULL(mModuleForceField); // PhysX 3.x only : Instantiate the ForceField module +} + +void ModuleParticlesImpl::initializeDefaultDatabases(void) +{ + WRITE_ZONE(); + /* Register the NvParameterized factories */ + NvParameterized::Traits* traits = mSdk->getParameterizedTraits(); + + if (mTurbulenceModule == NULL) + { + uint32_t count = mSdk->getNbModules(); + Module** modules = mSdk->getModules(); + for (uint32_t i = 0; i < count; i++) + { + Module* m = modules[i]; + const char* name = m->getName(); + if (nvidia::strcmp(name, "TurbulenceFS") == 0) + { + mTurbulenceModule = static_cast< ModuleTurbulenceFS*>(m); + break; + } + } + } + + // Initialize the effect package databases + if (mEffectPackageIOSDatabaseParams == NULL) + { + NvParameterized::Interface* iface = traits->createNvParameterized(EffectPackageIOSDatabaseParams::staticClassName()); + if (iface) + { + setEffectPackageIOSDatabase(iface); + iface->destroy(); + } + } + if (mEffectPackageIOFXDatabaseParams == NULL) + { + NvParameterized::Interface* iface = traits->createNvParameterized(EffectPackageIOFXDatabaseParams::staticClassName()); + if (iface) + { + setEffectPackageIOFXDatabase(iface); + iface->destroy(); + } + } + if (mEffectPackageEmitterDatabaseParams == NULL) + { + NvParameterized::Interface* iface = traits->createNvParameterized(EffectPackageEmitterDatabaseParams::staticClassName()); + if (iface) + { + setEffectPackageEmitterDatabase(iface); + iface->destroy(); + } + } + if (mEffectPackageFieldSamplerDatabaseParams == NULL) + { + NvParameterized::Interface* iface = traits->createNvParameterized(EffectPackageFieldSamplerDatabaseParams::staticClassName()); + setEffectPackageFieldSamplerDatabase(iface); + iface->destroy(); + } + if (mEffectPackageDatabaseParams == NULL) + { + NvParameterized::Interface* iface = traits->createNvParameterized(EffectPackageDatabaseParams::staticClassName()); + if (iface) + { + setEffectPackageDatabase(iface); + iface->destroy(); + } + } + if (mGraphicsMaterialsDatabase == NULL) + { + NvParameterized::Interface* iface = traits->createNvParameterized(EffectPackageGraphicsMaterialsParams::staticClassName()); + if (iface) + { + setEffectPackageGraphicsMaterialsDatabase(iface); + iface->destroy(); + } + } + +} + +#define MODULE_NAME_CHECK(x) if ( x ) { if ( nvidia::strcmp(x->getName(),moduleName) == 0) ret = x; } + +nvidia::apex::Module* ModuleParticlesImpl::getModule(const char* moduleName) +{ + READ_ZONE(); + nvidia::apex::Module* ret = NULL; + MODULE_NAME_CHECK(mModuleBasicIos); + MODULE_NAME_CHECK(mModuleEmitter); + MODULE_NAME_CHECK(mModuleIofx); + MODULE_NAME_CHECK(mModuleFieldSampler); + MODULE_NAME_CHECK(mModuleBasicFS); + MODULE_NAME_CHECK(mModuleParticleIos); + MODULE_NAME_CHECK(mModuleForceField); + return ret; +} + +} +} // end namespace nvidia + |