Initial commit:

PhysX 3.4.0 Update @ 21294896
APEX 1.4.0 Update @ 21275617

[CL 21300167]

1 files changed, 742 insertions, 0 deletions

diff --git a/APEX_1.4/module/emitter/src/EmitterAssetImpl.cpp b/APEX_1.4/module/emitter/src/EmitterAssetImpl.cpp
new file mode 100644
index 00000000..d716b7a3
--- /dev/null
+++ b/APEX_1.4/module/emitter/src/EmitterAssetImpl.cpp
@@ -0,0 +1,742 @@
+/*
+ * 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 "Apex.h"
+#include "ModuleEmitterImpl.h"
+#include "EmitterAssetImpl.h"
+#include "EmitterActorImpl.h"
+//#include "ApexSharedSerialization.h"
+
+#include "EmitterGeomBoxImpl.h"
+#include "EmitterGeomSphereImpl.h"
+#include "EmitterGeomSphereShellImpl.h"
+#include "EmitterGeomCylinderImpl.h"
+#include "EmitterGeomExplicitImpl.h"
+#include "EmitterAssetPreview.h"
+
+#include "EmitterGeomBoxParams.h"
+#include "EmitterGeomSphereParams.h"
+#include "EmitterGeomSphereShellParams.h"
+#include "EmitterGeomCylinderParams.h"
+#include "EmitterGeomExplicitParams.h"
+
+#include "IofxAsset.h"
+
+namespace nvidia
+{
+namespace emitter
+{
+
+
+struct ApexEmitterGeomTypes
+{
+	enum Enum
+	{
+		GEOM_GROUND = 0,
+		GEOM_BOX,
+		GEOM_SPHERE,
+		GEOM_SPHERE_SHELL,
+		GEOM_EXLICIT,
+	};
+};
+
+void EmitterAssetImpl::copyLodDesc2(EmitterLodParamDesc& dst, const ApexEmitterAssetParametersNS::emitterLodParamDesc_Type& src)
+{
+	PX_ASSERT(src.version == dst.current);
+
+	dst.bias			= src.bias;
+	dst.distanceWeight	= src.distanceWeight;
+	dst.lifeWeight		= src.lifeWeight;
+	dst.maxDistance		= src.maxDistance;
+	dst.separationWeight = src.separationWeight;
+	dst.speedWeight		= src.speedWeight;
+}
+
+void EmitterAssetImpl::copyLodDesc2(ApexEmitterAssetParametersNS::emitterLodParamDesc_Type& dst, const EmitterLodParamDesc& src)
+{
+	dst.version			= src.current;
+	dst.bias			= src.bias;
+	dst.distanceWeight	= src.distanceWeight;
+	dst.lifeWeight		= src.lifeWeight;
+	dst.maxDistance		= src.maxDistance;
+	dst.separationWeight = src.separationWeight;
+	dst.speedWeight		= src.speedWeight;
+}
+
+void EmitterAssetImpl::postDeserialize(void* userData_)
+{
+	PX_UNUSED(userData_);
+
+	ApexSimpleString tmpStr;
+	NvParameterized::Handle h(*mParams);
+	NvParameterized::Interface* refPtr;
+
+	if (mParams->iofxAssetName == NULL)
+	{
+		NvParameterized::Handle h(mParams);
+		h.getParameter("iofxAssetName");
+		h.initParamRef(h.parameterDefinition()->refVariantVal(0), true);
+	}
+
+	if (mParams->iosAssetName == NULL)
+	{
+		NvParameterized::Handle h(mParams);
+		h.getParameter("iosAssetName");
+		h.initParamRef(h.parameterDefinition()->refVariantVal(0), true);
+	}
+
+	if (mParams->geometryType == NULL)
+	{
+		NvParameterized::Handle h(mParams);
+		h.getParameter("geometryType");
+		h.initParamRef(h.parameterDefinition()->refVariantVal(0), true);
+	}
+
+
+	ApexSimpleString iofxName(mParams->iofxAssetName->name());
+	ApexSimpleString iosName(mParams->iosAssetName->name());
+	ApexSimpleString iosTypeName(mParams->iosAssetName->className());
+
+	if (!iofxName.len() || !iosName.len() || !iosTypeName.len())
+	{
+		APEX_INTERNAL_ERROR("IOFX, IOS, or IOS type not initialized");
+		return;
+	}
+
+	if (mGeom)
+	{
+		mGeom->destroy();
+	}
+
+	mParams->getParameterHandle("geometryType", h);
+	mParams->getParamRef(h, refPtr);
+	PX_ASSERT(refPtr);
+	if (!refPtr)
+	{
+		APEX_INTERNAL_ERROR("No emitter geometry specified");
+		return;
+	}
+
+	tmpStr = refPtr->className();
+
+	if (tmpStr == EmitterGeomBoxParams::staticClassName())
+	{
+		EmitterGeomBoxImpl* exp = PX_NEW(EmitterGeomBoxImpl)(refPtr);
+		mGeom = exp;
+	}
+	else if (tmpStr == EmitterGeomSphereParams::staticClassName())
+	{
+		EmitterGeomSphereImpl* exp = PX_NEW(EmitterGeomSphereImpl)(refPtr);
+		mGeom = exp;
+	}
+	else if (tmpStr == EmitterGeomSphereShellParams::staticClassName())
+	{
+		EmitterGeomSphereShellImpl* exp = PX_NEW(EmitterGeomSphereShellImpl)(refPtr);
+		mGeom = exp;
+	}
+	else if (tmpStr == EmitterGeomCylinderParams::staticClassName())
+	{
+		EmitterGeomCylinderImpl* exp = PX_NEW(EmitterGeomCylinderImpl)(refPtr);
+		mGeom = exp;
+	}
+	else if (tmpStr == EmitterGeomExplicitParams::staticClassName())
+	{
+		EmitterGeomExplicitImpl* exp = PX_NEW(EmitterGeomExplicitImpl)(refPtr);
+		mGeom = exp;
+	}
+	else
+	{
+		PX_ASSERT(0 && "Invalid geometry type for APEX emitter");
+		return;
+	}
+
+	copyLodDesc2(mLodDesc, mParams->lodParamDesc);
+
+	initializeAssetNameTable();
+}
+
+
+void EmitterAssetImpl::initializeAssetNameTable()
+{
+	// clean up asset tracker list
+	mIosAssetTracker.removeAllAssetNames();
+	mIofxAssetTracker.removeAllAssetNames();
+
+	mIosAssetTracker.addAssetName(mParams->iosAssetName->className(),
+	                              mParams->iosAssetName->name());
+
+	mIofxAssetTracker.addAssetName(mParams->iofxAssetName->name(), false);
+
+	ParamArray<Vec2R> cp(mParams, "rateVsTimeCurvePoints", (ParamDynamicArrayStruct*)&mParams->rateVsTimeCurvePoints);
+	for (uint32_t i = 0; i < cp.size(); i++)
+	{
+		mRateVsTimeCurve.addControlPoint(cp[i]);
+	}
+}
+
+EmitterAssetImpl::EmitterAssetImpl(ModuleEmitterImpl* module, ResourceList& list, const char* name):
+	mDefaultActorParams(NULL),
+	mDefaultPreviewParams(NULL),
+	mModule(module),
+	mName(name),
+	mGeom(NULL),
+	mIofxAssetTracker(module->mSdk, IOFX_AUTHORING_TYPE_NAME),
+	mIosAssetTracker(module->mSdk)
+{
+	NvParameterized::Traits* traits = GetInternalApexSDK()->getParameterizedTraits();
+	mParams = static_cast<ApexEmitterAssetParameters*>(traits->createNvParameterized(ApexEmitterAssetParameters::staticClassName()));
+
+	PX_ASSERT(mParams);
+
+	mParams->setSerializationCallback(this);
+	list.add(*this);
+}
+
+EmitterAssetImpl::EmitterAssetImpl(ModuleEmitterImpl* module,
+                                   ResourceList& list,
+                                   NvParameterized::Interface* params,
+                                   const char* name) :
+	mParams(static_cast<ApexEmitterAssetParameters*>(params)),
+	mDefaultActorParams(NULL),
+	mDefaultPreviewParams(NULL),
+	mModule(module),
+	mName(name),
+	mGeom(NULL),
+	mIofxAssetTracker(module->mSdk, IOFX_AUTHORING_TYPE_NAME),
+	mIosAssetTracker(module->mSdk)
+{
+	// this may no longer make any sense
+	mParams->setSerializationCallback(this);
+
+	// call this now to "initialize" the asset
+	postDeserialize();
+
+	list.add(*this);
+}
+
+EmitterAssetImpl::~EmitterAssetImpl()
+{
+}
+
+void EmitterAssetImpl::release()
+{
+	mModule->mSdk->releaseAsset(*this);
+}
+
+void EmitterAssetImpl::destroy()
+{
+	/* Assets that were forceloaded or loaded by actors will be automatically
+	 * released by the ApexAssetTracker member destructors.
+	 */
+
+	if (mGeom)
+	{
+		mGeom->destroy();
+	}
+	mGeom = NULL;
+
+	if (mDefaultActorParams)
+	{
+		mDefaultActorParams->destroy();
+		mDefaultActorParams = 0;
+	}
+
+	if (mDefaultPreviewParams)
+	{
+		mDefaultPreviewParams->destroy();
+		mDefaultPreviewParams = 0;
+	}
+
+	if (mParams)
+	{
+		mParams->destroy();
+		mParams = NULL;
+	}
+
+	/* Actors are automatically cleaned up on deletion by ResourceList dtor */
+	delete this;
+}
+
+EmitterGeomExplicit* EmitterAssetImpl::isExplicitGeom()
+{
+	READ_ZONE();
+	return const_cast<EmitterGeomExplicit*>(mGeom->getEmitterGeom()->isExplicitGeom());
+}
+
+const EmitterGeomExplicit* EmitterAssetImpl::isExplicitGeom() const
+{
+	return mGeom->getEmitterGeom()->isExplicitGeom();
+}
+
+NvParameterized::Interface* EmitterAssetImpl::getDefaultActorDesc()
+{
+	WRITE_ZONE();
+	NvParameterized::Traits* traits = GetInternalApexSDK()->getParameterizedTraits();
+	PX_ASSERT(traits);
+	if (!traits)
+	{
+		return NULL;
+	}
+
+	// create if not yet created
+	if (!mDefaultActorParams)
+	{
+		const char* className = ApexEmitterActorParameters::staticClassName();
+		NvParameterized::Interface* param = traits->createNvParameterized(className);
+		mDefaultActorParams = static_cast<ApexEmitterActorParameters*>(param);
+
+		PX_ASSERT(param);
+		if (!param)
+		{
+			return NULL;
+		}
+	}
+
+	if (mDefaultActorParams)
+	{
+		mDefaultActorParams->emitterDuration = mParams->emitterDuration;
+	}
+
+	return mDefaultActorParams;
+}
+
+NvParameterized::Interface* EmitterAssetImpl::getDefaultAssetPreviewDesc()
+{
+	WRITE_ZONE();
+	NvParameterized::Traits* traits = GetInternalApexSDK()->getParameterizedTraits();
+	PX_ASSERT(traits);
+	if (!traits)
+	{
+		return NULL;
+	}
+
+	// create if not yet created
+	if (!mDefaultPreviewParams)
+	{
+		const char* className = EmitterAssetPreviewParameters::staticClassName();
+		NvParameterized::Interface* param = traits->createNvParameterized(className);
+		mDefaultPreviewParams = static_cast<EmitterAssetPreviewParameters*>(param);
+
+		PX_ASSERT(param);
+		if (!param)
+		{
+			return NULL;
+		}
+	}
+
+	return mDefaultPreviewParams;
+}
+
+Actor* EmitterAssetImpl::createApexActor(const NvParameterized::Interface& parms, Scene& apexScene)
+{
+	WRITE_ZONE();
+	if (!isValidForActorCreation(parms, apexScene))
+	{
+		return NULL;
+	}
+
+	Actor* ret = 0;
+
+	const char* className = parms.className();
+	if (nvidia::strcmp(className, ApexEmitterActorParameters::staticClassName()) == 0)
+	{
+		EmitterActorDesc desc;
+		const ApexEmitterActorParameters* pDesc = static_cast<const ApexEmitterActorParameters*>(&parms);
+
+		desc.attachRelativePose	= pDesc->attachRelativePose;
+		desc.initialPose		= pDesc->initialPose;
+		desc.emitAssetParticles	= pDesc->emitAssetParticles;
+		desc.emitterDuration	= pDesc->emitterDuration;
+		desc.initialScale		= pDesc->initialScale;
+
+		/* Resolve the authored collision group mask name into the actual ID */
+		if (pDesc->overlapTestGroupMaskName != NULL &&
+		        pDesc->overlapTestGroupMaskName[0] != 0)
+		{
+			ResourceProviderIntl* nrp = mModule->mSdk->getInternalResourceProvider();
+			ResID cgmns = mModule->mSdk->getCollisionGroupMaskNameSpace();
+			ResID cgresid = nrp->createResource(cgmns, pDesc->overlapTestGroupMaskName);
+			desc.overlapTestCollisionGroups = (uint32_t)(size_t) nrp->getResource(cgresid);
+		}
+
+		ret = createEmitterActor(desc, apexScene);
+	}
+
+	return ret;
+}
+
+
+
+AssetPreview* EmitterAssetImpl::createApexAssetPreview(const NvParameterized::Interface& parms, AssetPreviewScene* previewScene)
+{
+	WRITE_ZONE();
+	AssetPreview* ret = 0;
+
+	const char* className = parms.className();
+	if (nvidia::strcmp(className, EmitterAssetPreviewParameters::staticClassName()) == 0)
+	{
+		EmitterPreviewDesc desc;
+		const EmitterAssetPreviewParameters* pDesc = static_cast<const EmitterAssetPreviewParameters*>(&parms);
+
+		desc.mPose	= pDesc->pose;
+		desc.mScale = pDesc->scale;
+
+		ret = createEmitterPreview(desc, previewScene);
+	}
+
+	return ret;
+}
+
+
+EmitterActor* EmitterAssetImpl::createEmitterActor(const EmitterActorDesc& desc, const Scene& scene)
+{
+	if (!desc.isValid())
+	{
+		return NULL;
+	}
+
+	EmitterScene* es = mModule->getEmitterScene(scene);
+	EmitterActorImpl* actor = PX_NEW(EmitterActorImpl)(desc, *this, mEmitterActors, *es);
+	if (!actor->isValid())
+	{
+		actor->destroy();
+		return NULL;
+	}
+	return actor;
+}
+
+void EmitterAssetImpl::releaseEmitterActor(EmitterActor& nxactor)
+{
+	EmitterActorImpl* actor = DYNAMIC_CAST(EmitterActorImpl*)(&nxactor);
+	actor->destroy();
+}
+
+EmitterPreview* EmitterAssetImpl::createEmitterPreview(const EmitterPreviewDesc& desc, AssetPreviewScene* previewScene)
+{
+	if (!desc.isValid())
+	{
+		return NULL;
+	}
+
+	EmitterAssetPreview* p = PX_NEW(EmitterAssetPreview)(desc, *this, previewScene, GetApexSDK());
+	if (p && !p->isValid())
+	{
+		p->destroy();
+		p = NULL;
+	}
+	return p;
+}
+
+void EmitterAssetImpl::releaseEmitterPreview(EmitterPreview& nxpreview)
+{
+	EmitterAssetPreview* preview = DYNAMIC_CAST(EmitterAssetPreview*)(&nxpreview);
+	preview->destroy();
+}
+
+
+uint32_t EmitterAssetImpl::forceLoadAssets()
+{
+	uint32_t assetLoadedCount = 0;
+
+	assetLoadedCount += mIofxAssetTracker.forceLoadAssets();
+	assetLoadedCount += mIosAssetTracker.forceLoadAssets();
+
+	return assetLoadedCount;
+}
+
+bool EmitterAssetImpl::isValidForActorCreation(const ::NvParameterized::Interface& /*actorParams*/, Scene& /*apexScene*/) const
+{
+	READ_ZONE();
+	if (!mGeom)
+	{
+		return false;
+	}
+
+	const EmitterGeomExplicit* explicitGeom = isExplicitGeom();
+	if (explicitGeom)
+	{
+		// Velocity array must be same size as positions or 0
+
+		const EmitterGeomExplicit::PointParams* points;
+		const PxVec3* velocities;
+		uint32_t numPoints, numVelocities;
+		explicitGeom->getParticleList(points, numPoints, velocities, numVelocities);
+		if (!(numPoints == numVelocities || 0 == numVelocities))
+		{
+			return false;
+		}
+
+		const EmitterGeomExplicit::SphereParams* spheres;
+		uint32_t numSpheres;
+		explicitGeom->getSphereList(spheres, numSpheres, velocities, numVelocities);
+		if (!(numSpheres == numVelocities || 0 == numVelocities))
+		{
+			return false;
+		}
+
+		const EmitterGeomExplicit::EllipsoidParams* ellipsoids;
+		uint32_t numEllipsoids;
+		explicitGeom->getEllipsoidList(ellipsoids, numEllipsoids, velocities, numVelocities);
+		if (!(numEllipsoids == numVelocities || 0 == numVelocities))
+		{
+			return false;
+		}
+
+		// Radiuses are > 0
+
+		for (uint32_t i = 0; i < numSpheres; ++i)
+			if (explicitGeom->getSphereRadius(i) <= 0)
+			{
+				return false;
+			}
+
+		for (uint32_t i = 0; i < numEllipsoids; ++i)
+			if (explicitGeom->getEllipsoidRadius(i) <= 0)
+			{
+				return false;
+			}
+
+		/*		// Normals are normalized
+
+				for(uint32_t i = 0; i < numEllipsoids; ++i)
+					if( !explicitGeom->getEllipsoidNormal(i).isNormalized() )
+						return false;
+		*/
+		// Distance >= 0
+
+		if (explicitGeom->getDistance() < 0)
+		{
+			return false;
+		}
+
+		// Distance > 0 if we have shapes
+
+		if ((numSpheres || numEllipsoids) && !explicitGeom->getDistance())
+		{
+			return false;
+		}
+	}
+
+	return true;
+}
+
+/*===============  Asset Authoring =================*/
+#ifndef WITHOUT_APEX_AUTHORING
+void EmitterAssetAuthoringImpl::setInstancedObjectEffectsAssetName(const char* iofxname)
+{
+	NvParameterized::Handle h(*mParams);
+	NvParameterized::Interface* refPtr;
+
+	mParams->getParameterHandle("iofxAssetName", h);
+	mParams->initParamRef(h, NULL, true);
+	mParams->getParamRef(h, refPtr);
+	PX_ASSERT(refPtr);
+	if (refPtr)
+	{
+		refPtr->setName(iofxname);
+	}
+
+}
+
+
+void EmitterAssetAuthoringImpl::setInstancedObjectSimulatorAssetName(const char* iosname)
+{
+	NvParameterized::Handle h(*mParams);
+	NvParameterized::Interface* refPtr;
+
+	mParams->getParameterHandle("iosAssetName", h);
+	mParams->initParamRef(h, NULL, true);
+	mParams->getParamRef(h, refPtr);
+	PX_ASSERT(refPtr);
+	if (refPtr)
+	{
+		refPtr->setName(iosname);
+	}
+}
+
+
+void EmitterAssetAuthoringImpl::setInstancedObjectSimulatorTypeName(const char* iostname)
+{
+	NvParameterized::Handle h(*mParams);
+	NvParameterized::Interface* refPtr;
+
+	mParams->getParameterHandle("iosAssetName", h);
+	mParams->initParamRef(h, iostname, true);
+	mParams->getParamRef(h, refPtr);
+	PX_ASSERT(refPtr);
+	if (refPtr)
+	{
+		refPtr->setClassName(iostname);
+	}
+}
+
+
+void EmitterAssetAuthoringImpl::release()
+{
+	mModule->mSdk->releaseAssetAuthoring(*this);
+}
+
+
+EmitterGeomBox* EmitterAssetAuthoringImpl::setBoxGeom()
+{
+	if (mGeom)
+	{
+		mGeom->destroy();
+		if (mParams->geometryType)
+		{
+			mParams->geometryType->destroy();
+			mParams->geometryType = NULL;
+		}
+	}
+
+	NvParameterized::Handle h(*mParams);
+	NvParameterized::Interface* refPtr = 0;
+	mParams->getParameterHandle("geometryType", h);
+
+	mParams->getParamRef(h, refPtr);
+	if (refPtr)
+	{
+		refPtr->destroy();
+		mParams->setParamRef(h, 0);
+	}
+
+	mParams->initParamRef(h, EmitterGeomBoxParams::staticClassName(), true);
+
+	refPtr = 0;
+	mParams->getParamRef(h, refPtr);
+	PX_ASSERT(refPtr);
+	if (!refPtr)
+	{
+		return NULL;
+	}
+
+	EmitterGeomBoxImpl* box = PX_NEW(EmitterGeomBoxImpl)(refPtr);
+	mGeom = box;
+	return box;
+}
+
+EmitterGeomSphere* EmitterAssetAuthoringImpl::setSphereGeom()
+{
+	if (mGeom)
+	{
+		mGeom->destroy();
+		if (mParams->geometryType)
+		{
+			mParams->geometryType->destroy();
+			mParams->geometryType = NULL;
+		}
+	}
+
+	NvParameterized::Handle h(*mParams);
+	NvParameterized::Interface* refPtr = 0;
+	mParams->getParameterHandle("geometryType", h);
+
+	mParams->getParamRef(h, refPtr);
+	if (refPtr)
+	{
+		refPtr->destroy();
+		mParams->setParamRef(h, 0);
+	}
+
+	mParams->initParamRef(h, EmitterGeomSphereParams::staticClassName(), true);
+
+	refPtr = 0;
+	mParams->getParamRef(h, refPtr);
+	PX_ASSERT(refPtr);
+	if (!refPtr)
+	{
+		return NULL;
+	}
+
+	EmitterGeomSphereImpl* sphere = PX_NEW(EmitterGeomSphereImpl)(refPtr);
+	mGeom = sphere;
+	return sphere;
+}
+
+EmitterGeomSphereShell* 	EmitterAssetAuthoringImpl::setSphereShellGeom()
+{
+	if (mGeom)
+	{
+		mGeom->destroy();
+		if (mParams->geometryType)
+		{
+			mParams->geometryType->destroy();
+			mParams->geometryType = NULL;
+		}
+	}
+
+	NvParameterized::Handle h(*mParams);
+	NvParameterized::Interface* refPtr = 0;
+	mParams->getParameterHandle("geometryType", h);
+
+	mParams->getParamRef(h, refPtr);
+	if (refPtr)
+	{
+		refPtr->destroy();
+		mParams->setParamRef(h, 0);
+	}
+
+	mParams->initParamRef(h, EmitterGeomSphereShellParams::staticClassName(), true);
+
+	refPtr = 0;
+	mParams->getParamRef(h, refPtr);
+	PX_ASSERT(refPtr);
+	if (!refPtr)
+	{
+		return NULL;
+	}
+
+	EmitterGeomSphereShellImpl* sphereshell = PX_NEW(EmitterGeomSphereShellImpl)(refPtr);
+	mGeom = sphereshell;
+	return sphereshell;
+}
+
+EmitterGeomExplicit* 	EmitterAssetAuthoringImpl::setExplicitGeom()
+{
+	if (mGeom)
+	{
+		mGeom->destroy();
+		if (mParams->geometryType)
+		{
+			mParams->geometryType->destroy();
+			mParams->geometryType = NULL;
+		}
+	}
+
+	NvParameterized::Handle h(*mParams);
+	NvParameterized::Interface* refPtr = 0;
+	mParams->getParameterHandle("geometryType", h);
+
+	mParams->getParamRef(h, refPtr);
+	if (refPtr)
+	{
+		refPtr->destroy();
+		mParams->setParamRef(h, 0);
+	}
+
+	mParams->initParamRef(h, EmitterGeomExplicitParams::staticClassName(), true);
+
+	refPtr = 0;
+	mParams->getParamRef(h, refPtr);
+	PX_ASSERT(refPtr);
+	if (!refPtr)
+	{
+		return NULL;
+	}
+
+	EmitterGeomExplicitImpl* exp = PX_NEW(EmitterGeomExplicitImpl)(refPtr);
+	mGeom = exp;
+	return exp;
+}
+#endif
+
+}
+} // namespace nvidia::apex