Initial commit:

PhysX 3.4.0 Update @ 21294896
APEX 1.4.0 Update @ 21275617

[CL 21300167]

1 files changed, 343 insertions, 0 deletions

diff --git a/APEX_1.4/module/basicfs/src/AttractorFSActorImpl.cpp b/APEX_1.4/module/basicfs/src/AttractorFSActorImpl.cpp
new file mode 100644
index 00000000..64ebc1fe
--- /dev/null
+++ b/APEX_1.4/module/basicfs/src/AttractorFSActorImpl.cpp
@@ -0,0 +1,343 @@
+/*
+ * 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 "RenderMeshActorDesc.h"
+#include "RenderMeshActor.h"
+#include "RenderMeshAsset.h"
+
+#include "Apex.h"
+
+#include "AttractorFSActorImpl.h"
+#include "AttractorFSAsset.h"
+#include "BasicFSScene.h"
+#include "ApexSDKIntl.h"
+#include "SceneIntl.h"
+#include "RenderDebugInterface.h"
+
+#include <PxScene.h>
+
+#include <FieldSamplerManagerIntl.h>
+#include "ApexResourceHelper.h"
+#include "ReadCheck.h"
+#include "WriteCheck.h"
+
+#include "PsMathUtils.h"
+
+namespace nvidia
+{
+namespace basicfs
+{
+
+#define NUM_DEBUG_POINTS 512
+
+AttractorFSActorImpl::AttractorFSActorImpl(const AttractorFSActorParams& params, AttractorFSAsset& asset, ResourceList& list, BasicFSScene& scene)
+	: BasicFSActor(scene)
+	, mAsset(&asset)
+{
+	WRITE_ZONE();
+	mFieldWeight = asset.mParams->fieldWeight;
+
+	mPose					= params.initialPose;
+	mScale					= params.initialScale;
+	mRadius					= mAsset->mParams->radius;
+	mConstFieldStrength		= mAsset->mParams->constFieldStrength;
+	mVariableFieldStrength	= mAsset->mParams->variableFieldStrength;
+
+	list.add(*this);			// Add self to asset's list of actors
+	addSelfToContext(*scene.getApexScene().getApexContext());    // Add self to ApexScene
+	addSelfToContext(scene);	// Add self to BasicFSScene's list of actors
+
+	FieldSamplerManagerIntl* fieldSamplerManager = mScene->getInternalFieldSamplerManager();
+	if (fieldSamplerManager != 0)
+	{
+		FieldSamplerDescIntl fieldSamplerDesc;
+		if (asset.mParams->fieldDragCoeff > 0)
+		{
+			fieldSamplerDesc.type = FieldSamplerTypeIntl::VELOCITY_DRAG;
+			fieldSamplerDesc.dragCoeff = asset.mParams->fieldDragCoeff;
+		}
+		else
+		{
+			fieldSamplerDesc.type = FieldSamplerTypeIntl::VELOCITY_DIRECT;
+		}
+		fieldSamplerDesc.gridSupportType = FieldSamplerGridSupportTypeIntl::NONE;
+		fieldSamplerDesc.samplerFilterData = ApexResourceHelper::resolveCollisionGroup128(params.fieldSamplerFilterDataName ? params.fieldSamplerFilterDataName : mAsset->mParams->fieldSamplerFilterDataName);
+		fieldSamplerDesc.boundaryFilterData = ApexResourceHelper::resolveCollisionGroup128(params.fieldBoundaryFilterDataName ? params.fieldBoundaryFilterDataName : mAsset->mParams->fieldBoundaryFilterDataName);
+		fieldSamplerDesc.boundaryFadePercentage = mAsset->mParams->boundaryFadePercentage;
+
+		fieldSamplerManager->registerFieldSampler(this, fieldSamplerDesc, mScene);
+		mFieldSamplerChanged = true;
+	}
+}
+
+AttractorFSActorImpl::~AttractorFSActorImpl()
+{
+}
+
+/* Must be defined inside CPP file, since they require knowledge of asset class */
+Asset* 		AttractorFSActorImpl::getOwner() const
+{
+	READ_ZONE();
+	return static_cast<Asset*>(mAsset);
+}
+
+BasicFSAsset* 	AttractorFSActorImpl::getAttractorFSAsset() const
+{
+	READ_ZONE();
+	return mAsset;
+}
+
+void				AttractorFSActorImpl::release()
+{
+	if (mInRelease)
+	{
+		return;
+	}
+	destroy();
+} 
+
+void AttractorFSActorImpl::destroy()
+{
+	{
+		WRITE_ZONE();
+		ApexActor::destroy();
+
+		setPhysXScene(NULL);
+
+		FieldSamplerManagerIntl* fieldSamplerManager = mScene->getInternalFieldSamplerManager();
+		if (fieldSamplerManager != 0)
+		{
+			fieldSamplerManager->unregisterFieldSampler(this);
+		}
+	}
+	delete this;
+}
+
+void AttractorFSActorImpl::getLodRange(float& min, float& max, bool& intOnly) const
+{
+	READ_ZONE();
+	PX_UNUSED(min);
+	PX_UNUSED(max);
+	PX_UNUSED(intOnly);
+	APEX_INVALID_OPERATION("not implemented");
+}
+
+float AttractorFSActorImpl::getActiveLod() const
+{
+	READ_ZONE();
+	APEX_INVALID_OPERATION("NxExampleActor does not support this operation");
+	return -1.0f;
+}
+
+void AttractorFSActorImpl::forceLod(float lod)
+{
+	WRITE_ZONE();
+	PX_UNUSED(lod);
+	APEX_INVALID_OPERATION("not implemented");
+}
+
+// Called by game render thread
+void AttractorFSActorImpl::updateRenderResources(bool rewriteBuffers, void* userRenderData)
+{
+	WRITE_ZONE();
+	PX_UNUSED(rewriteBuffers);
+	PX_UNUSED(userRenderData);
+}
+
+// Called by game render thread
+void AttractorFSActorImpl::dispatchRenderResources(UserRenderer& renderer)
+{
+	READ_ZONE();
+	PX_UNUSED(renderer);
+}
+
+bool AttractorFSActorImpl::updateFieldSampler(FieldShapeDescIntl& shapeDesc, bool& isEnabled)
+{
+	WRITE_ZONE();
+	isEnabled = mFieldSamplerEnabled;
+	if (mFieldSamplerChanged)
+	{
+		mExecuteParams.origin					= mPose.p;
+		mExecuteParams.radius					= mRadius * mScale;
+		mExecuteParams.constFieldStrength		= mConstFieldStrength * mScale;
+		mExecuteParams.variableFieldStrength	= mVariableFieldStrength * mScale;
+
+		shapeDesc.type = FieldShapeTypeIntl::SPHERE;
+		shapeDesc.worldToShape.q = PxIdentity;
+		shapeDesc.worldToShape.p = -mExecuteParams.origin;
+		shapeDesc.dimensions = PxVec3(mExecuteParams.radius, 0, 0);
+		shapeDesc.weight = mFieldWeight;
+
+		mFieldSamplerChanged					= false;
+		return true;
+	}
+	return false;
+}
+
+void AttractorFSActorImpl::simulate(float dt)
+{
+	WRITE_ZONE();
+	PX_UNUSED(dt);
+}
+
+void AttractorFSActorImpl::setConstFieldStrength(float strength)
+{
+	WRITE_ZONE();
+	mConstFieldStrength = strength;
+	mFieldSamplerChanged = true;
+}
+
+void AttractorFSActorImpl::setVariableFieldStrength(float strength)
+{
+	WRITE_ZONE();
+	mVariableFieldStrength = strength;
+	mFieldSamplerChanged = true;
+}
+
+void AttractorFSActorImpl::visualize()
+{
+	WRITE_ZONE();
+#ifndef WITHOUT_DEBUG_VISUALIZE
+	if ( !mEnableDebugVisualization ) return;
+	RenderDebugInterface* debugRender = mScene->mDebugRender;
+	BasicFSDebugRenderParams* debugRenderParams = mScene->mBasicFSDebugRenderParams;
+	const physx::PxMat44& savedPose = *RENDER_DEBUG_IFACE(debugRender)->getPoseTyped();
+	RENDER_DEBUG_IFACE(debugRender)->setIdentityPose();
+
+	if (!debugRenderParams->VISUALIZE_ATTRACTOR_FS_ACTOR)
+	{
+		return;
+	}
+
+	if (debugRenderParams->VISUALIZE_ATTRACTOR_FS_ACTOR_NAME)
+	{
+		char buf[128];
+		buf[sizeof(buf) - 1] = 0;
+		APEX_SPRINTF_S(buf, sizeof(buf) - 1, " %s %s", mAsset->getObjTypeName(), mAsset->getName());
+
+		PxVec3 textLocation = mPose.p;
+
+		RENDER_DEBUG_IFACE(debugRender)->setCurrentTextScale(4.0f);
+		RENDER_DEBUG_IFACE(debugRender)->setCurrentColor(RENDER_DEBUG_IFACE(debugRender)->getDebugColor(RENDER_DEBUG::DebugColors::Blue));
+		RENDER_DEBUG_IFACE(debugRender)->debugText(textLocation, buf);
+	}
+
+	if (debugRenderParams->VISUALIZE_ATTRACTOR_FS_SHAPE)
+	{
+		RENDER_DEBUG_IFACE(debugRender)->setCurrentColor(RENDER_DEBUG_IFACE(debugRender)->getDebugColor(RENDER_DEBUG::DebugColors::Blue));
+//		RENDER_DEBUG_IFACE(debugRender)->debugOrientedSphere(mExecuteParams.radius, 2, mDirToWorld);
+		RENDER_DEBUG_IFACE(debugRender)->debugSphere(mExecuteParams.origin, mExecuteParams.radius);
+	}
+
+	if (debugRenderParams->VISUALIZE_ATTRACTOR_FS_POSE)
+	{
+		RENDER_DEBUG_IFACE(debugRender)->debugAxes(PxMat44(mPose), 1);
+	}
+
+	if (debugRenderParams->VISUALIZE_ATTRACTOR_FS_FIELD)
+	{
+		if (mDebugPoints.empty())
+		{
+			mDebugPoints.resize(NUM_DEBUG_POINTS);
+			for (uint32_t i = 0; i < NUM_DEBUG_POINTS; ++i)
+			{
+				float rx, ry, rz;
+				do
+				{
+					rx = physx::shdfnd::rand(-1.0f, +1.0f);
+					ry = physx::shdfnd::rand(-1.0f, +1.0f);
+					rz = physx::shdfnd::rand(-1.0f, +1.0f);
+				}
+				while (rx * rx + ry * ry + rz * rz > 1.0f);
+
+				PxVec3& vec = mDebugPoints[i];
+
+				vec.x = rx;
+				vec.y = ry;
+				vec.z = rz;
+			}
+		}
+
+		uint32_t c1 = RENDER_DEBUG_IFACE(mScene->mDebugRender)->getDebugColor(RENDER_DEBUG::DebugColors::Blue);
+		uint32_t c2 = RENDER_DEBUG_IFACE(mScene->mDebugRender)->getDebugColor(RENDER_DEBUG::DebugColors::Red);
+
+		for (uint32_t i = 0; i < NUM_DEBUG_POINTS; ++i)
+		{
+			PxVec3 pos = mExecuteParams.origin + (mDebugPoints[i] * mExecuteParams.radius);
+			PxVec3 fieldVec = executeAttractorFS(mExecuteParams, pos/*, totalElapsedMS*/);
+			RENDER_DEBUG_IFACE(debugRender)->debugGradientLine(pos, pos + fieldVec, c1, c2);
+		}
+	}
+	RENDER_DEBUG_IFACE(debugRender)->setPose(savedPose);
+#endif
+}
+
+/******************************** CPU Version ********************************/
+
+AttractorFSActorCPU::AttractorFSActorCPU(const AttractorFSActorParams& params, AttractorFSAsset& asset, ResourceList& list, BasicFSScene& scene)
+	: AttractorFSActorImpl(params, asset, list, scene)
+{
+}
+
+AttractorFSActorCPU::~AttractorFSActorCPU()
+{
+}
+
+void AttractorFSActorCPU::executeFieldSampler(const ExecuteData& data)
+{
+	WRITE_ZONE();
+	for (uint32_t iter = 0; iter < data.count; ++iter)
+	{
+		uint32_t i = data.indices[iter & data.indicesMask] + (iter & ~data.indicesMask);
+		PxVec3* pos = (PxVec3*)((uint8_t*)data.position + i * data.positionStride);
+		data.resultField[iter] = executeAttractorFS(mExecuteParams, *pos/*, totalElapsedMS*/);
+	}
+}
+
+/******************************** GPU Version ********************************/
+
+#if APEX_CUDA_SUPPORT
+
+
+AttractorFSActorGPU::AttractorFSActorGPU(const AttractorFSActorParams& params, AttractorFSAsset& asset, ResourceList& list, BasicFSScene& scene)
+	: AttractorFSActorCPU(params, asset, list, scene)
+	, mConstMemGroup(CUDA_OBJ(fieldSamplerStorage))
+{
+}
+
+AttractorFSActorGPU::~AttractorFSActorGPU()
+{
+}
+
+bool AttractorFSActorGPU::updateFieldSampler(FieldShapeDescIntl& shapeDesc, bool& isEnabled)
+{
+	WRITE_ZONE();
+	if (AttractorFSActorImpl::updateFieldSampler(shapeDesc, isEnabled))
+	{
+		APEX_CUDA_CONST_MEM_GROUP_SCOPE(mConstMemGroup);
+
+		if (mParamsHandle.isNull())
+		{
+			mParamsHandle.alloc(_storage_);
+		}
+		mParamsHandle.update(_storage_, mExecuteParams);
+		return true;
+	}
+	return false;
+}
+
+
+#endif
+
+}
+} // end namespace nvidia::apex
+