void
PhysXRigidManager::update(const physx::PxActiveTransform * activeTransforms, physx::PxU32 nbActiveTransforms, float timeStep, physx::PxVec3 gravity) {
for (PxU32 i = 0; i < nbActiveTransforms; ++i) {
if (activeTransforms[i].userData != NULL) {
std::string *n = static_cast<std::string*>(activeTransforms[i].userData);
if (rigidBodies.find(*n) != rigidBodies.end()) {
PxRigidDynamic * actor = rigidBodies[*n].info.actor->is<PxRigidDynamic>();
if (rigidBodies[*n].rollingFriction >= 0.0f) {
float mass = actor->getMass();
float force = mass * gravity.magnitude() * rigidBodies[*n].rollingFriction;
float actorMotion = (mass * actor->getLinearVelocity().magnitude()) / ((float)rigidBodies[*n].rollingFrictionTimeStamp * timeStep);
if (force <= actorMotion) {
rigidBodies[*n].rollingFrictionTimeStamp++;
PxVec3 forceVec = -(actor->getLinearVelocity().getNormalized() * force);
actor->addForce(forceVec);
}
else {
rigidBodies[*n].rollingFrictionTimeStamp = 1;
//actor->setLinearVelocity(actor->getLinearVelocity() / 1.5f);
//actor->setAngularVelocity(actor->getAngularVelocity() / 1.5f);
//actor->setLinearVelocity(PxVec3(0.0f));
//actor->setAngularVelocity(PxVec3(0.0f));
}
}
PxMat44 mat(activeTransforms[i].actor2World);
mat.scale(PxVec4(PxVec3(rigidBodies[*n].scalingFactor), 1.0f));
//getMatFromPhysXTransform(activeTransforms[i].actor2World, rigidBodies[*n].extInfo.transform);
getMatFromPhysXTransform(mat, rigidBodies[*n].info.extInfo.transform);
}
}
}
}
void labscale::ControlFillBoxExperiment()
{
// Pour regolith, one by one every second
int nbGrains = gPhysX.mScene->getNbActors(gPhysX.roles.dynamics) - 1;
static PxReal poured_time = 0;
if ((gSim.codeTime - poured_time) > (1/labscale::reg_box.pourRate) && nbGrains < labscale::regolith.nbGrains)
{
// Pour a grain
PxRigidDynamic* grain = CreateRegolithGrain();
RandLaunchActor(grain,2);
PxVec3 v = grain->getLinearVelocity();
grain->setLinearVelocity(PxVec3(v.x,0,v.z));
// Reset timer
poured_time = gSim.codeTime;
}
// When done save scene and stop
if (nbGrains >= labscale::regolith.nbGrains && CountSleepers() == gPhysX.mScene->getNbActors(gPhysX.roles.dynamics))
{
gSim.isRunning = false;
SaveSceneToRepXDump();
}
// Hack if rebooting (F10 was pressed) - not really important
if ((gSim.codeTime - poured_time) < 0) poured_time = gSim.codeTime;
}
void
Spacetime::saveState(void) {
linearVelocityVector.clear();
angularVelocityVector.clear();
globalPoseVector.clear();
for (int i = 0; i < dynamic_actors.size(); i++) {
PxRigidDynamic* current = dynamic_actors[i];
linearVelocityVector.push_back(current->getLinearVelocity());
angularVelocityVector.push_back(current->getAngularVelocity());
globalPoseVector.push_back(current->getGlobalPose());
}
}
void PxVehicleCopyDynamicsData(const PxVehicleCopyDynamicsMap& wheelMap, const PxVehicleWheels& src, PxVehicleWheels* trg)
{
PX_CHECK_AND_RETURN(trg, "PxVehicleCopyDynamicsData requires that trg is a valid vehicle pointer");
PX_CHECK_AND_RETURN(src.getVehicleType() == trg->getVehicleType(), "PxVehicleCopyDynamicsData requires that both src and trg are the same type of vehicle");
#ifdef PX_CHECKED
{
const PxU32 numWheelsSrc = src.mWheelsSimData.getNbWheels();
const PxU32 numWheelsTrg = trg->mWheelsSimData.getNbWheels();
PxU8 copiedWheelsSrc[PX_MAX_NB_WHEELS];
PxMemZero(copiedWheelsSrc, sizeof(PxU8) * PX_MAX_NB_WHEELS);
PxU8 setWheelsTrg[PX_MAX_NB_WHEELS];
PxMemZero(setWheelsTrg, sizeof(PxU8) * PX_MAX_NB_WHEELS);
for(PxU32 i = 0; i < PxMin(numWheelsSrc, numWheelsTrg); i++)
{
const PxU32 srcWheelId = wheelMap.sourceWheelIds[i];
PX_CHECK_AND_RETURN(srcWheelId < numWheelsSrc, "PxVehicleCopyDynamicsData - wheelMap contains illegal source wheel id");
PX_CHECK_AND_RETURN(0 == copiedWheelsSrc[srcWheelId], "PxVehicleCopyDynamicsData - wheelMap contains illegal source wheel id");
copiedWheelsSrc[srcWheelId] = 1;
const PxU32 trgWheelId = wheelMap.targetWheelIds[i];
PX_CHECK_AND_RETURN(trgWheelId < numWheelsTrg, "PxVehicleCopyDynamicsData - wheelMap contains illegal target wheel id");
PX_CHECK_AND_RETURN(0 == setWheelsTrg[trgWheelId], "PxVehicleCopyDynamicsData - wheelMap contains illegal target wheel id");
setWheelsTrg[trgWheelId]=1;
}
}
#endif
const PxU32 numWheelsSrc = src.mWheelsSimData.getNbWheels();
const PxU32 numWheelsTrg = trg->mWheelsSimData.getNbWheels();
//Set all dynamics data on the target to zero.
//Be aware that setToRestState sets the rigid body to
//rest so set the momentum back after calling setToRestState.
PxRigidDynamic* actorTrg = trg->getRigidDynamicActor();
PxVec3 linVel = actorTrg->getLinearVelocity();
PxVec3 angVel = actorTrg->getAngularVelocity();
switch(src.getVehicleType())
{
case PxVehicleTypes::eDRIVE4W:
((PxVehicleDrive4W*)trg)->setToRestState();
break;
case PxVehicleTypes::eDRIVENW:
((PxVehicleDriveNW*)trg)->setToRestState();
break;
case PxVehicleTypes::eDRIVETANK:
((PxVehicleDriveTank*)trg)->setToRestState();
break;
case PxVehicleTypes::eNODRIVE:
((PxVehicleNoDrive*)trg)->setToRestState();
break;
default:
break;
}
actorTrg->setLinearVelocity(linVel);
actorTrg->setAngularVelocity(angVel);
//Keep a track of the wheels on trg that have their dynamics data set as a copy from src.
PxU8 setWheelsTrg[PX_MAX_NB_WHEELS];
PxMemZero(setWheelsTrg, sizeof(PxU8) * PX_MAX_NB_WHEELS);
//Keep a track of the average wheel rotation speed of all enabled wheels on src.
PxU32 numEnabledWheelsSrc = 0;
PxF32 accumulatedWheelRotationSpeedSrc = 0.0f;
//Copy wheel dynamics data from src wheels to trg wheels.
//Track the target wheels that have been given dynamics data from src wheels.
//Compute the accumulated wheel rotation speed of all enabled src wheels.
const PxU32 numMappedWheels = PxMin(numWheelsSrc, numWheelsTrg);
for(PxU32 i = 0; i < numMappedWheels; i++)
{
const PxU32 srcWheelId = wheelMap.sourceWheelIds[i];
const PxU32 trgWheelId = wheelMap.targetWheelIds[i];
trg->mWheelsDynData.copy(src.mWheelsDynData, srcWheelId, trgWheelId);
setWheelsTrg[trgWheelId] = 1;
if(!src.mWheelsSimData.getIsWheelDisabled(srcWheelId))
{
numEnabledWheelsSrc++;
accumulatedWheelRotationSpeedSrc += src.mWheelsDynData.getWheelRotationSpeed(srcWheelId);
}
}
//Compute the average wheel rotation speed of src.
PxF32 averageWheelRotationSpeedSrc = 0;
if(numEnabledWheelsSrc > 0)
{
averageWheelRotationSpeedSrc = (accumulatedWheelRotationSpeedSrc/ (1.0f * numEnabledWheelsSrc));
}
//For wheels on trg that have not had their dynamics data copied from src just set
//their wheel rotation speed to the average wheel rotation speed.
for(PxU32 i = 0; i < numWheelsTrg; i++)
{
if(0 == setWheelsTrg[i] && !trg->mWheelsSimData.getIsWheelDisabled(i))
{
trg->mWheelsDynData.setWheelRotationSpeed(i, averageWheelRotationSpeedSrc);
}
}
//Copy the engine rotation speed/gear states/autobox states/etc.
switch(src.getVehicleType())
{
case PxVehicleTypes::eDRIVE4W:
case PxVehicleTypes::eDRIVENW:
case PxVehicleTypes::eDRIVETANK:
{
const PxVehicleDriveDynData& driveDynDataSrc = ((const PxVehicleDrive&)src).mDriveDynData;
PxVehicleDriveDynData* driveDynDataTrg = &((PxVehicleDrive*)trg)->mDriveDynData;
*driveDynDataTrg = driveDynDataSrc;
}
break;
default:
break;
}
}
