Initial commit:

PhysX 3.4.0 Update @ 21294896
APEX 1.4.0 Update @ 21275617

[CL 21300167]

1 files changed, 229 insertions, 0 deletions

diff --git a/PhysX_3.4/Samples/SampleBase/SampleStepper.h b/PhysX_3.4/Samples/SampleBase/SampleStepper.h
new file mode 100644
index 00000000..e271caf7
--- /dev/null
+++ b/PhysX_3.4/Samples/SampleBase/SampleStepper.h
@@ -0,0 +1,229 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and 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.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2016 NVIDIA Corporation. All rights reserved.
+// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
+// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.  
+
+#ifndef SAMPLE_STEPPER_H
+#define SAMPLE_STEPPER_H
+
+#include "SampleAllocator.h"
+#include "SampleAllocatorSDKClasses.h"
+#include "RendererMemoryMacros.h"
+#include "task/PxTask.h"
+#include "PxPhysicsAPI.h"
+#include "PsTime.h"
+
+class PhysXSample;
+
+class Stepper: public SampleAllocateable
+{
+	public:
+							Stepper() : mSample(NULL) {}
+	virtual					~Stepper() {}
+
+	virtual	bool			advance(PxScene* scene, PxReal dt, void* scratchBlock, PxU32 scratchBlockSize)	= 0;
+	virtual	void			wait(PxScene* scene)				= 0;
+	virtual void			substepStrategy(const PxReal stepSize, PxU32& substepCount, PxReal& substepSize) = 0;
+	virtual void			postRender(const PxReal stepSize) = 0;
+	
+	virtual void			setSubStepper(const PxReal stepSize, const PxU32 maxSteps)	{}
+	virtual	void			renderDone()							{}
+	virtual	void			shutdown()								{}
+
+	PxReal					getSimulationTime()	const				{ return mSimulationTime; }
+
+	PhysXSample&			getSample()								{ return *mSample; }
+	const PhysXSample&		getSample()	const						{ return *mSample; }
+	void					setSample(PhysXSample* sample)			{ mSample = sample; }
+
+protected:
+	PhysXSample*			mSample;
+	Ps::Time				mTimer;
+	PxReal					mSimulationTime;
+
+};
+
+class MultiThreadStepper;
+class StepperTask : public physx::PxLightCpuTask
+{
+public:
+	void						setStepper(MultiThreadStepper* stepper) { mStepper = stepper; }
+	MultiThreadStepper*			getStepper()							{ return mStepper; }
+	const MultiThreadStepper*	getStepper() const 						{ return mStepper; }
+	const char*					getName() const							{ return "Stepper Task"; }
+	void						run();
+protected:
+	MultiThreadStepper*	mStepper;
+};
+
+class StepperTaskSimulate : public StepperTask
+{
+	
+public:
+	StepperTaskSimulate(){}
+	void run();
+};
+
+class MultiThreadStepper : public Stepper
+{
+public:
+	MultiThreadStepper()
+		: mFirstCompletionPending(false)
+		, mScene(NULL)
+		, mSync(NULL)
+		, mCurrentSubStep(0)
+		, mNbSubSteps(0)
+	{
+		mCompletion0.setStepper(this);
+		mCompletion1.setStepper(this);
+		mSimulateTask.setStepper(this);
+	}
+
+	~MultiThreadStepper()	{}
+
+	virtual bool			advance(PxScene* scene, PxReal dt, void* scratchBlock, PxU32 scratchBlockSize);
+	virtual void			substepDone(StepperTask* ownerTask);
+	virtual void			renderDone();
+	virtual void			postRender(const PxReal stepSize){}
+	
+	// if mNbSubSteps is 0 then the sync will never 
+	// be set so waiting would cause a deadlock
+	virtual void			wait(PxScene* scene)	{	if(mNbSubSteps && mSync)mSync->wait();	}
+	virtual void			shutdown()				{	DELETESINGLE(mSync);	}
+	virtual void			reset() = 0;
+	virtual void			substepStrategy(const PxReal stepSize, PxU32& substepCount, PxReal& substepSize) = 0;
+	virtual void			simulate(physx::PxBaseTask* ownerTask);
+	PxReal					getSubStepSize() const	{ return mSubStepSize; }
+
+protected:
+	void					substep(StepperTask& completionTask);
+
+	// we need two completion tasks because when multistepping we can't submit completion0 from the
+	// substepDone function which is running inside completion0
+	bool				mFirstCompletionPending;
+	StepperTaskSimulate	mSimulateTask;
+	StepperTask			mCompletion0, mCompletion1;
+	PxScene*			mScene;
+	PsSyncAlloc*		mSync;
+
+	PxU32				mCurrentSubStep;
+	PxU32				mNbSubSteps;
+	PxReal				mSubStepSize;
+	void*				mScratchBlock;
+	PxU32				mScratchBlockSize;
+};
+
+class DebugStepper : public Stepper
+{
+public:
+	DebugStepper(const PxReal stepSize) : mStepSize(stepSize) {}
+	
+	virtual void substepStrategy(const PxReal stepSize, PxU32& substepCount, PxReal& substepSize)
+	{
+		substepCount = 1;
+		substepSize = mStepSize;
+	}
+
+	virtual bool advance(PxScene* scene, PxReal dt, void* scratchBlock, PxU32 scratchBlockSize);
+
+	virtual void			postRender(const PxReal stepSize)
+	{
+	}
+
+	virtual void setSubStepper(const PxReal stepSize, const PxU32 maxSteps)
+	{
+		mStepSize = stepSize;
+	}
+
+	virtual void wait(PxScene* scene);
+
+	PxReal mStepSize;
+};
+
+// The way this should be called is:
+// bool stepped = advance(dt)
+//
+// ... reads from the scene graph for rendering
+//
+// if(stepped) renderDone()
+//
+// ... anything that doesn't need access to the physics scene
+//
+// if(stepped) sFixedStepper.wait()
+//
+// Note that per-substep callbacks to the sample need to be issued out of here, 
+// between fetchResults and simulate
+
+class FixedStepper : public MultiThreadStepper
+{
+public:
+	FixedStepper(const PxReal subStepSize, const PxU32 maxSubSteps)
+		: MultiThreadStepper()
+		, mAccumulator(0)
+		, mFixedSubStepSize(subStepSize)
+		, mMaxSubSteps(maxSubSteps)
+	{
+	}
+
+	virtual void	substepStrategy(const PxReal stepSize, PxU32& substepCount, PxReal& substepSize);
+	virtual void	reset() { mAccumulator = 0.0f; }
+	
+	virtual void	setSubStepper(const PxReal stepSize, const PxU32 maxSteps) { mFixedSubStepSize = stepSize; mMaxSubSteps = maxSteps;}
+
+	virtual void			postRender(const PxReal stepSize)
+	{
+	}
+
+	PxReal	mAccumulator;
+	PxReal	mFixedSubStepSize;
+	PxU32	mMaxSubSteps;
+};
+
+
+class VariableStepper : public MultiThreadStepper
+{
+public:
+	VariableStepper(const PxReal minSubStepSize, const PxReal maxSubStepSize, const PxU32 maxSubSteps)
+		: MultiThreadStepper()
+		, mAccumulator(0)
+		, mMinSubStepSize(minSubStepSize)
+		, mMaxSubStepSize(maxSubStepSize)
+		, mMaxSubSteps(maxSubSteps)
+	{
+	}
+
+	virtual void	substepStrategy(const PxReal stepSize, PxU32& substepCount, PxReal& substepSize);
+	virtual void	reset() { mAccumulator = 0.0f; }
+
+private:
+	VariableStepper& operator=(const VariableStepper&);
+			PxReal	mAccumulator;
+	const	PxReal	mMinSubStepSize;
+	const	PxReal	mMaxSubStepSize;
+	const	PxU32	mMaxSubSteps;
+};
+#endif