NxApexActor* ImpactEmitterAsset::createApexActor(const NxParameterized::Interface& parms, NxApexScene& apexScene)
{
NX_WRITE_ZONE();
if (!isValidForActorCreation(parms, apexScene))
{
return NULL;
}
NxApexActor* ret = 0;
const char* className = parms.className();
if (strcmp(className, ImpactEmitterActorParameters::staticClassName()) == 0)
{
EmitterScene* es = mModule->getEmitterScene(apexScene);
ImpactEmitterActor* actor = PX_NEW(ImpactEmitterActor)(parms, *this, mEmitterActors, *es);
if (!actor->isValid())
{
actor->destroy();
return NULL;
}
ret = actor;
}
else
{
APEX_INVALID_OPERATION("%s is not a valid descriptor class, expecting %s", className, ImpactEmitterActorParameters::staticClassName());
}
return ret;
}
void ProfileZoneHandler::onZoneAdded( PxProfileZone& inSDK )
{
if(strstr(mProfileZoneNames,inSDK.getName()))
{
ProfileZoneInterface* pzInt = PX_NEW (ProfileZoneInterface)(inSDK, mBufferedProfiler);
inSDK.addClient(*pzInt);
mProfileZoneInterfaces.pushBack(pzInt);
}
}
FileRenderDebug(const char *fileName,bool readAccess,bool echoLocally)
{
mLastDisplayType = PxProcessRenderDebug::DT_LAST;
mData = NULL;
mPrimitives = NULL;
mPrimitiveCount = 0;
mCurrentFrame = 0;
mFrameItemCount = 0;
mFrameStart = 0;
mFrameCount = 0;
mReadAccess = readAccess;
mEchoLocally = NULL;
if ( echoLocally )
{
mEchoLocally = createProcessRenderDebug();
}
mFileBuffer = PX_NEW(PxFileBuffer)(fileName, readAccess ? PxFileBuf::OPEN_READ_ONLY : PxFileBuf::OPEN_WRITE_ONLY);
if ( mFileBuffer->isOpen() )
{
if ( mReadAccess )
{
char temp[4];
PxU32 r = mFileBuffer->read(temp,4);
PxU32 version = mFileBuffer->readDword();
if ( r == 4 && magic[0] == temp[0] && magic[1] == temp[1] && magic[2] == temp[2] && magic[3] == temp[3] && version == MAGIC_VERSION )
{
// it's valid!
FrameHeader h;
while ( readFrameHeader(h,*mFileBuffer ) )
{
mFrameHeaders.pushBack(h);
}
mFrameCount = mFrameHeaders.size();
}
else
{
delete mFileBuffer;
mFileBuffer = NULL;
}
}
else
{
mFileBuffer->write(magic, 4 );
mFileBuffer->storeDword(MAGIC_VERSION);
mFileBuffer->flush();
}
}
else
{
delete mFileBuffer;
mFileBuffer = NULL;
}
}
PxFileRenderDebug * createFileRenderDebug(const char *fileName,
bool readAccess,
bool echoLocally)
{
FileRenderDebug *f = PX_NEW(FileRenderDebug)(fileName,readAccess,echoLocally);
if (!f->isOk() )
{
delete f;
f = NULL;
}
return static_cast< PxFileRenderDebug *>(f);
}
void ImpactEmitterAsset::buildEventNameIndexMap()
{
// destroy old mappings
for (physx::PxU32 j = 0; j < mEventNameIndexMaps.size(); j++)
{
if (mEventNameIndexMaps[j])
{
delete mEventNameIndexMaps[j];
}
}
// loop through all event sets, build a mapping for each new name found
// and store all indices for that event set
NxParamArray<NxParameterized::Interface*> assetEventSets(mParams,
"eventSetList",
(NxParamDynamicArrayStruct*) & (mParams->eventSetList));
for (physx::PxU32 i = 0; i < assetEventSets.size(); i++)
{
NxParameterized::Handle hEventSetName(*assetEventSets[i]);
const char* paramEventSetName = 0;
NxParameterized::getParamString(*(assetEventSets[i]), "eventSetName", paramEventSetName);
if (!paramEventSetName)
{
APEX_DEBUG_WARNING("Invalid eventSetName from Impact Emitter event sets");
continue;
}
/* first see if the name is already here */
bool foundEventSet = false;
for (physx::PxU32 j = 0; j < mEventNameIndexMaps.size(); j++)
{
if (mEventNameIndexMaps[j]->eventSetName == paramEventSetName)
{
// add index to list
mEventNameIndexMaps[j]->eventIndices.pushBack((physx::PxU16)i);
foundEventSet = true;
}
}
if (!foundEventSet)
{
/* now add it to the list */
EventNameIndexMap* newMap = PX_NEW(EventNameIndexMap)();
newMap->eventSetName = paramEventSetName;
newMap->eventIndices.pushBack((physx::PxU16)i);
mEventNameIndexMaps.pushBack(newMap);
}
}
}
void MirrorScene::mirrorShape(const PxTriggerPair &tp)
{
size_t hash = (size_t)tp.otherShape;
const ShapeHash::Entry *found = mShapes.find(hash);
MirrorActor *ma = found ? found->second : NULL;
if ( tp.flags & PxTriggerPairFlag::eDELETED_SHAPE_OTHER )
{
if ( found )
{
bool kill = ma->removeShape();
mShapes.erase(hash);
if ( kill )
{
ma->release();
mActors.erase( ma->mActorHash );
}
}
}
else if ( tp.status == PxPairFlag::eNOTIFY_TOUCH_FOUND )
{
PX_ASSERT( found == NULL );
size_t actorHash = (size_t) &tp.otherActor;
const ActorHash::Entry *foundActor = mActors.find(actorHash);
if ( foundActor == NULL )
{
ma = PX_NEW(MirrorActor)(actorHash,*tp.otherActor,*this);
mActors[actorHash] = ma;
}
else
{
ma = foundActor->second;
}
ma->addShape();
mShapes[hash] = ma;
}
else if ( tp.status == PxPairFlag::eNOTIFY_TOUCH_LOST )
{
PX_ASSERT( found );
if ( ma )
{
bool kill = ma->removeShape();
mShapes.erase(hash);
if ( kill )
{
mActors.erase( ma->mActorHash );
ma->release();
}
}
}
}
void ApexRenderMeshAsset::setSubmeshCount(physx::PxU32 submeshCount)
{
const physx::PxU32 oldSize = mSubmeshes.size();
for (physx::PxU32 i = oldSize; i-- > submeshCount;)
{
PX_DELETE(mSubmeshes[i]);
}
mSubmeshes.resize(submeshCount);
for (physx::PxU32 i = oldSize; i < submeshCount; ++i)
{
mSubmeshes[i] = PX_NEW(ApexRenderSubmesh);
}
}
PxCpuDispatcher* createDefaultThreadPool(unsigned int numThreads)
{
if (numThreads == 0)
{
#if defined(PX_WINDOWS)
numThreads = 4;
#elif defined(PX_X360)
numThreads = 3;
#elif defined(PX_PS3)
numThreads = 2;
#elif defined(PX_APPLE)
numThreads = 2;
#endif
}
return PX_NEW(DefaultCpuDispatcher)(numThreads, 0);
}
ClothingRenderProxy* ClothingScene::getRenderProxy(NiApexRenderMeshAsset* rma, bool useFallbackSkinning, bool useCustomVertexBuffer, const HashMap<PxU32, ApexSimpleString>& overrideMaterials, const PxVec3* morphTargetNewPositions, const PxU32* morphTargetVertexOffsets)
{
if (rma == NULL)
{
return NULL;
}
ClothingRenderProxy* renderProxy = NULL;
mRenderProxiesLock.lock();
Array<ClothingRenderProxy*>& renderProxies = mRenderProxies[rma];
for (PxU32 i = 0; i < renderProxies.size(); ++i)
{
ClothingRenderProxy* proxyInPool = renderProxies[i];
if (
proxyInPool->getTimeInPool() > 0 && // proxy is available
useFallbackSkinning == proxyInPool->usesFallbackSkinning() &&
useCustomVertexBuffer == proxyInPool->usesCustomVertexBuffer() &&
morphTargetNewPositions == proxyInPool->getMorphTargetBuffer() &&
proxyInPool->overrideMaterialsEqual(overrideMaterials)
)
{
renderProxy = proxyInPool;
break;
}
}
// no corresponding proxy in pool, so create one
if (renderProxy == NULL)
{
renderProxy = PX_NEW(ClothingRenderProxy)(rma, useFallbackSkinning, useCustomVertexBuffer, overrideMaterials, morphTargetNewPositions, morphTargetVertexOffsets, this);
renderProxies.pushBack(renderProxy);
}
renderProxy->setTimeInPool(0);
mRenderProxiesLock.unlock();
return renderProxy;
}
/* == Internal ResourceProviderIntl interface == */
ResID ApexResourceProvider::createNameSpaceInternal(const char* &nameSpace, bool releaseAtExit)
{
/* create or get a name space */
size_t nextID = mResources.size();
ResID nsID = mNSNames.getOrCreateID(nameSpace, "NameSpace");
if (nsID == (ResID) nextID)
{
NameSpace* ns = PX_NEW(NameSpace)(this, nsID, releaseAtExit, nameSpace);
if (ns)
{
ResID id = getNSID(nameSpace);
mNSID.insert(id, mNameSpaces.size());
mResources[nsID].ptr = (void*)(size_t) id;
mNameSpaces.pushBack(ns);
}
else
{
return INVALID_RESOURCE_ID;
}
}
ResID ret = (ResID)(size_t) mResources[nsID].ptr;
return ret;
}
PxDefaultBufferedProfiler* PxDefaultBufferedProfilerCreate(PxFoundation & foundation, const char * profileZoneNames)
{
PxDefaultBufferedProfiler* retVal = PX_NEW(Ext::DefaultBufferedProfiler)(foundation, profileZoneNames);
return retVal;
}
void instantiateModuleClothingLegacy()
{
ApexSDKIntl *sdk = GetInternalApexSDK();
ModuleClothingLegacy *impl = PX_NEW(ModuleClothingLegacy)(sdk);
sdk->registerExternalModule((Module *) impl, (ModuleIntl *) impl);
}
NxRenderMeshActor* ApexRenderMeshAsset::createActor(const NxRenderMeshActorDesc& desc)
{
return PX_NEW(ApexRenderMeshActor)(desc, *this, mActorList);
}
PxSpatialIndex* PxCreateSpatialIndex()
{
return PX_NEW(NpSpatialIndex)();
}
NpSpatialIndex::NpSpatialIndex()
: mPendingUpdates(false)
{
mPruner = PX_NEW(Sq::AABBPruner)(true);
}
