void PxCollectionExt::releaseObjects(PxCollection& collection, bool releaseExclusiveShapes)
{
shdfnd::Array<PxBase*> releasableObjects;
for (PxU32 i = 0; i < collection.getNbObjects(); ++i)
{
PxBase* s = &collection.getObject(i);
// pruning structure must be released before its actors
if(s->is<PxPruningStructure>())
{
if(!releasableObjects.empty())
{
PxBase* first = releasableObjects[0];
releasableObjects.pushBack(first);
releasableObjects[0] = s;
}
}
else
{
if (s->isReleasable() && (releaseExclusiveShapes || !s->is<PxShape>() || !s->is<PxShape>()->isExclusive()))
releasableObjects.pushBack(s);
}
}
for (PxU32 i = 0; i < releasableObjects.size(); ++i)
releasableObjects[i]->release();
while (collection.getNbObjects() > 0)
collection.remove(collection.getObject(0));
}
PxRigidActor* CPhysicManager::createFromFile(const std::string &file, int group, const IPhysic *component)
{
assert(m_scene);
PxSerializationRegistry* registry = PxSerialization::createSerializationRegistry(*m_physics);
PxDefaultFileInputData data(file.c_str());
PxCollection* collection;
collection = PxSerialization::createCollectionFromXml(data, *m_cooking, *registry);
m_scene->addCollection(*collection);
PxRigidActor *actor = nullptr;
for (unsigned int i=0; (i<collection->getNbObjects()) && !actor; i++) {
actor = collection->getObject(i).is<PxRigidActor>();
}
assert(actor);
actor->userData = (void*)component;
PxSetGroup(*actor,group);
collection->release();
registry->release();
return actor;
}
PxRigidActor* CServer::createFromFile(const std::string &file, int group, const IPhysics *component)
{
assert(_scene);
// Preparar parámetros para deserializar
PxSerializationRegistry* registry = PxSerialization::createSerializationRegistry(*_physics);
PxDefaultFileInputData data(file.c_str());
PxCollection* collection;
// Deserializar a partir del fichero RepX
collection = PxSerialization::createCollectionFromXml(data, *_cooking, *registry);
// Añadir entidades físicas a la escena
_scene->addCollection(*collection);
// Buscar una entidad de tipo PxRigidActor. Asumimos que hay exactamente 1 en el fichero.
PxRigidActor *actor = NULL;
for (unsigned int i=0; (i<collection->getNbObjects()) && !actor; i++) {
actor = collection->getObject(i).is<PxRigidActor>();
}
assert(actor);
// Anotar el componente lógico asociado a la entidad física
actor->userData = (void *) component;
// Establecer el grupo de colisión
PxSetGroup(*actor, group);
// Liberar recursos
collection->release();
registry->release();
return actor;
}
void PxCollectionExt::releaseObjects(PxCollection& collection)
{
shdfnd::Array<PxBase*> releasableObjects;
for (PxU32 i = 0; i < collection.getNbObjects(); ++i)
{
PxBase* s = &collection.getObject(i);
if(s->isReleasable())
releasableObjects.pushBack(s);
}
for (PxU32 i = 0; i < releasableObjects.size(); ++i)
releasableObjects[i]->release();
while (collection.getNbObjects() > 0)
collection.remove(collection.getObject(0));
}
void CEntity::deserializeFromRepXFile(const std::string &file, int group, const std::vector<int>& groupList, const Logic::IPhysics* component) {
// Obtenemos el puntero al servidor de fisicas
Physics::CServer* physicsServer = Physics::CServer::getSingletonPtr();
PxScene* scene = physicsServer->getActiveScene();
PxPhysics* physics = physicsServer->getPhysxSDK();
PxCooking* cooking = physicsServer->getCooking();
assert(scene);
// Preparar parámetros para deserializar
PxDefaultFileInputData data(file.c_str());
PxCollection* bufferCollection = physics->createCollection();
PxCollection* sceneCollection = physics->createCollection();
PxStringTable* stringTable = &PxStringTableExt::createStringTable( CServer::getSingletonPtr()->getFoundation()->getAllocatorCallback() );
PxUserReferences* externalRefs = NULL;
PxUserReferences* userRefs = NULL;
// Deserializar a partir del fichero RepX
repx::deserializeFromRepX(data, *physics, *cooking, stringTable, externalRefs,
*bufferCollection, *sceneCollection, userRefs);
// Añadir entidades físicas a la escena
physics->addCollection(*sceneCollection, *scene);
// Buscar una entidad de tipo PxRigidActor. Asumimos que hay exactamente 1 en el fichero.
_actor = NULL;
for (unsigned int i = 0; i < sceneCollection->getNbObjects() && !_actor; ++i) {
PxSerializable* p = sceneCollection->getObject(i);
_actor = p->is<PxRigidActor>();
}
assert(_actor);
// Anotar el componente lógico asociado a la entidad física
_actor->userData = (void*)component;
// Establecer el grupo de colisión
PxSetGroup(*_actor, group);
// Establecer los filtros de colisión
Physics::CServer::getSingletonPtr()->setupFiltering(_actor, group, groupList);
// Liberar recursos
bufferCollection->release();
sceneCollection->release();
}
void PxCollectionExt::remove(PxCollection& collection, PxType concreteType, PxCollection* to)
{
shdfnd::Array<PxBase*> removeObjects;
for (PxU32 i = 0; i < collection.getNbObjects(); i++)
{
PxBase& object = collection.getObject(i);
if(concreteType == object.getConcreteType())
{
if(to)
to->add(object);
removeObjects.pushBack(&object);
}
}
for (PxU32 i = 0; i < removeObjects.size(); ++i)
collection.remove(*removeObjects[i]);
}
void PxSerialization::createSerialObjectIds(PxCollection& collection, const PxSerialObjectId base)
{
PxSerialObjectId localBase = base;
PxU32 nbObjects = collection.getNbObjects();
for (PxU32 i = 0; i < nbObjects; ++i)
{
while(collection.find(localBase))
{
localBase++;
}
PxBase& s = collection.getObject(i);
if(PX_SERIAL_OBJECT_ID_INVALID == collection.getId(s))
{
collection.addId(s, localBase);
localBase++;
}
}
}
bool PhysXWorld::ExportWholeScene(const char *filename) const
{
using namespace physx::repx;
if (!PhysXSDK || !PhysXScene)
return false;
PxCollection *cl = PhysXSDK->createCollection();
if (!cl)
return false;
PhysxUserFileWriteStream fs(filename);
RepXCollection* theCollection = createCollection(PhysXSDK->getTolerancesScale(), PhysXFoundation->getAllocatorCallback());
RepXIdToRepXObjectMap* theIdMap = RepXIdToRepXObjectMap::create(PxGetFoundation().getAllocatorCallback());
addSDKItemsToRepX ( *PhysXSDK, *theIdMap, *theCollection); //add physcis object
addSceneItemsToRepX ( *PhysXScene, *theIdMap, *theCollection); //add physcis object
// physx::repx::addObjectsToScene(theCollection, physics, cooking, scene, mStringTable );
theCollection->save(fs);
theCollection->destroy();
theIdMap->destroy();
return true;
// PxCollectForExportSDK(*PhysXSDK, *cl);
// PxCollectForExportScene(*PhysXScene, *cl);
ObjectIterator iter = GameWorld().GetFirstOfAllObjects();
while( iter.current )
{
GameObject* o = iter.current;
if (o->PhysicsObject)
{
PxActor *a = o->PhysicsObject->getPhysicsActor();
PxSerialFlags f = a->getSerialFlags();
a->collectForExport(*cl);
break;
}
iter = GameWorld().GetNextOfAllObjects( iter );
}
PxU32 numObjs = cl->getNbObjects();
numObjs;
cl->serialize(fs);
PhysXSDK->releaseCollection(*cl);
fclose(fs.fpw);
FILE* fp=NULL;
if( (fp = fopen(filename, "rb")) )
{
fseek(fp, 0, SEEK_END);
PxU32 fileSize = ftell(fp);
fseek(fp, 0, SEEK_SET);
PX_ASSERT(fileSize!=0);
void* mem = malloc(fileSize+PX_SERIAL_FILE_ALIGN);
void* mem16 = (void*)((size_t(mem) + PX_SERIAL_FILE_ALIGN)&~(PX_SERIAL_FILE_ALIGN-1));
fread(mem16, 1, fileSize, fp);
fclose(fp);
PxUserReferences* convexRefs = PhysXSDK->createUserReferences();
PxCollection* collection = PhysXSDK->createCollection();
collection->deserialize(mem16, convexRefs, NULL);
PxU32 numObjs = collection->getNbObjects();
for (PxU32 i = 0; i < numObjs; ++i)
{
PxSerializable *o = collection->getObject(i);
const char * name = o->getConcreteTypeName();
PX_ASSERT(name);
}
}
return true;
}
bool PxSerialization::isSerializable(PxCollection& collection, PxSerializationRegistry& sr, const PxCollection* externalReferences)
{
PxCollection* subordinateCollection = PxCreateCollection();
PX_ASSERT(subordinateCollection);
for(PxU32 i = 0; i < collection.getNbObjects(); ++i)
{
PxBase& s = collection.getObject(i);
const PxSerializer* serializer = sr.getSerializer(s.getConcreteType());
PX_ASSERT(serializer);
if(serializer->isSubordinate())
subordinateCollection->add(s);
if(externalReferences)
{
PxSerialObjectId id = collection.getId(s);
if(id != PX_SERIAL_OBJECT_ID_INVALID)
{
PxBase* object = externalReferences->find(id);
if(object && (object != &s))
{
subordinateCollection->release();
Ps::getFoundation().error(physx::PxErrorCode::eINVALID_PARAMETER, __FILE__, __LINE__,
"PxSerialization::isSerializable: Reference id %llu used both in current collection and in externalReferences. "
"Please use unique identifiers.", id);
return false;
}
}
}
}
PxCollection* requiresCollection = PxCreateCollection();
PX_ASSERT(requiresCollection);
RequiresCallback requiresCallback0(*requiresCollection);
for (PxU32 i = 0; i < collection.getNbObjects(); ++i)
{
PxBase& s = collection.getObject(i);
const PxSerializer* serializer = sr.getSerializer(s.getConcreteType());
PX_ASSERT(serializer);
serializer->requires(s, requiresCallback0);
Cm::Collection* cmRequiresCollection = static_cast<Cm::Collection*>(requiresCollection);
for(PxU32 j = 0; j < cmRequiresCollection->getNbObjects(); ++j)
{
PxBase& s0 = cmRequiresCollection->getObject(j);
if(subordinateCollection->contains(s0))
{
subordinateCollection->remove(s0);
continue;
}
bool requiredIsInCollection = collection.contains(s0);
if(!requiredIsInCollection)
{
if(externalReferences)
{
if(!externalReferences->contains(s0))
{
Ps::getFoundation().error(physx::PxErrorCode::eINVALID_PARAMETER, __FILE__, __LINE__,
"PxSerialization::isSerializable: Object of type %s references a missing object of type %s. "
"The missing object needs to be added to either the current collection or the externalReferences collection.",
s.getConcreteTypeName(), s0.getConcreteTypeName());
}
else if(externalReferences->getId(s0) == PX_SERIAL_OBJECT_ID_INVALID)
{
Ps::getFoundation().error(physx::PxErrorCode::eINVALID_PARAMETER, __FILE__, __LINE__,
"PxSerialization::isSerializable: Object of type %s in externalReferences collection requires an id.",
s0.getConcreteTypeName());
}
else
continue;
}
else
{
Ps::getFoundation().error(physx::PxErrorCode::eINVALID_PARAMETER, __FILE__, __LINE__,
"PxSerialization::isSerializable: Object of type %s references a missing serial object of type %s. "
"Please completed the collection or specify an externalReferences collection containing the object.",
s.getConcreteTypeName(), s0.getConcreteTypeName());
}
subordinateCollection->release();
requiresCollection->release();
return false;
}
}
cmRequiresCollection->mObjects.clear();
}
requiresCollection->release();
PxU32 numOrphans = subordinateCollection->getNbObjects();
for(PxU32 j = 0; j < numOrphans; ++j)
{
PxBase& subordinate = subordinateCollection->getObject(j);
Ps::getFoundation().error(physx::PxErrorCode::eINVALID_PARAMETER, __FILE__, __LINE__,
"PxSerialization::isSerializable: An object of type %s is subordinate but not required "
"by other objects in the collection (orphan). Please remove the object from the collection or add its owner.",
subordinate.getConcreteTypeName());
}
subordinateCollection->release();
if(numOrphans>0)
return false;
if(externalReferences)
{
PxCollection* oppositeRequiresCollection = PxCreateCollection();
PX_ASSERT(oppositeRequiresCollection);
RequiresCallback requiresCallback(*oppositeRequiresCollection);
for (PxU32 i = 0; i < externalReferences->getNbObjects(); ++i)
{
PxBase& s = externalReferences->getObject(i);
const PxSerializer* serializer = sr.getSerializer(s.getConcreteType());
PX_ASSERT(serializer);
serializer->requires(s, requiresCallback);
Cm::Collection* cmCollection = static_cast<Cm::Collection*>(oppositeRequiresCollection);
for(PxU32 j = 0; j < cmCollection->getNbObjects(); ++j)
{
PxBase& s0 = cmCollection->getObject(j);
if(collection.contains(s0))
{
oppositeRequiresCollection->release();
Ps::getFoundation().error(physx::PxErrorCode::eINVALID_PARAMETER, __FILE__, __LINE__,
"PxSerialization::isSerializable: Object of type %s in externalReferences references an object "
"of type %s in collection (circular dependency).",
s.getConcreteTypeName(), s0.getConcreteTypeName());
return false;
}
}
cmCollection->mObjects.clear();
}
oppositeRequiresCollection->release();
}
return true;
}
bool PxSerialization::isSerializable(PxCollection& collection, PxSerializationRegistry& sr, const PxCollection* externalReferences)
{
bool bRet = true;
PxCollection* subordinateCollection = PxCreateCollection();
PX_ASSERT(subordinateCollection);
for(PxU32 i = 0; i < collection.getNbObjects(); ++i)
{
PxBase& s = collection.getObject(i);
const PxSerializer* serializer = sr.getSerializer(s.getConcreteType());
PX_ASSERT(serializer);
if(serializer->isSubordinate())
subordinateCollection->add(s);
if(externalReferences)
{
PxSerialObjectId id = collection.getId(s);
if(id != PX_SERIAL_OBJECT_ID_INVALID)
{
PxBase* object = externalReferences->find(id);
if(object && (object != &s))
{
subordinateCollection->release();
Ps::getFoundation().error(physx::PxErrorCode::eINVALID_PARAMETER, __FILE__, __LINE__,
"NpCollection::isSerializable: object shares reference name with other object in externalReferences (reference clash).");
return false;
}
}
}
}
PxCollection* requiresCollection = PxCreateCollection();
PX_ASSERT(requiresCollection);
RequiresCallback requiresCallback0(*requiresCollection);
for (PxU32 i = 0; i < collection.getNbObjects(); ++i)
{
PxBase& s = collection.getObject(i);
const PxSerializer* serializer = sr.getSerializer(s.getConcreteType());
PX_ASSERT(serializer);
serializer->requires(s, requiresCallback0);
}
for(PxU32 j = 0; j < subordinateCollection->getNbObjects(); ++j)
{
PxBase& subordinate = subordinateCollection->getObject(j);
bRet = requiresCollection->contains(subordinate);
if(!bRet)
{
requiresCollection->release();
subordinateCollection->release();
Ps::getFoundation().error(physx::PxErrorCode::eINVALID_PARAMETER, __FILE__, __LINE__,
"NpCollection::isSerializable: object is a subordinate and not required by other objects in the collection (orphan).");
return false;
}
}
subordinateCollection->release();
for(PxU32 j = 0; j < requiresCollection->getNbObjects(); ++j)
{
PxBase& s0 = requiresCollection->getObject(j);
bRet = collection.contains(s0);
if(!bRet && externalReferences)
{
bRet = externalReferences->contains(s0) && externalReferences->getId(s0) != PX_SERIAL_OBJECT_ID_INVALID;
}
if(!bRet)
{
requiresCollection->release();
Ps::getFoundation().error(physx::PxErrorCode::eINVALID_PARAMETER, __FILE__, __LINE__,
"NpCollection::isSerializable: cannot find a required serial object (collection is not complete).");
return false;
}
}
requiresCollection->release();
if(externalReferences)
{
PxCollection* oppsiteRequiresCollection = PxCreateCollection();
PX_ASSERT(oppsiteRequiresCollection);
RequiresCallback requiresCallback(*oppsiteRequiresCollection);
for (PxU32 i = 0; i < externalReferences->getNbObjects(); ++i)
{
PxBase& s = externalReferences->getObject(i);
const PxSerializer* serializer = sr.getSerializer(s.getConcreteType());
PX_ASSERT(serializer);
serializer->requires(s, requiresCallback);
}
for(PxU32 j = 0; j < oppsiteRequiresCollection->getNbObjects(); ++j)
{
PxBase& s0 = oppsiteRequiresCollection->getObject(j);
if(collection.contains(s0))
{
oppsiteRequiresCollection->release();
Ps::getFoundation().error(physx::PxErrorCode::eINVALID_PARAMETER, __FILE__, __LINE__,
"NpCollection::isSerializable: object in externalReferences requires an object in collection (circular dependency).");
return false;
}
}
oppsiteRequiresCollection->release();
}
return true;
}