Initial commit:

PhysX 3.4.0 Update @ 21294896
APEX 1.4.0 Update @ 21275617

[CL 21300167]

1 files changed, 397 insertions, 0 deletions

diff --git a/APEX_1.4/module/emitter/include/GroundEmitterActorImpl.h b/APEX_1.4/module/emitter/include/GroundEmitterActorImpl.h
new file mode 100644
index 00000000..918feb67
--- /dev/null
+++ b/APEX_1.4/module/emitter/include/GroundEmitterActorImpl.h
@@ -0,0 +1,397 @@
+/*
+ * 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 __GROUND_EMITTER_ACTOR_IMPL_H__
+#define __GROUND_EMITTER_ACTOR_IMPL_H__
+
+#include "GroundEmitterActor.h"
+#include "GroundEmitterAssetImpl.h"
+#include "EmitterScene.h"
+#include "ApexActor.h"
+#include "ApexFIFO.h"
+#include "ApexSharedUtils.h"
+#include "PsUserAllocated.h"
+#include "PxPlane.h"
+
+namespace nvidia
+{
+namespace emitter
+{
+
+template<typename T>
+struct ApexVec2
+{
+	T x;
+	T y;
+};
+
+class InjectorData : public UserAllocated
+{
+public:
+	virtual ~InjectorData()
+	{
+	}
+
+	IosInjectorIntl* 				mInjector;  // For emitting
+	float						mObjectRadius;
+
+	ApexSimpleString			iofxAssetName;
+	ApexSimpleString			iosAssetName;
+
+	physx::Array<IosNewObject>	particles;
+
+	class InjectTask : public PxTask
+	{
+	public:
+		InjectTask() {}
+		void run();
+		const char* getName() const
+		{
+			return "GroundEmitterActor::InjectTask";
+		}
+		GroundEmitterActorImpl* mActor;
+		InjectorData* mData;
+	};
+	void initTask(GroundEmitterActorImpl& actor, InjectorData& data)
+	{
+		mTask.mActor = &actor;
+		mTask.mData = &data;
+	}
+
+	InjectTask					mTask;
+};
+
+
+struct MaterialData
+{
+	physx::Array<uint32_t>  injectorIndices;
+	physx::Array<float>  accumWeights;
+	physx::Array<float>  maxSlopeAngles;
+
+	uint32_t chooseIOFX(float& maxSlopeAngle, QDSRand& rand)
+	{
+		PX_ASSERT(injectorIndices.size() == accumWeights.size());
+
+		float u = rand.getScaled(0, accumWeights.back());
+		for (uint32_t i = 0; i < accumWeights.size(); i++)
+		{
+			if (u <= accumWeights[i])
+			{
+				maxSlopeAngle = maxSlopeAngles[i];
+				return injectorIndices[i];
+			}
+		}
+
+		PX_ALWAYS_ASSERT();
+		return (uint32_t) - 1;
+	}
+};
+
+
+class GroundEmitterActorImpl : public GroundEmitterActor, public EmitterActorBase, public ApexResourceInterface, public ApexResource, public ApexRWLockable
+{
+private:
+	GroundEmitterActorImpl& operator=(const GroundEmitterActorImpl&);
+
+public:
+	APEX_RW_LOCKABLE_BOILERPLATE
+
+	GroundEmitterActorImpl(const GroundEmitterActorDesc&, GroundEmitterAssetImpl&, ResourceList&, EmitterScene&);
+	~GroundEmitterActorImpl();
+
+	Renderable* 			getRenderable()
+	{
+		return NULL;
+	}
+	Actor* 				getActor()
+	{
+		return this;
+	}
+	void						removeActorAtIndex(uint32_t index);
+
+	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)
+	{
+		ApexActor::setEnableDebugVisualization(state);
+	}
+
+	/* ApexResourceInterface, ApexResource */
+	void						release();
+	uint32_t				getListIndex() const
+	{
+		return m_listIndex;
+	}
+	void						setListIndex(class ResourceList& list, uint32_t index)
+	{
+		m_list = &list;
+		m_listIndex = index;
+	}
+
+	/* EmitterActorBase */
+	void                        destroy();
+	Asset*		        getOwner() const;
+	void						visualize(RenderDebugInterface& renderDebug);
+
+	void						setPhysXScene(PxScene*);
+	PxScene*					getPhysXScene() const
+	{
+		return mPxScene;
+	}
+	PxScene* 					mPxScene;
+
+	void						submitTasks();
+	void						setTaskDependencies();
+	void						fetchResults();
+
+	GroundEmitterAsset*       getEmitterAsset() const;
+
+	const PxMat44		getPose() const;
+	void						setPose(const PxMat44& pos);
+
+	const PxVec3& 		getPosition() const
+	{
+		return mLocalPlayerPosition;
+	}
+	void				        setPosition(const PxVec3& pos);
+	const PxTransform& getRotation() const
+	{
+		return mPose;
+	}
+	void				setRotation(const PxTransform& rotation);
+	const PxVec3 &getVelocityLow() const
+	{
+		return mAsset->getVelocityLow();
+	}
+	const PxVec3 &getVelocityHigh() const
+	{
+		return mAsset->getVelocityHigh();
+	}
+	const float &getLifetimeLow() const
+	{
+		return mAsset->getLifetimeLow();
+	}
+	const float &getLifetimeHigh() const
+	{
+		return mAsset->getLifetimeHigh();
+	}
+	uint32_t				getRaycastCollisionGroups() const
+	{
+		READ_ZONE();
+		return mRaycastCollisionGroups;
+	}
+	void						setRaycastCollisionGroups(uint32_t g)
+	{
+		WRITE_ZONE();
+		mRaycastCollisionGroups = g;
+	}
+
+	const physx::PxFilterData*			getRaycastCollisionGroupsMask() const
+	{
+		READ_ZONE();
+		return mShouldUseGroupsMask ? &mRaycastCollisionGroupsMask : NULL;
+	}
+	void						setRaycastCollisionGroupsMask(physx::PxFilterData*);
+
+	void						setMaterialLookupCallback(MaterialLookupCallback* mlc)
+	{
+		WRITE_ZONE();
+		mMaterialCallback = mlc;
+	}
+	MaterialLookupCallback* 	getMaterialLookupCallback() const
+	{
+		READ_ZONE();
+		return mMaterialCallback;
+	}
+
+	void						setAttachActor(PxActor* a)
+	{
+		WRITE_ZONE();
+		mAttachActor = a;
+	}
+	const PxActor* 				getAttachActor() const
+	{
+		READ_ZONE();
+		return mAttachActor;
+	}
+	PxActor* 					mAttachActor;
+
+	void						setAttachRelativePosition(const PxVec3& pos)
+	{
+		WRITE_ZONE();
+		mAttachRelativePosition = pos;
+	}
+
+	const PxVec3& 		getAttachRelativePosition() const
+	{
+		READ_ZONE();
+		return mAttachRelativePosition;
+	}
+
+	bool						addMeshForGroundMaterial(const MaterialFactoryMappingDesc&, const EmitterLodParamDesc&);
+	void						setDensity(const float& d)
+	{
+		READ_ZONE();
+		mDensity = d;
+	}
+	void                        setMaxRaycastsPerFrame(uint32_t m)
+	{
+		WRITE_ZONE();
+		mMaxNumRaycastsPerFrame = m;
+	}
+	void                        setRaycastHeight(float h)
+	{
+		WRITE_ZONE();
+		mRaycastHeight = h;
+	}
+	void						setSpawnHeight(float h)
+	{
+		WRITE_ZONE();
+		mSpawnHeight = h;
+	}
+	void                        setRadius(float);
+	void						setPreferredRenderVolume(nvidia::apex::RenderVolume*);
+
+
+	const float &getDensity() const
+	{
+		READ_ZONE();
+		return mDensity;
+	}
+	float				getRadius() const
+	{
+		READ_ZONE();
+		return mRadius;
+	}
+	uint32_t				getMaxRaycastsPerFrame() const
+	{
+		READ_ZONE();
+		return mMaxNumRaycastsPerFrame;
+	}
+	float				getRaycastHeight() const
+	{
+		READ_ZONE();
+		return mRaycastHeight;
+	}
+	float				getSpawnHeight() const
+	{
+		READ_ZONE();
+		return mSpawnHeight;
+	}
+
+	void							setSeed(uint32_t seed)
+	{
+		mRand.setSeed(seed);
+	}
+
+protected:
+	/* internal methods */
+	void                        submitRaycasts();
+	void                        injectParticles(InjectorData& data);
+	void                        refreshCircle(bool edgeOnly);
+	void						tick();
+
+	bool						onRaycastQuery(uint32_t nbHits, const physx::PxRaycastHit* hits);
+
+	GroundEmitterAssetImpl* 		mAsset;
+	EmitterScene* 				mScene;
+
+	/* Actor modifiable versions of asset data */
+	float 				mDensity;
+	float				mRadius;
+	uint32_t				mMaxNumRaycastsPerFrame;
+	float				mRaycastHeight;
+	float				mSpawnHeight;
+	PxVec3				mLocalUpDirection;
+	PxTransform		mPose;
+	PxTransform		mInversePose;
+	uint32_t				mRaycastCollisionGroups;
+	physx::PxFilterData			mRaycastCollisionGroupsMask;
+
+	PxVec3				mAttachRelativePosition;
+
+	MaterialLookupCallback* 	mMaterialCallback;
+	physx::Array<MaterialLookupCallback::MaterialRequest> mMaterialRequestArray;
+
+	/* Actor local data */
+	Bank<MaterialData, uint16_t> mPerMaterialData;
+	physx::Array<InjectorData*>	mInjectorList;
+	physx::Array<InstancedObjectSimulationIntl*> mIosList;
+	float				mGridCellSize;
+	uint32_t				mTotalElapsedTimeMs;
+
+	struct RaycastVisInfo
+	{
+		PxVec3 rayStart;
+		uint32_t  timeSubmittedMs;	// running time in milliseconds (should last for 50 days or so)
+	};
+	physx::Array<RaycastVisInfo>	mVisualizeRaycastsList;
+
+
+	// use FIFO so it does the earliest (that are probably the closest to the player first)
+	ApexFIFO<PxVec3>		mToRaycast;
+	physx::Array<uint32_t>  mCellLastRefreshSteps;
+	uint32_t                mSimulationSteps;
+	ApexVec2<int32_t>		mNextGridCell;
+
+	/* runtime state members */
+
+	PxVec3				mLocalPlayerPosition;
+	PxVec3				mWorldPlayerPosition;
+	PxVec3				mOldLocalPlayerPosition; // used to determine when to clear per cell step counts
+	float                mStepsize;
+	PxPlane				mHorizonPlane;
+
+	float				mCurrentDensity;
+	float                mRadius2;
+	float                mCircleArea;
+	bool                        mShouldUseGroupsMask;
+	float                mMaxStepSize;
+	bool                        mRefreshFullCircle;
+
+	nvidia::Mutex				mInjectorDataLock;
+
+	nvidia::QDSRand				mRand;
+
+	class GroundEmitterTickTask : public PxTask
+	{
+	public:
+		GroundEmitterTickTask(GroundEmitterActorImpl& actor) : mActor(actor) {}
+
+		const char* getName() const
+		{
+			return "GroundEmitterActor::TickTask";
+		}
+		void run()
+		{
+			mActor.tick();
+		}
+
+	protected:
+		GroundEmitterActorImpl& mActor;
+
+	private:
+		GroundEmitterTickTask& operator=(const GroundEmitterTickTask&);
+	};
+	GroundEmitterTickTask 		mTickTask;
+
+	friend class InjectorData::InjectTask;
+	friend class QueryReport;
+};
+
+}
+} // end namespace nvidia
+
+#endif