Initial commit:

PhysX 3.4.0 Update @ 21294896
APEX 1.4.0 Update @ 21275617

[CL 21300167]

1 files changed, 250 insertions, 0 deletions

diff --git a/APEX_1.4/module/forcefield/src/ForceFieldScene.cpp b/APEX_1.4/module/forcefield/src/ForceFieldScene.cpp
new file mode 100644
index 00000000..6d8e7774
--- /dev/null
+++ b/APEX_1.4/module/forcefield/src/ForceFieldScene.cpp
@@ -0,0 +1,250 @@
+/*
+ * 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"
+#include "ApexUsingNamespace.h"
+#include "ScopedPhysXLock.h"
+
+#include "ForceFieldScene.h"
+#include "ForceFieldActorImpl.h"
+#include "SceneIntl.h"
+#include "ModulePerfScope.h"
+#include "ModuleFieldSamplerIntl.h"
+
+#if APEX_CUDA_SUPPORT
+#include "ApexCudaSource.h"
+#endif
+
+#pragma warning(disable: 4355) // 'this' : used in base member initializer list
+
+#include "Lock.h"
+
+namespace nvidia
+{
+namespace forcefield
+{
+
+ForceFieldScene::ForceFieldScene(ModuleForceFieldImpl& module, SceneIntl& scene, RenderDebugInterface* renderDebug, ResourceList& list)
+	: mRenderDebug(renderDebug)
+	, mFieldSamplerManager(NULL)
+	, mUpdateTask(*this)
+{
+	mModule = &module;
+	mApexScene = &scene;
+	mPhysXScene = NULL;
+	list.add(*this);		// Add self to module's list of ForceFieldScenes
+
+	/* Initialize reference to ForceFieldDebugRenderParams */
+	mDebugRenderParams = DYNAMIC_CAST(DebugRenderParams*)(mApexScene->getDebugRenderParams());
+	PX_ASSERT(mDebugRenderParams);
+	NvParameterized::Handle handle(*mDebugRenderParams), memberHandle(*mDebugRenderParams);
+	int size;
+
+	if (mDebugRenderParams->getParameterHandle("moduleName", handle) == NvParameterized::ERROR_NONE)
+	{
+		handle.getArraySize(size, 0);
+		handle.resizeArray(size + 1);
+		if (handle.getChildHandle(size, memberHandle) == NvParameterized::ERROR_NONE)
+		{
+			memberHandle.initParamRef(ForceFieldDebugRenderParams::staticClassName(), true);
+		}
+	}
+
+	/* Load reference to ForceFieldDebugRenderParams */
+	NvParameterized::Interface* refPtr = NULL;
+	memberHandle.getParamRef(refPtr);
+	mForceFieldDebugRenderParams = DYNAMIC_CAST(ForceFieldDebugRenderParams*)(refPtr);
+	PX_ASSERT(mForceFieldDebugRenderParams);
+}
+
+ForceFieldScene::~ForceFieldScene()
+{
+}
+
+// Called by scene task graph between LOD and PhysX::simulate()
+void ForceFieldScene::TaskUpdate::run()
+{
+	setProfileStat((uint16_t) mOwner.mActorArray.size());
+	float dt = mOwner.mApexScene->getElapsedTime();
+	mOwner.updateActors(dt);
+}
+
+// Called by updateTask between LOD and PhysX simulate.  Any writes
+// to render data must be protected by acquiring the actor's render data lock
+void ForceFieldScene::updateActors(float dt)
+{
+	SCOPED_PHYSX_LOCK_WRITE(mApexScene);
+	for (uint32_t i = 0 ; i < mActorArray.size() ; i++)
+	{
+		ForceFieldActorImpl* actor = DYNAMIC_CAST(ForceFieldActorImpl*)(mActorArray[i]);
+		actor->updateForceField(dt);
+	}
+}
+
+// submit the task that updates the explosion actors
+// called from ApexScene::simulate()
+void ForceFieldScene::submitTasks(float /*elapsedTime*/, float /*substepSize*/, uint32_t /*numSubSteps*/)
+{
+	PxTaskManager* tm;
+	{
+		READ_LOCK(*mApexScene);
+		tm = mApexScene->getTaskManager();
+	}
+	tm->submitUnnamedTask(mUpdateTask);
+	mUpdateTask.startAfter(tm->getNamedTask(FSST_PHYSX_MONITOR_LOAD));
+	mUpdateTask.finishBefore(tm->getNamedTask(FSST_PHYSX_MONITOR_FETCH));
+}
+
+void ForceFieldScene::setTaskDependencies()
+{
+}
+
+// Called by ApexScene::fetchResults() with all actors render data locked.
+void ForceFieldScene::fetchResults()
+{
+	PX_PROFILE_ZONE("ForceFieldSceneFetchResults", GetInternalApexSDK()->getContextId());
+
+	for (uint32_t i = 0 ; i < mActorArray.size() ; i++)
+	{
+		ForceFieldActorImpl* actor = DYNAMIC_CAST(ForceFieldActorImpl*)(mActorArray[i]);
+		actor->updatePoseAndBounds();
+	}
+}
+
+void ForceFieldScene::visualize()
+{
+#ifndef WITHOUT_DEBUG_VISUALIZE
+	if (!mForceFieldDebugRenderParams->VISUALIZE_FORCEFIELD_ACTOR)
+	{
+		return;
+	}
+
+	RENDER_DEBUG_IFACE(mRenderDebug)->pushRenderState();
+	for (uint32_t i = 0 ; i < mActorArray.size() ; i++)
+	{
+		ForceFieldActorImpl* actor = DYNAMIC_CAST(ForceFieldActorImpl*)(mActorArray[i]);
+		actor->visualize();
+	}
+	RENDER_DEBUG_IFACE(mRenderDebug)->popRenderState();
+#endif
+}
+
+void ForceFieldScene::visualizeForceFieldForces()
+{
+}
+
+void ForceFieldScene::visualizeForceFieldForceFields()
+{
+}
+
+void ForceFieldScene::destroy()
+{
+	removeAllActors();
+	mApexScene->moduleReleased(*this);
+	delete this;
+}
+
+void ForceFieldScene::setModulePhysXScene(PxScene* pxScene)
+{
+	if (pxScene)
+	{
+		for (uint32_t i = 0 ; i < mActorArray.size() ; i++)
+		{
+			ForceFieldActorImpl* actor = DYNAMIC_CAST(ForceFieldActorImpl*)(mActorArray[i]);
+			actor->setPhysXScene(pxScene);
+		}
+	}
+	else
+	{
+		for (uint32_t i = 0 ; i < mActorArray.size() ; i++)
+		{
+			ForceFieldActorImpl* actor = DYNAMIC_CAST(ForceFieldActorImpl*)(mActorArray[i]);
+			actor->setPhysXScene(NULL);
+		}
+	}
+
+	mPhysXScene = pxScene;
+}
+
+FieldSamplerManagerIntl* ForceFieldScene::getInternalFieldSamplerManager()
+{
+	if (mFieldSamplerManager == NULL)
+	{
+		ModuleFieldSamplerIntl* moduleFieldSampler = mModule->getInternalModuleFieldSampler();
+		if (moduleFieldSampler != NULL)
+		{
+			mFieldSamplerManager = moduleFieldSampler->getInternalFieldSamplerManager(*mApexScene);
+			PX_ASSERT(mFieldSamplerManager != NULL);
+		}
+	}
+	return mFieldSamplerManager;
+}
+
+/******************************** CPU Version ********************************/
+
+ForceFieldSceneCPU::ForceFieldSceneCPU(ModuleForceFieldImpl& module, SceneIntl& scene, RenderDebugInterface* renderDebug, ResourceList& list) :
+	ForceFieldScene(module, scene, renderDebug, list)
+{
+}
+
+ForceFieldSceneCPU::~ForceFieldSceneCPU()
+{
+}
+
+ForceFieldActorImpl* ForceFieldSceneCPU::createForceFieldActor(const ForceFieldActorDesc& desc, ForceFieldAssetImpl& asset, ResourceList& list)
+{
+	return PX_NEW(ForceFieldActorCPU)(desc, asset, list, *this);
+}
+
+/******************************** GPU Version ********************************/
+
+#if APEX_CUDA_SUPPORT
+
+ForceFieldSceneGPU::ForceFieldSceneGPU(ModuleForceFieldImpl& module, SceneIntl& scene, RenderDebugInterface* renderDebug, ResourceList& list)
+	: ForceFieldScene(module, scene, renderDebug, list)
+	, CudaModuleScene(scene, *mModule, APEX_CUDA_TO_STR(APEX_CUDA_MODULE_PREFIX))
+{
+	{
+		PxGpuDispatcher* gd = mApexScene->getTaskManager()->getGpuDispatcher();
+		PX_ASSERT(gd != NULL);
+		mCtxMgr = gd->getCudaContextManager();
+		PxScopedCudaLock _lock_(*mCtxMgr);
+
+//CUDA module objects
+#include "../cuda/include/ForceField.h"
+	}
+}
+
+ForceFieldSceneGPU::~ForceFieldSceneGPU()
+{
+	CudaModuleScene::destroy(*mApexScene);
+}
+
+ForceFieldActorImpl* ForceFieldSceneGPU::createForceFieldActor(const ForceFieldActorDesc& desc, ForceFieldAssetImpl& asset, ResourceList& list)
+{
+	return PX_NEW(ForceFieldActorGPU)(desc, asset, list, *this);
+}
+
+ApexCudaConstStorage* ForceFieldSceneGPU::getFieldSamplerCudaConstStorage()
+{
+	return &APEX_CUDA_OBJ_NAME(fieldSamplerStorage);
+}
+
+bool ForceFieldSceneGPU::launchFieldSamplerCudaKernel(const nvidia::fieldsampler::FieldSamplerKernelLaunchDataIntl& launchData)
+{
+	LAUNCH_FIELD_SAMPLER_KERNEL(launchData);
+}
+
+#endif
+
+}
+} // end namespace nvidia