//-----------------------------------------------------------------------
void PhysXActorExtern::_processParticle(
ParticleTechnique* particleTechnique,
Particle* particle,
Ogre::Real timeElapsed,
bool firstParticle)
{
// Only update after a PhysX simulation step
if (mSynchronize)
{
if (particle->particleType != Particle::PT_VISUAL)
return;
if (!particle->physicsActor)
return;
VisualParticle* visualParticle = static_cast<VisualParticle*>(particle);
PhysXActor* physXActor = static_cast<PhysXActor*>(particle->physicsActor);
NxActor* nxActor = physXActor->nxActor;
if (nxActor)
{
// Synchronize both the particle and the pysicsActor with the nxActor
particle->position = PhysXMath::convert(nxActor->getGlobalPosition());
particle->direction = PhysXMath::convert(nxActor->getLinearVelocity());
visualParticle->orientation = PhysXMath::convert(nxActor->getGlobalOrientationQuat());
physXActor->position = particle->position;
physXActor->direction = particle->direction;
physXActor->orientation = visualParticle->orientation;
if (nxActor->getNbShapes())
{
NxShape *shape = nxActor->getShapes()[0]; // Max one.
switch(shape->getType())
{
case NX_SHAPE_BOX:
(static_cast<NxBoxShape*>(shape))->setDimensions(
PhysXMath::convert(0.5 * Ogre::Vector3(
visualParticle->width, visualParticle->height, visualParticle->depth)));
break;
case NX_SHAPE_SPHERE:
(static_cast<NxSphereShape*>(shape))->setRadius(0.5f * visualParticle->width);
break;
case NX_SHAPE_CAPSULE:
{
(static_cast<NxCapsuleShape*>(shape))->setRadius(0.5f * visualParticle->width);
(static_cast<NxCapsuleShape*>(shape))->setHeight(0.5f * visualParticle->height);
}
break;
}
}
}
}
}
pRigidBody*pFactory::cloneRigidBody(CK3dEntity *src,CK3dEntity *dst,CKDependencies *deps,int copyFlags,int bodyFlags/* =0 */)
{
//src->Rest
pRigidBody *result = GetPMan()->getBody(dst);
pRigidBody *srcBody = GetPMan()->getBody(src);
CK3dEntity *referenceObject = dst;
XString errMsg;
pObjectDescr oDescr;
//----------------------------------------------------------------
//
// sanity checks
//
#ifdef _DEBUG
assert(src);
assert(dst);
#endif // _DEBUG
if (!(copyFlags & PB_CF_PHYSICS))
{
errMsg.Format("Nothing to copy, aborting");
xLogger::xLog(XL_START,ELOGWARNING,E_LI_MANAGER,errMsg.Str());
return NULL;
}
//iAssertW(!result,"","Object :%s already physicalized");
//----------------------------------------------------------------
//
// fill object description
//
if (!result && IParameter::Instance()->copyTo(oDescr,src,copyFlags))
{
pWorld *world = GetPMan()->getWorld(oDescr.worlReference) ? GetPMan()->getWorld(oDescr.worlReference) : GetPMan()->getDefaultWorld();
if(world)
{
if ( (copyFlags && PB_CF_OVRRIDE_BODY_FLAGS) )
oDescr.flags = (BodyFlags)bodyFlags;
//now create the final rigid body :
result = pFactory::Instance()->createRigidBody(dst,oDescr);
}
}
if (!result){
xLogger::xLog(XL_START,ELOGERROR,E_LI_MANAGER,"cloning failed");
return NULL;
}
//----------------------------------------------------------------
//
// clone joints
//
if ( (copyFlags & PB_CF_JOINTS) )
{
pFactory::cloneJoints(src,dst,copyFlags);
}
//----------------------------------------------------------------
//
// copy velocities
//
if ( (copyFlags & PB_CF_VELOCITIES) )
{
NxActor *actorSrc = srcBody->getActor();
NxActor *actorDst = result->getActor();
actorDst->setLinearVelocity( actorSrc->getLinearVelocity() );
actorDst->setAngularVelocity( actorSrc->getAngularVelocity() );
}
//----------------------------------------------------------------
//
// copy forces
//
if ( (copyFlags & PB_CF_FORCE) )
{
NxActor *actorSrc = srcBody->getActor();
NxActor *actorDst = result->getActor();
actorDst->setLinearMomentum( actorSrc->getLinearMomentum() );
actorDst->setAngularMomentum( actorSrc->getAngularMomentum() );
}
//----------------------------------------------------------------
//
// copy sub shapes if :
//
// "Copy Children In Dependencies" &&
// ( copyFlags::OverrideBodyFlags & hierarchy && newBodyFlags & hierarchy ) ||
// ( oldBodyFlags & hierarchy )
if ( ((*deps->At(CKCID_3DENTITY)) & CK_DEPENDENCIES_COPY_3DENTITY_CHILDREN) &&
( (( copyFlags & PB_CF_OVRRIDE_BODY_FLAGS ) && (bodyFlags & BF_Hierarchy)) ||
( oDescr.flags & BF_Hierarchy) )
)
{
int dCount = dst->GetChildrenCount();
CK3dEntity* subEntity = NULL;
while (subEntity= dst->HierarchyParser(subEntity) )
{
if (subEntity==dst)
continue;
CK3dEntity *orginalObject = findSimilarInSourceObject(src,dst,subEntity);
if (orginalObject)
{
iAssertW(cloneShape(orginalObject,subEntity,dst,copyFlags,bodyFlags),"","clone of sub shape failed");
}
}
}
return NULL;
}
//-----------------------------------------------------------------------
PhysicsActor* PhysXActorExtern::createPhysicsActor(PhysicsActorDesc* physicsActorDesc, PhysicsShapeDesc* physicsShapeDesc)
{
if (!PhysXBridge::getSingletonPtr()->getScene() || !physicsActorDesc || !physicsShapeDesc)
return 0;
NxBodyDesc bodyDesc;
bodyDesc.setToDefault();
NxReal angularDamping = bodyDesc.angularDamping;
NxVec3 angularVelocity = bodyDesc.angularVelocity;
NxVec3 linearVelocity = bodyDesc.linearVelocity;
bodyDesc.angularDamping = physicsShapeDesc->mAngularDamping;
bodyDesc.angularVelocity = PhysXMath::convert(physicsShapeDesc->mAngularVelocity);
bodyDesc.linearVelocity = PhysXMath::convert(physicsActorDesc->direction);
NxActorDesc actorDesc;
NxActorDesc defaultActorDesc;
actorDesc.setToDefault();
defaultActorDesc.setToDefault();
switch (physicsShapeDesc->mPhysicsShapeType)
{
case ST_BOX:
{
PhysicsBoxDesc* physicsBoxDesc = static_cast<PhysicsBoxDesc*>(physicsShapeDesc);
NxBoxShapeDesc boxDesc;
boxDesc.setToDefault();
boxDesc.dimensions = PhysXMath::convert(physicsBoxDesc->mDimensions);
boxDesc.group = physicsBoxDesc->mCollisionGroup;
boxDesc.groupsMask = PhysXMath::convert(physicsBoxDesc->mGroupMask);
boxDesc.materialIndex = physicsBoxDesc->mMaterialIndex;
actorDesc.density = NxComputeBoxDensity(2 * boxDesc.dimensions, physicsActorDesc->mass);
actorDesc.shapes.pushBack(&boxDesc);
}
break;
case ST_SPHERE:
{
PhysicsSphereDesc* physicsSphereDesc = static_cast<PhysicsSphereDesc*>(physicsShapeDesc);
NxSphereShapeDesc sphereDec;
sphereDec.setToDefault();
sphereDec.radius = physicsSphereDesc->mRadius;
sphereDec.group = physicsSphereDesc->mCollisionGroup;
sphereDec.groupsMask = PhysXMath::convert(physicsSphereDesc->mGroupMask);
sphereDec.materialIndex = physicsSphereDesc->mMaterialIndex;
actorDesc.density = NxComputeSphereDensity(sphereDec.radius, physicsActorDesc->mass);
actorDesc.shapes.pushBack(&sphereDec);
}
break;
case ST_CAPSULE:
{
PhysicsCapsuleDesc* physicsCapsuleDesc = static_cast<PhysicsCapsuleDesc*>(physicsShapeDesc);
NxCapsuleShapeDesc capsuleDec;
capsuleDec.setToDefault();
capsuleDec.radius = physicsCapsuleDesc->mRadius;
capsuleDec.height = physicsCapsuleDesc->mHeight;
capsuleDec.group = physicsCapsuleDesc->mCollisionGroup;
capsuleDec.groupsMask = PhysXMath::convert(physicsCapsuleDesc->mGroupMask);
capsuleDec.materialIndex = physicsCapsuleDesc->mMaterialIndex;
actorDesc.density = NxComputeCylinderDensity(capsuleDec.radius, capsuleDec.height, physicsActorDesc->mass);
actorDesc.shapes.pushBack(&capsuleDec);
}
break;
}
actorDesc.globalPose.t = PhysXMath::convert(physicsActorDesc->position);
actorDesc.body = &bodyDesc;
actorDesc.group = physicsActorDesc->collisionGroup;
PhysXActor* physXActor = 0;
if (!actorDesc.isValid())
{
actorDesc = defaultActorDesc;
Ogre::LogManager::getSingleton().logMessage("ParticleUniverse PhysXActor: Cannot create actor; use default attributes.");
}
NxActor* nxActor = PhysXBridge::getSingletonPtr()->getScene()->createActor(actorDesc);
if (nxActor)
{
physXActor = OGRE_NEW_T(PhysXActor, Ogre::MEMCATEGORY_SCENE_OBJECTS)();
physXActor->position = PhysXMath::convert(nxActor->getGlobalPosition());
physXActor->direction = PhysXMath::convert(nxActor->getLinearVelocity());
nxActor->setGlobalOrientationQuat(PhysXMath::convert(physicsActorDesc->orientation));
physXActor->orientation = physicsActorDesc->orientation;
physXActor->mass = nxActor->getMass();
physXActor->collisionGroup = nxActor->getGroup();
physXActor->nxActor = nxActor;
}
return physXActor;
}