Initial commit:

PhysX 3.4.0 Update @ 21294896
APEX 1.4.0 Update @ 21275617

[CL 21300167]

1 files changed, 228 insertions, 0 deletions

diff --git a/PhysX_3.4/Samples/SampleBase/InputEventBuffer.h b/PhysX_3.4/Samples/SampleBase/InputEventBuffer.h
new file mode 100644
index 00000000..824cd64a
--- /dev/null
+++ b/PhysX_3.4/Samples/SampleBase/InputEventBuffer.h
@@ -0,0 +1,228 @@
+// 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 INPUT_BUFFER_H
+#define INPUT_BUFFER_H
+
+#include "SamplePreprocessor.h"
+#include "SampleAllocator.h"
+#include "SampleUserInput.h"
+#include "foundation/PxAssert.h"
+#include "PsIntrinsics.h"
+
+class PhysXSampleApplication;
+
+template<typename T, PxU32 SIZE> 
+class RingBuffer
+{
+public:
+	RingBuffer()
+	: mReadCount(0)
+	, mWriteCount(0)
+	{
+		// SIZE has to be power of two
+#if PX_VC
+		PX_COMPILE_TIME_ASSERT(SIZE > 0);
+		PX_COMPILE_TIME_ASSERT((SIZE&(SIZE-1)) == 0);
+#else
+		PX_ASSERT(SIZE > 0);
+		PX_ASSERT((SIZE&(SIZE-1)) == 0);
+#endif
+	}
+	
+	PX_FORCE_INLINE bool		isEmpty() const			{ return mReadCount==mWriteCount;								}
+	PX_FORCE_INLINE bool		isFull() const			{ return isFull(mReadCount, mWriteCount);						}
+	PX_FORCE_INLINE PxU32		size() const			{ return size(mReadCount, mWriteCount);							}
+	PX_FORCE_INLINE PxU32		capacity() const		{ return SIZE;													}
+	// clear is only save if called from reader thread!
+	PX_FORCE_INLINE void		clear()					{ mReadCount=mWriteCount;										}
+	PX_FORCE_INLINE const T&	back() const			{ PX_ASSERT(!isEmpty()); return mRing[mReadCount&moduloMask];	}
+	PX_FORCE_INLINE T&			front()					{ return mRing[mWriteCount&moduloMask];							}
+	PX_FORCE_INLINE void		incFront(PxU32 inc)		{ PX_ASSERT(SIZE-size() >= inc); mWriteCount+=inc;				}
+	PX_FORCE_INLINE void		incBack(PxU32 inc)		{ PX_ASSERT(size() >= inc); mReadCount+=inc; 					}
+
+	PX_FORCE_INLINE bool		pushFront(const T& e)	
+	{ 
+		if(!isFull())
+		{
+			mRing[mWriteCount&moduloMask] = e;
+			Ps::memoryBarrier();
+			mWriteCount++;
+			return true;
+		}
+		else
+			return false;
+
+	}
+
+	PX_FORCE_INLINE bool popBack(T& e)	
+	{ 
+		if(!isEmpty())
+		{
+			e = mRing[mReadCount&moduloMask];
+			mReadCount++;
+			return true;
+		}
+		else
+			return false;
+	}
+
+private:
+	PX_FORCE_INLINE static PxU32	moduloDistance(PxI32 r, PxI32 w) 	{ return PxU32((w-r)&moduloMask);						}
+	PX_FORCE_INLINE static bool		isFull(PxI32 r, PxI32 w) 			{ return r!=w && moduloDistance(r,w)==0;				}
+	PX_FORCE_INLINE static PxU32	size(PxI32 r, PxI32 w) 				{ return isFull(r, w) ? SIZE : moduloDistance(r, w);	}
+
+private:
+	static const PxU32	moduloMask = SIZE-1;
+	T					mRing[SIZE];
+	volatile PxI32		mReadCount;
+	volatile PxI32		mWriteCount;
+};
+
+
+class InputEventBuffer: public SampleFramework::InputEventListener, public SampleAllocateable
+{
+public:
+
+	InputEventBuffer(PhysXSampleApplication& p);
+	virtual ~InputEventBuffer();
+
+	virtual	void	onKeyDownEx(SampleFramework::SampleUserInput::KeyCode keyCode, PxU32 wParam);
+	virtual	void	onAnalogInputEvent(const SampleFramework::InputEvent& , float val);
+	virtual	void	onDigitalInputEvent(const SampleFramework::InputEvent& , bool val);        
+	virtual	void	onPointerInputEvent(const SampleFramework::InputEvent&, PxU32 x, PxU32 y, PxReal dx, PxReal dy, bool val);
+			void 	clear();
+			void 	flush();
+private:
+	PX_FORCE_INLINE void checkResetLastInput()
+	{
+		if(mResetInputCacheReq!=mResetInputCacheAck)
+		{
+			mLastKeyDownEx = NULL;
+			mLastDigitalInput = NULL;
+			mLastAnalogInput = NULL;
+			mLastPointerInput = NULL;
+			mResetInputCacheAck++;
+			PX_ASSERT(mResetInputCacheReq==mResetInputCacheAck);
+		}
+	}
+	struct EventType
+	{
+        virtual ~EventType() {}
+		virtual void report(PhysXSampleApplication& app) const { }
+	};
+	struct KeyDownEx: public EventType
+	{ 
+		virtual void report(PhysXSampleApplication& app) const;
+
+		bool isEqual(SampleFramework::SampleUserInput::KeyCode _keyCode, PxU32 _wParam)
+		{
+			return (_keyCode == keyCode) && (_wParam == wParam);
+		}
+
+		SampleFramework::SampleUserInput::KeyCode keyCode;
+		PxU32 wParam;
+	};
+	struct AnalogInput: public EventType
+	{ 
+		virtual void report(PhysXSampleApplication& app) const;
+
+		bool isEqual(SampleFramework::InputEvent _e, float _val)
+		{
+			return (_e.m_Id == e.m_Id) && (_e.m_Analog == e.m_Analog) && (_e.m_Sensitivity == e.m_Sensitivity) && (_val == val);
+		}
+
+		SampleFramework::InputEvent e;
+		float val;
+	};
+	struct DigitalInput: public EventType
+	{ 
+		virtual void report(PhysXSampleApplication& app) const;
+
+		bool isEqual(SampleFramework::InputEvent _e, bool _val)
+		{
+			return (_e.m_Id == e.m_Id) && (_e.m_Analog == e.m_Analog) && (_e.m_Sensitivity == e.m_Sensitivity) && (_val == val);
+		}
+
+		SampleFramework::InputEvent e;
+		bool val;
+	};
+	struct PointerInput: public EventType
+	{ 
+		virtual void report(PhysXSampleApplication& app) const;
+
+		bool isEqual(SampleFramework::InputEvent _e, PxU32 _x, PxU32 _y, PxReal _dx, PxReal _dy, bool _val)
+		{
+			return (_e.m_Id == e.m_Id) && (_e.m_Analog == e.m_Analog) && (_e.m_Sensitivity == e.m_Sensitivity) && 
+				(_x == x) && (_y == y) && (_dx == dx) && (_dy == dy) && (_val == val);
+		}
+
+		SampleFramework::InputEvent e;
+		PxU32 x;
+		PxU32 y;
+		PxReal dx;
+		PxReal dy;
+		bool val;
+	};
+
+	struct EventsUnion
+	{
+			template<class Event> PX_CUDA_CALLABLE PX_FORCE_INLINE Event& get()
+			{
+				return reinterpret_cast<Event&>(events);
+			}
+			template<class Event> PX_CUDA_CALLABLE PX_FORCE_INLINE const Event& get() const
+			{
+				return reinterpret_cast<const Event&>(events);
+			}
+		union
+		{
+			PxU8	eventType[sizeof(EventType)];
+			PxU8	keyDownEx[sizeof(KeyDownEx)];
+			PxU8	analogInput[sizeof(AnalogInput)];
+			PxU8	digitalInput[sizeof(DigitalInput)];
+			PxU8	pointerInput[sizeof(PointerInput)];
+		} events;
+	};
+
+	static const PxU32					MAX_EVENTS = 64;
+	static const PxU32					MAX_MOUSE_EVENTS = 48;
+	static const PxU32					MAX_ANALOG_EVENTS = 48;
+	RingBuffer<EventsUnion, MAX_EVENTS>	mRingBuffer; 
+	volatile PxU32						mResetInputCacheReq;
+	volatile PxU32						mResetInputCacheAck;
+	KeyDownEx*							mLastKeyDownEx;
+	DigitalInput*						mLastDigitalInput;
+	AnalogInput*						mLastAnalogInput;
+	PointerInput*						mLastPointerInput;
+	PhysXSampleApplication&				mApp;
+	bool								mClearBuffer;
+};
+
+#endif