Skip to content

A fast 2D and 3D game engine — TypeScript SDK, C++/WebAssembly core, visual editor. Ship one project to web, desktop, WeChat MiniGames, playable ads, and native Android / iOS.

5.8 KB
Raw Blame
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// SPDX-FileCopyrightText: Copyright (c) 2008-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
// SPDX-License-Identifier: Apache-2.0

#include "CmCollection.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)
		{
			 PxGetFoundation().error(physx::PxErrorCode::eINVALID_PARAMETER, PX_FL,
		        "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))
		{
		   PxGetFoundation().error(physx::PxErrorCode::eINVALID_PARAMETER, PX_FL,
		        "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.size() + 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);
}