void DefaultCpuDispatcher::flush( PxBaseTask& task, PxI32 targetRef)
{
// TODO: implement
PX_ALWAYS_ASSERT();
PX_UNUSED(task);
PX_UNUSED(targetRef);
}
virtual void reportError(physx::PxErrorCode::Enum code, const char* message, const char* file, int line)
{
PX_UNUSED(code);
PX_UNUSED(file);
PX_UNUSED(line);
printf("PhysX: %s\r\n", message );
}
extern "C" void CUDARTAPI __cudaRegisterShared(
void** fatCubinHandle,
void** devicePtr
)
{
PX_UNUSED(fatCubinHandle);
PX_UNUSED(devicePtr);
}
virtual void* allocate(size_t size, const char* typeName, const char* filename, int line)
{
PX_UNUSED(typeName);
PX_UNUSED(filename);
PX_UNUSED(line);
void *ret = platformAlignedAlloc(size);
return ret;
}
cudaError_t CUDARTAPI cudaSetupArgument(
const void* arg,
size_t size,
size_t offset)
{
PX_UNUSED(arg);
PX_UNUSED(size);
PX_UNUSED(offset);
return cudaSuccess;
}
void onTrigger(PxTriggerPair* pairs, PxU32 count) {
PX_UNUSED(pairs); PX_UNUSED(count);
for (PxU32 i = 0; i < count; i++)
{
// ignore pairs when shapes have been deleted
if (pairs[i].flags & (PxTriggerPairFlag::eREMOVED_SHAPE_TRIGGER |
PxTriggerPairFlag::eREMOVED_SHAPE_OTHER))
continue;
//printf("Trigger:%d-%d\n", pairs[i].otherShape, pairs[i].triggerShape);
}
}
void PxTaskMgr::emitStopEvent(PxBaseTask& basetask, uint32_t threadId)
{
PxBaseTask* tmp = &basetask;
PX_UNUSED(tmp);
PX_UNUSED(threadId);
/* This does not need a lock! */
#if PX_SUPPORT_PXTASK_PROFILING
//PX_COMPILE_TIME_ASSERT(sizeof(PxProfileEventId::mEventId) == sizeof(PxBaseTask::mEventID));
PX_PROFILE_STOP_CROSSTHREAD(basetask.getName(),0);
#endif
}
void CUDARTAPI __cudaRegisterFunction(
void** fatCubinHandle,
const char* hostFun,
char* deviceFun,
const char* deviceName,
int thread_limit,
uint3* tid,
uint3* bid,
dim3* bDim,
dim3* gDim,
int* wSize)
{
PX_UNUSED(hostFun);
PX_UNUSED(deviceFun);
PX_UNUSED(thread_limit);
PX_UNUSED(tid);
PX_UNUSED(bid);
PX_UNUSED(bDim);
PX_UNUSED(gDim);
PX_UNUSED(wSize);
if (numRegisteredFunctions < MAX_FUNCTIONS)
{
// We need this association of function to module in order to find textures and globals
functionTable[ numRegisteredFunctions ].modIndex = (int)(size_t) fatCubinHandle;
functionTable[ numRegisteredFunctions ].funcName = deviceName;
funcNameTable[ numRegisteredFunctions ] = deviceName;
numRegisteredFunctions++;
}
}
extern "C" void CUDARTAPI __cudaRegisterVar(
void** fatCubinHandle,
char* hostVar,
char* deviceAddress,
const char* deviceName,
int ext,
int size,
int constant,
int global)
{
PX_UNUSED(fatCubinHandle);
PX_UNUSED(hostVar);
PX_UNUSED(deviceAddress);
PX_UNUSED(deviceName);
PX_UNUSED(ext);
PX_UNUSED(size);
PX_UNUSED(constant);
PX_UNUSED(global);
if (constant != 0 && numRegisteredVariables < MAX_VARIABLES)
{
variableTable[ numRegisteredVariables ].modIndex = (int)(size_t) fatCubinHandle;
variableTable[ numRegisteredVariables ].varName = deviceName;
variableTable[ numRegisteredVariables ].size = size;
numRegisteredVariables++;
}
}
void SampleApexResourceCallback::releaseResource(const char* nameSpace, const char* name, void* resource)
{
PX_ASSERT(resource);
PX_UNUSED(name);
if (resource)
{
#if DEBUG_RESOURCE_REQUESTS
fprintf(gDebugOutput, "free - %s\n", name);
#endif
if (!strcmp(nameSpace, APEX_MATERIALS_NAME_SPACE))
{
SampleFramework::SampleMaterialAsset* asset = static_cast<SampleFramework::SampleMaterialAsset*>(resource);
m_assetManager.returnAsset(*asset);
}
else if (!strcmp(nameSpace, APEX_CUSTOM_VB_NAME_SPACE))
{
delete(char*) resource; // char* allocated above with new
}
else if (!strcmp(nameSpace, APEX_COLLISION_GROUP_128_NAME_SPACE))
{
PX_ALWAYS_ASSERT();
}
else if (!strcmp(nameSpace, APEX_COLLISION_GROUP_64_NAME_SPACE))
{
PX_ALWAYS_ASSERT();
}
else
{
nvidia::apex::Asset* asset = (nvidia::apex::Asset*)resource;
m_apexSDK->releaseAsset(*asset);
}
m_numGets--;
}
}
PxU32 DefaultCpuDispatcher::getAffinityMask(PxU32 numThreads)
{
PX_UNUSED(numThreads);
PX_ASSERT(numThreads);
#ifdef PX_X360
switch (numThreads)
{
case 1:
return 0x01;
case 2:
return 0x14;
case 3:
return 0x15;
case 4:
return 0x3c;
case 5:
return 0x3e;
case 6:
return 0x3f;
default:
return 0x0;
}
#else
return 0;
#endif
}
void CUDARTAPI __cudaRegisterTexture(
void** fatCubinHandle,
const struct textureReference* hostvar,
const void** deviceAddress,
const char* deviceName,
int dim,
int read_normalized_float,
int ext)
{
PX_UNUSED(fatCubinHandle);
PX_UNUSED(hostvar);
PX_UNUSED(deviceAddress);
PX_UNUSED(deviceName);
PX_UNUSED(dim);
PX_UNUSED(read_normalized_float);
PX_UNUSED(ext);
if (numRegisteredTextures < MAX_TEXTURES)
{
//Fix for CUDA 5.5 - remove leading "::"
while (*deviceName == ':')
{
++deviceName;
}
// We need this association of function to module in order to find textures and globals
textureTable[ numRegisteredTextures ].modIndex = (int)(size_t) fatCubinHandle;
textureTable[ numRegisteredTextures ].texRefName = deviceName;
textureTable[ numRegisteredTextures ].texRefData = hostvar;
textureTable[ numRegisteredTextures ].dim = dim;
textureTable[ numRegisteredTextures ].read_normalized_float = read_normalized_float;
numRegisteredTextures++;
}
}
PxSceneQueryHitType::Enum VehicleWheelRaycastPreFilter
(
PxFilterData filterData0,
PxFilterData filterData1,
const void* constantBlock,
PxU32 constantBlockSize,
PxSceneQueryFilterFlags& filterFlags
)
{
//filterData0 is the vehicle suspension raycast.
//filterData1 is the shape potentially hit by the raycast.
PX_UNUSED(filterFlags);
PX_UNUSED(constantBlockSize);
PX_UNUSED(constantBlock);
PX_UNUSED(filterData0);
PxSceneQueryHitType::Enum ht = ((0 == (filterData1.word3 & VEHICLE_DRIVABLE_SURFACE)) ? PxSceneQueryHitType::eNONE : PxSceneQueryHitType::eBLOCK);
return ht;
}
ClothFactory ClothingScene::getClothFactory(bool& useCuda)
{
#ifdef PX_WINDOWS
if (useCuda)
{
if (mGpuFactory.factory == NULL)
{
PxCudaContextManager* contextManager = NULL;
PxGpuDispatcher* gpuDispatcher = mApexScene->getTaskManager()->getGpuDispatcher();
if (gpuDispatcher != NULL)
{
contextManager = gpuDispatcher->getCudaContextManager();
}
if (contextManager != NULL)
{
mGpuFactory = mModule->createClothFactory(contextManager);
if (mGpuFactory.factory != NULL)
{
NiApexSDK* apexSdk = NiGetApexSDK();
mPhysXGpuIndicator = apexSdk->registerPhysXIndicatorGpuClient();
}
}
}
//APEX_DEBUG_INFO("Gpu Factory %p", mGpuFactory);
if (mGpuFactory.factory != NULL)
{
return mGpuFactory;
}
else
{
APEX_DEBUG_INFO("Gpu Factory could not be created");
useCuda = false;
}
}
if (!useCuda)
#else
PX_UNUSED(useCuda);
#endif
{
if (mCpuFactory.factory == NULL)
{
mCpuFactory = mModule->createClothFactory(NULL);
}
//APEX_DEBUG_INFO("Cpu Factory %p", mCpuFactory.factory);
return mCpuFactory;
}
#ifdef PX_WINDOWS
PX_ALWAYS_ASSERT_MESSAGE("this code path is unreachable, at least it used to be.");
return ClothFactory(NULL, NULL);
#endif
}
void ApexCudaProfileSession::onFuncFinish(uint32_t id, void* stream)
{
PX_UNUSED(id);
ProfileData& data = mProfileDataList.back();
PX_ASSERT(data.id == id);
CUT_SAFE_CALL(cuEventRecord((CUevent)data.stop, (CUstream)stream));
mLock.unlock();
}
void MutexImpl::lock()
{
int err = pthread_mutex_lock(&getMutex(this)->lock);
PX_ASSERT(!err);
PX_UNUSED(err);
#if PX_DEBUG
getMutex(this)->owner = Thread::getId();
#endif
}
void RTree::validateRecursive(PxU32 level, RTreeNodeQ parentBounds, RTreePage* page, CallbackRefit* cbLeaf)
{
PX_UNUSED(parentBounds);
static PxU32 validateCounter = 0; // this is to suppress a warning that recursive call has no side effects
validateCounter++;
RTreeNodeQ n;
PxU32 pageNodeCount = page->nodeCount();
for (PxU32 j = 0; j < pageNodeCount; j++)
{
page->getNode(j, n);
if (page->isEmpty(j))
continue;
PX_ASSERT(n.minx >= parentBounds.minx); PX_ASSERT(n.miny >= parentBounds.miny); PX_ASSERT(n.minz >= parentBounds.minz);
PX_ASSERT(n.maxx <= parentBounds.maxx); PX_ASSERT(n.maxy <= parentBounds.maxy); PX_ASSERT(n.maxz <= parentBounds.maxz);
if (!n.isLeaf())
{
PX_ASSERT((n.ptr&1) == 0);
RTreePage* childPage = (RTreePage*)(size_t(CONVERT_PTR_TO_INT(reinterpret_cast<size_t>(get64BitBasePage()))) + n.ptr);
validateRecursive(level+1, n, childPage, cbLeaf);
} else if (cbLeaf)
{
Vec3V mnv, mxv;
cbLeaf->recomputeBounds(page->ptrs[j] & ~1, mnv, mxv);
PxVec3 mn3, mx3; V3StoreU(mnv, mn3); V3StoreU(mxv, mx3);
const PxBounds3 lb(mn3, mx3);
const PxVec3& mn = lb.minimum; const PxVec3& mx = lb.maximum; PX_UNUSED(mn); PX_UNUSED(mx);
PX_ASSERT(mn.x >= n.minx); PX_ASSERT(mn.y >= n.miny); PX_ASSERT(mn.z >= n.minz);
PX_ASSERT(mx.x <= n.maxx); PX_ASSERT(mx.y <= n.maxy); PX_ASSERT(mx.z <= n.maxz);
}
}
RTreeNodeQ recomputedBounds;
page->computeBounds(recomputedBounds);
PX_ASSERT((recomputedBounds.minx - parentBounds.minx)<=RTREE_INFLATION_EPSILON);
PX_ASSERT((recomputedBounds.miny - parentBounds.miny)<=RTREE_INFLATION_EPSILON);
PX_ASSERT((recomputedBounds.minz - parentBounds.minz)<=RTREE_INFLATION_EPSILON);
PX_ASSERT((recomputedBounds.maxx - parentBounds.maxx)<=RTREE_INFLATION_EPSILON);
PX_ASSERT((recomputedBounds.maxy - parentBounds.maxy)<=RTREE_INFLATION_EPSILON);
PX_ASSERT((recomputedBounds.maxz - parentBounds.maxz)<=RTREE_INFLATION_EPSILON);
}
void collideWithPlane(PxsParticleCollData* particleCollData, PxU32 numCollData, const Gu::GeometryUnion& planeShape,
PxReal proxRadius)
{
PX_ASSERT(particleCollData);
PX_ASSERT(planeShape.getType() == PxGeometryType::ePLANE);
PX_UNUSED(planeShape);
for(PxU32 p=0; p < numCollData; p++)
{
collideWithPlane(particleCollData[p], proxRadius);
}
}
void PxcLtbComputeJv(Vec3V* jv, const PxcFsData& m, const PxcSIMDSpatial* velocity)
{
typedef PxcArticulationFnsSimd<PxcArticulationFnsSimdBase> Fns;
const PxcLtbRow* rows = getLtbRows(m);
const PxcFsRow* fsRows = getFsRows(m);
const PxcFsJointVectors* jointVectors = getJointVectors(m);
PX_UNUSED(rows);
PX_UNUSED(fsRows);
for(PxU32 i=1;i<m.linkCount;i++)
{
PxcSIMDSpatial pv = velocity[m.parent[i]], v = velocity[i];
Vec3V parentOffset = V3Add(jointVectors[i].jointOffset, jointVectors[i].parentOffset);
Vec3V k0v = V3Add(pv.linear, V3Cross(pv.angular, parentOffset)),
k1v = V3Add(v.linear, V3Cross(v.angular,jointVectors[i].jointOffset));
jv[i] = V3Sub(k0v, k1v);
}
}
void CUDARTAPI __cudaRegisterSurface(
void** fatCubinHandle,
const struct surfaceReference* hostvar,
const void** deviceAddress,
const char* deviceName,
int dim,
int ext)
{
PX_UNUSED(fatCubinHandle);
PX_UNUSED(hostvar);
PX_UNUSED(deviceAddress);
PX_UNUSED(deviceName);
PX_UNUSED(dim);
PX_UNUSED(ext);
if (numRegisteredSurfaces < MAX_SURFACES)
{
//Fix for CUDA 5.5 - remove leading "::"
while (*deviceName == ':')
{
++deviceName;
}
surfaceTable[ numRegisteredSurfaces ].modIndex = (int)(size_t) fatCubinHandle;
surfaceTable[ numRegisteredSurfaces ].surfRefName = deviceName;
surfaceTable[ numRegisteredSurfaces ].surfRefData = hostvar;
surfaceTable[ numRegisteredSurfaces ].dim = dim;
numRegisteredSurfaces++;
}
}
bool PxcContactPlaneCapsule(CONTACT_METHOD_ARGS)
{
PX_UNUSED(npCache);
PX_UNUSED(shape0);
// Get actual shape data
//const PxPlaneGeometry& shapePlane = shape.get<const PxPlaneGeometry>();
const PxCapsuleGeometry& shapeCapsule = shape1.get<const PxCapsuleGeometry>();
const PxTransform capsuleToPlane = transform0.transformInv(transform1);
//Capsule in plane space
Gu::Segment segment;
getCapsuleSegment(capsuleToPlane, shapeCapsule, segment);
const PxVec3 negPlaneNormal = transform0.q.getBasisVector0();
bool contact = false;
const PxReal separation0 = segment.p0.x - shapeCapsule.radius;
const PxReal separation1 = segment.p1.x - shapeCapsule.radius;
if(separation0 <= contactDistance)
{
const PxVec3 temp(segment.p0.x - shapeCapsule.radius, segment.p0.y, segment.p0.z);
const PxVec3 point = transform0.transform(temp);
contactBuffer.contact(point, -negPlaneNormal, separation0);
contact = true;
}
if(separation1 <= contactDistance)
{
const PxVec3 temp(segment.p1.x - shapeCapsule.radius, segment.p1.y, segment.p1.z);
const PxVec3 point = transform0.transform(temp);
contactBuffer.contact(point, -negPlaneNormal, separation1);
contact = true;
}
return contact;
}
void ProfileEventHandler::onStopEvent( const PxProfileEventId& inId, PxU32 threadId, PxU64 contextId, PxU8 cpuId, PxU8 threadPriority, PxU64 timestamp )
{
PX_UNUSED(contextId);
PX_UNUSED(cpuId);
PX_UNUSED(threadPriority);
EventCollection* threadCollection = findCollection(threadId);
PX_ASSERT(threadCollection != NULL);
// an event (e.g. narrow phase batch) can occur several times per thread per frame, so
// we take the earliest event with a matching id that does not yet have a stop time
const PxU32 eventsSize = threadCollection->events.size();
for (PxU32 i = 0; i < eventsSize; i++)
{
ProfileEvent& ev = threadCollection->events[i];
if(ev.id == inId.mEventId && ev.stopTime == ProfileEvent::INVALID_TIME)
{
ev.stopTime = timestamp;
PX_ASSERT(ev.stopTime >= ev.startTime);
break;
}
}
}
void MutexImpl::unlock()
{
#if PX_DEBUG
if (getMutex(this)->owner != Thread::getId())
{
shdfnd::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Mutex must be unlocked only by thread that has already acquired lock");
return;
}
#endif
int err = pthread_mutex_unlock(&getMutex(this)->lock);
PX_ASSERT(!err);
PX_UNUSED(err);
}
void JF::JFCPhysXDevice::DeviceDestory()
{
//
PX_UNUSED(false);
//
ReleasePX(m_pScene);
ReleasePX(m_Dispatcher);
//
ReleasePX(m_Connection);
ReleasePX(m_Physics);
ReleasePX(m_Foundation);
}
void ClothingScene::setSceneRunning(bool on)
{
#ifndef _DEBUG
PxI32 newValue;
if (on)
{
APEX_CHECK_STAT_TIMER("--------- Start ClothingSimulationTime");
mClothingSimulationTime.getElapsedSeconds();
newValue = shdfnd::atomicIncrement(&mSceneRunning);
}
else
{
ApexStatValue dataVal;
dataVal.Float = (PxF32)(1000.0f * mClothingSimulationTime.getElapsedSeconds());
APEX_CHECK_STAT_TIMER("--------- Stop ClothingSimulationTime");
mApexScene->setApexStatValue(NiApexScene::ClothingSimulationTime, dataVal);
// Warn if simulation time was bigger than timestep for 10 or more consecutive frames
PxF32 simulatedTime = 1000.0f * mApexScene->getElapsedTime();
if (simulatedTime < dataVal.Float)
{
mFramesCount++;
mSimulatedTime += simulatedTime;
mTimestep += dataVal.Float;
}
if (mFramesCount >= 10)
{
float averageSimulatedTime = mSimulatedTime / (PxF32)mFramesCount;
float averageTimestep = mTimestep / (PxF32)mFramesCount;
APEX_DEBUG_WARNING("Cloth complexity in scene is too high to be simulated in real time for 10 consecutive frames. (Average Delta Time: %f ms, Average Simulation Time: %f ms)",
averageSimulatedTime, averageTimestep);
mFramesCount = 0;
mSimulatedTime = 0.f;
mTimestep = 0.f;
}
newValue = shdfnd::atomicDecrement(&mSceneRunning);
}
if (newValue != (on ? 1 : 0))
{
APEX_INTERNAL_ERROR("scene running state was not tracked properly!: on = %s, prevValue = %d", on ? "true" : "false", newValue);
}
#else
PX_UNUSED(on);
#endif
}
bool PxVehicleWheels4SimData::isValid(const PxU32 id) const
{
PX_ASSERT(id<4);
PX_CHECK_AND_RETURN_VAL(mSuspensions[id].isValid(), "Invalid PxVehicleSuspWheelTire4SimulationData.mSuspensions", false);
PX_CHECK_AND_RETURN_VAL(mWheels[id].isValid(), "Invalid PxVehicleSuspWheelTire4SimulationData.mWheels", false);
PX_CHECK_AND_RETURN_VAL(mTires[id].isValid(), "Invalid PxVehicleSuspWheelTire4SimulationData.mTires", false);
PX_CHECK_AND_RETURN_VAL(mSuspDownwardTravelDirections[id].magnitude()>=0.999f && mSuspDownwardTravelDirections[id].magnitude()<=1.001f, "Invalid PxVehicleSuspWheelTire4SimulationData.mSuspDownwardTravelDirections", false);
PX_CHECK_AND_RETURN_VAL(mSuspForceAppPointOffsets[id].magnitude()!=0.0f, "Invalid PxVehicleSuspWheelTire4SimulationData.mSuspForceAppPointOffsets.mSuspForceAppPointOffsets", false);
PX_CHECK_AND_RETURN_VAL(mTireForceAppPointOffsets[id].magnitude()!=0.0f, "Invalid PxVehicleSuspWheelTire4SimulationData.mTireForceAppPointOffsets.mTireForceAppPointOffsets", false);
PX_CHECK_AND_RETURN_VAL(mWheelCentreOffsets[id].magnitude()!=0.0f, "Invalid PxVehicleSuspWheelTire4SimulationData.mWheelCentreOffsets.mWheelCentreOffsets", false);
PX_CHECK_AND_RETURN_VAL(mTireRestLoads[id]>0.0f, "Invalid PxVehicleSuspWheelTire4SimulationData.mTireRestLoads", false);
PX_CHECK_AND_RETURN_VAL(PxAbs((1.0f/mTireRestLoads[id]) - mRecipTireRestLoads[id]) <= 0.001f, "Invalid PxVehicleSuspWheelTire4SimulationData.mRecipTireRestLoads", false);
PX_UNUSED(id);
return true;
}
Foundation::Foundation(PxErrorCallback& errc, PxAllocatorCallback& alloc):
mErrorCallback(errc),
mAllocator(alloc),
#ifdef PX_CHECKED
mReportAllocationNames(true),
#else
mReportAllocationNames(false),
#endif
mErrorMask(PxErrorCode::Enum(~0)),
mErrorMutex(PX_DEBUG_EXP("Foundation::mErrorMutex")),
mNamedAllocMutex(PX_DEBUG_EXP("Foundation::mNamedAllocMutex")),
mTempAllocMutex(PX_DEBUG_EXP("Foundation::mTempAllocMutex"))
{
PxI32 callbackIdx = mInteralErrorHandler.registerErrorCallback( mErrorCallback );
PX_ASSERT(callbackIdx==0);
PX_UNUSED(callbackIdx);
}
NxParameterized::Interface* ImpactEmitterAsset::getDefaultActorDesc()
{
NX_WRITE_ZONE();
NxParameterized::ErrorType error = NxParameterized::ERROR_NONE;
PX_UNUSED(error);
NxParameterized::Traits* traits = NiGetApexSDK()->getParameterizedTraits();
PX_ASSERT(traits);
if (!traits)
{
return NULL;
}
// create if not yet created
if (!mDefaultActorParams)
{
const char* className = ImpactEmitterActorParameters::staticClassName();
NxParameterized::Interface* param = traits->createNxParameterized(className);
mDefaultActorParams = static_cast<ImpactEmitterActorParameters*>(param);
PX_ASSERT(param);
if (!param)
{
return NULL;
}
}
NxParameterized::Handle hDest(*mDefaultActorParams);
#if NX_SDK_VERSION_MAJOR == 2
NxParameterized::Interface* explParams = 0;
error = mDefaultActorParams->getParameterHandle("explosionEnv", hDest);
PX_ASSERT(NxParameterized::ERROR_NONE == error);
mDefaultActorParams->initParamRef(hDest, hDest.parameterDefinition()->refVariantVal(0), true);
mDefaultActorParams->getParamRef(hDest, explParams);
PX_ASSERT(explParams);
if (explParams)
{
explParams->initDefaults();
}
#endif
return mDefaultActorParams;
}
bool RTree::load(PxInputStream& stream, PxU32 meshVersion)
{
PX_ASSERT((mFlags & IS_DYNAMIC) == 0);
PX_UNUSED(meshVersion);
release();
PxI8 a, b, c, d;
readChunk(a, b, c, d, stream);
if(a!='R' || b!='T' || c!='R' || d!='E')
return false;
bool mismatch = (littleEndian() == 1);
if(readDword(mismatch, stream) != mVersion)
return false;
readFloatBuffer(&mBoundsMin.x, 4, mismatch, stream);
readFloatBuffer(&mBoundsMax.x, 4, mismatch, stream);
readFloatBuffer(&mInvDiagonal.x, 4, mismatch, stream);
readFloatBuffer(&mDiagonalScaler.x, 4, mismatch, stream);
mPageSize = readDword(mismatch, stream);
mNumRootPages = readDword(mismatch, stream);
mNumLevels = readDword(mismatch, stream);
mTotalNodes = readDword(mismatch, stream);
mTotalPages = readDword(mismatch, stream);
mUnused = readDword(mismatch, stream);
mPages = static_cast<RTreePage*>(
Ps::AlignedAllocator<128>().allocate(sizeof(RTreePage)*mTotalPages, __FILE__, __LINE__));
Cm::markSerializedMem(mPages, sizeof(RTreePage)*mTotalPages);
for (PxU32 j = 0; j < mTotalPages; j++)
{
readFloatBuffer(mPages[j].minx, RTreePage::SIZE, mismatch, stream);
readFloatBuffer(mPages[j].miny, RTreePage::SIZE, mismatch, stream);
readFloatBuffer(mPages[j].minz, RTreePage::SIZE, mismatch, stream);
readFloatBuffer(mPages[j].maxx, RTreePage::SIZE, mismatch, stream);
readFloatBuffer(mPages[j].maxy, RTreePage::SIZE, mismatch, stream);
readFloatBuffer(mPages[j].maxz, RTreePage::SIZE, mismatch, stream);
ReadDwordBuffer(mPages[j].ptrs, RTreePage::SIZE, mismatch, stream);
}
return true;
}
static bool fullContactsGenerationCapsuleConvex(const CapsuleV& capsule, const ConvexHullV& convexHull, const PsMatTransformV& aToB, const PsTransformV& transf0,const PsTransformV& transf1,
PersistentContact* manifoldContacts, ContactBuffer& contactBuffer, const bool idtScale, PersistentContactManifold& manifold, Vec3VArg normal,
const Vec3VArg closest, const FloatVArg tolerance, const FloatVArg contactDist, const bool doOverlapTest, Cm::RenderOutput* renderOutput, const FloatVArg toleranceScale)
{
PX_UNUSED(renderOutput);
Gu::PolygonalData polyData;
getPCMConvexData(convexHull,idtScale, polyData);
PxU8 buff[sizeof(SupportLocalImpl<ConvexHullV>)];
SupportLocal* map = (idtScale ? static_cast<SupportLocal*>(PX_PLACEMENT_NEW(buff, SupportLocalImpl<ConvexHullNoScaleV>)(static_cast<const ConvexHullNoScaleV&>(convexHull), transf1, convexHull.vertex2Shape, convexHull.shape2Vertex, idtScale)) :
static_cast<SupportLocal*>(PX_PLACEMENT_NEW(buff, SupportLocalImpl<ConvexHullV>)(convexHull, transf1, convexHull.vertex2Shape, convexHull.shape2Vertex, idtScale)));
PxU32 numContacts = 0;
if (generateFullContactManifold(capsule, polyData, map, aToB, manifoldContacts, numContacts, contactDist, normal, closest, tolerance, doOverlapTest, toleranceScale))
{
if (numContacts > 0)
{
manifold.addBatchManifoldContacts2(manifoldContacts, numContacts);
//transform normal into the world space
normal = transf1.rotate(normal);
manifold.addManifoldContactsToContactBuffer(contactBuffer, normal, transf0, capsule.radius, contactDist);
}
else
{
if (!doOverlapTest)
{
normal = transf1.rotate(normal);
manifold.addManifoldContactsToContactBuffer(contactBuffer, normal, transf0, capsule.radius, contactDist);
}
}
#if PCM_LOW_LEVEL_DEBUG
manifold.drawManifold(*renderOutput, transf0, transf1);
#endif
return true;
}
return false;
}