Initial commit:

PhysX 3.4.0 Update @ 21294896
APEX 1.4.0 Update @ 21275617

[CL 21300167]

1 files changed, 405 insertions, 0 deletions

diff --git a/APEX_1.4/module/basicfs/src/ModuleBasicFSImpl.cpp b/APEX_1.4/module/basicfs/src/ModuleBasicFSImpl.cpp
new file mode 100644
index 00000000..c065b72e
--- /dev/null
+++ b/APEX_1.4/module/basicfs/src/ModuleBasicFSImpl.cpp
@@ -0,0 +1,405 @@
+/*
+ * 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"
+
+#include "Apex.h"
+
+/* === ModuleBasicFSImpl DLL Setup === */
+
+#include "ModuleBasicFSImpl.h"
+#include "ModuleBasicFSRegistration.h"
+#include "ModulePerfScope.h"
+//#include "BasicFSAsset.h"
+#include "JetFSAsset.h"
+#include "AttractorFSAsset.h"
+#include "VortexFSAsset.h"
+#include "NoiseFSAsset.h"
+#include "WindFSAsset.h"
+#include "BasicFSScene.h"
+#include "SceneIntl.h"
+#include "PsMemoryBuffer.h"
+//#include "BasicFSActor.h"
+#include "JetFSActorImpl.h"
+#include "AttractorFSActorImpl.h"
+#include "VortexFSActorImpl.h"
+#include "NoiseFSActorImpl.h"
+#include "WindFSActorImpl.h"
+#include "ModuleFieldSamplerIntl.h"
+
+using namespace basicfs;
+
+#include "Lock.h"
+#include "ReadCheck.h"
+#include "WriteCheck.h"
+
+namespace nvidia
+{
+namespace apex
+{
+
+#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;
+}
+
+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;
+	}
+
+	gApexSdk = inSdk;
+	ModuleBasicFSImpl* impl = PX_NEW(ModuleBasicFS)(inSdk);
+	*niRef  = (ModuleIntl*) impl;
+	return (Module*) impl;
+}
+
+#else
+/* Statically linking entry function */
+void instantiateModuleBasicFS()
+{
+	ApexSDKIntl* sdk = GetInternalApexSDK();
+	nvidia::basicfs::ModuleBasicFSImpl* impl = PX_NEW(nvidia::basicfs::ModuleBasicFSImpl)(sdk);
+	sdk->registerExternalModule((Module*) impl, (ModuleIntl*) impl);
+}
+#endif // `defined(_USRDLL)
+}
+
+namespace basicfs
+{
+/* === ModuleBasicFSImpl Implementation === */
+
+#ifdef WITHOUT_APEX_AUTHORING
+
+class BasicFSAssetDummyAuthoring : public AssetAuthoring, public UserAllocated
+{
+public:
+	BasicFSAssetDummyAuthoring(ModuleBasicFSImpl* module, ResourceList& list, NvParameterized::Interface* params, const char* name)
+	{
+		PX_UNUSED(module);
+		PX_UNUSED(list);
+		PX_UNUSED(params);
+		PX_UNUSED(name);
+	}
+
+	BasicFSAssetDummyAuthoring(ModuleBasicFSImpl* module, ResourceList& list, const char* name)
+	{
+		PX_UNUSED(module);
+		PX_UNUSED(list);
+		PX_UNUSED(name);
+	}
+
+	BasicFSAssetDummyAuthoring(ModuleBasicFSImpl* module, ResourceList& list)
+	{
+		PX_UNUSED(module);
+		PX_UNUSED(list);
+	}
+
+	virtual void setToolString(const char* /*toolName*/, const char* /*toolVersion*/, uint32_t /*toolChangelist*/)
+	{
+
+	}
+
+
+	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 JetFSAsset::getClassName(); // Fix
+	}
+
+	/**
+	 * \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() const
+	{
+		PX_ASSERT(0);
+		return NULL;
+	}
+
+	virtual NvParameterized::Interface* releaseAndReturnNvParameterizedInterface(void)
+	{
+		PX_ALWAYS_ASSERT();
+		return NULL;
+	}
+};
+
+typedef ApexAuthorableObject<ModuleBasicFSImpl, JetFSAsset, JetFSAssetAuthoring> JetFSAO;
+typedef ApexAuthorableObject<ModuleBasicFSImpl, AttractorFSAsset, AttractorFSAssetAuthoring> AttractorFSAO;
+typedef ApexAuthorableObject<ModuleBasicFSImpl, VortexFSAsset, VortexFSAssetAuthoring> VortexFSAO;
+typedef ApexAuthorableObject<ModuleBasicFSImpl, NoiseFSAsset, NoiseFSAssetAuthoring> NoiseFSAO;
+typedef ApexAuthorableObject<ModuleBasicFSImpl, WindFSAsset, WindFSAssetAuthoring> WindFSAO;
+
+#else
+typedef ApexAuthorableObject<ModuleBasicFSImpl, JetFSAsset, JetFSAssetAuthoring> JetFSAO;
+typedef ApexAuthorableObject<ModuleBasicFSImpl, AttractorFSAsset, AttractorFSAssetAuthoring> AttractorFSAO;
+typedef ApexAuthorableObject<ModuleBasicFSImpl, VortexFSAsset, VortexFSAssetAuthoring> VortexFSAO;
+typedef ApexAuthorableObject<ModuleBasicFSImpl, NoiseFSAsset, NoiseFSAssetAuthoring> NoiseFSAO;
+typedef ApexAuthorableObject<ModuleBasicFSImpl, WindFSAsset, WindFSAssetAuthoring> WindFSAO;
+#endif
+
+ModuleBasicFSImpl::ModuleBasicFSImpl(ApexSDKIntl* sdk)
+{
+	mName = "BasicFS";
+	mSdk = sdk;
+	mApiProxy = this;
+	mModuleParams = NULL;
+	mFieldSamplerModule = NULL;
+
+	/* Register asset type and create a namespace for its assets */
+	const char* pName1 = JetFSAssetParams::staticClassName();					
+	JetFSAO* eAO1 = PX_NEW(JetFSAO)(this, mAuthorableObjects, pName1);
+	JetFSAsset::mAssetTypeID = eAO1->getResID();
+
+	const char* pName2 = AttractorFSAssetParams::staticClassName();					
+	AttractorFSAO* eAO2 = PX_NEW(AttractorFSAO)(this, mAuthorableObjects, pName2);
+	AttractorFSAsset::mAssetTypeID = eAO2->getResID();
+
+	const char* pName3 = NoiseFSAssetParams::staticClassName();					
+	NoiseFSAO* eAO3 = PX_NEW(NoiseFSAO)(this, mAuthorableObjects, pName3);
+	NoiseFSAsset::mAssetTypeID = eAO3->getResID();
+
+	const char* pName4 = VortexFSAssetParams::staticClassName();					
+	VortexFSAO* eAO4 = PX_NEW(VortexFSAO)(this, mAuthorableObjects, pName4);
+	VortexFSAsset::mAssetTypeID = eAO4->getResID();
+
+	const char* pName5 = WindFSAssetParams::staticClassName();					
+	WindFSAO* eAO5 = PX_NEW(WindFSAO)(this, mAuthorableObjects, pName5);
+	WindFSAsset::mAssetTypeID = eAO5->getResID();
+
+	/* Register the NvParameterized factories */
+	NvParameterized::Traits* traits = mSdk->getParameterizedTraits();
+	ModuleBasicFSRegistration::invokeRegistration(traits);
+}
+
+ModuleBasicFSImpl::~ModuleBasicFSImpl()
+{
+}
+
+void ModuleBasicFSImpl::destroy()
+{
+	NvParameterized::Traits* traits = mSdk->getParameterizedTraits();
+
+	if (mModuleParams)
+	{
+		mModuleParams->destroy();
+		mModuleParams = NULL;
+	}
+
+	ModuleBase::destroy();
+
+	if (traits)
+	{
+		/* Remove the NvParameterized factories */
+		ModuleBasicFSRegistration::invokeUnregistration(traits);
+	}
+	delete this;
+}
+
+
+void ModuleBasicFSImpl::init(NvParameterized::Interface&)
+{
+}
+
+NvParameterized::Interface* ModuleBasicFSImpl::getDefaultModuleDesc()
+{
+	WRITE_ZONE();
+	NvParameterized::Traits* traits = mSdk->getParameterizedTraits();
+
+	if (!mModuleParams)
+	{
+		mModuleParams = DYNAMIC_CAST(BasicFSModuleParameters*)
+		                (traits->createNvParameterized("BasicFSModuleParameters"));
+		PX_ASSERT(mModuleParams);
+	}
+	else
+	{
+		mModuleParams->initDefaults();
+	}
+
+	return mModuleParams;
+}
+
+AuthObjTypeID ModuleBasicFSImpl::getJetFSAssetTypeID() const
+{
+	return JetFSAsset::mAssetTypeID;
+}
+
+AuthObjTypeID ModuleBasicFSImpl::getAttractorFSAssetTypeID() const
+{
+	return AttractorFSAsset::mAssetTypeID;
+}
+
+AuthObjTypeID ModuleBasicFSImpl::getVortexFSAssetTypeID() const
+{
+	return VortexFSAsset::mAssetTypeID;
+}
+
+AuthObjTypeID ModuleBasicFSImpl::getNoiseFSAssetTypeID() const
+{
+	return NoiseFSAsset::mAssetTypeID;
+}
+
+AuthObjTypeID ModuleBasicFSImpl::getWindFSAssetTypeID() const
+{
+	return WindFSAsset::mAssetTypeID;
+}
+
+AuthObjTypeID ModuleBasicFSImpl::getModuleID() const
+{
+	return JetFSAsset::mAssetTypeID; // What should return?
+}
+
+ApexActor* ModuleBasicFSImpl::getApexActor(Actor* nxactor, AuthObjTypeID type) const
+{
+	if (type == JetFSAsset::mAssetTypeID)
+	{
+		return static_cast<JetFSActorImpl*>(nxactor);
+	}
+	else if (type == AttractorFSAsset::mAssetTypeID)
+	{
+		return static_cast<AttractorFSActorImpl*>(nxactor);
+	}
+	else if (type == VortexFSAsset::mAssetTypeID)
+	{
+		return static_cast<VortexFSActorImpl*>(nxactor);
+	}
+	else if (type == NoiseFSAsset::mAssetTypeID)
+	{
+		return static_cast<NoiseFSActorImpl*>(nxactor);
+	}
+	else if (type == WindFSAsset::mAssetTypeID)
+	{
+		return static_cast<WindFSActorImpl*>(nxactor);
+	}
+
+	return NULL;
+}
+
+/* == Example Scene methods == */
+ModuleSceneIntl* ModuleBasicFSImpl::createInternalModuleScene(SceneIntl& scene, RenderDebugInterface* debugRender)
+{
+#if APEX_CUDA_SUPPORT
+	READ_LOCK(scene);
+	if (scene.getTaskManager()->getGpuDispatcher())
+	{
+		return PX_NEW(BasicFSSceneGPU)(*this, scene, debugRender, mBasicFSScenes);
+	}
+	else
+#endif
+		return PX_NEW(BasicFSSceneCPU)(*this, scene, debugRender, mBasicFSScenes);
+}
+
+void ModuleBasicFSImpl::releaseModuleSceneIntl(ModuleSceneIntl& scene)
+{
+	BasicFSScene* es = DYNAMIC_CAST(BasicFSScene*)(&scene);
+	es->destroy();
+}
+
+BasicFSScene* ModuleBasicFSImpl::getBasicFSScene(const Scene& apexScene)
+{
+	for (uint32_t i = 0 ; i < mBasicFSScenes.getSize() ; i++)
+	{
+		BasicFSScene* es = DYNAMIC_CAST(BasicFSScene*)(mBasicFSScenes.getResource(i));
+		if (es->mApexScene == &apexScene)
+		{
+			return es;
+		}
+	}
+
+	PX_ASSERT(!"Unable to locate an appropriate BasicFSScene");
+	return NULL;
+}
+
+RenderableIterator* ModuleBasicFSImpl::createRenderableIterator(const Scene& apexScene)
+{
+	WRITE_ZONE();
+	BasicFSScene* es = getBasicFSScene(apexScene);
+	if (es)
+	{
+		return es->createRenderableIterator();
+	}
+
+	return NULL;
+}
+
+ModuleFieldSamplerIntl* ModuleBasicFSImpl::getInternalModuleFieldSampler()
+{
+	if (!mFieldSamplerModule)
+	{
+		ModuleIntl* nim = mSdk->getInternalModuleByName("FieldSampler");
+		if (nim)
+		{
+			mFieldSamplerModule = DYNAMIC_CAST(ModuleFieldSamplerIntl*)(nim);
+		}
+	}
+
+	return mFieldSamplerModule;
+}
+
+}
+} // end namespace nvidia::apex
+
+