Initial commit:

PhysX 3.4.0 Update @ 21294896
APEX 1.4.0 Update @ 21275617

[CL 21300167]

2 files changed, 342 insertions, 0 deletions

diff --git a/PhysX_3.4/Snippets/SnippetUtils/SnippetUtils.cpp b/PhysX_3.4/Snippets/SnippetUtils/SnippetUtils.cpp
new file mode 100644
index 00000000..20afaaa9
--- /dev/null
+++ b/PhysX_3.4/Snippets/SnippetUtils/SnippetUtils.cpp
@@ -0,0 +1,214 @@
+// 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.
+
+#include "SnippetUtils.h"
+
+#include "foundation/PxSimpleTypes.h"
+
+#include "CmPhysXCommon.h"
+
+#include "PsAtomic.h"
+#include "PsString.h"
+#include "PsSync.h"
+#include "PsThread.h"
+#include "PsTime.h"
+#include "PsMutex.h"
+#include "PsAllocator.h"
+#include "extensions/PxDefaultAllocator.h"
+
+
+namespace physx
+{
+
+namespace
+{
+PxDefaultAllocator gUtilAllocator;
+
+struct UtilAllocator // since we're allocating internal classes here, make sure we align properly
+{
+	void* allocate(size_t size,const char* file,  PxU32 line) 	{ return gUtilAllocator.allocate(size, NULL, file, int(line));		}
+	void deallocate(void* ptr)									{ gUtilAllocator.deallocate(ptr);								}
+};
+}
+
+
+namespace SnippetUtils
+{
+
+	PxI32 atomicIncrement(volatile PxI32* val)
+	{
+		return Ps::atomicIncrement(val);
+	}
+
+	PxI32 atomicDecrement(volatile PxI32* val)
+	{
+		return Ps::atomicDecrement(val);
+	}
+
+	//******************************************************************************//
+
+	PxU32 getNbPhysicalCores()
+	{
+		return Ps::Thread::getNbPhysicalCores();
+	}
+
+	//******************************************************************************//
+
+	PxU32 getThreadId()
+	{
+		return static_cast<PxU32>(Ps::Thread::getId());
+	}
+
+	//******************************************************************************//
+
+	PxU64 getCurrentTimeCounterValue()
+	{
+		return Ps::Time::getCurrentCounterValue();
+	}
+
+	PxReal getElapsedTimeInMilliseconds(const PxU64 elapsedTime)
+	{
+		return Ps::Time::getCounterFrequency().toTensOfNanos(elapsedTime)/(100.0f * 1000.0f);
+	}
+
+	PxReal getElapsedTimeInMicroSeconds(const PxU64 elapsedTime)
+	{
+		return Ps::Time::getCounterFrequency().toTensOfNanos(elapsedTime)/(100.0f);
+	}
+
+	//******************************************************************************//
+
+	struct Sync: public Ps::SyncT<UtilAllocator> {};
+
+	Sync* syncCreate()
+	{
+		return new(gUtilAllocator.allocate(sizeof(Sync), 0, 0, 0)) Sync();
+	}
+
+	void syncWait(Sync* sync)
+	{
+		sync->wait();
+	}
+
+	void syncSet(Sync* sync)
+	{
+		sync->set();
+	}
+
+	void syncReset(Sync* sync)
+	{
+		sync->reset();
+	}
+	
+	void syncRelease(Sync* sync)
+	{
+		sync->~Sync();
+		gUtilAllocator.deallocate(sync);
+	}
+
+	//******************************************************************************//
+
+	struct Thread: public Ps::ThreadT<UtilAllocator>
+	{
+		Thread(ThreadEntryPoint entryPoint, void* data): 
+			Ps::ThreadT<UtilAllocator>(),
+			mEntryPoint(entryPoint),
+			mData(data)
+		{
+		}
+
+		virtual void execute(void)											
+		{ 
+			mEntryPoint(mData);
+		}
+
+		ThreadEntryPoint mEntryPoint;
+		void* mData;
+	};
+
+	Thread* threadCreate(ThreadEntryPoint entryPoint, void* data)
+	{
+		Thread* createThread = static_cast<Thread*>(gUtilAllocator.allocate(sizeof(Thread), 0, 0, 0));
+		PX_PLACEMENT_NEW(createThread, Thread(entryPoint, data));
+		createThread->start();
+		return createThread;
+	}
+
+	void threadQuit(Thread* thread)
+	{
+		thread->quit();
+	}
+
+	void threadSignalQuit(Thread* thread)
+	{
+		thread->signalQuit();
+	}
+
+	bool threadWaitForQuit(Thread* thread)
+	{
+		return thread->waitForQuit();
+	}
+
+	bool threadQuitIsSignalled(Thread* thread)
+	{
+		return thread->quitIsSignalled();
+	}
+
+	void threadRelease(Thread* thread)
+	{
+		thread->~Thread();
+		gUtilAllocator.deallocate(thread);
+	}
+
+	//******************************************************************************//
+
+	struct Mutex: public Ps::MutexT<UtilAllocator> {};
+
+	Mutex* mutexCreate()
+	{
+		return new(gUtilAllocator.allocate(sizeof(Mutex), 0, 0, 0)) Mutex();
+	}
+
+	void mutexLock(Mutex* mutex)
+	{
+		mutex->lock();
+	}
+
+	void mutexUnlock(Mutex* mutex)
+	{
+		mutex->unlock();
+	}
+
+	void mutexRelease(Mutex* mutex)
+	{
+		mutex->~Mutex();
+		gUtilAllocator.deallocate(mutex);
+	}
+
+
+} // namespace physXUtils
+} // namespace physx
diff --git a/PhysX_3.4/Snippets/SnippetUtils/SnippetUtils.h b/PhysX_3.4/Snippets/SnippetUtils/SnippetUtils.h
new file mode 100644
index 00000000..060d18a9
--- /dev/null
+++ b/PhysX_3.4/Snippets/SnippetUtils/SnippetUtils.h
@@ -0,0 +1,128 @@
+// 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.
+
+#include "foundation/PxSimpleTypes.h"
+
+namespace physx
+{
+	namespace SnippetUtils
+	{
+
+		/* Increment the specified location. Return the incremented value. */
+		PxI32 atomicIncrement(volatile PxI32* val);
+
+		/* Decrement the specified location. Return the decremented value. */
+		PxI32 atomicDecrement(volatile PxI32* val);
+
+		//******************************************************************************//
+		
+		/* Return the number of physical cores (does not include hyper-threaded cores), returns 0 on failure. */
+		PxU32 getNbPhysicalCores();
+
+		//******************************************************************************//
+
+		/* Return the id of a thread. */
+		PxU32 getThreadId();
+
+		//******************************************************************************//
+
+		/* Return the current time */
+		PxU64 getCurrentTimeCounterValue();
+
+		/* Convert to milliseconds an elapsed time computed from the difference of the times returned from two calls to getCurrentTimeCounterValue. */
+		PxReal getElapsedTimeInMilliseconds(const PxU64 elapsedTime);
+
+		/* Convert to microseconds an elapsed time computed from the difference of the times returned from two calls to getCurrentTimeCounterValue. */
+		PxReal getElapsedTimeInMicroSeconds(const PxU64 elapsedTime);
+
+		//******************************************************************************//
+
+		struct Sync;
+
+		/* Create a sync object. Returns a unique handle to the sync object so that it may be addressed through syncWait etc. */
+		Sync* syncCreate();
+
+		/* Wait indefinitely until the specified sync object is signaled. */
+		void syncWait(Sync* sync);
+
+		/* Signal the specified synchronization object, waking all threads waiting on it. */
+		void syncSet(Sync* sync);
+
+		/** Reset the specified synchronization object. */
+		void syncReset(Sync* sync);
+
+		/* Release the specified sync object so that it may be reused with syncCreate. */
+		void syncRelease(Sync* sync);
+
+
+		//******************************************************************************//
+
+		struct Thread;
+
+		/* Prototype of callback passed to threadCreate. */
+		typedef void (*ThreadEntryPoint)(void*);
+
+		/* Create a thread object and return a unique handle to the thread object so that it may be addressed through threadStart etc. 
+		entryPoint implements ThreadEntryPoint and data will be passed as a function argument, POSIX-style. */
+		Thread* threadCreate(ThreadEntryPoint entryPoint, void* data);
+
+		/* Cleanly shut down the specified thread. Called in the context of the spawned thread. */
+		void threadQuit(Thread* thread);
+
+		/* Stop the specified thread. Signals the spawned thread that it should stop, so the 
+		thread should check regularly. */
+		void threadSignalQuit(Thread* thread);
+
+		/* Wait for the specified thread to stop. Should be called in the context of the spawning
+		thread. Returns false if the thread has not been started.*/
+		bool threadWaitForQuit(Thread* thread);
+
+		/* Check whether the thread is signalled to quit. Called in the context of the
+		spawned thread. */
+		bool threadQuitIsSignalled(Thread* thread);
+
+		/* Release the specified thread object so that it may be reused with threadCreate. */
+		void threadRelease(Thread* thread);
+
+		//******************************************************************************//
+
+		struct Mutex;
+
+		/* Create a mutex object and return a unique handle to the mutex object so that it may be addressed through mutexLock etc. */
+		Mutex* mutexCreate();
+
+		/* Acquire (lock) the specified mutex. If the mutex is already locked by another thread, this method blocks until the mutex is unlocked.*/
+		void mutexLock(Mutex* mutex);
+
+		/* Release (unlock) the specified mutex, the calling thread must have previously called lock() or method will error. */
+		void mutexUnlock(Mutex* mutex);
+
+		/* Release the specified mutex so that it may be reused with mutexCreate. */
+		void mutexRelease(Mutex* mutex);
+
+	}
+}