void NpArticulationJoint::setExternalCompliance(PxReal r)
{
PX_CHECK_AND_RETURN(PxIsFinite(r) && r>0, "PxArticulationJoint::setExternalCompliance: compliance must be > 0");
NP_WRITE_CHECK(getOwnerScene());
mJoint.setExternalCompliance(r);
}
void NpArticulationJoint::setTangentialDamping(PxReal damping)
{
PX_CHECK_AND_RETURN(PxIsFinite(damping) && damping >= 0, "PxArticulationJoint::setTangentialDamping: damping must be > 0");
NP_WRITE_CHECK(getOwnerScene());
mJoint.setTangentialDamping(damping);
}
PxArticulationLink* NpArticulation::createLink(PxArticulationLink* parent, const PxTransform& pose)
{
PX_CHECK_AND_RETURN_NULL(pose.isSane(), "NpArticulation::createLink pose is not valid.");
NP_WRITE_CHECK(getOwnerScene());
if(parent && mArticulationLinks.empty())
{
Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Root articulation link must have NULL parent pointer!");
return NULL;
}
if(!parent && !mArticulationLinks.empty())
{
Ps::getFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Non-root articulation link must have valid parent pointer!");
return NULL;
}
NpArticulationLink* parentLink = static_cast<NpArticulationLink*>(parent);
NpArticulationLink* link = static_cast<NpArticulationLink*>(NpFactory::getInstance().createArticulationLink(*this, parentLink, pose.getNormalized()));
if(link)
{
NpScene* scene = getAPIScene();
if(scene)
scene->addArticulationLink(*link);
}
return link;
}
void NpArticulation::release()
{
NP_WRITE_CHECK(getOwnerScene());
NpPhysics::getInstance().notifyDeletionListenersUserRelease(this, userData);
//!!!AL TODO: Order should not matter in this case. Optimize by having a path which does not restrict release to leaf links or
// by using a more advanced data structure
PxU32 idx = 0;
while(mArticulationLinks.size())
{
idx = idx % mArticulationLinks.size();
if (mArticulationLinks[idx]->getNbChildren() == 0)
{
mArticulationLinks[idx]->releaseInternal(); // deletes joint, link and removes link from list
}
else
{
idx++;
}
}
NpScene* npScene = getAPIScene();
if(npScene)
{
npScene->getScene().removeArticulation(getArticulation());
npScene->removeFromArticulationList(*this);
}
mArticulationLinks.clear();
mArticulation.destroy();
}
void NpArticulationJoint::setTangentialStiffness(PxReal stiffness)
{
PX_CHECK_AND_RETURN(PxIsFinite(stiffness) && stiffness >= 0, "PxArticulationJoint::setTangentialStiffness: stiffness must be > 0");
NP_WRITE_CHECK(getOwnerScene());
mJoint.setTangentialStiffness(stiffness);
}
void NpArticulationJoint::setSwingLimit(PxReal yLimit, PxReal zLimit)
{
PX_CHECK_AND_RETURN(PxIsFinite(yLimit) && PxIsFinite(zLimit) && yLimit > 0 && zLimit > 0 && yLimit < PxPi && zLimit < PxPi,
"PxArticulationJoint::setSwingLimit: values must be >0 and < Pi");
NP_WRITE_CHECK(getOwnerScene());
mJoint.setSwingLimit(yLimit, zLimit);
}
void NpArticulationJoint::setTwistLimitContactDistance(PxReal d)
{
PX_CHECK_AND_RETURN(PxIsFinite(d) && d >= 0.0f, "PxArticulationJoint::setTwistLimitContactDistance: padding coefficient must be > 0!");
NP_WRITE_CHECK(getOwnerScene());
mJoint.setTwistLimitContactDistance(d);
}
void NpArticulationJoint::setDamping(PxReal d)
{
PX_CHECK_AND_RETURN(PxIsFinite(d) && d >= 0.0f, "PxArticulationJoint::setDamping: damping coefficient must be >= 0!");
NP_WRITE_CHECK(getOwnerScene());
mJoint.setDamping(d);
}
void NpArticulationJoint::setStiffness(PxReal s)
{
PX_CHECK_AND_RETURN(PxIsFinite(s) && s >= 0.0f, "PxArticulationJoint::setStiffness: spring coefficient must be >= 0!");
NP_WRITE_CHECK(getOwnerScene());
mJoint.setStiffness(s);
}
void NpArticulationJoint::setTargetVelocity(const PxVec3& v)
{
PX_CHECK_AND_RETURN(v.isFinite(), "NpArticulationJoint::setTargetVelocity v is not valid.");
NP_WRITE_CHECK(getOwnerScene());
mJoint.setTargetVelocity(v);
}
void NpArticulationJoint::setTwistLimit(PxReal lower, PxReal upper)
{
PX_CHECK_AND_RETURN(PxIsFinite(lower) && PxIsFinite(upper) && lower<upper && lower>-PxPi && upper < PxPi, "PxArticulationJoint::setTwistLimit: illegal parameters");
NP_WRITE_CHECK(getOwnerScene());
mJoint.setTwistLimit(lower, upper);
}
void NpArticulationJoint::setChildPose(const PxTransform& t)
{
PX_CHECK_AND_RETURN(t.isSane(), "NpArticulationJoint::setChildPose t is not valid.");
NP_WRITE_CHECK(getOwnerScene());
mJoint.setChildPose(mChild->getCMassLocalPose().transformInv(t.getNormalized()));
}
void NpArticulationJoint::setTargetOrientation(const PxQuat& p)
{
PX_CHECK_AND_RETURN(mJoint.getDriveType() != PxArticulationJointDriveType::eTARGET || p.isUnit(), "NpArticulationJoint::setTargetOrientation, quat orientation is not valid.");
PX_CHECK_AND_RETURN(mJoint.getDriveType() != PxArticulationJointDriveType::eERROR || (p.getImaginaryPart().isFinite() && p.w == 0), "NpArticulationJoint::setTargetOrientation rotation vector orientation is not valid.");
NP_WRITE_CHECK(getOwnerScene());
mJoint.setTargetOrientation(p);
}
void NpArticulationJoint::setParentPose(const PxTransform& t)
{
PX_CHECK_AND_RETURN(t.isSane(), "NpArticulationJoint::setParentPose t is not valid.");
NP_WRITE_CHECK(getOwnerScene());
if(mParent==NULL)
return;
mJoint.setParentPose(mParent->getCMassLocalPose().transformInv(t.getNormalized()));
}
void NpArticulation::setSolverIterationCounts(PxU32 positionIters, PxU32 velocityIters)
{
NP_WRITE_CHECK(getOwnerScene());
PX_CHECK_AND_RETURN(positionIters > 0, "Articulation::setSolverIterationCount: positionIters must be more than zero!");
PX_CHECK_AND_RETURN(positionIters <= 255, "Articulation::setSolverIterationCount: positionIters must be no greater than 255!");
PX_CHECK_AND_RETURN(velocityIters > 0, "Articulation::setSolverIterationCount: velocityIters must be more than zero!");
PX_CHECK_AND_RETURN(velocityIters <= 255, "Articulation::setSolverIterationCount: velocityIters must be no greater than 255!");
getArticulation().setSolverIterationCounts((velocityIters & 0xff) << 8 | (positionIters & 0xff));
}
void NpArticulation::setWakeCounter(PxReal wakeCounterValue)
{
NP_WRITE_CHECK(getOwnerScene());
for(PxU32 i=0; i < mArticulationLinks.size(); i++)
{
mArticulationLinks[i]->getScbBodyFast().setWakeCounter(wakeCounterValue);
}
getArticulation().setWakeCounter(wakeCounterValue);
}
void NpArticulation::putToSleep()
{
NP_WRITE_CHECK(getOwnerScene());
PX_CHECK_AND_RETURN(getAPIScene(), "Articulation::putToSleep: articulation must be in a scene.");
for(PxU32 i=0; i < mArticulationLinks.size(); i++)
{
mArticulationLinks[i]->getScbBodyFast().putToSleepInternal();
}
getArticulation().putToSleep();
}
void NpArticulation::wakeUp()
{
NpScene* scene = getAPIScene();
NP_WRITE_CHECK(getOwnerScene()); // don't use the API scene, since it will be NULL on pending removal
PX_CHECK_AND_RETURN(scene, "Articulation::wakeUp: articulation must be in a scene.");
for(PxU32 i=0; i < mArticulationLinks.size(); i++)
{
mArticulationLinks[i]->getScbBodyFast().wakeUpInternal(scene->getWakeCounterResetValueInteral());
}
getArticulation().wakeUp();
}
void NpArticulation::applyImpulse(PxArticulationLink* link,
const PxArticulationDriveCache& driveCache,
const PxVec3& force,
const PxVec3& torque)
{
PX_CHECK_AND_RETURN(getAPIScene(), "PxArticulation::applyImpulse: object must be in a scene");
PX_CHECK_AND_RETURN(force.isFinite() && torque.isFinite(), "PxArticulation::applyImpulse: invalid force/torque");
const Sc::ArticulationDriveCache& c = reinterpret_cast<const Sc::ArticulationDriveCache&>(driveCache);
PX_CHECK_AND_RETURN(mArticulation.getScArticulation().getCacheLinkCount(c) == mArticulationLinks.size(), "PxArticulation::applyImpulse: Articulation size has changed; drive cache is invalid");
NP_WRITE_CHECK(getOwnerScene());
if(isSleeping())
wakeUp();
mArticulation.getScArticulation().applyImpulse(static_cast<NpArticulationLink*>(link)->getScbBodyFast().getScBody(), c,force, torque);
for(PxU32 i=0;i<mArticulationLinks.size();i++)
{
PxVec3 lv = mArticulationLinks[i]->getScbBodyFast().getScBody().getLinearVelocity(),
av = mArticulationLinks[i]->getScbBodyFast().getScBody().getAngularVelocity();
mArticulationLinks[i]->setLinearVelocity(lv);
mArticulationLinks[i]->setAngularVelocity(av);
}
}
void NpArticulation::setName(const char* debugName)
{
NP_WRITE_CHECK(getOwnerScene());
mName = debugName;
}
void NpArticulationJoint::setDriveType(PxArticulationJointDriveType::Enum driveType)
{
NP_WRITE_CHECK(getOwnerScene());
mJoint.setDriveType(driveType);
}
void NpArticulation::setStabilizationThreshold(PxReal threshold)
{
NP_WRITE_CHECK(getOwnerScene());
getArticulation().setFreezeThreshold(threshold);
}
void NpArticulation::setSleepThreshold(PxReal threshold)
{
NP_WRITE_CHECK(getOwnerScene());
getArticulation().setSleepThreshold(threshold);
}
void NpArticulation::setSeparationTolerance(PxReal tolerance)
{
NP_WRITE_CHECK(getOwnerScene());
getArticulation().setSeparationTolerance(tolerance);
}
void NpArticulation::setMaxProjectionIterations(PxU32 iterations)
{
NP_WRITE_CHECK(getOwnerScene());
getArticulation().setMaxProjectionIterations(iterations);
}
void NpArticulation::setExternalDriveIterations(PxU32 iterations)
{
NP_WRITE_CHECK(getOwnerScene());
getArticulation().setExternalDriveIterations(iterations);
}
void NpArticulationJoint::setTwistLimitEnabled(bool e)
{
NP_WRITE_CHECK(getOwnerScene());
mJoint.setTwistLimitEnabled(e);
}
