Initial commit:

PhysX 3.4.0 Update @ 21294896
APEX 1.4.0 Update @ 21275617

[CL 21300167]

1 files changed, 217 insertions, 0 deletions

diff --git a/PhysX_3.4/Source/Common/src/CmCollection.cpp b/PhysX_3.4/Source/Common/src/CmCollection.cpp
new file mode 100644
index 00000000..dc3634d7
--- /dev/null
+++ b/PhysX_3.4/Source/Common/src/CmCollection.cpp
@@ -0,0 +1,217 @@
+// 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.  
+
+#include "CmCollection.h"
+#include "PsFoundation.h"
+
+using namespace physx;
+using namespace Cm;
+
+void Collection::add(PxBase& object, PxSerialObjectId id)
+{
+	PxSerialObjectId originId = getId(object);
+	if( originId != PX_SERIAL_OBJECT_ID_INVALID)
+	{
+		if( originId != id)
+		{
+			 physx::shdfnd::getFoundation().error(physx::PxErrorCode::eINVALID_PARAMETER, __FILE__, __LINE__,
+		        "PxCollection::add called for an object that has an associated id already present in the collection!");
+		}
+		return;		   
+	}
+	
+	if(id != PX_SERIAL_OBJECT_ID_INVALID)
+	{		
+		if(!mIds.insert(id, &object))
+		{
+		   physx::shdfnd::getFoundation().error(physx::PxErrorCode::eINVALID_PARAMETER, __FILE__, __LINE__,
+		        "PxCollection::add called with an id which is already used in the collection");
+		   return;	
+		}
+	}
+    
+	mObjects[&object] = id;	
+}
+
+void Collection::remove(PxBase& object)
+{
+	PX_CHECK_AND_RETURN(contains(object), "PxCollection::remove called for an object not contained in the collection!");
+	
+	const ObjectToIdMap::Entry* e = mObjects.find(&object);
+	if(e)
+	{
+		mIds.erase(e->second);
+	    mObjects.erase(&object);
+	}
+}
+
+bool Collection::contains(PxBase& object) const
+{	
+	return  mObjects.find(&object) != NULL;
+}
+
+void Collection::addId(PxBase& object, PxSerialObjectId id)
+{
+	PX_CHECK_AND_RETURN(contains(object), "PxCollection::addId called for object that is not contained in the collection!");
+	PX_CHECK_AND_RETURN(id != PX_SERIAL_OBJECT_ID_INVALID, "PxCollection::addId called with PxSerialObjectId being set to PX_SERIAL_OBJECT_ID_INVALID!");
+	PX_CHECK_AND_RETURN(mIds.find(id) == NULL, "PxCollection::addId called with an id which is already used in the collection!");
+	
+	const ObjectToIdMap::Entry* e = mObjects.find(&object);
+	if(e  && e->second != PX_SERIAL_OBJECT_ID_INVALID)
+		mIds.erase(e->second);
+
+	mIds.insert(id, &object);	
+	mObjects[&object] = id;
+}
+
+void Collection::removeId(PxSerialObjectId id)
+{
+	PX_CHECK_AND_RETURN(id != PX_SERIAL_OBJECT_ID_INVALID, "PxCollection::removeId called with PxSerialObjectId being set to PX_SERIAL_OBJECT_ID_INVALID!");
+	PX_CHECK_AND_RETURN(mIds.find(id), "PxCollection::removeId called with PxSerialObjectId not contained in the collection!");
+	const IdToObjectMap::Entry* e = mIds.find(id);
+	if(e)
+	{	
+		mObjects[e->second] = PX_SERIAL_OBJECT_ID_INVALID;
+	    mIds.erase(id);	   
+	}
+}
+
+PxBase* Collection::find(PxSerialObjectId id) const
+{
+	PX_CHECK_AND_RETURN_NULL(id != PX_SERIAL_OBJECT_ID_INVALID, "PxCollection::find called with PxSerialObjectId being set to PX_SERIAL_OBJECT_ID_INVALID!");
+	const IdToObjectMap::Entry* e = mIds.find(id);
+	return e ? static_cast<PxBase*>(e->second) : NULL;
+}
+
+void Collection::add(PxCollection& _collection)
+{
+	Collection& collection = static_cast<Collection&>(_collection);
+	PX_CHECK_AND_RETURN(this != &collection, "PxCollection::add(PxCollection&) called with itself!");
+
+	mObjects.reserve(mObjects.capacity() + collection.mObjects.size());
+	const ObjectToIdMap::Entry* e = collection.mObjects.getEntries();
+	for (PxU32 i = 0; i < collection.mObjects.size(); ++i)
+	{
+        PxSerialObjectId id = e[i].second;
+		if( id != PX_SERIAL_OBJECT_ID_INVALID)
+		{
+			if(!mIds.insert(id, e[i].first))
+		    {
+			    if(mIds[id] != e[i].first)
+				{
+				    PX_CHECK_MSG( false, "PxCollection::add(PxCollection&) called with conflicting id!");
+				    mObjects.insert(e[i].first, PX_SERIAL_OBJECT_ID_INVALID);
+				}
+		    }
+			else
+			   mObjects[ e[i].first ] = id;
+		}
+		else
+		    mObjects.insert(e[i].first, PX_SERIAL_OBJECT_ID_INVALID);				
+	}
+}
+
+void Collection::remove(PxCollection& _collection)
+{
+	Collection& collection = static_cast<Collection&>(_collection);
+	PX_CHECK_AND_RETURN(this != &collection, "PxCollection::remove(PxCollection&) called with itself!");
+
+	const ObjectToIdMap::Entry* e = collection.mObjects.getEntries();
+	for (PxU32 i = 0; i < collection.mObjects.size(); ++i)
+	{
+		const ObjectToIdMap::Entry* e1 = mObjects.find(e[i].first);
+		if(e1)
+		{
+		    mIds.erase(e1->second);
+	        mObjects.erase(e1->first);
+		}
+	}
+}
+
+PxU32 Collection::getNbObjects() const
+{
+	return mObjects.size();
+}
+
+PxBase& Collection::getObject(PxU32 index) const
+{
+	PX_ASSERT(index < mObjects.size());
+	return *mObjects.getEntries()[index].first;
+}
+
+PxU32 Collection::getObjects(PxBase** userBuffer, PxU32 bufferSize, PxU32 startIndex) const
+{
+	PX_CHECK_AND_RETURN_NULL(userBuffer != NULL, "PxCollection::getObjects called with userBuffer NULL!");
+	PX_CHECK_AND_RETURN_NULL(bufferSize != 0, "PxCollection::getObjects called with bufferSize 0!");
+	PxU32 dstIndex = 0;
+	const ObjectToIdMap::Entry* e  = mObjects.getEntries();
+	for (PxU32 srcIndex = startIndex; srcIndex < mObjects.size() && dstIndex < bufferSize; ++srcIndex)
+		userBuffer[dstIndex++] = e[srcIndex].first;
+
+	return dstIndex;
+}
+
+PxU32 Collection::getNbIds() const
+{
+	return mIds.size();
+}
+
+PxSerialObjectId Collection::getId(const PxBase& object) const
+{	
+	const ObjectToIdMap::Entry* e =  mObjects.find(const_cast<PxBase*>(&object));
+	return e ? e->second : PX_SERIAL_OBJECT_ID_INVALID;
+}
+
+PxU32 Collection::getIds(PxSerialObjectId* userBuffer, PxU32 bufferSize, PxU32 startIndex) const
+{
+	PX_CHECK_AND_RETURN_NULL(userBuffer != NULL, "PxCollection::getIds called with userBuffer NULL!");
+	PX_CHECK_AND_RETURN_NULL(bufferSize != 0, "PxCollection::getIds called with bufferSize 0!");
+	PxU32 dstIndex = 0;
+
+	IdToObjectMap::Iterator srcIt = (const_cast<IdToObjectMap&>(mIds)).getIterator();
+
+	while (!srcIt.done() &&  dstIndex < bufferSize)
+	{
+		if(srcIt->first != PX_SERIAL_OBJECT_ID_INVALID)
+		{
+			if(startIndex > 0)
+				startIndex--;
+			else
+				userBuffer[dstIndex++] = srcIt->first;
+		}
+		srcIt++;
+	}
+
+	return dstIndex;
+}
+
+PxCollection*	PxCreateCollection()
+{
+	return PX_NEW(Collection);
+}