PxRigidDynamic* PxCreateKinematic(PxPhysics& sdk, const PxTransform& transform, const PxGeometry& geometry, PxMaterial& material, PxReal density, const PxTransform& shapeOffset) { PX_CHECK_AND_RETURN_NULL(transform.isValid(), "PxCreateKinematic: transform is not valid."); PX_CHECK_AND_RETURN_NULL(shapeOffset.isValid(), "PxCreateKinematic: shapeOffset is not valid."); bool isDynGeom = isDynamicGeometry(geometry); if(isDynGeom && density <= 0.0f) return NULL; PxShape* shape; PxRigidDynamic* actor = setShape(sdk.createRigidDynamic(transform), geometry, material, shapeOffset, shape); if(actor) { actor->setRigidDynamicFlag(PxRigidDynamicFlag::eKINEMATIC, true); if(isDynGeom) PxRigidBodyExt::updateMassAndInertia(*actor, density); else { shape->setFlag(PxShapeFlag::eSIMULATION_SHAPE, false); actor->setMass(1); actor->setMassSpaceInertiaTensor(PxVec3(1,1,1)); } } return actor; }
void PhysX3::ApplyActionAtPoint(PintObjectHandle handle, PintActionType action_type, const Point& action, const Point& pos) { PxRigidActor* RigidActor = GetActorFromHandle(handle); if(!RigidActor) { PxShape* Shape = GetShapeFromHandle(handle); ASSERT(Shape); #ifdef SUPPORT_SHARED_SHAPES RigidActor = Shape->getActor(); #else RigidActor = &Shape->getActor(); #endif } if(RigidActor->getConcreteType()==PxConcreteType::eRIGID_DYNAMIC) { PxRigidDynamic* RigidDynamic = static_cast<PxRigidDynamic*>(RigidActor); if(!(RigidDynamic->getRigidBodyFlags() & PxRigidBodyFlag::eKINEMATIC)) { PxForceMode::Enum mode; if(action_type==PINT_ACTION_FORCE) mode = PxForceMode::eFORCE; else if(action_type==PINT_ACTION_IMPULSE) mode = PxForceMode::eIMPULSE; else ASSERT(0); PxRigidBodyExt::addForceAtPos(*RigidDynamic, ToPxVec3(action), ToPxVec3(pos), mode); } } }
void SetupShapesUserData(const VehicleDescriptor &vd) { PxRigidDynamic *a = vd.vehicle->mActor; if (!a) return; PxU32 numShapes = a->getNbShapes(); r3d_assert(numShapes <= vd.numWheels + vd.numHullParts); for (PxU32 i = 0; i < numShapes; ++i) { PxShape *s = 0; a->getShapes(&s, 1, i); if (!s) continue; if (i < vd.numWheels) { s->userData = reinterpret_cast<void*>(vd.wheelBonesRemapIndices[i]); } else { s->userData = reinterpret_cast<void*>(vd.hullBonesRemapIndices[i - vd.numWheels]); } } }
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); } } } }
/** @brief @date 2013-12-03 */ void CEvc::pickup() { PxU32 width; PxU32 height; mApplication.getPlatform()->getWindowSize(width, height); mPicking->moveCursor(width/2,height/2); mPicking->lazyPick(); PxActor *actor = mPicking->letGo(); //PxRigidDynamic *rigidActor = static_cast<PxRigidDynamic*>(actor->is<PxRigidDynamic>()); PxRigidDynamic *rigidActor = (PxRigidDynamic*)actor; if (rigidActor) { const PxVec3 pos = getCamera().getPos() + (getCamera().getViewDir()*10.f); const PxVec3 vel = getCamera().getViewDir() * 20.f; rigidActor->addForce( getCamera().getViewDir()*g_pDbgConfig->force ); PxU32 nbShapes = rigidActor->getNbShapes(); if(!nbShapes) return; PxShape** shapes = (PxShape**)SAMPLE_ALLOC(sizeof(PxShape*)*nbShapes); PxU32 nb = rigidActor->getShapes(shapes, nbShapes); PX_ASSERT(nb==nbShapes); for(PxU32 i=0;i<nbShapes;i++) { RenderBaseActor *renderActor = getRenderActor(rigidActor, shapes[i]); if (renderActor) { renderActor->setRenderMaterial(mManagedMaterials[ 1]); } } SAMPLE_FREE(shapes); } }
PxRigidDynamic* PxCreateKinematic(PxPhysics& sdk, const PxTransform& transform, PxShape& shape, PxReal density) { PX_CHECK_AND_RETURN_NULL(transform.isValid(), "PxCreateKinematic: transform is not valid."); bool isDynGeom = isDynamicGeometry(shape.getGeometryType()); if(isDynGeom && density <= 0.0f) return NULL; PxRigidDynamic* actor = sdk.createRigidDynamic(transform); if(actor) { actor->setRigidBodyFlag(PxRigidBodyFlag::eKINEMATIC, true); if(!isDynGeom) shape.setFlag(PxShapeFlag::eSIMULATION_SHAPE, false); actor->attachShape(shape); if(isDynGeom) PxRigidBodyExt::updateMassAndInertia(*actor, density); else { actor->setMass(1.f); actor->setMassSpaceInertiaTensor(PxVec3(1.f,1.f,1.f)); } } return actor; }
/** Interpolates kinematic actor transform - Assumes caller has obtained writer lock */ void FPhysSubstepTask::InterpolateKinematicActor_AssumesLocked(const FPhysTarget& PhysTarget, FBodyInstance* BodyInstance, float InAlpha) { #if WITH_PHYSX PxRigidDynamic * PRigidDynamic = BodyInstance->GetPxRigidDynamic_AssumesLocked(); InAlpha = FMath::Clamp(InAlpha, 0.f, 1.f); /** Interpolate kinematic actors */ if (PhysTarget.bKinematicTarget) { //It's possible that the actor is no longer kinematic and is now simulating. In that case do nothing if (!BodyInstance->IsNonKinematic()) { const FKinematicTarget& KinematicTarget = PhysTarget.KinematicTarget; const FTransform& TargetTM = KinematicTarget.TargetTM; const FTransform& StartTM = KinematicTarget.OriginalTM; FTransform InterTM = FTransform::Identity; InterTM.SetLocation(FMath::Lerp(StartTM.GetLocation(), TargetTM.GetLocation(), InAlpha)); InterTM.SetRotation(FMath::Lerp(StartTM.GetRotation(), TargetTM.GetRotation(), InAlpha)); const PxTransform PNewPose = U2PTransform(InterTM); check(PNewPose.isValid()); PRigidDynamic->setKinematicTarget(PNewPose); } } #endif }
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; }
/** Interpolates kinematic actor transform - Assumes caller has obtained writer lock */ void FPhysSubstepTask::InterpolateKinematicActor(const FPhysTarget & PhysTarget, FBodyInstance * BodyInstance, float Alpha) { #if WITH_PHYSX PxRigidDynamic * PRigidDynamic = BodyInstance->GetPxRigidDynamic(); Alpha = FMath::Clamp(Alpha, 0.f, 1.f); /** Interpolate kinematic actors */ if (PhysTarget.bKinematicTarget) { //We should only be interpolating kinematic actors check(!IsRigidDynamicNonKinematic(PRigidDynamic)); const FKinematicTarget & KinematicTarget = PhysTarget.KinematicTarget; const FTransform & TargetTM = KinematicTarget.TargetTM; const FTransform & StartTM = KinematicTarget.OriginalTM; FTransform InterTM = FTransform::Identity; InterTM.SetLocation(FMath::Lerp(StartTM.GetLocation(), TargetTM.GetLocation(), Alpha)); InterTM.SetRotation(FMath::Lerp(StartTM.GetRotation(), TargetTM.GetRotation(), Alpha)); const PxTransform PNewPose = U2PTransform(InterTM); check(PNewPose.isValid()); PRigidDynamic->setKinematicTarget(PNewPose); } #endif }
void Apex::LoadDynamicTriangleMesh(int numVerts, PxVec3* verts, ObjectInfo info) { PxRigidDynamic* meshActor = mPhysics->createRigidDynamic(PxTransform::createIdentity()); PxShape* meshShape, *convexShape; if(meshActor) { //meshActor->setRigidDynamicFlag(PxRigidDynamicFlag::eKINEMATIC, true); PxTriangleMeshDesc meshDesc; meshDesc.points.count = numVerts; meshDesc.points.stride = sizeof(PxVec3); meshDesc.points.data = verts; //meshDesc.triangles.count = numInds/3.; //meshDesc.triangles.stride = 3*sizeof(int); //meshDesc.triangles.data = inds; PxToolkit::MemoryOutputStream writeBuffer; bool status = mCooking->cookTriangleMesh(meshDesc, writeBuffer); if(!status) return; PxToolkit::MemoryInputData readBuffer(writeBuffer.getData(), writeBuffer.getSize()); PxTriangleMeshGeometry triGeom; triGeom.triangleMesh = mPhysics->createTriangleMesh(readBuffer); //triGeom.scale = PxMeshScale(PxVec3(info.sx,info.sy,info.sz),physx::PxQuat::createIdentity()); meshShape = meshActor->createShape(triGeom, *defaultMaterial); //meshShape->setLocalPose(PxTransform(PxVec3(info.x,info.y,info.z))); meshShape->setFlag(PxShapeFlag::eUSE_SWEPT_BOUNDS, true); PxConvexMeshDesc convexDesc; convexDesc.points.count = numVerts; convexDesc.points.stride = sizeof(PxVec3); convexDesc.points.data = verts; convexDesc.flags = PxConvexFlag::eCOMPUTE_CONVEX; if(!convexDesc.isValid()) return; PxToolkit::MemoryOutputStream buf; if(!mCooking->cookConvexMesh(convexDesc, buf)) return; PxToolkit::MemoryInputData input(buf.getData(), buf.getSize()); PxConvexMesh* convexMesh = mPhysics->createConvexMesh(input); PxConvexMeshGeometry convexGeom = PxConvexMeshGeometry(convexMesh); convexShape = meshActor->createShape(convexGeom, *defaultMaterial); //convexShape->setLocalPose(PxTransform(PxVec3(info.x,info.y,info.z))); //convexShape->setFlag(PxShapeFlag::eSIMULATION_SHAPE, false); convexShape->setFlag(PxShapeFlag::eSIMULATION_SHAPE, true); meshShape->setFlag(PxShapeFlag::eSIMULATION_SHAPE, false); meshActor->setRigidDynamicFlag(PxRigidDynamicFlag::eKINEMATIC, false); meshActor->setGlobalPose(PxTransform(PxVec3(info.x,info.y,info.z), PxQuat(info.ry, PxVec3(0.0f,1.0f,0.0f)))); mScene[mCurrentScene]->addActor(*meshActor); dynamicActors.push_back(meshActor); } }
void AddRadialForceToPxRigidDynamic(PxRigidDynamic& PRigidDynamic, const FVector& Origin, float Radius, float Strength, uint8 Falloff) { #if WITH_PHYSX if (!(PRigidDynamic.getRigidDynamicFlags() & PxRigidDynamicFlag::eKINEMATIC)) { float Mass = PRigidDynamic.getMass(); PxTransform PCOMTransform = PRigidDynamic.getGlobalPose().transform(PRigidDynamic.getCMassLocalPose()); PxVec3 PCOMPos = PCOMTransform.p; // center of mass in world space PxVec3 POrigin = U2PVector(Origin); // origin of radial impulse, in world space PxVec3 PDelta = PCOMPos - POrigin; // vector from float Mag = PDelta.magnitude(); // Distance from COM to origin, in Unreal scale : @todo: do we still need conversion scale? // If COM is outside radius, do nothing. if (Mag > Radius) { return; } PDelta.normalize(); // If using linear falloff, scale with distance. float ForceMag = Strength; if (Falloff == RIF_Linear) { ForceMag *= (1.0f - (Mag / Radius)); } // Apply force PxVec3 PImpulse = PDelta * ForceMag; PRigidDynamic.addForce(PImpulse, PxForceMode::eFORCE); } #endif // WITH_PHYSX }
void AddRadialImpulseToPxRigidDynamic(PxRigidDynamic& PRigidDynamic, const FVector& Origin, float Radius, float Strength, uint8 Falloff, bool bVelChange) { #if WITH_PHYSX if (!(PRigidDynamic.getRigidDynamicFlags() & PxRigidDynamicFlag::eKINEMATIC)) { float Mass = PRigidDynamic.getMass(); PxTransform PCOMTransform = PRigidDynamic.getGlobalPose().transform(PRigidDynamic.getCMassLocalPose()); PxVec3 PCOMPos = PCOMTransform.p; // center of mass in world space PxVec3 POrigin = U2PVector(Origin); // origin of radial impulse, in world space PxVec3 PDelta = PCOMPos - POrigin; // vector from origin to COM float Mag = PDelta.magnitude(); // Distance from COM to origin, in Unreal scale : @todo: do we still need conversion scale? // If COM is outside radius, do nothing. if (Mag > Radius) { return; } PDelta.normalize(); // Scale by U2PScale here, because units are velocity * mass. float ImpulseMag = Strength; if (Falloff == RIF_Linear) { ImpulseMag *= (1.0f - (Mag / Radius)); } PxVec3 PImpulse = PDelta * ImpulseMag; PxForceMode::Enum Mode = bVelChange ? PxForceMode::eVELOCITY_CHANGE : PxForceMode::eIMPULSE; PRigidDynamic.addForce(PImpulse, Mode); } #endif // WITH_PHYSX }
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 PhysXRigidManager::setImpulse(std::string scene, float * impulse) { if (rigidBodies.find(scene) != rigidBodies.end()) { PxRigidDynamic * actor = rigidBodies[scene].info.actor->is<PxRigidDynamic>(); if (actor) { actor->addForce(PxVec3(impulse[0], impulse[1], impulse[2]), PxForceMode::eIMPULSE); } } }
void PhysXRigidManager::setInertiaTensor(std::string name, float * value) { if (rigidBodies.find(name) != rigidBodies.end()) { PxRigidDynamic * dyn = rigidBodies[name].info.actor->is<PxRigidDynamic>(); if (dyn) { dyn->setMassSpaceInertiaTensor(PxVec3(value[0], value[1], value[2])); } } }
PxRigidDynamic* createDynamic(const PxTransform& t, const PxGeometry& geometry, const PxVec3& velocity = PxVec3(0)) { PxRigidDynamic* dynamic = PxCreateDynamic(*gPhysics, t, geometry, *gMaterial, 10.0f); dynamic->setAngularDamping(0.5f); dynamic->setLinearVelocity(velocity); gScene->addActor(*dynamic); return dynamic; }
int RayCastManagerImpl::CastSweep(const XMFLOAT3& p_origin, XMFLOAT3& p_direction, float p_width, const float& p_range, int& o_flag) { if(p_range <= 0.0f) { cout << "Physcs. Raytracer. Sweep. Range of sweep was zero or below" << endl; return -1; } // Cast directx things to physx PxVec3 origin = PxVec3(p_origin.x, p_origin.y, p_origin.z); PxVec3 direction = PxVec3(p_direction.x, p_direction.y, p_direction.z); direction.normalize(); PxSweepBuffer hit; // Used to save the hit /// Paramters for the sweep // PxGeometry* geometry bool status = m_utils.m_worldScene->sweep(PxSphereGeometry(p_width), PxTransform(origin), direction, p_range, hit, PxHitFlag::eMESH_BOTH_SIDES); // hit.block.position; if(!status && !hit.hasBlock) { // No hit detected, return -1 TODOKO Maybee i should return something better? return -1; } // Start with checking static and dynamic rigid bodies unordered_map<PxRigidActor*, int> idsByRigidBody = m_utils.m_rigidBodyManager->GetIDsByBodies(); if(idsByRigidBody.find(hit.block.actor) != idsByRigidBody.end()) { PxRigidActor* actorAsRigic = (PxRigidActor*)hit.block.actor; if(actorAsRigic->isRigidDynamic()) { PxRigidDynamic* actorsAsDynamic = (PxRigidDynamic*)hit.block.actor; if(actorsAsDynamic->getRigidBodyFlags() & PxRigidBodyFlag::eKINEMATIC) { o_flag = 0; } } else if(actorAsRigic->isRigidStatic()) { o_flag = 3; } return idsByRigidBody.find(hit.block.actor)->second; } else { // Nothing } // Now comes the difficult task of checking vs character controllers unordered_map<PxController*, int> idsByCharacterController = m_utils.m_characterControlManager->GetIdsByControllers(); for(auto pairs : idsByCharacterController) // Loop through every pair in the list { if(pairs.first->getActor() == hit.block.actor) // The first part contains the actor pointer { o_flag = 1; return pairs.second; // If this is true we found a hit vs character controller, second contains ID } } return -1; }
void PhysXRigidManager::setMass(std::string name, float value) { if (rigidBodies.find(name) != rigidBodies.end()) { PxRigidDynamic * dyn = rigidBodies[name].info.actor->is<PxRigidDynamic>(); if (dyn) { dyn->setMass(value); } } }
void Spacetime::restoreState(void) { for (int i = 0; i < dynamic_actors.size(); i++) { PxRigidDynamic *current = dynamic_actors[i]; current->setLinearVelocity(linearVelocityVector[i]); current->setAngularVelocity(angularVelocityVector[i]); current->setGlobalPose(globalPoseVector[i]); } }
void Vehicle::applyNitroBoost() { PxRigidDynamic* vehBody = vehDrive4W->getRigidDynamicActor(); vec3 forceVec = lastState->getPlayer(vehicleNum)->getForward(); forceVec = 39050.f * forceVec * vec3(1, 0, 1); vehBody->addForce(getPxVec3(forceVec)); }
void PhysXRigidManager::setForce(std::string scene, float * force) { if (rigidBodies.find(scene) != rigidBodies.end()) { PxRigidDynamic * actor = rigidBodies[scene].info.actor->is<PxRigidDynamic>(); if (actor) { actor->addForce(PxVec3(force[0], force[1], force[2])); } } }
CPhysicsEntity* CPhysics::CreateBall(float radius, CVector3 const& position) { PxTransform Transform (PxVec3 (position.X, position.Y, position.Z)); PxRigidDynamic* aSphereActor = m_SDK->createRigidDynamic(Transform); PxShape* aSphereShape = aSphereActor->createShape(PxSphereGeometry(radius), *m_Material); float SphereDensity = 0.0f; PxRigidBodyExt::updateMassAndInertia(*aSphereActor, SphereDensity); m_Scene->addActor(*aSphereActor); return new CPhysicsEntity(aSphereActor); }
void getSimplePose( PxActor* actor, float* data ) //TODO rework { PxShape* shp[1]; PxRigidDynamic* rigid = (PxRigidDynamic*)actor; rigid->getShapes( shp, PxU32(1) ); PxMat44 shape_pose = rigid->getGlobalPose(); //(PxShapeExt::getGlobalPose(*shp[0], *rigid)); for( int i = 0; i < 4; i++ ) for( int j = 0; j < 4; j++ ) data[i*4 + j] = shape_pose[j][i]; }
void Physics::Shoot() { float densityS = 100; PxSphereGeometry sphere(1); PxTransform transformS(PxVec3(m_camera.world[3].x, m_camera.world[3].y, m_camera.world[3].z)); PxRigidDynamic* dynamicActorS = PxCreateDynamic(*g_Physics, transformS, sphere, *g_PhysicsMaterial, densityS); //add it to the physx scene g_PhysicsScene->addActor(*dynamicActorS); dynamicActorS->addForce(PxVec3(-m_camera.world[2].x, -m_camera.world[2].y, -m_camera.world[2].z)*muzzleSpeed, PxForceMode::eIMPULSE, true); }
void FireAction() { PxRigidDynamic* ball = CreateRubbleGrain(gCamera.pos+PxVec3(0,0,-0.3),gExp.defGrainType,gExp.defGrainSize,*gPhysX.mDefaultMaterial,gExp.defGrainDensity); if (ball) { ball->setLinearVelocity(gCamera.forward*2.5); ColorActor(ball, ncc::rgb::oDarkOrange); } gBall=ball; }
void PhysXInterface::createSphere( int id, double radius, double density ) { PxSphereGeometry geometry( radius ); PxRigidDynamic* actor = PxCreateDynamic( *_physicsSDK, PxTransform::createIdentity(), geometry, *_material, density ); if ( actor ) { actor->setAngularDamping( 0.75 ); _scene->addActor( *actor ); _actors[id] = actor; } }
void PhysXInterface::createBox( int id, const osg::Vec3& dim, double density ) { PxBoxGeometry geometry( PxVec3(dim[0], dim[1], dim[2]) ); PxRigidDynamic* actor = PxCreateDynamic( *_physicsSDK, PxTransform::createIdentity(), geometry, *_material, density ); if ( actor ) { actor->setAngularDamping( 0.75 ); _scene->addActor( *actor ); _actors[id] = actor; } }
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 ShapeActor::Create() { void* s = NULL; if(m_aType == DynamicActor) { PxRigidDynamic* ptr = StaticCast(s, PxRigidDynamic*); // Receive Correctly Cast Pointer ptr = Physics::PxGetPhysics()->createRigidDynamic(m_pose); m_shape = ptr->createShape(m_geometry.any(), *m_material, IDENTITY_TRANS); PxRigidBodyExt::setMassAndUpdateInertia(*ptr, m_density); m_actor.dynamicActor = ptr; }
PxRigidDynamic * labscale::CreateRegolithGrain() { PxMaterial* glass = gPhysX.mPhysics->createMaterial(0.5, 0.5, 0.5); // "glass" PxReal radius = labscale::regolith.diameter/2; PxReal rho = labscale::regolith.materialDensity; PxRigidDynamic* actor = CreateRubbleGrain(PxVec3(0,1.5*labscale::reg_box.fillHeight,0),eSPHERE_GRAIN,radius,*glass,rho); actor->setName("regolith"); if (!actor) ncc__error("actor creations failed"); return actor; }