PxActor* World::createRigidBody(const PxGeometry& geometry, float mass, const ofVec3f& pos, const ofQuaternion& rot, float density)
{
assert(inited);
PxTransform transform;
toPx(pos, transform.p);
toPx(rot, transform.q);
PxActor *actor;
if (mass > 0)
{
PxRigidDynamic* rigid = PxCreateDynamic(*physics, transform, geometry, *defaultMaterial, density);
rigid->setMass(mass);
rigid->setLinearDamping(0.25);
rigid->setAngularDamping(0.25);
actor = rigid;
}
else
{
PxRigidStatic *rigid = PxCreateStatic(*physics, transform, geometry, *defaultMaterial);
actor = rigid;
}
scene->addActor(*actor);
return actor;
}
PxRigidDynamic* PxCloneDynamic(PxPhysics& physicsSDK,
const PxTransform& transform,
const PxRigidDynamic& from)
{
PxRigidDynamic* to = physicsSDK.createRigidDynamic(transform);
if(!to)
return NULL;
copyStaticProperties(*to, from);
to->setRigidDynamicFlags(from.getRigidDynamicFlags());
to->setMass(from.getMass());
to->setMassSpaceInertiaTensor(from.getMassSpaceInertiaTensor());
to->setCMassLocalPose(from.getCMassLocalPose());
to->setLinearVelocity(from.getLinearVelocity());
to->setAngularVelocity(from.getAngularVelocity());
to->setLinearDamping(from.getAngularDamping());
to->setAngularDamping(from.getAngularDamping());
to->setMaxAngularVelocity(from.getMaxAngularVelocity());
PxU32 posIters, velIters;
from.getSolverIterationCounts(posIters, velIters);
to->setSolverIterationCounts(posIters, velIters);
to->setSleepThreshold(from.getSleepThreshold());
to->setContactReportThreshold(from.getContactReportThreshold());
return to;
}
void PhysXPhysics::AddShape(Actor* pActor, PxGeometry* geometry, float density, const std::string& physicsMaterial, bool gravityEnabled, float linearDamping, float angularDamping, const std::string& bodyType)
{
BE_ASSERT(pActor);
ActorId actorId = pActor->GetId();
BE_ASSERTf(m_actorRigidBodyMap.find(actorId) == m_actorRigidBodyMap.end(), "Actor with more than one rigidbody");
Mat4x4 transform = Mat4x4::g_Identity;
TransformComponent* pTransformComponent = pActor->GetComponent<TransformComponent>(TransformComponent::g_Name);
if (pTransformComponent)
{
transform = pTransformComponent->GetTransform();
}
else
{
//Doesnt work without transform
BE_ERROR("Actor %s PhysicsComponent requires Shape to have Transform Component: %d", actorId);
return;
}
PhysicsMaterialData material(LookupMaterialData(physicsMaterial));
PxMaterial* mat = m_pPhysicsSdk->createMaterial(material.m_friction, material.m_friction, material.m_restitution);
Vec3 translation, scale;
Quaternion rotation;
bool ok = transform.Decompose(translation, rotation, scale);
PxQuat pxRot;
PxVec3 pxLoc;
Vec3ToPxVec(translation, &pxLoc);
QuaternionToPxQuat(rotation, &pxRot);
PxTransform t(pxLoc, pxRot);
if (bodyType == "Dynamic")
{
PxRigidDynamic* body = PxCreateDynamic(*m_pPhysicsSdk, t, *geometry, *mat, density);
body->setActorFlag(PxActorFlag::eDISABLE_GRAVITY, !gravityEnabled);
PxRigidBodyExt::updateMassAndInertia(*body, density);
body->setLinearDamping(linearDamping);
body->setAngularDamping(angularDamping);
m_pScene->addActor(*body);
m_actorRigidBodyMap[actorId] = body;
m_rigidBodyActorMap[body] = actorId;
}
else
{
BE_ERROR("[Physics] BodyType not supported: %s", bodyType.c_str());
return;
}
}
bool Collider::Init(bool isDynamic)
{
bool ret = false;
const Transform& transform = mOwner.GetTransform();
mTransform.position = transform.position;
mTransform.rotation = transform.rotation;
PxVec3 pos = ConvertPxVec3(transform.position);
PxQuat rot = ConvertPxQuat(transform.rotation);
PxScene* scene = mOwner.GetScene().GetPxScene();
CHECK(scene);
if (isDynamic)
{
PxRigidDynamic* dyn = gPhysics->createRigidDynamic(PxTransform(pos, rot));
dyn->setLinearDamping(0.25);
dyn->setAngularDamping(0.25);
mActor = dyn;
mRigidBody = new RigidBody(*dyn);
}
else
{
mActor = gPhysics->createRigidStatic(PxTransform(pos, rot));
}
CHECK(mActor);
mActor->userData = &mOwner;
OnInitShape();
CHECK(mGizmo);
mOwner.GetScene().AddGizmo(mGizmo);
mGizmo->SetColor(Color(0, 1, 0, 1));
scene->addActor(*mActor);
SetLocalPose(Vector3(), Quat());
ret = true;
Exit0:
return ret;
}
PxRigidDynamic* CloneDynamic(PxPhysics& physicsSDK,
const PxTransform& transform,
const PxRigidDynamic& from,
NxMirrorScene::MirrorFilter &mirrorFilter)
{
PxRigidDynamic* to = physicsSDK.createRigidDynamic(transform);
if(!to)
return NULL;
if ( !copyStaticProperties(*to, from, mirrorFilter) )
{
to->release();
to = NULL;
return NULL;
}
to->setRigidDynamicFlags(from.getRigidDynamicFlags());
to->setMass(from.getMass());
to->setMassSpaceInertiaTensor(from.getMassSpaceInertiaTensor());
to->setCMassLocalPose(from.getCMassLocalPose());
if ( !(to->getRigidDynamicFlags() & PxRigidDynamicFlag::eKINEMATIC) )
{
to->setLinearVelocity(from.getLinearVelocity());
to->setAngularVelocity(from.getAngularVelocity());
}
to->setLinearDamping(from.getAngularDamping());
to->setAngularDamping(from.getAngularDamping());
to->setMaxAngularVelocity(from.getMaxAngularVelocity());
PxU32 posIters, velIters;
from.getSolverIterationCounts(posIters, velIters);
to->setSolverIterationCounts(posIters, velIters);
to->setSleepThreshold(from.getSleepThreshold());
to->setContactReportThreshold(from.getContactReportThreshold());
return to;
}
void SampleSubmarine::explode(PxRigidActor* actor, const PxVec3& explosionPos, const PxReal explosionStrength)
{
size_t numRenderActors = mRenderActors.size();
for(PxU32 i = 0; i < numRenderActors; i++)
{
if(&(mRenderActors[i]->getPhysicsShape()->getActor()) == actor)
{
PxShape* shape = mRenderActors[i]->getPhysicsShape();
PxTransform pose = PxShapeExt::getGlobalPose(*shape);
PxGeometryHolder geom = shape->getGeometry();
// create new actor from shape (to split compound)
PxRigidDynamic* newActor = mPhysics->createRigidDynamic(pose);
if(!newActor) fatalError("createRigidDynamic failed!");
PxShape* newShape = newActor->createShape(geom.any(), *mMaterial);
newShape->userData = mRenderActors[i];
mRenderActors[i]->setPhysicsShape(newShape);
newActor->setActorFlag(PxActorFlag::eVISUALIZATION, true);
newActor->setLinearDamping(10.5f);
newActor->setAngularDamping(0.5f);
PxRigidBodyExt::updateMassAndInertia(*newActor, 1.0f);
mScene->addActor(*newActor);
mPhysicsActors.push_back(newActor);
PxVec3 explosion = pose.p - explosionPos;
PxReal len = explosion.normalize();
explosion *= (explosionStrength / len);
newActor->setLinearVelocity(explosion);
newActor->setAngularVelocity(PxVec3(1,2,3));
}
}
removeActor(actor);
}
// Creates an physics entity from an entity info structure and a starting transform
void PhysicsEngine::createEntity(PhysicsEntity* entity, PhysicsEntityInfo* info, PxTransform transform)
{
transform.p.y += info->yPosOffset;
// Set static/dynamic info for actor depending on its type
PxRigidActor* actor;
if (info->type == PhysicsType::DYNAMIC)
{
DynamicInfo* dInfo = info->dynamicInfo;
PxRigidDynamic* dynamicActor = physics->createRigidDynamic(transform);
dynamicActor->setLinearDamping(dInfo->linearDamping);
dynamicActor->setAngularDamping(dInfo->angularDamping);
dynamicActor->setMaxAngularVelocity(dInfo->maxAngularVelocity);
actor = dynamicActor;
}
else if (info->type == PhysicsType::STATIC)
{
PxRigidStatic* staticActor = physics->createRigidStatic(transform);
actor = staticActor;
}
// All shapes in actor
for (auto sInfo : info->shapeInfo)
{
// Create material and geometry for shape and add it to actor
PxGeometry* geometry;
PxMaterial* material;
if (sInfo->geometry == Geometry::SPHERE)
{
SphereInfo* sphInfo = (SphereInfo*)sInfo;
geometry = new PxSphereGeometry(sphInfo->radius);
}
else if (sInfo->geometry == Geometry::BOX)
{
BoxInfo* boxInfo = (BoxInfo*)sInfo;
geometry = new PxBoxGeometry(boxInfo->halfX, boxInfo->halfY, boxInfo->halfZ);
}
else if (sInfo->geometry == Geometry::CAPSULE)
{
CapsuleInfo* capInfo = (CapsuleInfo*)sInfo;
geometry = new PxCapsuleGeometry(capInfo->radius, capInfo->halfHeight);
}
else if (sInfo->geometry == Geometry::CONVEX_MESH)
{
ConvexMeshInfo* cmInfo = (ConvexMeshInfo*)sInfo;
PxConvexMesh* mesh = helper->createConvexMesh(cmInfo->verts.data(), cmInfo->verts.size());
geometry = new PxConvexMeshGeometry(mesh);
}
// Not working until index drawing is set up
else if (sInfo->geometry == Geometry::TRIANGLE_MESH)
{
TriangleMeshInfo* tmInfo = (TriangleMeshInfo*)sInfo;
PxTriangleMesh* mesh = helper->createTriangleMesh(tmInfo->verts.data(), tmInfo->verts.size(), tmInfo->faces.data(), tmInfo->faces.size()/3);
geometry = new PxTriangleMeshGeometry(mesh);
}
material = (sInfo->isDrivable) ? drivingSurfaces[0] : physics->createMaterial(sInfo->dynamicFriction, sInfo->staticFriction, sInfo->restitution);
PxShape* shape = actor->createShape(*geometry, *material); // TODO support shape flags
shape->setLocalPose(sInfo->transform);
material->release();
delete geometry;
// Set up querry filter data for shape
PxFilterData qryFilterData;
qryFilterData.word3 = (sInfo->isDrivable) ? (PxU32)Surface::DRIVABLE : (PxU32)Surface::UNDRIVABLE;
shape->setQueryFilterData(qryFilterData);
// Set up simulation filter data for shape
PxFilterData simFilterData;
simFilterData.word0 = (PxU32)sInfo->filterFlag0;
simFilterData.word1 = (PxU32)sInfo->filterFlag1;
simFilterData.word2 = (PxU32)sInfo->filterFlag2;
simFilterData.word3 = (PxU32)sInfo->filterFlag3;
shape->setSimulationFilterData(simFilterData);
if (info->type == PhysicsType::DYNAMIC)
{
DynamicInfo* dInfo = info->dynamicInfo;
PxRigidBodyExt::updateMassAndInertia(*(PxRigidBody*)actor, dInfo->density, &dInfo->cmOffset);
PxRigidBody* body = (PxRigidBody*)actor;
}
}
// Add actor to scene, set actor for entity, and set user data for actor. Creates one to one between entities and phyX
scene->addActor(*actor);
entity->setActor(actor);
actor->userData = entity;
}
Seamine* SampleSubmarine::createSeamine(const PxVec3& inPosition, PxReal inHeight)
{
static const PxReal chainLinkLength = 2.0f;
static const PxReal linkSpacing = 0.05f;
static const PxReal mineHeadRadius = 1.5f;
const PxVec3 mineStartPos = inPosition;
static const PxVec3 linkOffset = PxVec3(0, chainLinkLength + linkSpacing, 0);
static const PxVec3 halfLinkOffset = linkOffset * 0.5f;
static const PxVec3 linkDim = PxVec3(chainLinkLength*0.125f, chainLinkLength*0.5f, chainLinkLength*0.125f);
PxU32 numLinks = PxU32((inHeight - 2.0f*mineHeadRadius) / (chainLinkLength + linkSpacing));
numLinks = numLinks ? numLinks : 1;
Seamine* seamine = SAMPLE_NEW(Seamine);
mSeamines.push_back(seamine);
// create links from floor
PxVec3 linkPos = mineStartPos + halfLinkOffset;
PxRigidActor* prevActor = NULL;
for(PxU32 i = 0; i < numLinks; i++)
{
// create the link actor
PxRigidDynamic* link = createBox(linkPos, linkDim, NULL, mSeamineMaterial, 1.0f)->is<PxRigidDynamic>();
if(!link) fatalError("createBox failed!");
// back reference to mineHead
link->userData = seamine;
seamine->mLinks.push_back(link);
setupFiltering(link, FilterGroup::eMINE_LINK, FilterGroup::eSUBMARINE);
link->setLinearDamping(0.5f);
link->setAngularDamping(0.5f);
link->setActorFlag(PxActorFlag::eDISABLE_GRAVITY, true);
// create distance joint between link and prevActor
PxTransform linkFrameA = prevActor ? PxTransform(halfLinkOffset, PxQuat::createIdentity()) : PxTransform(mineStartPos, PxQuat::createIdentity());
PxTransform linkFrameB = PxTransform(-halfLinkOffset, PxQuat::createIdentity());
PxDistanceJoint *joint = PxDistanceJointCreate(getPhysics(), prevActor, linkFrameA, link, linkFrameB);
if(!joint) fatalError("PxDistanceJointCreate failed!");
// set min & max distance to 0
joint->setMaxDistance(0.0f);
joint->setMinDistance(0.0f);
// setup damping & spring
joint->setDamping(1.0f * link->getMass());
joint->setSpring(400.0f * link->getMass());
joint->setDistanceJointFlags(PxDistanceJointFlag::eMAX_DISTANCE_ENABLED | PxDistanceJointFlag::eMIN_DISTANCE_ENABLED | PxDistanceJointFlag::eSPRING_ENABLED);
// add to joints array for cleanup
mJoints.push_back(joint);
prevActor = link;
linkPos += linkOffset;
}
// create mine head
linkPos.y += mineHeadRadius - (chainLinkLength*0.5f);
PxRigidDynamic* mineHead = createSphere(linkPos, mineHeadRadius, NULL, mSeamineMaterial, 1.0f)->is<PxRigidDynamic>();
mineHead->userData = seamine;
seamine->mMineHead = mineHead;
mineHead->setLinearDamping(0.5f);
mineHead->setAngularDamping(0.5f);
mineHead->setActorFlag(PxActorFlag::eDISABLE_GRAVITY, true);
// setup filtering to trigger contact reports when submarine touches the minehead
setupFiltering(mineHead, FilterGroup::eMINE_HEAD, FilterGroup::eSUBMARINE);
// create distance joint between mine head and prevActor
PxTransform linkFrameA = PxTransform(halfLinkOffset, PxQuat::createIdentity());
PxTransform linkFrameB = PxTransform(PxVec3(0, -mineHeadRadius - linkSpacing*0.5f, 0), PxQuat::createIdentity());
PxDistanceJoint *joint = PxDistanceJointCreate(getPhysics(), prevActor, linkFrameA, mineHead, linkFrameB);
if(!joint) fatalError("PxDistanceJointCreate failed!");
// set min & max distance to 0
joint->setMaxDistance(0.0f);
joint->setMinDistance(0.0f);
// setup damping & spring
joint->setDamping(1.0f * mineHead->getMass());
joint->setSpring(400.0f * mineHead->getMass());
joint->setDistanceJointFlags(PxDistanceJointFlag::eMAX_DISTANCE_ENABLED | PxDistanceJointFlag::eMIN_DISTANCE_ENABLED | PxDistanceJointFlag::eSPRING_ENABLED);
// add to joints array for cleanup
mJoints.push_back(joint);
return seamine;
}
