Initial commit:

PhysX 3.4.0 Update @ 21294896
APEX 1.4.0 Update @ 21275617

[CL 21300167]

1 files changed, 321 insertions, 0 deletions

diff --git a/APEX_1.4/module/pxparticleios/include/ParticleIosActorImpl.h b/APEX_1.4/module/pxparticleios/include/ParticleIosActorImpl.h
new file mode 100644
index 00000000..51d52341
--- /dev/null
+++ b/APEX_1.4/module/pxparticleios/include/ParticleIosActorImpl.h
@@ -0,0 +1,321 @@
+/*
+ * 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.
+ */
+
+
+#ifndef __PARTICLE_IOS_ACTOR_IMPL_H__
+#define __PARTICLE_IOS_ACTOR_IMPL_H__
+
+#include "Apex.h"
+
+#include "ParticleIosActor.h"
+#include "iofx/IofxActor.h"
+#include "ParticleIosAssetImpl.h"
+#include "InstancedObjectSimulationIntl.h"
+#include "ParticleIosScene.h"
+#include "ApexActor.h"
+#include "ApexContext.h"
+#include "ApexFIFO.h"
+#include "ParticleIosCommonCode.h"
+#include "InplaceStorage.h"
+#include "ApexMirroredArray.h"
+#include "PxParticleExt.h"
+#include "ApexRWLockable.h"
+
+namespace nvidia
+{
+namespace apex
+{
+class FieldSamplerQueryIntl;
+class FieldSamplerCallbackIntl;
+}
+namespace pxparticleios
+{
+
+/* Class for managing the interactions with each emitter */
+class ParticleParticleInjector : public IosInjectorIntl, public ApexResourceInterface, public ApexResource, public ApexRWLockable
+{
+public:
+	APEX_RW_LOCKABLE_BOILERPLATE
+
+	void	setPreferredRenderVolume(RenderVolume* volume);
+	float	getLeastBenefitValue() const
+	{
+		return 0.0f;
+	}
+	bool	isBacklogged() const
+	{
+		return false;
+	}
+
+	void	createObjects(uint32_t count, const IosNewObject* createList);
+#if APEX_CUDA_SUPPORT
+	void	createObjects(ApexMirroredArray<const IosNewObject>& createArray);
+#endif
+
+	void	setLODWeights(float maxDistance, float distanceWeight, float speedWeight, float lifeWeight, float separationWeight, float bias);
+
+	PxTaskID getCompletionTaskID() const;
+
+	void	release();
+	void	destroy();
+
+	// ApexResourceInterface methods
+	void	setListIndex(ResourceList& list, uint32_t index);
+	
+	uint32_t		getListIndex() const
+	{
+		return m_listIndex;
+	}
+
+	virtual void		setPhysXScene(PxScene*)	{}
+	virtual PxScene*	getPhysXScene() const
+	{
+		return NULL;
+	}
+
+	void				assignSimParticlesCount(uint32_t input)
+	{
+		mSimulatedParticlesCount = input;
+	}
+
+	virtual uint32_t		getSimParticlesCount() const
+	{
+		return mSimulatedParticlesCount;
+	}
+
+	virtual uint32_t getActivePaticleCount() const;
+
+	virtual void setObjectScale(float objectScale);
+
+protected:
+	ParticleIosActorImpl* 		mIosActor;
+	IofxManagerClientIntl*	mIofxClient;
+	RenderVolume* 	mVolume;
+	physx::Array<uint16_t>		mRandomActorClassIDs;
+	uint32_t					mLastRandomID;
+	uint16_t					mVolumeID;
+
+	uint32_t					mInjectorID;
+	uint32_t					mSimulatedParticlesCount;
+
+
+	/* insertion buffer */
+	ApexFIFO<IosNewObject>	mInjectedParticles;
+
+	ParticleParticleInjector(ResourceList& list, ParticleIosActorImpl& actor, uint32_t injectorID);
+	~ParticleParticleInjector() {}
+
+	void init(IofxAsset* iofxAsset);
+
+	friend class ParticleIosActorImpl;
+};
+
+
+class ParticleIosActorImpl : public InstancedObjectSimulationIntl,
+	public ParticleIosActor,
+	public ApexResourceInterface,
+	public ApexResource,
+	public ApexRWLockable
+{
+public:
+	APEX_RW_LOCKABLE_BOILERPLATE
+
+	ParticleIosActorImpl(ResourceList& list, ParticleIosAssetImpl& asset, ParticleIosScene& scene, IofxAsset& iofxAsset, bool isDataOnDevice);
+	~ParticleIosActorImpl();
+
+	// ApexInterface API
+	void								release();
+	void								destroy();
+
+	// Actor API
+	void								setPhysXScene(PxScene* s);
+	PxScene*							getPhysXScene() const;
+	virtual void						putInScene(PxScene* scene);
+
+	Asset*						getOwner() const
+	{
+		READ_ZONE();
+		return (Asset*) mAsset;
+	}
+
+	// ApexContext
+	void								getLodRange(float& min, float& max, bool& intOnly) const;
+	float						getActiveLod() const;
+	void								forceLod(float lod);
+	/**
+	\brief Selectively enables/disables debug visualization of a specific APEX actor.  Default value it true.
+	*/
+	virtual void setEnableDebugVisualization(bool state)
+	{
+		WRITE_ZONE();
+		ApexActor::setEnableDebugVisualization(state);
+	}
+
+	// ApexResourceInterface methods
+	void								setListIndex(ResourceList& list, uint32_t index)
+	{
+		m_listIndex = index;
+		m_list = &list;
+	}
+	uint32_t						getListIndex() const
+	{
+		return m_listIndex;
+	}
+
+	// IOSIntl
+	float						getObjectRadius() const
+	{
+		return getParticleRadius();
+	}
+	float						getObjectDensity() const
+	{
+		return 1.0f;
+	} // mAsset->getRestDensity(); }
+
+	// ParticleIosActor
+	float						getParticleRadius() const
+	{
+		return mAsset->getParticleRadius();
+	}
+	//float						getRestDensity() const			{ return mAsset->getRestDensity();}
+	uint32_t						getParticleCount() const
+	{
+		return mParticleCount;
+	}
+
+	PX_INLINE void						setOnStartFSCallback(FieldSamplerCallbackIntl* callback)
+	{
+		if (mFieldSamplerQuery)
+		{
+			mFieldSamplerQuery->setOnStartCallback(callback);
+		}
+	}
+	PX_INLINE void						setOnFinishIOFXCallback(IofxManagerCallbackIntl* callback)
+	{
+		if (mIofxMgr)
+		{
+			mIofxMgr->setOnFinishCallback(callback);
+		}
+	}
+
+	const PxVec3* 				getRecentPositions(uint32_t& count, uint32_t& stride) const;
+
+	void								visualize();
+	virtual PxTaskID				submitTasks(PxTaskManager* tm) = 0;
+	virtual void						setTaskDependencies(PxTaskID taskStartAfterID, PxTaskID taskFinishBeforeID) = 0;
+	virtual void						fetchResults();
+
+	IosInjectorIntl*						allocateInjector(IofxAsset* iofxAsset);
+	void								releaseInjector(IosInjectorIntl&);
+
+	virtual void								setDensityOrigin(const PxVec3& v) 
+	{ 
+		mDensityOrigin = v; 
+	}
+
+protected:
+	virtual void						removeFromScene();
+
+	void								injectNewParticles();
+	bool								isParticleDescValid( const ParticleIosAssetParam* desc) const;
+	void								initStorageGroups(InplaceStorage& storage);
+
+	void								setTaskDependencies(PxTaskID taskStartAfterID, PxTaskID taskFinishBeforeID, PxTask* iosTask, bool isDataOnDevice);
+
+	ParticleIosAssetImpl* 					mAsset;
+	ParticleIosScene* 					mParticleIosScene;
+	bool								mIsParticleSystem;	// true:SimpleParticleSystemParams , false:FluidParticleSystemParams
+	PxActor*							mParticleActor;
+
+	IofxManagerIntl* 						mIofxMgr;
+	IosBufferDescIntl						mBufDesc;
+
+	ResourceList						mInjectorList;
+
+	physx::Array<IofxAsset*>			mIofxAssets;
+	physx::Array<uint32_t>					mIofxAssetRefs;
+
+	PxVec3						mUp;
+	float						mGravity;
+	float						mTotalElapsedTime;			//AM: People, methinks this will backfire eventually due to floating point precision loss!
+
+	uint32_t						mMaxParticleCount;
+	uint32_t						mMaxTotalParticleCount;
+
+	uint32_t						mParticleCount;
+	uint32_t						mParticleBudget;
+
+	uint32_t						mInjectedCount;
+	float						mInjectedBenefitSum;
+	float						mInjectedBenefitMin;
+	float						mInjectedBenefitMax;
+
+	uint32_t						mLastActiveCount;
+	float						mLastBenefitSum;
+	float						mLastBenefitMin;
+	float						mLastBenefitMax;
+
+	ApexMirroredArray<float>		mLifeSpan;
+	ApexMirroredArray<float>		mLifeTime;
+	ApexMirroredArray<uint32_t>		mInjector;
+	ApexMirroredArray<float>		mBenefit;
+	ApexMirroredArray<uint32_t>		mInjectorsCounters;
+	ApexMirroredArray<uint32_t>		mInputIdToParticleIndex;
+
+	ApexMirroredArray<float>		mGridDensityGrid;
+	ApexMirroredArray<float>		mGridDensityGridLowPass;
+
+	// Only for use by the IOS Asset, the actor is unaware of this
+	bool								mIsMesh;
+	
+	FieldSamplerQueryIntl*				mFieldSamplerQuery;
+	ApexMirroredArray<PxVec4>	mField;
+
+	InplaceStorageGroup					mSimulationStorageGroup;
+
+	class InjectTask : public PxTask
+	{
+	public:
+		InjectTask(ParticleIosActorImpl& actor) : mActor(actor) {}
+
+		const char* getName() const
+		{
+			return "ParticleIosActorImpl::InjectTask";
+		}
+		void run()
+		{
+			mActor.injectNewParticles();
+		}
+
+	protected:
+		ParticleIosActorImpl& mActor;
+
+	private:
+		InjectTask& operator=(const InjectTask&);
+	};
+	InjectTask							mInjectTask;
+
+	// Particle Density Origin
+	PxVec3 mDensityOrigin;
+	PxMat44 mDensityDebugMatInv;
+
+	GridDensityParams		mGridDensityParams;
+
+	FieldSamplerCallbackIntl*				mOnStartCallback;
+	IofxManagerCallbackIntl*				mOnFinishCallback;
+
+	friend class ParticleIosAssetImpl;
+	friend class ParticleParticleInjector;
+};
+
+}
+} // namespace nvidia
+
+#endif // __PARTICLE_IOS_ACTOR_IMPL_H__