void ParticleEmitter::updateDerivedBase()
{
PX_ASSERT(mSpacingX > 0.0f);
mSpacingY = mSpacingX * PxSqrt(3.0f) * 0.5f;
mSpacingZ = mSpacingX;
mNumX = 2*(int)floor(mExtentX/mSpacingX);
mNumY = 2*(int)floor(mExtentY/mSpacingY);
//SDS: limit minimal dimension to 1
if (mNumX == 0)
{
mNumX = 1;
mSpacingX = 0.0f;
}
if (mNumY == 0)
{
mNumY = 1;
mSpacingY = 0.0f;
}
mNumSites = mNumX * mNumY;
if (mShape == Shape::eELLIPSE)
{
if (mNumX > 1)
mEllipseRadius2 = 0.5f - 1.0f/(mNumX-1);
else
mEllipseRadius2 = 0.5f;
mEllipseRadius2 *= mEllipseRadius2;
mEllipseConstX0 = (mNumX-0.5f) * 0.5f;
mEllipseConstX1 = 1.0f/mNumX;
mEllipseConstY0 = (mNumY-1.0f) * 0.5f;
mEllipseConstY1 = PxSqrt(3.0f) * 0.5f / mNumY;
}
else
{
mEllipseRadius2 = 0;
mEllipseConstX0 = 0;
mEllipseConstX1 = 0;
mEllipseConstY0 = 0;
mEllipseConstY1 = 0;
}
}
void ProfileEventHandler::reportEvents(Ps::Array<PxBufferedProfilerCallback*>& callbacks)
{
PX_ASSERT(mProfileZoneInterface);
for (PxU32 callbackIndex = callbacks.size(); callbackIndex--; )
{
PxBufferedProfilerCallback& callback = *callbacks[callbackIndex];
reportCollection(callback, mCrossThreadCollection);
for (PxU32 i = mThreadCollections.size(); i--;)
{
reportCollection(callback, mThreadCollections[i]);
}
reportCudaCollection(callback);
}
clear();
}
void CudaModuleScene::initCudaObj(ApexCudaFunc& func)
{
for (int j = 0 ; j < numRegisteredFunctions ; j++)
{
const char* funcName = functionTable[j].funcName;
if (func.testNameMatch(funcName))
{
ApexCudaModule* cudaModule = getCudaModule(functionTable[j].modIndex);
PX_ASSERT(cudaModule->isValid());
CUfunction cuFunc = 0;
CUT_SAFE_CALL(cuModuleGetFunction(&cuFunc, cudaModule->getCuModule(), funcName));
PxU16 id = getGpuDispatcher()->registerKernelNames( &funcName, 1 );
func.init(this, funcName, cuFunc, cudaModule, id);
}
}
}
//export this in the physx namespace so we can unit test it
PxQuat angularProject(PxU32 lockedDofs, const PxQuat& q, PxReal cosHalfTol, bool& truncated)
{
PX_ASSERT(lockedDofs <= 7);
truncated = false;
switch (lockedDofs)
{
case 0: return q;
case 1: return q; // currently unimplemented
case 2: return q; // currently unimplemented
case 3: return project(q, PxVec3(0, 0, 1), cosHalfTol, truncated);
case 4: return q; // currently unimplemented
case 5: return project(q, PxVec3(0, 1, 0), cosHalfTol, truncated);
case 6: return project(q, PxVec3(1, 0, 0), cosHalfTol, truncated);
case 7: return truncate(q, cosHalfTol, truncated);
default: return PxQuat(PxIdentity);
}
}
PxConvexMesh* createCylinderConvexMesh(const PxF32 width, const PxF32 radius, const PxU32 numCirclePoints, PxPhysics& physics, PxCooking& cooking)
{
#define MAX_NUM_VERTS_IN_CIRCLE 16
PX_ASSERT(numCirclePoints<MAX_NUM_VERTS_IN_CIRCLE);
PxVec3 verts[2*MAX_NUM_VERTS_IN_CIRCLE];
PxU32 numVerts=2*numCirclePoints;
const PxF32 dtheta=2*PxPi/(1.0f*numCirclePoints);
for(PxU32 i=0;i<MAX_NUM_VERTS_IN_CIRCLE;i++)
{
const PxF32 theta=dtheta*i;
const PxF32 cosTheta=radius*PxCos(theta);
const PxF32 sinTheta=radius*PxSin(theta);
verts[2*i+0]=PxVec3(-0.5f*width, cosTheta, sinTheta);
verts[2*i+1]=PxVec3(+0.5f*width, cosTheta, sinTheta);
}
return createConvexMesh(verts,numVerts,physics,cooking);
}
unsigned int MaterialList::addTexture(const char* /*directory*/, const char* prefix, const char* textureName)
{
char saneFileName[128];
physx::string::sprintf_s(saneFileName, 128, "%s%s", prefix, textureName);
if (mTextureNames.find(saneFileName) != mTextureNames.end())
{
PX_ASSERT(!"duplicated texture found!");
}
else
{
TextureInfo info;
info.fromPath = (unsigned int)mPaths.size();
mTextureNames[saneFileName] = info;
return 1;
}
return 0;
}
//process value in range(0,1)
PX_FORCE_INLINE PxF32 processPositiveAnalogValue
(const PxF32 riseRate, const PxF32 fallRate,
const PxF32 currentVal, const PxF32 targetVal,
const PxF32 timestep)
{
PX_ASSERT(targetVal>=-0.01f && targetVal<=1.01f);
PxF32 val;
if(currentVal<targetVal)
{
val=currentVal + riseRate*timestep;
val=PxMin(val,targetVal);
}
else
{
val=currentVal - fallRate*timestep;
val=PxMax(val,targetVal);
}
return val;
}
//GroupsMask64
void SampleApexResourceCallback::setApexSupport(nvidia::apex::ApexSDK& apexSDK)
{
PX_ASSERT(!m_apexSDK);
m_apexSDK = &apexSDK;
#if APEX_USE_PARTICLES
uint32_t count = m_apexSDK->getNbModules();
nvidia::apex::Module **modules = m_apexSDK->getModules();
for (uint32_t i=0; i<count; i++)
{
nvidia::apex::Module *m = modules[i];
const char *name = m->getName();
if ( strcmp(name,"Particles") == 0 )
{
mModuleParticles = static_cast< nvidia::apex::ModuleParticles *>(m);
break;
}
}
#endif
}
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;
}
ResID ApexResourceProvider::createResource(ResID nameSpace, const char* name, bool refCount)
{
uint32_t nsIndex = getNSIndex(nameSpace);
if (nsIndex < mNameSpaces.size())
{
NameSpace* ns = mNameSpaces[nsIndex];
ResID id = ns->getOrCreateID(name, mResources[ns->getID()].name);
PX_ASSERT(id < mResources.size());
if (id < mResources.size() && refCount)
{
mResources[id].refCount++;
}
return id;
}
else
{
return INVALID_RESOURCE_ID;
}
}
ImpactEmitterAsset::ImpactEmitterAsset(ModuleEmitter* m, NxResourceList& list, const char* name) :
mModule(m),
mName(name),
mIofxAssetTracker(m->mSdk, NX_IOFX_AUTHORING_TYPE_NAME),
mIosAssetTracker(m->mSdk),
#if NX_SDK_VERSION_MAJOR == 2
mExplosionAssetTracker(m->mSdk, NX_EXPLOSION_AUTHORING_TYPE_NAME),
#endif
mDefaultActorParams(NULL),
mDefaultPreviewParams(NULL)
{
NxParameterized::Traits* traits = NiGetApexSDK()->getParameterizedTraits();
mParams = (ImpactEmitterAssetParameters*)traits->createNxParameterized(ImpactEmitterAssetParameters::staticClassName());
PX_ASSERT(mParams);
mParams->setSerializationCallback(this);
list.add(*this);
}
Foundation* Foundation::createInstance(PxU32 version, PxErrorCallback& errc, PxAllocatorCallback& alloc)
{
if (version != PX_PHYSICS_VERSION)
{
char* buffer = new char[256];
physx::string::sprintf_s(buffer,256, "Wrong version: foundation version is 0x%08x, tried to create 0x%08x", PX_PHYSICS_VERSION, version);
errc.reportError(PxErrorCode::eINVALID_PARAMETER, buffer, __FILE__, __LINE__);
return 0;
}
if (!mInstance)
{
// if we don't assign this here, the Foundation object can't create member
// subobjects which require the allocator
mInstance = reinterpret_cast<Foundation*>( alloc.allocate(
sizeof(Foundation), "Foundation", __FILE__,__LINE__));
if (mInstance)
{
PX_PLACEMENT_NEW(mInstance, Foundation)(errc, alloc);
PX_ASSERT(mRefCount == 0);
mRefCount = 1;
//skip 0 which marks uninitialized timestaps in PX_WARN_ONCE
mWarnOnceTimestap = (mWarnOnceTimestap == PX_MAX_U32) ? 1 : mWarnOnceTimestap + 1;
return mInstance;
}
else
{
errc.reportError(PxErrorCode::eINTERNAL_ERROR, "Memory allocation for foundation object failed.", __FILE__, __LINE__);
}
}
else
{
errc.reportError(PxErrorCode::eINVALID_OPERATION, "Foundation object exists already. Only one instance per process can be created.", __FILE__, __LINE__);
}
return 0;
}
void ApexQuadricSimplifier::heapUpdate(uint32_t i)
{
const uint32_t num = mHeap.size() - mNumDeletedHeapElements;
PX_ASSERT(1 <= i && i < num);
QuadricEdge* e = mHeap[i];
while (i > 1)
{
uint32_t j = i >> 1;
if (heapElementSmaller(e, mHeap[j]))
{
mHeap[i] = mHeap[j];
mHeap[i]->heapPos = (int32_t)i;
i = j;
}
else
{
break;
}
}
while ((i << 1) < num)
{
uint32_t j = i << 1;
if (j + 1 < num && heapElementSmaller(mHeap[j + 1], mHeap[j]))
{
j++;
}
if (heapElementSmaller(mHeap[j], e))
{
mHeap[i] = mHeap[j];
mHeap[i]->heapPos = (int32_t)i;
i = j;
}
else
{
break;
}
}
mHeap[i] = e;
mHeap[i]->heapPos = (int32_t)i;
}
void CudaModuleScene::initCudaObj(ApexCudaVar& var)
{
const char* varName = var.getName();
for (int j = 0 ; j < numRegisteredVariables ; j++)
{
if (nvidia::strcmp(variableTable[j].varName, varName) == 0)
{
ApexCudaModule* cudaModule = getCudaModule(variableTable[j].modIndex);
PX_ASSERT(cudaModule->isValid());
CUdeviceptr cuDevPtr;
size_t size;
cuModuleGetGlobal(&cuDevPtr, &size, cudaModule->getCuModule(), varName);
var.init(this, cudaModule, cuDevPtr, size, getGpuDispatcher()->getCudaContextManager());
break;
}
}
}
void SampleVehicle_VehicleManager::updateAndRecordTelemetryData
(const PxF32 timestep, const PxVec3& gravity, PxVehicleWheels* focusVehicle, PxVehicleTelemetryData* telemetryData)
{
PX_ASSERT(focusVehicle && telemetryData);
//Update the vehicle for which we want to record debug data.
PxVehicleUpdateSingleVehicleAndStoreTelemetryData(timestep,gravity,*mSurfaceTirePairs,focusVehicle,*telemetryData);
//Update the remaining vehicles.
PxVehicleWheels* vehicles[MAX_NUM_4W_VEHICLES];
PxU32 numVehicles=0;
for(PxU32 i=0;i<mNumVehicles;i++)
{
if(focusVehicle!=mVehicles[i])
{
vehicles[numVehicles]=mVehicles[i];
numVehicles++;
}
}
PxVehicleUpdates(timestep,gravity,*mSurfaceTirePairs,numVehicles,vehicles);
}
void ApexRenderSubmesh::setParams(SubmeshParameters* submeshParams, VertexBufferParameters* vertexBufferParams)
{
if (vertexBufferParams == NULL && submeshParams != NULL)
{
vertexBufferParams = static_cast<VertexBufferParameters*>(submeshParams->vertexBuffer);
PX_ASSERT(vertexBufferParams != NULL);
}
else if (submeshParams != NULL && submeshParams->vertexBuffer == NULL)
{
submeshParams->vertexBuffer = vertexBufferParams;
}
else if (mParams == NULL)
{
// Only emit this warning if mParams is empty yet (not on destruction of the object)
APEX_INTERNAL_ERROR("Confliciting parameterized objects!");
}
mParams = submeshParams;
mVertexBuffer.setParams(vertexBufferParams);
}
PxStream& MemoryWriteBuffer::storeBuffer(const void* buffer, PxU32 size)
{
PxU32 expectedSize = currentSize + size;
if(expectedSize > maxSize)
{
maxSize = expectedSize + 4096;
PxU8* newData = new PxU8[maxSize];
PX_ASSERT(newData!=NULL);
if(data)
{
memcpy(newData, data, currentSize);
delete[] data;
}
data = newData;
}
memcpy(data+currentSize, buffer, size);
currentSize += size;
return *this;
}
PxU32 MemoryOutputStream::write(const void* src, PxU32 size)
{
PxU32 expectedSize = mSize + size;
if(expectedSize > mCapacity)
{
mCapacity = expectedSize + 4096;
PxU8* newData = new PxU8[mCapacity];
PX_ASSERT(newData!=NULL);
if(newData)
{
memcpy(newData, mData, mSize);
delete[] mData;
}
mData = newData;
}
memcpy(mData+mSize, src, size);
mSize += size;
return size;
}
void Gu::GeometryUnion::set(const PxGeometry& g)
{
switch(g.getType())
{
case PxGeometryType::eBOX :
reinterpret_cast<PxBoxGeometry&>(geometry) = static_cast<const PxBoxGeometry&>(g);
break;
case PxGeometryType::eCAPSULE :
reinterpret_cast<PxCapsuleGeometry&>(geometry) = static_cast<const PxCapsuleGeometry&>(g);
break;
case PxGeometryType::eSPHERE :
reinterpret_cast<PxSphereGeometry&>(geometry) = static_cast<const PxSphereGeometry&>(g);
reinterpret_cast<PxCapsuleGeometry&>(geometry).halfHeight = 0.0f; //AM: make sphere geometry also castable as a zero height capsule.
break;
case PxGeometryType::ePLANE :
reinterpret_cast<PxPlaneGeometry&>(geometry) = static_cast<const PxPlaneGeometry&>(g);
break;
case PxGeometryType::eCONVEXMESH :
{
reinterpret_cast<PxConvexMeshGeometry&>(geometry) = static_cast<const PxConvexMeshGeometry&>(g);
reinterpret_cast<PxConvexMeshGeometryLL&>(geometry).hullData = &(Gu::getConvexMesh(get<PxConvexMeshGeometryLL>().convexMesh).getHull());
}
break;
case PxGeometryType::eTRIANGLEMESH :
{
reinterpret_cast<PxTriangleMeshGeometry&>(geometry) = static_cast<const PxTriangleMeshGeometry&>(g);
reinterpret_cast<PxTriangleMeshGeometryLL&>(geometry).meshData = &(Gu::getTriangleMesh(get<PxTriangleMeshGeometryLL>().triangleMesh).mesh.mData);
}
break;
case PxGeometryType::eHEIGHTFIELD :
{
reinterpret_cast<PxHeightFieldGeometry&>(geometry) = static_cast<const PxHeightFieldGeometry&>(g);
reinterpret_cast<PxHeightFieldGeometryLL&>(geometry).heightFieldData = &Gu::getHeightField(get<PxHeightFieldGeometryLL>().heightField).getData();
}
break;
default :
PX_ASSERT(0 && "geometry type not handled");
break;
}
}
/*
* Called by the owner (Scene) to start simulating the task graph.
* Dispatch all tasks with refCount == 1
*/
void PxTaskMgr::startSimulation()
{
PX_ASSERT( mCpuDispatcher );
if( mGpuDispatcher )
{
mGpuDispatcher->startSimulation();
}
/* Handle empty task graph */
if( mPendingTasks == 0 )
{
return;
}
bool gpuDispatch = false;
for( PxTaskID i = 0 ; i < mTaskTable.size() ; i++ )
{
if( mTaskTable[ i ].mType == PxTaskType::TT_COMPLETED )
{
continue;
}
if( !shdfnd::atomicDecrement( &mTaskTable[ i ].mRefCount ) )
{
mStartDispatch.pushBack(i);
}
}
for( uint32_t i=0; i<mStartDispatch.size(); ++i)
{
gpuDispatch |= dispatchTask( mStartDispatch[i], gpuDispatch );
}
//mStartDispatch.resize(0);
mStartDispatch.forceSize_Unsafe(0);
if( mGpuDispatcher && gpuDispatch )
{
mGpuDispatcher->finishGroup();
}
}
PxStream& MemoryStream::storeBuffer(const void* buffer, PxU32 size)
{
unsigned int newPos = mCurrentPos + size;
if(newPos > mMaxSize)
{ //resize
mMaxSize = newPos + BUFFER_RESIZE_STEP;
unsigned char* newData = new unsigned char[mMaxSize];
PX_ASSERT(newData != nullptr);
if(mData)
{
memcpy(newData, mData, mCurrentPos);
delete[] mData;
}
mData = newData;
}
memcpy(mData + mCurrentPos, buffer, size);
mCurrentPos += size;
return *this;
}
const char* SampleApexResourceCallback::mapHackyPath(const char* path)
{
const char* mappedPath = path;
static const HackyPath map[] =
{
// John, fix the apex debug renderer to allow the user to specify the material path...
{ "ApexSolidShaded", "materials/simple_lit_color.xml" },
{ "ApexWireframe", "materials/simple_unlit.xml" },
};
const uint32_t mapSize = PX_ARRAY_SIZE(map);
for (uint32_t i = 0; i < mapSize; i++)
{
const HackyPath& hp = map[i];
if (!strcmp(hp.original, mappedPath))
{
mappedPath = hp.mapped;
break;
}
}
PX_ASSERT(mappedPath == path && "IF YOU HIT THIS ASSET IT MEANS A HACKY PATH WAS MAPPED, FIX YOUR F-ING ASSET FILES!!!");
return mappedPath;
}
PathEntry* readfetchconf() // (PathEntry* pe_p)
{
FILE* fp = fopen("/px/conf/fetch.conf", "r");
if(fp == NULL)
{
return NULL;
}
PathEntry* pe = NULL;
PathEntry* petail = NULL;
char buf[PATH_MAX];
while (readLine(fp, buf))
{
char tmp[PATH_MAX];
PathEntry* pet = NULL;
if((pet = parseentry(buf, PATHDIR_T, tmp)) == NULL)
pet = parseentry(buf, PATHFILE_T, tmp);
if(pe == NULL)
{
pe = pet;
petail = pet;
}
else
{
if(petail)
{
petail->next = pet;
petail = pet;
}
}
continue;
}
PX_ASSERT(fclose(fp) == 0);
return pe;
}
physx::PxU32 write(const void* src, physx::PxU32 size)
{
physx::PxU32 expectedSize = mSize + size;
if (expectedSize > mCapacity)
{
mCapacity = expectedSize + 4096;
physx::PxU8* newData = new physx::PxU8[mCapacity];
PX_ASSERT(newData != nullptr);
if (newData)
{
memcpy(newData, mData, mSize);
delete[] mData;
}
mData = newData;
}
memcpy(mData + mSize, src, size);
mSize += size;
return size;
}
uint32_t ApexVertexBuffer::getAllocationSize() const
{
uint32_t size = sizeof(ApexVertexBuffer);
for (uint32_t index = 0; (int32_t)index < mParams->buffers.arraySizes[0]; ++index)
{
PX_ASSERT(index < getFormat().getBufferCount());
if (index >= getFormat().getBufferCount())
{
break;
}
const uint32_t dataSize = RenderDataFormat::getFormatDataSize(getFormat().getBufferFormat(index));
NvParameterized::Interface* buffer = mParams->buffers.buf[index];
if (buffer != NULL)
{
BufferU8x1* particularBuffer = DYNAMIC_CAST(BufferU8x1*)(buffer);
size += particularBuffer->data.arraySizes[0] * dataSize;
}
}
return size;
}
void ApexParticles::CreateEmitter(NxApexSDK* gApexSDK, NxApexScene* gApexScene)
{
NxApexEmitterAsset* emitterAsset;
physx::apex::NxApexAsset* asset = reinterpret_cast<physx::apex::NxApexAsset*>(gApexSDK->getNamedResourceProvider()->getResource(NX_APEX_EMITTER_AUTHORING_TYPE_NAME, "testSpriteEmitter4ParticleFluidIos"));
if (asset)
{
emitterAsset = static_cast<NxApexEmitterAsset*> (asset);
}
//NxApexEmitterAsset* emitterAsset = static_cast<NxApexEmitterAsset*> (gApexSDK->createAsset(asParams, "testMeshEmitter4ParticleIos.apb"));
gApexSDK->forceLoadAssets();
NxParameterized::Interface* descParams = emitterAsset->getDefaultActorDesc();
PX_ASSERT(descParams);
if (!descParams)
{
return;
}
// Set Actor pose
//NxParameterized::setParamMat44( *descParams, "initialPose", pose );
NxApexEmitterActor* emitterActor;
if(descParams->areParamsOK())
{
emitterActor = static_cast<NxApexEmitterActor*>(emitterAsset->createApexActor(*descParams,*gApexScene));
if(emitterActor)
{
emitterActor->setCurrentPosition(PxVec3(0.0f, 1.0f, 0.0f));
emitterActor->startEmit( true );
//emitterActor->setLifetimeRange(physx::apex::NxRange<PxF32>(1,5));
//emitterActor->setRateRange(physx::apex::NxRange<PxF32>(10, 10));
}
}
PxBounds3 b;
b.setInfinite();
mRenderVolume = mIofxModule->createRenderVolume(*gApexScene, b, 0, true );
emitterActor->setPreferredRenderVolume( mRenderVolume );
}
TextRenderResourceManager::TextRenderResourceManager(int verbosity, const char* outputFilename) :
mVerbosity(verbosity),
mOutputFile(NULL),
mVertexBufferCount(0),
mIndexBufferCount(0),
mBoneBufferCount(0),
mInstanceBufferCount(0),
mSpriteBufferCount(0),
mRenderResourceCount(0)
{
if (outputFilename != NULL)
{
mOutputFile = fopen(outputFilename, "w");
}
else
{
mOutputFile = stdout;
}
PX_ASSERT(mOutputFile != NULL);
mIO = new Writer(mOutputFile);
}
void Foundation::errorImpl(PxErrorCode::Enum e, const char* file, int line, const char* messageFmt, va_list va)
{
PX_ASSERT(messageFmt);
if (e & mErrorMask)
{
//this function is reentrant but user's error callback may not be, so...
Mutex::ScopedLock lock(mErrorMutex);
// using a static fixed size buffer here because:
// 1. vsnprintf return values differ between platforms
// 2. va_start is only usable in functions with ellipses
// 3. ellipses (...) cannot be passed to called function
// which would be necessary to dynamically grow the buffer here
const int bufSize = 1024;
static char stringBuffer[bufSize+1];
vsnprintf(stringBuffer, (size_t)bufSize, messageFmt, va);
stringBuffer[bufSize] = 0; // make sure there is a null termination character on all platforms
mInteralErrorHandler.reportError(e, stringBuffer, file, line);
}
}
void PxcFsGetImpulseSelfResponse(const PxcFsData& matrix,
PxU32 linkID0,
const PxcSIMDSpatial& impulse0,
PxcSIMDSpatial& deltaV0,
PxU32 linkID1,
const PxcSIMDSpatial& impulse1,
PxcSIMDSpatial& deltaV1)
{
typedef PxcArticulationFnsSimd<PxcArticulationFnsSimdBase> Fns;
PX_ASSERT(linkID0 != linkID1);
const PxcFsRow* rows = getFsRows(matrix);
const PxcFsRowAux* aux = getAux(matrix);
const PxcFsJointVectors* jointVectors = getJointVectors(matrix);
// standard case: parent-child limit
if(matrix.parent[linkID1] == linkID0)
{
Vec3V SZ;
PxcSIMDSpatial Z = impulse0 - Fns::propagateImpulse(rows[linkID1], jointVectors[linkID1], SZ, -impulse1, aux[linkID1]);
PxcFsGetImpulseResponse(matrix, linkID0, Z, deltaV0);
deltaV1 = Fns::propagateVelocity(rows[linkID1], jointVectors[linkID1], SZ, deltaV0, aux[linkID1]);
}
else
getImpulseResponseSlow(matrix, linkID0, impulse0, deltaV0, linkID1, impulse1, deltaV1);
#if PXC_ARTICULATION_DEBUG_VERIFY
Cm::SpatialVector V[PXC_ARTICULATION_MAX_SIZE];
for(PxU32 i=0;i<matrix.linkCount;i++) V[i] = Cm::SpatialVector::zero();
PxcArticulationRef::applyImpulse(matrix,V,linkID0, reinterpret_cast<const Cm::SpatialVector&>(impulse0));
PxcArticulationRef::applyImpulse(matrix,V,linkID1, reinterpret_cast<const Cm::SpatialVector&>(impulse1));
Cm::SpatialVector refV0 = V[linkID0];
Cm::SpatialVector refV1 = V[linkID1];
#endif
}
virtual void processRenderDebug(const DebugPrimitive **dplist,
PxU32 pcount,
RenderDebugInterface *iface,
PxProcessRenderDebug::DisplayType type)
{
if ( !mReadAccess )
{
PX_ASSERT(pcount);
if ( mFrameStart == 0 )
{
PxU32 pv = 0;
mFrameStart = mFileBuffer->tellWrite();
mFileBuffer->storeDword(pv);
mFileBuffer->storeDword(pv);
}
if ( type != mLastDisplayType )
{
flushDisplayType(mLastDisplayType);
beginDisplayType(type);
}
mTypeHeaders[type].mPrimitiveCount+=pcount;
for (PxU32 i=0; i<pcount; i++)
{
const DebugPrimitive *dp = dplist[i];
PxU32 plen = DebugCommand::getPrimtiveSize(*dp);
mFileBuffer->write(dp,plen);
}
mFrameItemCount+=pcount;
}
if ( mEchoLocally )
{
mEchoLocally->processRenderDebug(dplist,pcount,iface,type);
}
}
