/**
* Method is used to add heightfield actor to physics scene.
* @param entity is actor logic object.
* @param heightData is terrain height map data.
* @param params is terrain parameters: heightmap size, row/column scale, max. height.
* @param filterGroup is actor own id.
* @param filterMask is mask to filter pairs that trigger a contact callback.
*/
void PhysicsManager::addHeightFieldActor(SceneEntity* entity, unsigned char* heightData, const Vector4D& params, PxU32 filterGroup, PxU32 filterMask)
{
int terrainSize = static_cast<int>(params.x());
PxHeightFieldSample* samples = new PxHeightFieldSample[terrainSize*terrainSize];
PxHeightFieldDesc descriptor;
descriptor.nbColumns = static_cast<int>(terrainSize);
descriptor.nbRows = static_cast<int>(terrainSize);
for(int i = 0; i < terrainSize*terrainSize; ++i)
samples[i].height = static_cast<PxI16>(heightData[i]);
descriptor.samples.data = samples;
descriptor.samples.stride = sizeof(PxHeightFieldSample);
PxHeightField* heightField = physicsSDK->createHeightField(descriptor);
PxHeightFieldGeometry geometry(heightField, PxMeshGeometryFlags(),params.w()*0.00390625f,params.y(),params.z());
PxTransform transformation = PxTransform(PxVec3(-terrainSize*0.5f*params.y(),0.0f,-terrainSize*0.5f*params.z()),PxQuat::createIdentity());
PxRigidStatic* heightFieldActor = physicsSDK->createRigidStatic(transformation);
PxShape* aHeightFieldShape = heightFieldActor->createShape(geometry,*materials[0].second);
heightFieldActor->setName(entity->entityName.c_str());
setupFiltering(heightFieldActor,filterGroup,filterMask);
scene->addActor(*heightFieldActor);
StaticActor* s = new StaticActor();
s->entityLogic = entity;
s->entityPhysics = heightFieldActor;
staticActors.push_back(s);
}
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);
dynamicActorS->setName("Bullet");
setupFiltering(dynamicActorS, FilterGroup::ePLAYER, FilterGroup::eGROUND);
//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 Physics::SetUpTutorial1()
{
//Add a plane
PxTransform pose = PxTransform(PxVec3(0.0f, 0, 0.0f), PxQuat(PxHalfPi*1.0f, PxVec3(0.0f, 0.0f, 1.0f)));
PxRigidStatic* plane = PxCreateStatic(*g_Physics, pose, PxPlaneGeometry(), *g_PhysicsMaterial);
//Add it to the physx scene
g_PhysicsScene->addActor(*plane);
//Add a box
float density = 5000;
PxBoxGeometry box(5,5,5);
PxTransform transformS(PxVec3(0, 5, 0));
PxRigidStatic* StaticActor = PxCreateStatic(*g_Physics, transformS, box, *g_PhysicsMaterial);
StaticActor->setName("TriggerBox");
setupFiltering(StaticActor, FilterGroup::eGROUND, FilterGroup::ePLAYER);
setShapeAsTrigger(StaticActor);
//add it to the physx scene
g_PhysicsScene->addActor(*StaticActor);
}
Player::Player(Rath::Node* head) :
m_fFramesToSmoothMouseData(2.0f),
m_fRotationScaler(0.01f),
m_fMoveScaler(15.0f),
m_bUseGamepad(false),
m_bUseMouse(true),
m_bUseKeyboard(true),
m_pHead(head)
{
m_pHead->SetParent(this);
mWorld = DirectX::SimpleMath::Matrix(
-0.459742427f, 0.000000000f, 0.888052285f, 0.000000000f,
0.000000000f, 1.00000000f, 0.000000000f, 0.000000000f,
-0.888052285f, 0.000000000f, -0.459742427f, 0.000000000f,
46.7789955f, 141.000000f, 55.7633896f, 1.00000000f);
setupFiltering(CollisionType::ePlayer, CollisionType::eEntityItem | CollisionType::eEnemy);
}
/**
* Method is used to add new static actor to physics scene. Now only plane shape can be used.
* @param entity is pointer to scene entity which will be added to physics simulation.
* @param type is enumeration of shape type.
* @param filterGroup is actor own id.
* @param filterMask is mask to filter pairs that trigger a contact callback.
*/
void PhysicsManager::addStaticActor(SceneEntity* entity, ShapeType type, PxU32 filterGroup, PxU32 filterMask)
{
PxVec3 position;
PxQuat orientation;
PxTransform transformation;
if(entity == nullptr)
{
transformation = PxTransform(PxVec3(0.0f,1.0f,0.0f),PxQuat(PxHalfPi,PxVec3(0.0f, 0.0f, 1.0f)));
}
else
{
position = PxVec3(entity->entityState.position[0],entity->entityState.position[1],entity->entityState.position[2]);
orientation = PxQuat(entity->entityState.orientation[0],entity->entityState.orientation[1],entity->entityState.orientation[2],entity->entityState.orientation[3]);
transformation = PxTransform(position,orientation);
}
PxRigidStatic* actor = nullptr;
actor = physicsSDK->createRigidStatic(transformation);
if(!actor)
Logger::getInstance()->saveLog(Log<string>("Static Actor creation error occurred!"));
PxShape* shape = nullptr;
if(type == PLANE)
shape = actor->createShape(PxPlaneGeometry(),*materials[0].second);
else
return;
if(!shape)
Logger::getInstance()->saveLog(Log<string>("Static Actor shape creation error occurred!"));
actor->setName("World Plane");
setupFiltering(actor,filterGroup,filterMask);
scene->addActor(*actor);
StaticActor* s = new StaticActor();
s->entityLogic = entity;
s->entityPhysics = actor;
staticActors.push_back(s);
}
/**
* Method is used to add new dynamic actor to physics scene.
* @param entity is pointer to scene entity which will be added to physics simulation.
* @param type is enumeration of shape type.
* @param filterGroup is actor own id.
* @param filterMask is mask to filter pairs that trigger a contact callback.
*/
void PhysicsManager::addDynamicActor(SceneEntity* entity, ShapeType type, PxU32 filterGroup, PxU32 filterMask)
{
PxRigidDynamic* actor = nullptr;
PxVec3 position = PxVec3(entity->entityState.position[0],entity->entityState.position[1],entity->entityState.position[2]);
PxQuat orientation = PxQuat(entity->entityState.orientation[0],entity->entityState.orientation[1],entity->entityState.orientation[2],entity->entityState.orientation[3]);
PxReal density = 1.0f;
PxTransform transformation = PxTransform(position,orientation);
if(type == BOX)
{
float x = (entity->entityGeometry.geometryBox->max.x() - entity->entityGeometry.geometryBox->min.x())*entity->entityState.scale.x()*0.5f;
float y = (entity->entityGeometry.geometryBox->max.y() - entity->entityGeometry.geometryBox->min.y())*entity->entityState.scale.y()*0.5f;
float z = (entity->entityGeometry.geometryBox->max.z() - entity->entityGeometry.geometryBox->min.z())*entity->entityState.scale.z()*0.5f;
PxVec3 dimensions(x,y,z);
actor = PxCreateDynamic(*physicsSDK,transformation,PxBoxGeometry(dimensions),*materials[0].second,density);
PxRigidBodyExt::updateMassAndInertia(*actor, density);
}
else if(type == SPHERE)
{
float radius = entity->entityGeometry.geometrySphere->sphereRadius;
actor = PxCreateDynamic(*physicsSDK,transformation,PxSphereGeometry(radius),*materials[0].second,density);
}
else if(type == CAPSULE)
{
float radius = entity->entityGeometry.geometrySphere->sphereRadius;
actor = PxCreateDynamic(*physicsSDK,transformation,PxCapsuleGeometry(radius/2, radius),*materials[0].second,density);
}
else if(type == CONVEX)
{
/*int vertsCount = entity->entityGeometry.geometryMesh->getVerticesAmount();
AyumiUtils::Vertex<>* verts = entity->entityGeometry.geometryMesh->getVertices();
PxVec3* convexVerts = new PxVec3[vertsCount];
for(int i = 0; i < vertsCount; ++i)
convexVerts[i] = PxVec3(verts[i].x,verts[i].y,verts[i].z);
PxConvexMeshDesc convexDesc;
convexDesc.points.count = entity->entityGeometry.geometryMesh->getVerticesAmount();
convexDesc.points.stride = sizeof(PxVec3);
convexDesc.points.data = convexVerts;
convexDesc.flags = PxConvexFlag::eCOMPUTE_CONVEX;
MemoryWriteBuffer buf;
if(cooking->cookConvexMesh(convexDesc, buf))
{
PxConvexMesh* convexMesh = physicsSDK->createConvexMesh(MemoryReadBuffer(buf.data));
actor = PxCreateDynamic(*physicsSDK,transformation,PxConvexMeshGeometry(convexMesh,PxMeshScale()),*materials[0].second,density);
}
else
{
Logger::getInstance()->saveLog(Log<string>("Convex Mesh creation error occurred!"));
return;
}*/
//delete[] convexVerts;
}
else
{
Logger::getInstance()->saveLog(Log<string>("Dynamic Actor shape creation error occurred!"));
return;
}
if(!actor)
Logger::getInstance()->saveLog(Log<string>("Static Actor creation error occurred!"));
PxRigidBodyExt::updateMassAndInertia(*actor, density);
actor->setAngularDamping(0.75);
actor->setLinearVelocity(PxVec3(0,0,0));
actor->setName(entity->entityName.c_str());
setupFiltering(actor,filterGroup,filterMask);
scene->addActor(*actor);
DynamicActor* d = new DynamicActor();
d->entityLogic = entity;
d->entityPhysics = actor;
d->shapesAmount = actor->getNbShapes();
d->shapes = new PxShape*[d->shapesAmount];
dynamicActors.push_back(d);
}
