/*********************************************************** create box actor ***********************************************************/ NxActor* PhysXEngine::CreateBox(const NxVec3 & StartPosition, float dimX, float dimY, float dimZ, float density, bool Pushable) { // Add a single-shape actor to the scene NxActorDesc actorDesc; // The actor has one shape, a box, 1m on a side NxBoxShapeDesc boxDesc; boxDesc.dimensions.set(dimX, dimY, dimZ); boxDesc.localPose.t = NxVec3(0, 0, 0); if(Pushable) { NxBodyDesc bodyDesc; actorDesc.body = &bodyDesc; actorDesc.density = density; boxDesc.group = GROUP_COLLIDABLE_PUSHABLE; } else boxDesc.group = GROUP_COLLIDABLE_NON_PUSHABLE; actorDesc.shapes.pushBack(&boxDesc); actorDesc.globalPose.t = StartPosition; assert(actorDesc.isValid()); NxActor *pActor = gScene->createActor(actorDesc); assert(pActor); return pActor; }
// Create a static trigger static void CreateTrigger(const NxVec3& pos, NxF32 size = 2, const NxVec3* initial_velocity=NULL, bool kinematic = false) { // Our trigger is a cube NxBodyDesc triggerBody; NxBoxShapeDesc dummyShape; NxBoxShapeDesc BoxDesc; BoxDesc.dimensions = NxVec3(size, size, size); BoxDesc.shapeFlags |= NX_TRIGGER_ENABLE; NxActorDesc ActorDesc; if(initial_velocity || kinematic) { if (initial_velocity) { triggerBody.linearVelocity = *initial_velocity; } if (kinematic) { triggerBody.flags |= NX_BF_KINEMATIC; } triggerBody.mass = 1; ActorDesc.body = &triggerBody; NxF32 sizeinc = 1.01f; dummyShape.dimensions.set(size*sizeinc, size*sizeinc, size*sizeinc); dummyShape.group = 1; ActorDesc.shapes.pushBack(&dummyShape); } ActorDesc.shapes.pushBack(&BoxDesc); ActorDesc.globalPose.t = pos; int thisNb = ++gNbTriggers; gNbTouchedBodies.pushBack(0); NX_ASSERT(gNbTouchedBodies.size() == gNbTriggers); gMyPhysX.getScene()->setGroupCollisionFlag(1,0, false); gMyPhysX.getScene()->setGroupCollisionFlag(1,1, false); gMyPhysX.getScene()->setGroupCollisionFlag(1,2, true); ActorDesc.userData = (void*)(-thisNb); if (!ActorDesc.isValid()) { printf("Invalid ActorDesc\n"); return; } NxActor* actor = gMyPhysX.getScene()->createActor(ActorDesc); // This is just a quick-and-dirty way to identify the trigger for rendering NX_ASSERT(actor != NULL); if (kinematic) { KinematicActor k; k.actor = actor; if (initial_velocity) { k.vel = *initial_velocity; } else { k.vel.set(0,0,0); } gKinematicActors.pushBack(k); } gMyPhysX.getScene()->setUserTriggerReport(&myTriggerCallback); }
/*===================================*/ void CFragment::DiscreteInit( void ) { NxVec3 Dimensions[CBreakWall::FragmentType] = { NxVec3( 0.60f , 0.30f , 1.15f ) , NxVec3( 0.25f , 0.15f , 1.65f ) , NxVec3( 0.60f , 0.30f , 1.65f ) }; NxBodyDesc bodyDesc; bodyDesc.setToDefault(); NxActorDesc actorDesc; actorDesc.setToDefault(); NxBoxShapeDesc boxDesc; boxDesc.setToDefault(); boxDesc.skinWidth = 0.0f; actorDesc.density = 1000000.0f; actorDesc.body = &bodyDesc; actorDesc.globalPose.t = NxVec3( m_vPos.x , m_vPos.y , m_vPos.z ); NxMat33 Mat; CRandomize Rand; D3DXVECTOR3 Rot( (float)Rand.GetRandomize( 0.0 , 359.0 ) , (float)Rand.GetRandomize( 0.0 , 359.0 ) , (float)Rand.GetRandomize( 0.0 , 359.0 ) ); CDPConverter::SetRot( &Mat , &Rot ); actorDesc.globalPose.M = Mat; bodyDesc.angularDamping = 0.0f; boxDesc.dimensions = Dimensions[m_Type-1]*m_Scale; if( m_MaterialIndex == -1 ) { // アクターのマテリアルを設定する NxMaterialDesc materialDesc; materialDesc.restitution = 0.4f; materialDesc.dynamicFriction = 3.8f; materialDesc.staticFriction = 3.5f; m_MaterialIndex = m_pPhysX->GetScene()->createMaterial( materialDesc )->getMaterialIndex(); boxDesc.materialIndex = m_MaterialIndex; } else { boxDesc.materialIndex = m_MaterialIndex; } actorDesc.shapes.pushBack( &boxDesc ); m_Actor = m_pPhysX->GetScene()->createActor( actorDesc ); m_Actor->putToSleep(); m_Material = m_lpXFile->GetMaterial(); }
/** * CreateSphere(float r, float xInit, float yInit, float zInit) * @float r: radius of the sphere * @float xInit: Initial Position on X * @float yInit: Initial Position on Y * @float zInit: Initial Position on Z * @return */ void CreateSphere(float r, float xInit, float yInit, float zInit){ NxActorDesc actorDesc; NxBodyDesc bodyDesc; NxSphereShapeDesc sphereDesc; //デフォルト値で初期化 (クリア) actorDesc.setToDefault(); bodyDesc.setToDefault(); sphereDesc.setToDefault(); bodyDesc.angularDamping = 0.5f; //転がり摩擦係数 sphereDesc.radius = r; //球の半径を指定 sphereDesc.userData = (void *)size_t(sphereDesc.radius); actorDesc.shapes.pushBack(&sphereDesc); //球をアクターに追加 actorDesc.body = &bodyDesc; //動的情報を指定 actorDesc.density = 100.0f; //質量密度 (kg/m^3) actorDesc.globalPose.t = NxVec3(xInit, yInit, zInit); //Scene上の位置 //Set userData to NULL if you are not doing anyting with it. NxActor*pActor = pScene->createActor( actorDesc ); pActor->userData = (void *)size_t((int)r); }
void PhysXCapsule::createCapsule(const CapsuleInfo& info) { NxCapsuleShapeDesc capsuleDesc; capsuleDesc.setToDefault(); capsuleDesc.height = info.mHeight; capsuleDesc.radius = info.mRadius; NxMat33 rot0, rot1,rot2; rot0.rotX(info.mLocalPose.x); rot1.rotY(info.mLocalPose.y); rot2.rotZ(info.mLocalPose.z); rot0 = rot0 * rot1 * rot2; capsuleDesc.localPose.M = rot0; NxActorDesc actorDesc; actorDesc.setToDefault(); actorDesc.shapes.pushBack(&capsuleDesc); actorDesc.density = 1.0; actorDesc.globalPose.t = info.mGlobalPose; mCapsule = mScene->createActor(actorDesc); mCapsule->userData = (void*) &mInvisible; }
NxActor* CreateSphere(const NxVec3 &pos, int flag) { // Add a single-shape actor to the scene NxActorDesc actorDesc; NxBodyDesc bodyDesc; // The actor has one shape, a sphere NxSphereShapeDesc sphereDesc; sphereDesc.radius = 1.5f; sphereDesc.localPose.t = NxVec3(0,2.0f,0); assert(sphereDesc.isValid()); actorDesc.shapes.pushBack(&sphereDesc); if (0 == flag) { //Dynamic actor bodyDesc.flags |= NX_BF_DISABLE_GRAVITY; actorDesc.body = &bodyDesc; actorDesc.density = 1.0f; } else if (1 == flag) { //Static actor actorDesc.body = NULL; actorDesc.density = 1.0f; } else if (2 == flag) { // Kinematic actor bodyDesc.flags |= NX_BF_KINEMATIC; actorDesc.body = &bodyDesc; actorDesc.density = 1.0f; } actorDesc.globalPose.t = pos; //NxVec3(-6.5f, 0, 0); assert(actorDesc.isValid()); NxActor *pActor = gScene->createActor(actorDesc); assert(pActor); return pActor; }
pRigidBody*pFactory::createBox(CK3dEntity *referenceObject,CK3dEntity *worldReferenceObject,pObjectDescr*descr,int creationFlags) { pWorld *world=getManager()->getWorld(worldReferenceObject,referenceObject); pRigidBody*result = world->getBody(referenceObject); if(result) { result->destroy(); delete result; result = NULL; } // we create our final body in the given world : result = createBody(referenceObject,worldReferenceObject); if (result) { result->setWorld(world); using namespace vtTools::AttributeTools; result->setFlags(descr->flags); result->setHullType(descr->hullType); result->setDataFlags(0x000); result->checkDataFlags(); if (result->getSkinWidth()==-1.0f) { result->setSkinWidth(0.01f); } VxMatrix v_matrix ; VxVector position,scale; VxQuaternion quat; v_matrix = referenceObject->GetWorldMatrix(); Vx3DDecomposeMatrix(v_matrix,quat,position,scale); VxVector box_s= BoxGetZero(referenceObject); NxVec3 pos = pMath::getFrom(position); NxQuat rot = pMath::getFrom(quat); float density = result->getDensity(); float radius = referenceObject->GetRadius(); if (referenceObject->GetRadius() < 0.001f ) { radius = 1.0f; } ////////////////////////////////////////////////////////////////////////// //create actors description NxActorDesc actorDesc;actorDesc.setToDefault(); NxBodyDesc bodyDesc;bodyDesc.setToDefault(); ////////////////////////////////////////////////////////////////////////// NxMaterialDesc *materialDescr = NULL; NxMaterial *material = NULL; if (isFlagOn(result->getDataFlags(),EDF_MATERIAL_PARAMETER)) { NxMaterialDesc entMatNull;entMatNull.setToDefault(); NxMaterialDesc *entMat = createMaterialFromEntity(referenceObject); material = world->getScene()->createMaterial(entMatNull); material->loadFromDesc(*entMat); result->setMaterial(material); }else{ if (world->getDefaultMaterial()) { result->setMaterial(world->getDefaultMaterial()); } } ////////////////////////////////////////////////////////////////////////// NxBoxShapeDesc boxShape; if (creationFlags & E_OFC_DIMENSION ) { boxShape.dimensions = pMath::getFrom(box_s)*0.5f; } boxShape.density = descr->density; boxShape.materialIndex = result->getMaterial()->getMaterialIndex(); if (result->getSkinWidth()!=-1.0f) boxShape.skinWidth = result->getSkinWidth(); actorDesc.shapes.pushBack(&boxShape); ////////////////////////////////////////////////////////////////////////// //dynamic object ? if (result->getFlags() & BF_Moving){ actorDesc.body = &bodyDesc; } else actorDesc.body = NULL; ////////////////////////////////////////////////////////////////////////// //set transformations actorDesc.density = descr->density; if (creationFlags & E_OFC_POSITION) { actorDesc.globalPose.t = pos; } if (creationFlags & E_OFC_POSITION) { actorDesc.globalPose.M = rot; } ////////////////////////////////////////////////////////////////////////// //create the actor int v = actorDesc.isValid(); NxActor *actor = world->getScene()->createActor(actorDesc); if (!actor) { xLogger::xLog(ELOGERROR,E_LI_AGEIA,"Couldn't create actor"); delete result; return NULL; } ////////////////////////////////////////////////////////////////////////// //set additional settings : result->setActor(actor); actor->setName(referenceObject->GetName()); actor->userData= result; if (result->getFlags() & BF_Moving) { VxVector massOffsetOut;referenceObject->Transform(&massOffsetOut,&result->getMassOffset()); actor->setCMassOffsetGlobalPosition(pMath::getFrom(massOffsetOut)); } if (result->getFlags() & BF_Kinematic) { actor->raiseBodyFlag(NX_BF_KINEMATIC); } result->enableCollision((result->getFlags() & BF_Collision)); if (result->getFlags() & BF_Moving) { if (!(result->getFlags() & BF_Gravity)) { actor->raiseBodyFlag(NX_BF_DISABLE_GRAVITY); } } NxShape *shape = result->getShapeByIndex(); if (shape) { pSubMeshInfo *sInfo = new pSubMeshInfo(); sInfo->entID = referenceObject->GetID(); sInfo->refObject = (CKBeObject*)referenceObject; shape->userData = (void*)sInfo; result->setMainShape(shape); shape->setName(referenceObject->GetName()); } } return result; }
pRigidBody*pFactory::createRigidBody(CK3dEntity *referenceObject,pObjectDescr& oDescr) { CK3dEntity *worldReferenceObject = (CK3dEntity*)GetPMan()->GetContext()->GetObject(oDescr.worlReference); pWorld *world=getManager()->getWorld(worldReferenceObject,referenceObject); if (!world) { xLogger::xLog(XL_START,ELOGWARNING,E_LI_MANAGER,"world object invalid, setting to default world"); world = GetPMan()->getDefaultWorld(); } pRigidBody*result = world->getBody(referenceObject); // create minimum object result = createBody(referenceObject,worldReferenceObject); if (!result) { xLogger::xLog(XL_START,ELOGERROR,E_LI_MANAGER,"failed"); return NULL; } result->setWorld(world); result->setFlags(oDescr.flags); result->setHullType(oDescr.hullType); if (oDescr.density <= 0.001f) oDescr.density = 1.0f; if (oDescr.skinWidth <= 0.001f) oDescr.skinWidth = 0.025f; result->setDensity(oDescr.density); bool hierarchy = (oDescr.flags & BF_Hierarchy); bool isDeformable = oDescr.flags & BF_Deformable; bool trigger = oDescr.flags & BF_TriggerShape; //################################################################ // // Deformable ? // pCloth *cloth = NULL; pClothDesc cDescr; if (isDeformable) { xLogger::xLog(XL_START,ELOGERROR,E_LI_MANAGER,"deformable feature disabled in this release"); return NULL; cDescr.setToDefault(); cDescr.worldReference = worldReferenceObject->GetID(); if ( result->getFlags() & BF_Gravity ) { cDescr.flags |= PCF_Gravity; } if ( result->getFlags() & BF_Collision ) { } if (!cloth) { cloth = pFactory::Instance()->createCloth(referenceObject,cDescr); if (!cloth) { xLogger::xLog(XL_START,ELOGERROR,E_LI_MANAGER,"Cannot create cloth : factory object failed !"); } } } float density = oDescr.density; VxVector box_s= BoxGetZero(referenceObject); VxMatrix v_matrix ; VxVector position,scale; VxQuaternion quat; v_matrix = referenceObject->GetWorldMatrix(); Vx3DDecomposeMatrix(v_matrix,quat,position,scale); NxVec3 pos = pMath::getFrom(position); NxQuat rot = pMath::getFrom(quat); //---------------------------------------------------------------- // // Fill NxActorDescr // NxActorDesc actorDesc;actorDesc.setToDefault(); NxBodyDesc bodyDesc;bodyDesc.setToDefault(); // // Fix parameters to default values actorDesc.density = oDescr.density; //skin width if (oDescr.skinWidth<=0.0001f) oDescr.skinWidth=0.025f; float radius = result->GetVT3DObject()->GetRadius(); //---------------------------------------------------------------- // // Create the physic mesh. Externalizing this procedure will corrupt the // actor description object. // switch(oDescr.hullType) { ////////////////////////////////////////////////////////////////////////// case HT_Box: { NxBoxShapeDesc shape; if (! (oDescr.flags & BF_Deformable) ) { shape.dimensions = pMath::getFrom(box_s)*0.5f; } shape.density = density; shape.skinWidth = oDescr.skinWidth; actorDesc.shapes.pushBack(&shape); break; } ////////////////////////////////////////////////////////////////////////// case HT_Sphere: { NxSphereShapeDesc shape; if (! (oDescr.flags & BF_Deformable) ) { shape.radius = radius; } shape.density = density; shape.skinWidth = oDescr.skinWidth; actorDesc.shapes.pushBack(&shape); break; } ////////////////////////////////////////////////////////////////////////// case HT_Mesh: { NxTriangleMeshDesc myMesh; myMesh.setToDefault(); pFactory::Instance()->createMesh(result->getWorld()->getScene(),result->GetVT3DObject()->GetCurrentMesh(),myMesh); NxTriangleMeshShapeDesc shape; bool status = InitCooking(); if (!status) { xLogger::xLog(ELOGERROR,E_LI_AGEIA,"Couldn't initiate cooking lib!"); return false; } MemoryWriteBuffer buf; status = CookTriangleMesh(myMesh, buf); if (!status) { xLogger::xLog(ELOGERROR,E_LI_AGEIA,"Couldn't cook mesh!"); return false; } shape.meshData = GetPMan()->getPhysicsSDK()->createTriangleMesh(MemoryReadBuffer(buf.data)); shape.density = density; shape.group = oDescr.collisionGroup; actorDesc.shapes.pushBack(&shape); shape.skinWidth = oDescr.skinWidth; CloseCooking(); if (myMesh.points) { delete [] myMesh.points; } if (myMesh.triangles) { delete []myMesh.triangles; } break; } ////////////////////////////////////////////////////////////////////////// case HT_ConvexMesh: { if (result->GetVT3DObject()->GetCurrentMesh()) { if (result->GetVT3DObject()->GetCurrentMesh()->GetVertexCount()>=256 ) { xLogger::xLog(ELOGERROR,E_LI_AGEIA,"Only 256 vertices for convex meshes allowed, by Ageia!"); return false; } }else { xLogger::xLog(ELOGERROR,E_LI_AGEIA,"Object has no mesh!"); return false; } NxConvexMeshDesc myMesh; myMesh.setToDefault(); pFactory::Instance()->createConvexMesh(result->getWorld()->getScene(),result->GetVT3DObject()->GetCurrentMesh(),myMesh); NxConvexShapeDesc shape; bool status = InitCooking(); if (!status) { xLogger::xLog(XL_START,ELOGERROR,E_LI_AGEIA,"Couldn't initiate cooking lib!"); return false; } MemoryWriteBuffer buf; status = CookConvexMesh(myMesh, buf); if (!status) { xLogger::xLog(XL_START,ELOGERROR,E_LI_AGEIA,"Couldn't cook convex mesh!"); return false; } shape.meshData = GetPMan()->getPhysicsSDK()->createConvexMesh(MemoryReadBuffer(buf.data)); shape.density = density; actorDesc.shapes.pushBack(&shape); if (oDescr.skinWidth!=-1.0f) shape.skinWidth = oDescr.skinWidth; int h = shape.isValid(); CloseCooking(); if (myMesh.points) { delete [] myMesh.points; } if (myMesh.triangles) { delete []myMesh.triangles; } break; } ////////////////////////////////////////////////////////////////////////// case HT_ConvexCylinder: { NxConvexShapeDesc shape; pConvexCylinderSettings &cSettings = oDescr.convexCylinder; iAssertW( (oDescr.mask & OD_ConvexCylinder),pFactory::Instance()->findSettings(cSettings,result->GetVT3DObject()), "Hull type has been set to convex cylinder but there is no descriptions passed or activated in the pObjectDescr::mask.Trying object attributes...."); if (cSettings.radius.reference) cSettings.radius.evaluate(cSettings.radius.reference); if (cSettings.height.reference) cSettings.height.evaluate(cSettings.height.reference); iAssertW( cSettings.isValid() , cSettings.setToDefault(),""); cSettings.radius.value = cSettings.radius.value > 0.0f ? (cSettings.radius.value*0.5) : (box_s.v[cSettings.radius.referenceAxis] * 0.5f); cSettings.height.value = cSettings.height.value > 0.0f ? cSettings.height.value : (box_s.v[cSettings.height.referenceAxis] * 0.5f); bool resultAssert = true; iAssertWR( pFactory::Instance()->_createConvexCylinderMesh(&shape,cSettings,result->GetVT3DObject()),"",resultAssert); shape.density = density; shape.skinWidth = oDescr.skinWidth; actorDesc.shapes.pushBack(&shape); break; } ////////////////////////////////////////////////////////////////////////// case HT_Capsule: { NxCapsuleShapeDesc shape; pCapsuleSettingsEx &cSettings = oDescr.capsule; if (!( oDescr.mask & OD_Capsule) ) { // try over attribute : pFactory::Instance()->findSettings(cSettings,result->GetVT3DObject()); } bool resultAssert = true; if (cSettings.radius.reference) cSettings.radius.evaluate(cSettings.radius.reference); if (cSettings.height.reference) cSettings.height.evaluate(cSettings.height.reference); iAssertWR(cSettings.isValid(),cSettings.setToDefault(),resultAssert); shape.radius = cSettings.radius.value > 0.0f ? (cSettings.radius.value*0.5) : (box_s.v[cSettings.radius.referenceAxis] * 0.5f); shape.height = cSettings.height.value > 0.0f ? (cSettings.height.value-( 2*shape.radius)) : (box_s.v[cSettings.height.referenceAxis] - ( 2*shape.radius)) ; shape.density = density; shape.skinWidth = oDescr.skinWidth; actorDesc.shapes.pushBack(&shape); break; } case HT_Wheel: { xLogger::xLog(XL_START,ELOGERROR,E_LI_AGEIA,"Wheel shape can be sub shape only!"); return false; } } if ( !isDeformable) { actorDesc.globalPose.t = pos; actorDesc.globalPose.M = rot; } //---------------------------------------------------------------- // // Create the final NxActor // if (oDescr.flags & BF_Moving) actorDesc.body = &bodyDesc; NxActor *actor = world->getScene()->createActor(actorDesc); if (!actor) { xLogger::xLog(ELOGERROR,E_LI_AGEIA,"Couldn't create actor"); delete result; return NULL; } //---------------------------------------------------------------- // // // result->setActor(actor); actor->setName(referenceObject->GetName()); result->SetVT3DObject(referenceObject); actor->userData= result; ////////////////////////////////////////////////////////////////////////// //Deformable : if (isDeformable && cloth) { pDeformableSettings dSettings; dSettings.ImpulsThresold = 50.0f; dSettings.PenetrationDepth= 0.1f ; dSettings.MaxDeform = 2.0f; CKParameterOut *poutDS = referenceObject->GetAttributeParameter(GetPMan()->att_deformable); if (poutDS) { pFactory::Instance()->copyTo(dSettings,poutDS); } cloth->attachToCore(referenceObject,dSettings.ImpulsThresold,dSettings.PenetrationDepth,dSettings.MaxDeform); result->setCloth(cloth); } ////////////////////////////////////////////////////////////////////////// // // Extra settings : // if (result->getFlags() & BF_Moving) { VxVector massOffsetOut;referenceObject->Transform(&massOffsetOut,&oDescr.massOffsetLinear); actor->setCMassOffsetGlobalPosition(pMath::getFrom(massOffsetOut)); } if (result->getFlags() & BF_Kinematic) { result->setKinematic(true); } if (result->getFlags() & BF_Moving ) { result->enableGravity(result->getFlags() & BF_Gravity); } if (result->getFlags() & BF_Sleep ) { result->setSleeping(true); } if (oDescr.worlReference == 0) { if (GetPMan()->getDefaultWorld()) { oDescr.worlReference = GetPMan()->getDefaultWorld()->getReference()->GetID(); } } //---------------------------------------------------------------- // // store mesh meta info in the first main mesh // NxShape *shape = result->getShapeByIndex(); if (shape) { pSubMeshInfo *sInfo = new pSubMeshInfo(); sInfo->entID = referenceObject->GetID(); sInfo->refObject = (CKBeObject*)referenceObject; shape->userData = (void*)sInfo; result->setMainShape(shape); shape->setName(referenceObject->GetName()); } result->enableCollision( (result->getFlags() & BF_Collision), referenceObject ); //---------------------------------------------------------------- // // Adjust pivot // if ( (oDescr.mask & OD_Pivot) ) { iAssertW1( oDescr.pivot.isValid(),oDescr.pivot.setToDefault()); result->updatePivotSettings(oDescr.pivot,referenceObject); }else if(pFactory::Instance()->findSettings(oDescr.collision,referenceObject)) result->updatePivotSettings(oDescr.pivot,referenceObject); //---------------------------------------------------------------- // // Optimization // if ((oDescr.mask & OD_Optimization )) { iAssertW1( oDescr.optimization.isValid(),oDescr.optimization.setToDefault()); result->updateOptimizationSettings(oDescr.optimization); } else{ if(pFactory::Instance()->findSettings(oDescr.optimization,referenceObject)) { iAssertW1( oDescr.optimization.isValid(),oDescr.optimization.setToDefault()); result->updateOptimizationSettings(oDescr.optimization); } } //---------------------------------------------------------------- // // Collision // if ((oDescr.mask & OD_Collision)) result->updateCollisionSettings(oDescr.collision,referenceObject); else if(pFactory::Instance()->findSettings(oDescr.collision,referenceObject)) result->updateCollisionSettings(oDescr.collision,referenceObject); //---------------------------------------------------------------- // // Material // NxMaterialDesc *materialDescr = NULL; NxMaterial *material = NULL; pMaterial &bMaterial = oDescr.material; if (oDescr.mask & OD_Material) { result->updateMaterialSettings(bMaterial,referenceObject); }else { bool hasMaterial = pFactory::Instance()->findSettings(bMaterial,referenceObject); if (!hasMaterial) { if (world->getDefaultMaterial()) { int z = (int)world->getDefaultMaterial()->userData; shape->setMaterial(world->getDefaultMaterial()->getMaterialIndex()); } }else{ iAssertW( bMaterial.isValid(),bMaterial.setToDefault(), "Material settings were still invalid : "); NxMaterialDesc nxMatDescr; pFactory::Instance()->copyTo(nxMatDescr,bMaterial); NxMaterial *nxMaterial = world->getScene()->createMaterial(nxMatDescr); if (nxMaterial) { shape->setMaterial(nxMaterial->getMaterialIndex()); } } } xLogger::xLog(ELOGINFO,E_LI_MANAGER,"Rigid body creation successful : %s",referenceObject->GetName()); result->setInitialDescription(&oDescr); //---------------------------------------------------------------- // // Hierarchy mode fix : // if ( (oDescr.flags & BF_Hierarchy) ) oDescr.hirarchy = true; if ( oDescr.hirarchy ) oDescr.flags << BF_Hierarchy; if ( (!oDescr.hirarchy) || !(oDescr.flags & BF_Hierarchy) ) return result; //---------------------------------------------------------------- // // Parse hirarchy // CK3dEntity* subEntity = NULL; while (subEntity= referenceObject->HierarchyParser(subEntity) ) { pObjectDescr *subDescr = NULL; int attTypePBSetup = GetPMan()->getAttributeTypeByGuid(VTS_PHYSIC_ACTOR); if (subEntity->HasAttribute(attTypePBSetup)) { subDescr = new pObjectDescr(); CKParameterOut *par = subEntity->GetAttributeParameter(attTypePBSetup); IParameter::Instance()->copyTo(subDescr,par); subDescr->version = pObjectDescr::E_OD_VERSION::OD_DECR_V1; } if (!subDescr) continue; if (subDescr->flags & BF_SubShape) { ////////////////////////////////////////////////////////////////////////// // // Regular Mesh : // if (subDescr->hullType != HT_Cloth) { //result->addSubShape(NULL,*subDescr,subEntity); VxQuaternion refQuad;subEntity->GetQuaternion(&refQuad,referenceObject); VxVector relPos;subEntity->GetPosition(&relPos,referenceObject); shape = pFactory::Instance()->createShape(referenceObject,*subDescr,subEntity,subEntity->GetCurrentMesh(),relPos,refQuad); //NxShape *shape = result->getSubShape(subEntity); if (shape) { //---------------------------------------------------------------- // // check for collision setup // //try to get get from child attributes first /* if(pFactory::Instance()->findSettings(subDescr->collision,subEntity)) { result->updateCollisionSettings(subDescr->collision,subEntity); continue; } if ( (subDescr->mask & OD_Optimization) ) { //if (pFactory::Instance()->findSettings(subDescr->collision,subEntity)) result->updateCollisionSettings(subDescr->collision,subEntity); } else if ( (oDescr.mask & OD_Optimization) ) { result->updateCollisionSettings(oDescr.collision,subEntity); }else if(pFactory::Instance()->findSettings(subDescr->collision,subEntity)) { result->updateCollisionSettings(subDescr->collision,subEntity); } */ } } ////////////////////////////////////////////////////////////////////////// // // Cloth Mesh : // if (subDescr->hullType == HT_Cloth) { //pClothDesc *cloth = pFactory::Instance()->createPObjectDescrFromParameter(subEntity->GetAttributeParameter(GetPMan()->GetPAttribute())); } } } //---------------------------------------------------------------- // // Adjust mass // //---------------------------------------------------------------- // // Collision // if ((oDescr.mask & OD_Mass)) result->updateMassSettings(oDescr.mass); else if(pFactory::Instance()->findSettings(oDescr.mass,referenceObject)) result->updateMassSettings(oDescr.mass); return result; nothing: return result; }
pRigidBody*pFactory::createRigidBodyFull(CK3dEntity *referenceObject, CK3dEntity *worldReferenceObject) { //################################################################ // // Sanity checks // pWorld *world=getManager()->getWorld(worldReferenceObject,referenceObject); pRigidBody*result = world->getBody(referenceObject); if(result) { result->destroy(); delete result; result = NULL; } //################################################################ // // Construct the result // result = createBody(referenceObject,worldReferenceObject); if (result) { result->setWorld(world); //---------------------------------------------------------------- // // Handle different attribute types (Object or pBSetup) // int attTypeOld = GetPMan()->GetPAttribute(); int attTypeNew = GetPMan()->getAttributeTypeByGuid(VTS_PHYSIC_ACTOR); pObjectDescr *oDescr = NULL; //---------------------------------------------------------------- // // the old way : // if (referenceObject->HasAttribute(attTypeOld)) { result->retrieveSettingsFromAttribute(); oDescr = pFactory::Instance()->createPObjectDescrFromParameter(referenceObject->GetAttributeParameter(GetPMan()->GetPAttribute())); } bool hierarchy = result->getFlags() & BF_Hierarchy; bool isDeformable = result->getFlags() & BF_Deformable; bool trigger = (result->getFlags() & BF_TriggerShape); //---------------------------------------------------------------- // // the new way // if (referenceObject->HasAttribute(attTypeNew)) { oDescr = new pObjectDescr(); } result->checkDataFlags(); /* pObjectDescr *oDescr = if (!oDescr) return result; */ //################################################################ // // Older versions have the hierarchy mode settings not the body flags // We migrate it : // if (oDescr->hirarchy) { result->setFlags( (result->getFlags() | BF_Hierarchy )); } if (hierarchy) { oDescr->hirarchy = hierarchy; } //################################################################ // // Deformable ? // pCloth *cloth = NULL; pClothDesc cDescr; if (isDeformable) { cDescr.setToDefault(); cDescr.worldReference = worldReferenceObject->GetID(); if ( result->getFlags() & BF_Gravity ) { cDescr.flags |= PCF_Gravity; } if ( result->getFlags() & BF_Collision ) { } if (!cloth) { cloth = pFactory::Instance()->createCloth(referenceObject,cDescr); if (!cloth) { xLogger::xLog(XL_START,ELOGERROR,E_LI_MANAGER,"Cannot create cloth : factory object failed !"); } } } //################################################################ // // Some settings // if (result->getSkinWidth()==-1.0f) { result->setSkinWidth(0.01f); } float radius = referenceObject->GetRadius(); if (referenceObject->GetRadius() < 0.001f ) { radius = 1.0f; } float density = result->getDensity(); VxVector box_s= BoxGetZero(referenceObject); //################################################################ // // Calculate destination matrix // VxMatrix v_matrix ; VxVector position,scale; VxQuaternion quat; v_matrix = referenceObject->GetWorldMatrix(); Vx3DDecomposeMatrix(v_matrix,quat,position,scale); NxVec3 pos = pMath::getFrom(position); NxQuat rot = pMath::getFrom(quat); ////////////////////////////////////////////////////////////////////////// //create actors description NxActorDesc actorDesc;actorDesc.setToDefault(); NxBodyDesc bodyDesc;bodyDesc.setToDefault(); NxMaterialDesc *materialDescr = NULL; NxMaterial *material = NULL; switch(result->getHullType()) { ////////////////////////////////////////////////////////////////////////// case HT_Box: { NxBoxShapeDesc shape; if (! isDeformable ) { shape.dimensions = pMath::getFrom(box_s)*0.5f; } shape.density = density; //shape.localPose.t = pMath::getFrom(shapeOffset); if (result->getSkinWidth()!=-1.0f) shape.skinWidth = result->getSkinWidth(); actorDesc.shapes.pushBack(&shape); break; } ////////////////////////////////////////////////////////////////////////// case HT_Sphere: { NxSphereShapeDesc shape; if (! isDeformable ) { shape.radius = radius; } shape.density = density; //shape.localPose.t = pMath::getFrom(shapeOffset); if (result->getSkinWidth()!=-1.0f) shape.skinWidth = result->getSkinWidth(); actorDesc.shapes.pushBack(&shape); break; } ////////////////////////////////////////////////////////////////////////// case HT_Mesh: { if (! (result->getFlags() & BF_Deformable) ) { //xLogger::xLog(ELOGERROR,E_LI_AGEIA,"Can not use a mesh as de"); //return NULL; } NxTriangleMeshDesc myMesh; myMesh.setToDefault(); createMesh(world->getScene(),referenceObject->GetCurrentMesh(),myMesh); NxTriangleMeshShapeDesc shape; bool status = InitCooking(); if (!status) { xLogger::xLog(ELOGERROR,E_LI_AGEIA,"Couldn't initiate cooking lib!"); return NULL; } MemoryWriteBuffer buf; status = CookTriangleMesh(myMesh, buf); if (!status) { xLogger::xLog(ELOGERROR,E_LI_AGEIA,"Couldn't cook mesh!"); return NULL; } shape.meshData = getManager()->getPhysicsSDK()->createTriangleMesh(MemoryReadBuffer(buf.data)); shape.density = density; // shape.materialIndex = result->getMaterial()->getMaterialIndex(); actorDesc.shapes.pushBack(&shape); //shape.localPose.t = pMath::getFrom(shapeOffset); if (result->getSkinWidth()!=-1.0f) shape.skinWidth = result->getSkinWidth(); CloseCooking(); if (myMesh.points) { delete [] myMesh.points; } if (myMesh.triangles) { delete []myMesh.triangles; } break; } ////////////////////////////////////////////////////////////////////////// case HT_ConvexMesh: { if (referenceObject->GetCurrentMesh()) { if (referenceObject->GetCurrentMesh()->GetVertexCount()>=256 ) { xLogger::xLog(ELOGERROR,E_LI_AGEIA,"Only 256 vertices for convex meshs allowed, by Ageia!"); goto nothing; } }else { xLogger::xLog(ELOGERROR,E_LI_AGEIA,"Object has no mesh!"); goto nothing; } NxConvexMeshDesc myMesh; myMesh.setToDefault(); createConvexMesh(world->getScene(),referenceObject->GetCurrentMesh(),myMesh); NxConvexShapeDesc shape; bool status = InitCooking(); if (!status) { xLogger::xLog(XL_START,ELOGERROR,E_LI_AGEIA,"Couldn't initiate cooking lib!"); goto nothing; } MemoryWriteBuffer buf; status = CookConvexMesh(myMesh, buf); if (!status) { xLogger::xLog(XL_START,ELOGERROR,E_LI_AGEIA,"Couldn't cook convex mesh!"); goto nothing; } shape.meshData = getManager()->getPhysicsSDK()->createConvexMesh(MemoryReadBuffer(buf.data)); shape.density = density; // shape.materialIndex = result->getMaterial()->getMaterialIndex(); actorDesc.shapes.pushBack(&shape); //shape.localPose.t = pMath::getFrom(shapeOffset); if (result->getSkinWidth()!=-1.0f) shape.skinWidth = result->getSkinWidth(); int h = shape.isValid(); CloseCooking(); if (myMesh.points) { delete [] myMesh.points; } if (myMesh.triangles) { delete []myMesh.triangles; } break; } ////////////////////////////////////////////////////////////////////////// case HT_ConvexCylinder: { NxConvexShapeDesc shape; if (!_createConvexCylinder(&shape,referenceObject)) xLogger::xLog(XL_START,ELOGERROR,E_LI_AGEIA,"Couldn't create convex cylinder mesh"); shape.density = density; if (result->getSkinWidth()!=-1.0f) shape.skinWidth = result->getSkinWidth(); actorDesc.shapes.pushBack(&shape); break; } ////////////////////////////////////////////////////////////////////////// case HT_Capsule: { NxCapsuleShapeDesc shape; if ( !isDeformable ) { pCapsuleSettings cSettings; pFactory::Instance()->findSettings(cSettings,referenceObject); shape.radius = cSettings.radius > 0.0f ? cSettings.radius : box_s.v[cSettings.localRadiusAxis] * 0.5f; shape.height = cSettings.height > 0.0f ? cSettings.height : box_s.v[cSettings.localLengthAxis] - ( 2*shape.radius) ; } shape.density = density; // shape.materialIndex = result->getMaterial()->getMaterialIndex(); // shape.localPose.t = pMath::getFrom(shapeOffset); if (result->getSkinWidth()!=-1.0f) shape.skinWidth = result->getSkinWidth(); actorDesc.shapes.pushBack(&shape); break; } case HT_Wheel: { // xLogger::xLog(XL_START,ELOGERROR,E_LI_AGEIA,"Couldn't create convex cylinder mesh"); /* NxWheelShapeDesc shape; shape.radius = box_s.z*0.5f; shape.density = density; if (result->getSkinWidth()!=-1.0f) shape.skinWidth = result->getSkinWidth(); if (referenceObject && referenceObject->HasAttribute(GetPMan()->att_wheelDescr )) { CKParameter *par = referenceObject->GetAttributeParameter(GetPMan()->att_wheelDescr ); if (par) { pWheelDescr *wheelDescr = pFactory::Instance()->copyTo(par); if (wheelDescr) { float heightModifier = (wheelDescr->wheelSuspension + radius ) / wheelDescr->wheelSuspension; shape.suspension.damper = wheelDescr->springDamping * heightModifier; shape.suspension.targetValue = wheelDescr->springBias * heightModifier; shape.suspensionTravel = wheelDescr->wheelSuspension; shape.lateralTireForceFunction.stiffnessFactor *= wheelDescr->frictionToSide; shape.longitudalTireForceFunction.stiffnessFactor*=wheelDescr->frictionToFront; shape.inverseWheelMass = 0.1; int isValid = shape.isValid(); actorDesc.shapes.pushBack(&shape); } }else { XString name = result->GetVT3DObject()->GetName(); name << " needs to have an additional wheel attribute attached ! "; xLogger::xLog(XL_START,ELOGERROR,E_LI_AGEIA,name.CStr()); } } */ break; } } ////////////////////////////////////////////////////////////////////////// //dynamic object ? if (result->getFlags() & BF_Moving){ actorDesc.body = &bodyDesc; } else actorDesc.body = NULL; ////////////////////////////////////////////////////////////////////////// //set transformations actorDesc.density = result->getDensity(); if ( !isDeformable) { actorDesc.globalPose.t = pos; actorDesc.globalPose.M = rot; } ////////////////////////////////////////////////////////////////////////// //create the actor int v = actorDesc.isValid(); NxActor *actor = world->getScene()->createActor(actorDesc); if (!actor) { xLogger::xLog(ELOGERROR,E_LI_AGEIA,"Couldn't create actor"); delete result; return NULL; } ////////////////////////////////////////////////////////////////////////// //set additional settings : result->setActor(actor); actor->setName(referenceObject->GetName()); actor->userData= result; ////////////////////////////////////////////////////////////////////////// //Deformable : if (isDeformable && cloth) { pDeformableSettings dSettings; dSettings.ImpulsThresold = 50.0f; dSettings.PenetrationDepth= 0.1f ; dSettings.MaxDeform = 2.0f; CKParameterOut *poutDS = referenceObject->GetAttributeParameter(GetPMan()->att_deformable); if (poutDS) { pFactory::Instance()->copyTo(dSettings,poutDS); } cloth->attachToCore(referenceObject,dSettings.ImpulsThresold,dSettings.PenetrationDepth,dSettings.MaxDeform); result->setCloth(cloth); } ////////////////////////////////////////////////////////////////////////// // // Extra settings : // if (result->getFlags() & BF_Moving) { VxVector massOffsetOut;referenceObject->Transform(&massOffsetOut,&result->getMassOffset()); actor->setCMassOffsetGlobalPosition(pMath::getFrom(massOffsetOut)); } if (result->getFlags() & BF_Kinematic) { result->setKinematic(true); } if (result->getFlags() & BF_Moving ) { result->enableGravity(result->getFlags() & BF_Gravity); } //---------------------------------------------------------------- // // Special Parameters // //- look for optimization attribute : result->checkForOptimization(); //---------------------------------------------------------------- // // store mesh meta info in the first main mesh // NxShape *shape = result->getShapeByIndex(); if (shape) { pSubMeshInfo *sInfo = new pSubMeshInfo(); sInfo->entID = referenceObject->GetID(); sInfo->refObject = (CKBeObject*)referenceObject; shape->userData = (void*)sInfo; result->setMainShape(shape); shape->setName(referenceObject->GetName()); pMaterial bMaterial; bool hasMaterial = pFactory::Instance()->findSettings(bMaterial,referenceObject); if (!hasMaterial) { if (world->getDefaultMaterial()) { int z = (int)world->getDefaultMaterial()->userData; shape->setMaterial(world->getDefaultMaterial()->getMaterialIndex()); //pFactory::Instance()->copyTo(bMaterial,world->getDefaultMaterial()); } }else{ NxMaterialDesc nxMatDescr; pFactory::Instance()->copyTo(nxMatDescr,bMaterial); NxMaterial *nxMaterial = world->getScene()->createMaterial(nxMatDescr); if (nxMaterial) { shape->setMaterial(nxMaterial->getMaterialIndex()); } } } result->enableCollision( (result->getFlags() & BF_Collision), referenceObject ); //- handle collisions setup if (oDescr->version == pObjectDescr::E_OD_VERSION::OD_DECR_V1) result->updateCollisionSettings(*oDescr,referenceObject); xLogger::xLog(ELOGINFO,E_LI_MANAGER,"Rigid body creation successful : %s",referenceObject->GetName()); //---------------------------------------------------------------- // // Parse hierarchy // if (!oDescr->hirarchy) return result; CK3dEntity* subEntity = NULL; while (subEntity= referenceObject->HierarchyParser(subEntity) ) { if (subEntity->HasAttribute(GetPMan()->GetPAttribute())) { pObjectDescr *subDescr = pFactory::Instance()->createPObjectDescrFromParameter(subEntity->GetAttributeParameter(GetPMan()->GetPAttribute())); if (subDescr->flags & BF_SubShape) { ////////////////////////////////////////////////////////////////////////// // // Regular Mesh : // if (subDescr->hullType != HT_Cloth) { result->addSubShape(NULL,*oDescr,subEntity); } ////////////////////////////////////////////////////////////////////////// // // Cloth Mesh : // if (subDescr->hullType == HT_Cloth) { //pClothDesc *cloth = pFactory::Instance()->createPObjectDescrFromParameter(subEntity->GetAttributeParameter(GetPMan()->GetPAttribute())); } } } } if (oDescr->hirarchy) { if (oDescr->newDensity!=0.0f || oDescr->totalMass!=0.0f ) { result->updateMassFromShapes(oDescr->newDensity,oDescr->totalMass); } } return result; } nothing: return result; }
//----------------------------------------------------------------------- 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; }
NxActor* CreateConvex(const NxVec3 &pos, int flag) { NxActorDesc actorDesc; NxBodyDesc bodyDesc; NxVec3 boxDim(1,0.8,1.5); // Pyramid NxVec3 verts[8] = { NxVec3(boxDim.x, -boxDim.y, -boxDim.z), NxVec3(-boxDim.x, -boxDim.y, -boxDim.z), NxVec3(-boxDim.x, -boxDim.y, boxDim.z), NxVec3(boxDim.x, -boxDim.y, boxDim.z), NxVec3(boxDim.x*0.5, boxDim.y, -boxDim.z*0.5), NxVec3(-boxDim.x*0.5, boxDim.y, -boxDim.z*0.5), NxVec3(-boxDim.x*0.5, boxDim.y, boxDim.z*0.5), NxVec3(boxDim.x*0.5, boxDim.y, boxDim.z*0.5) }; // Create descriptor for convex mesh if (!convexDesc) { convexDesc = new NxConvexMeshDesc(); assert(convexDesc); } convexDesc->numVertices = 8; convexDesc->pointStrideBytes = sizeof(NxVec3); convexDesc->points = verts; convexDesc->flags = NX_CF_COMPUTE_CONVEX; NxConvexShapeDesc convexShapeDesc; convexShapeDesc.localPose.t = NxVec3(0, 2.0f, boxDim.z * 0.4); convexShapeDesc.userData = convexDesc; NxInitCooking(); // Cooking from memory MemoryWriteBuffer buf; bool status = NxCookConvexMesh(*convexDesc, buf); // // Please note about the created Convex Mesh, user needs to release it when no one uses it to save memory. It can be detected // by API "meshData->getReferenceCount() == 0". And, the release API is "gPhysicsSDK->releaseConvexMesh(*convexShapeDesc.meshData);" // NxConvexMesh *pMesh = gPhysicsSDK->createConvexMesh(MemoryReadBuffer(buf.data)); assert(pMesh); convexShapeDesc.meshData = pMesh; NxCloseCooking(); if (pMesh) { // Save mesh in userData for drawing. pMesh->saveToDesc(*convexDesc); // NxActorDesc actorDesc; assert(convexShapeDesc.isValid()); actorDesc.shapes.pushBack(&convexShapeDesc); if (0 == flag) { //Dynamic actor bodyDesc.flags |= NX_BF_DISABLE_GRAVITY; actorDesc.body = &bodyDesc; actorDesc.density = 1.0f; } else if (1 == flag) { //Static actor actorDesc.body = NULL; actorDesc.density = 1.0f; } else if (2 == flag) { // Kinematic actor bodyDesc.flags |= NX_BF_KINEMATIC; actorDesc.body = &bodyDesc; actorDesc.density = 1.0f; } actorDesc.globalPose.t = pos; //NxVec3(6.5f, 0.0f, 0.0f); assert(actorDesc.isValid()); NxActor* actor = gScene->createActor(actorDesc); assert(actor); return actor; } return NULL; }
NxActor* CreateLander(NxVec3 position) { NxActor* actor=NULL; switch (gLanderType) { case CAPSULE_LANDER: actor = CreateCapsuleGrain(position,gLanderMass/pow(gLanderSize.x,3.0f),gLanderSize.x); break; case SPHERE_LANDER: actor = CreateSphericalGrain(position,gLanderMass/pow(gLanderSize.x,3.0f),gLanderSize.x); break; case ROLY_POLY: {// Two slightly offset spheres, one heavy, one slightly smaller, and hollow NxActorDesc actorDesc; NxBodyDesc bodyDesc; NxReal radius=gLanderSize.x; // The bottom "roly" NxSphereShapeDesc rolyDesc; rolyDesc.radius=radius*gLanderSize.z; // relative to top hemisphere rolyDesc.localPose.t=NxVec3(0.0f,radius,0.0f); rolyDesc.materialIndex=gLanderDownMaterial->getMaterialIndex(); // note: both hemispheres use "down" material rolyDesc.mass=1; // relative to top hemisphere rolyDesc.skinWidth=radius/60; rolyDesc.name="downside"; actorDesc.shapes.pushBack(&rolyDesc); // The top "poly" NxSphereShapeDesc polyDesc; polyDesc.radius=radius; polyDesc.localPose.t=NxVec3(0.0f,radius+gLanderSize.y,0.0f); polyDesc.materialIndex=gLanderDownMaterial->getMaterialIndex(); // note: both hemispheres use "down" material polyDesc.mass=1; polyDesc.skinWidth=radius/60; polyDesc.name="upside"; actorDesc.shapes.pushBack(&polyDesc); // The weight NxSphereShapeDesc wDesc; wDesc.radius=radius/10; wDesc.localPose.t=NxVec3(0.0f,wDesc.radius,0.0f); wDesc.materialIndex=gLanderDownMaterial->getMaterialIndex(); // note: this is irrelevant wDesc.mass=gRPWeight; // relative to top hemisphere wDesc.skinWidth=radius/120; wDesc.name="weight"; actorDesc.shapes.pushBack(&wDesc); // the lander bodyDesc.mass=gLanderMass; actorDesc.body=&bodyDesc; actorDesc.globalPose.t=position; assert(actorDesc.isValid()); actor=gScene->createActor(actorDesc); assert(actor); actor->setName("~lander"); //actor->raiseBodyFlag(NX_BF_KINEMATIC); break; } case SHAPED_CHARGE: {// Two flat plates, like a two-layer ruler, one heavy and absorbing, one hollow and elastic NxActorDesc actorDesc; NxBodyDesc bodyDesc; NxVec3 boxDim=gLanderSize/2; // remember NxShapeDesc.dimension is the "radius" boxDim.y/=2; // remember we're going to stack two of these // The down side NxBoxShapeDesc downsideDesc; downsideDesc.dimensions.set(boxDim); downsideDesc.localPose.t=NxVec3(0.0f,boxDim.y,0.0f); downsideDesc.materialIndex=gLanderDownMaterial->getMaterialIndex(); downsideDesc.density=gLanderMassRatio; downsideDesc.skinWidth=boxDim.y/60; downsideDesc.name="downside"; actorDesc.shapes.pushBack(&downsideDesc); // The up side NxBoxShapeDesc upsideDesc; upsideDesc.dimensions.set(boxDim); upsideDesc.localPose.t=NxVec3(0.0f,3.0*boxDim.y,0.0f); upsideDesc.materialIndex=gLanderUpMaterial->getMaterialIndex(); upsideDesc.density=1; upsideDesc.skinWidth=boxDim.y/60; upsideDesc.name="upside"; actorDesc.shapes.pushBack(&upsideDesc); // The Lander bodyDesc.mass=gLanderMass; actorDesc.body = &bodyDesc; actorDesc.globalPose.t = position; assert(actorDesc.isValid()); actor = gScene->createActor(actorDesc); assert(actor); actor->setName("~lander"); break; } case CUBESAT: {// JPL's new fad, comes in units of 10x10x10 cm NxActorDesc actorDesc; NxBodyDesc bodyDesc; NxVec3 boxDim(0.05); // remember NxShapeDesc.dimension is the "radius" // U1 - the dead weight NxBoxShapeDesc U1Desc; U1Desc.dimensions.set(boxDim); U1Desc.localPose.t=NxVec3(0.0f,boxDim.y,0.0f); U1Desc.materialIndex=gLanderDownMaterial->getMaterialIndex(); U1Desc.mass=10*gLanderMass; U1Desc.skinWidth=boxDim.y/60; U1Desc.name="U1"; actorDesc.shapes.pushBack(&U1Desc); // U2 NxBoxShapeDesc U2Desc; U2Desc.dimensions.set(boxDim); U2Desc.localPose.t=NxVec3(0.0f,3.0*boxDim.y,0.0f); U2Desc.materialIndex=gLanderUpMaterial->getMaterialIndex(); U2Desc.mass=gLanderMass; U2Desc.skinWidth=boxDim.y/60; U2Desc.name="U2"; actorDesc.shapes.pushBack(&U2Desc); // U3 NxBoxShapeDesc U3Desc; U3Desc.dimensions.set(boxDim); U3Desc.localPose.t=NxVec3(0.0f,5.0*boxDim.y,0.0f); U3Desc.materialIndex=gLanderUpMaterial->getMaterialIndex(); U3Desc.mass=gLanderMass; U3Desc.skinWidth=boxDim.y/60; U3Desc.name="U3"; actorDesc.shapes.pushBack(&U3Desc); // The Cubesat bodyDesc.mass=gLanderMass; actorDesc.body = &bodyDesc; actorDesc.globalPose.t = position; assert(actorDesc.isValid()); actor = gScene->createActor(actorDesc); assert(actor); actor->setName("~lander"); break; } default: printf("Error: unknown lander type\n"); break; } return actor; }
static bool InitNx() { if (!gAllocator) gAllocator = new UserAllocator; // Initialize PhysicsSDK NxPhysicsSDKDesc desc; NxSDKCreateError errorCode = NXCE_NO_ERROR; gPhysicsSDK = NxCreatePhysicsSDK(NX_PHYSICS_SDK_VERSION, gAllocator, &gErrorStream, desc, &errorCode); if(gPhysicsSDK == NULL) { printf("\nSDK create error (%d - %s).\nUnable to initialize the PhysX SDK, exiting the sample.\n\n", errorCode, getNxSDKCreateError(errorCode)); return false; } #if SAMPLES_USE_VRD // The settings for the VRD host and port are found in SampleCommonCode/SamplesVRDSettings.h if (gPhysicsSDK->getFoundationSDK().getRemoteDebugger() && !gPhysicsSDK->getFoundationSDK().getRemoteDebugger()->isConnected()) gPhysicsSDK->getFoundationSDK().getRemoteDebugger()->connect(SAMPLES_VRD_HOST, SAMPLES_VRD_PORT, SAMPLES_VRD_EVENTMASK); #endif gPhysicsSDK->setParameter(NX_SKIN_WIDTH, 0.025f); //enable visualisation gPhysicsSDK->setParameter(NX_VISUALIZE_COLLISION_SHAPES, 1.0f); gPhysicsSDK->setParameter(NX_VISUALIZATION_SCALE, 1.0f); // Create a scene NxSceneDesc sceneDesc; sceneDesc.gravity = gDefaultGravity; gScene = gPhysicsSDK->createScene(sceneDesc); if(gScene == NULL) { printf("\nError: Unable to create a PhysX scene, exiting the sample.\n\n"); return false; } //create some materials -- note that we reuse the same NxMaterialDesc every time, //as it gets copied to the SDK with every call, not just referenced. NxMaterialDesc material; //default material material.restitution = 0.0f; material.staticFriction = 0.5f; material.dynamicFriction = 0.5f; defaultMaterialIndex = 0; gScene->getMaterialFromIndex(defaultMaterialIndex)->loadFromDesc(material);//we redefine the default material in slot 0 //somewhat bouncy material material.restitution = 0.75f; material.staticFriction = 0.5f; material.dynamicFriction = 0.5f; somewhatBouncyMaterialIndex = gScene->createMaterial(material)->getMaterialIndex(); //very bouncy material material.restitution = 1.0f; material.staticFriction = 0.5f; material.dynamicFriction = 0.5f; veryBouncyMaterialIndex = gScene->createMaterial(material)->getMaterialIndex(); //almost frictionless material material.restitution = 0.0f; material.staticFriction = 0.01f; material.dynamicFriction = 0.01f; frictionlessMaterialIndex = gScene->createMaterial(material)->getMaterialIndex(); //really high friction material material.restitution = 0.0f; material.staticFriction = 20.0f;//static friction can be higher than 1. material.dynamicFriction = 1.0f; //dynamic friction should not be higher than 1. highFrictionMaterialIndex = gScene->createMaterial(material)->getMaterialIndex(); //anisotropic friction material material.restitution = 0.0f; material.staticFriction = 0.1f; material.dynamicFriction = 0.1f; material.dynamicFrictionV = 0.8f; material.staticFrictionV = 1.0f; material.dirOfAnisotropy.set(1.5,0,1); //this will be used on one of the ramps so that boxes slide off at an angle material.dirOfAnisotropy.normalize(); material.flags = NX_MF_ANISOTROPIC; anisoMaterialIndex = gScene->createMaterial(material)->getMaterialIndex(); material.setToDefault(); //turn off aniso on our material object in case we want to use it again. // Create ground plane NxPlaneShapeDesc planeDesc; planeDesc.materialIndex = frictionlessMaterialIndex; NxActorDesc actorDesc; actorDesc.shapes.pushBack(&planeDesc); gScene->createActor(actorDesc); //create some ramps NxBoxShapeDesc anisoBoxDesc; anisoBoxDesc.dimensions = NxVec3(float(20), float(2), float(30)); anisoBoxDesc.materialIndex = anisoMaterialIndex; actorDesc.setToDefault(); actorDesc.shapes.pushBack(&anisoBoxDesc); actorDesc.globalPose.t.set(0,20.0f,0); float angle = NxMath::degToRad(30.0f); actorDesc.globalPose.M(0,0) = 1; actorDesc.globalPose.M(0,1) = 0; actorDesc.globalPose.M(0,2) = 0; actorDesc.globalPose.M(1,0) = 0; actorDesc.globalPose.M(1,1) = cos(angle); actorDesc.globalPose.M(1,2) = -sin(angle); actorDesc.globalPose.M(2,0) = 0; actorDesc.globalPose.M(2,1) = sin(angle); actorDesc.globalPose.M(2,2) = cos(angle); gScene->createActor(actorDesc); NxBoxShapeDesc frictlessBoxDesc; frictlessBoxDesc.dimensions = NxVec3(float(20), float(2), float(30)); frictlessBoxDesc.materialIndex = frictionlessMaterialIndex; actorDesc.setToDefault(); actorDesc.shapes.clear(); actorDesc.shapes.pushBack(&frictlessBoxDesc); actorDesc.globalPose.t.set(-40,20.0f,0); actorDesc.globalPose.M(0,0) = 1; actorDesc.globalPose.M(0,1) = 0; actorDesc.globalPose.M(0,2) = 0; actorDesc.globalPose.M(1,0) = 0; actorDesc.globalPose.M(1,1) = cos(angle); actorDesc.globalPose.M(1,2) = -sin(angle); actorDesc.globalPose.M(2,0) = 0; actorDesc.globalPose.M(2,1) = sin(angle); actorDesc.globalPose.M(2,2) = cos(angle); gScene->createActor(actorDesc); NxBoxShapeDesc hiFrictBoxDesc; hiFrictBoxDesc.dimensions = NxVec3(float(20), float(2), float(30)); hiFrictBoxDesc.materialIndex = highFrictionMaterialIndex; actorDesc.setToDefault(); actorDesc.shapes.clear(); actorDesc.shapes.pushBack(&hiFrictBoxDesc); actorDesc.globalPose.t.set(40,20.0f,0); actorDesc.globalPose.M(0,0) = 1; actorDesc.globalPose.M(0,1) = 0; actorDesc.globalPose.M(0,2) = 0; actorDesc.globalPose.M(1,0) = 0; actorDesc.globalPose.M(1,1) = cos(angle); actorDesc.globalPose.M(1,2) = -sin(angle); actorDesc.globalPose.M(2,0) = 0; actorDesc.globalPose.M(2,1) = sin(angle); actorDesc.globalPose.M(2,2) = cos(angle); gScene->createActor(actorDesc); return true; }