void TutorialApplication::crearEscenario(void)
{
Ogre::Light* luzPrincipal = mSceneMgr->createLight();
luzPrincipal->setType(Ogre::Light::LT_DIRECTIONAL);
luzPrincipal->setPosition(Ogre::Vector3(0, 100, 0));
luzPrincipal->setDirection(Ogre::Vector3(0, -1, 0));
luzPrincipal->setDiffuseColour(Ogre::ColourValue(1, 1, 1));
luzPrincipal->setSpecularColour(Ogre::ColourValue(1, 1, 1));
Ogre::Plane plane(Ogre::Vector3::UNIT_Y, 0);
Ogre::MeshManager::getSingleton().createPlane("ground", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
plane, 254, 127, 10, 10, true, 1, 5, 5, Ogre::Vector3::UNIT_Z);
Ogre::Entity* groundEntity = mSceneMgr->createEntity("ground");
mSceneMgr->getRootSceneNode()->createChildSceneNode()->attachObject(groundEntity);
groundEntity->setCastShadows(false);
groundEntity->setMaterialName("Custom/TelaBillar");
PxPhysics* gPhysics = PhysxOgr::PhysxController::getInstance()->getPhysics();
PxRigidStatic* groundPlane = PxCreatePlane(*gPhysics, PxPlane(0, 1, 0, 0), *gPhysics->createMaterial(0.5f, 0.5f, 0.6f));
mPhysx->getScene()->addActor(*groundPlane);
crearBorde(Ogre::Vector3(-132, 0, 0), Ogre::Vector3(0.1, 0.1, 1.27));
crearBorde(Ogre::Vector3(132, 0, 0), Ogre::Vector3(0.1, 0.1, 1.27));
crearBorde(Ogre::Vector3(0, 0, 68.5), Ogre::Vector3(2.54, 0.1, 0.1));
crearBorde(Ogre::Vector3(0, 0, -68.5), Ogre::Vector3(2.54, 0.1, 0.1));
}
void Apex::CreatePlane(float nx, float ny, float nz, float distance)
{
// Create a plane
PxRigidStatic* plane = PxCreatePlane(*mPhysics, PxPlane(PxVec3(nx,ny,nz), distance), *defaultMaterial);
if (!plane)
return;
gApexScene[mCurrentScene]->getPhysXScene()->addActor(*plane);
}
PhysicsObject * PhysicsScene::CreatePlane()
{
physx::PxMaterial * material = m_physics->createMaterial(0.5f, 0.5f, 0.1f);
physx::PxRigidStatic * rigidActor = PxCreatePlane(*m_physics, physx::PxPlane(physx::PxVec3(0.0f, 1.0f, 0.0f), 0.0f), *material);
physx::PxShape * shape = rigidActor->createShape(physx::PxPlaneGeometry(), *material);
m_scene->addActor(*rigidActor);
return new PhysicsStaticObject(m_physics, rigidActor, shape, material);
}
// add some physics objects into the scene
void AddPhyObjects()
{
PxRigidStatic* groundPlane = PxCreatePlane(*gPhysics, PxPlane(0, 1, 0, 0), *gMaterial);
gScene->addActor(*groundPlane);
PxShape* shape = gPhysics->createShape(PxBoxGeometry(1.0f, 1.0f, 1.0f), *gMaterial);
PxTransform localTm(PxVec3(-3.0f, 5.0f, 0.f));
PxRigidDynamic* body = gPhysics->createRigidDynamic(localTm);
body->attachShape(*shape);
PxRigidBodyExt::updateMassAndInertia(*body, 10.0f);
gScene->addActor(*body);
shape->release();
shape = gPhysics->createShape(PxSphereGeometry(1.0f), *gMaterial);
PxTransform localTmS(PxVec3(3.0f, 5.0f, 0.f));
body = gPhysics->createRigidDynamic(localTmS);
body->attachShape(*shape);
PxRigidBodyExt::updateMassAndInertia(*body, 10.0f);
gScene->addActor(*body);
shape->release();
PxRigidDynamic* dynamic = PxCreateDynamic(*gPhysics, PxTransform(PxVec3(0, 20, 20)), PxSphereGeometry(1), *gMaterial, 10.0f);
dynamic->setAngularDamping(0.5f);
dynamic->setLinearVelocity(PxVec3(0, -5, -10));
gScene->addActor(*dynamic);
// add capsule into the scene
shape = gPhysics->createShape(PxCapsuleGeometry(1.0f, 3.0f), *gMaterial);
PxTransform localTmC(PxVec3(3.0f, 5.0f, -3.f));
body = gPhysics->createRigidDynamic(localTmC);
body->attachShape(*shape);
PxRigidBodyExt::updateMassAndInertia(*body, 10.0f);
gScene->addActor(*body);
// add a static box as the trigger
shape = gPhysics->createShape(PxBoxGeometry(1.0f, 1.0f, 1.0f), *gMaterial);
PxTransform localTmTrigger(PxVec3(0.0f, 1.0f, -10.f));
body = gPhysics->createRigidDynamic(localTmTrigger);
shape->setFlag(PxShapeFlag::eSIMULATION_SHAPE, false);
shape->setFlag(PxShapeFlag::eTRIGGER_SHAPE, true);
body->attachShape(*shape);
body->setRigidBodyFlag(PxRigidBodyFlag::eKINEMATIC, true);
gScene->addActor(*body);
shape->release();
}
Plane::Plane( PhysicsScene* scene, const Ogre::Plane& plane,
const Real width, const Real height, const Vector3& position, const Real u, const Real v ):
Primitive( scene )
{
PxPhysics& physics = mScene->getScene()->getPhysics();
mActor = PxCreatePlane( physics,
PxPlane( Glacier::Math::ogreVec3ToPx( plane.normal ), plane.d ),
*mScene->getDefaultMaterial() );
if ( !mActor )
ENGINE_EXCEPT( "Could not create physics plane actor" );
mScene->getScene()->addActor( *mActor );
Ogre::v1::MeshPtr planeMeshV1 = Ogre::v1::MeshManager::getSingleton().createPlane(
"",
Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
plane, width, height,
1, 1, true, 1, u, v, Ogre::Vector3::UNIT_Z,
Ogre::v1::HardwareBuffer::HBU_STATIC,
Ogre::v1::HardwareBuffer::HBU_STATIC );
mMesh = Ogre::MeshManager::getSingleton().createManual( "", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME );
mMesh->importV1( planeMeshV1.get(), true, true, true );
// mMesh = Procedural::PlaneGenerator().setEnableNormals( true ).setSize( Vector2( width, height ) ).setNormal( plane.normal ).setNumSegX( 8 ).setNumSegY( 8 ).setUTile( u ).setVTile( v ).realizeMesh();
auto scm = Locator::getGraphics().getScene();
mNode = scm->getRootSceneNode()->createChildSceneNode();
mItem = scm->createItem( mMesh );
mItem->setQueryFlags( SceneQueryFlag_World );
mItem->setDatablock( "GameTextures/TileLargeHexagon" );
mItem->setCastShadows( false );
mNode->attachObject( mItem );
mNode->setPosition( position );
mNode->setOrientation( Quaternion::IDENTITY );
}
bool Apex::InitPhysX()
{
static PxDefaultErrorCallback gDefaultErrorCallback;
static PxDefaultAllocator gDefaultAllocatorCallback;
mFoundation = PxCreateFoundation(PX_PHYSICS_VERSION, gDefaultAllocatorCallback, gDefaultErrorCallback);
if(!mFoundation)
return false;
bool recordMemoryAllocations = true;
mPhysics = PxCreatePhysics(PX_PHYSICS_VERSION, *mFoundation,
PxTolerancesScale(), recordMemoryAllocations);
if(!mPhysics)
return false;
mCooking = PxCreateCooking(PX_PHYSICS_VERSION, *mFoundation, PxCookingParams());
if (!mCooking)
return false;
if (!PxInitExtensions(*mPhysics))
return false;
//PxSceneDesc sceneDesc(mPhysics->getTolerancesScale());
//sceneDesc.gravity = PxVec3(0.0f, -9.81f, 0.0f);
//if(!sceneDesc.cpuDispatcher)
//{
// mCpuDispatcher = PxDefaultCpuDispatcherCreate(mNbThreads);
// if(!mCpuDispatcher)
// return false;
// sceneDesc.cpuDispatcher = mCpuDispatcher;
//}
//if(!sceneDesc.filterShader)
//{
// sceneDesc.filterShader = PxDefaultSimulationFilterShader;
//}
//
///*#ifdef PX_WINDOWS
//if(!sceneDesc.gpuDispatcher && mCudaContextManager)
//{
// sceneDesc.gpuDispatcher = mCudaContextManager->getGpuDispatcher();
//}
//#*/
//mProfileZoneManager = &PxProfileZoneManager::createProfileZoneManager(mFoundation);
//pxtask::CudaContextManagerDesc cudaContextManagerDesc;
//mCudaContextManager = pxtask::createCudaContextManager(*mFoundation,cudaContextManagerDesc, mProfileZoneManager);
//sceneDesc.gpuDispatcher = mCudaContextManager->getGpuDispatcher();
//mScene[mCurrentScene] = mPhysics->createScene(sceneDesc);
//if (!mScene[mCurrentScene])
// return false;
defaultMaterial = mPhysics->createMaterial(0.5f, 0.5f, 0.1f); //static friction, dynamic friction, restitution
if(!defaultMaterial)
return false;
// Create a plane
PxRigidStatic* plane = PxCreatePlane(*mPhysics, PxPlane(PxVec3(0,1,0), 700), *defaultMaterial);
if (!plane)
return false;
//mScene[mCurrentScene]->addActor(*plane);
// Create a heightfield
PhysXHeightfield* heightfield = new PhysXHeightfield();
//heightfield->InitHeightfield(mPhysics, mScene[mCurrentScene], "terrain5.raw");
// check if PvdConnection manager is available on this platform
if(mPhysics->getPvdConnectionManager() == NULL)
{
return true;
}
// setup connection parameters
const char* pvd_host_ip = "127.0.0.1"; // IP of the PC which is running PVD
int port = 5425; // TCP port to connect to, where PVD is listening
unsigned int timeout = 100; // timeout in milliseconds to wait for PVD to respond,
// consoles and remote PCs need a higher timeout.
PxVisualDebuggerConnectionFlags connectionFlags = PxVisualDebuggerExt::getAllConnectionFlags();
// and now try to connect
pvdConnection = PxVisualDebuggerExt::createConnection(mPhysics->getPvdConnectionManager(),
pvd_host_ip, port, timeout, connectionFlags);
mPhysics->getVisualDebugger()->setVisualDebuggerFlag(PxVisualDebuggerFlags::eTRANSMIT_CONTACTS, true);
return true;
}
void GameWorld::init()
{
gFoundation = PxCreateFoundation(PX_PHYSICS_VERSION, gAllocator, gErrorCallback);
if (!gFoundation) {
printf("PxCreateFoundation failed!");
}
gPhysics = PxCreatePhysics(PX_PHYSICS_VERSION, *gFoundation, PxTolerancesScale(), true);
if (!PxInitExtensions(*gPhysics)) {
printf("init error pxinit\n");
}
gCooking = PxCreateCooking(PX_PHYSICS_VERSION, *gFoundation, PxCookingParams(gPhysics->getTolerancesScale()));
if (!gCooking) {
printf("PxCreateCooking failed!\n");
}
PxSceneDesc sceneDesc(gPhysics->getTolerancesScale());
sceneDesc.gravity = PxVec3(0.0f, -98.0f, 0.0f);
gDispatcher = PxDefaultCpuDispatcherCreate(2);
sceneDesc.cpuDispatcher = gDispatcher;
sceneDesc.filterShader = PxDefaultSimulationFilterShader;
gScene = gPhysics->createScene(sceneDesc);
gMaterial = gPhysics->createMaterial(0.5f, 0.5f, 0.6f);
PxRigidStatic* groundPlane = PxCreatePlane(*gPhysics, PxPlane(0, 0, 1, 400), *gMaterial);
gScene->addActor(*groundPlane);
groundPlane = PxCreatePlane(*gPhysics, PxPlane(0, 0, -1, 400), *gMaterial);
gScene->addActor(*groundPlane);
groundPlane = PxCreatePlane(*gPhysics, PxPlane(1, 0, 0, 280), *gMaterial);
gScene->addActor(*groundPlane);
groundPlane = PxCreatePlane(*gPhysics, PxPlane(-1, 0, 0, 280), *gMaterial);
gScene->addActor(*groundPlane);
groundPlane = PxCreatePlane(*gPhysics, PxPlane(0, -1, 0, 600), *gMaterial);
gScene->addActor(*groundPlane);
groundPlane = PxCreatePlane(*gPhysics, PxPlane(0, 1, 0, -1), *gMaterial);
gScene->addActor(*groundPlane);
gGround.loadFromObj(GROUND_FILE);
gGround.cookingMesh(*gPhysics, *gCooking);
gGround.createActor(*gMaterial, *gPhysics);
gScene->addActor(*(gGround.actor));
//包围盒
box.loadFromObj(BOX_FILE);
//初始化飞球
pxFlyBall = new PxFlyBall(Color4f(1.0, 200 / 255.0, 0), 5.0);
Material mtl;
PerlinImage perlinYellow = createPerlinLightYelloImage(40, 40, 6, 1.8);
PerlinTexture(perlinYellow, mtl.kd_texid);
mtl.ka = Color4f(1, 1, 1, 1);
mtl.kd = Color4f(1, 1, 1, 1);
mtl.ks = Color4f(1, 1, 1, 1);
pxFlyBall->mtl = mtl;
pxFlyBall->createPxBall(*gPhysics, PxTransform(PxVec3(rand() % 500 - 250, 100, rand() % 700 - 350)), *gMaterial);
pxFlyBall->pxActor->setAngularDamping(0.5);
perlinYellow.clear();
gScene->addActor(*(pxFlyBall->pxActor));
//初始化白球
pxControlBall = new PxControlBall(Color4f(1.0, 1.0, 1.0), 5.0);
PerlinImage perlinGray = createPerlinGrayImage(40, 40, 6, 1.8);
PerlinTexture(perlinGray, mtl.kd_texid);
mtl.ka = Color4f(1, 1, 1, 1);
mtl.kd = Color4f(1, 1, 1, 1);
mtl.ks = Color4f(0, 0, 0, 0);
pxControlBall->mtl = mtl;
pxControlBall->createPxBall(*gPhysics, PxTransform(PxVec3(0, 50, 0)), *gMaterial);
pxControlBall->pxActor->setAngularDamping(0.5);
perlinGray.clear();
gScene->addActor(*(pxControlBall->pxActor));
GLfloat light1PosType[] = { -5.0,1.0,5.0,0.0 };
GLfloat whiteColor[] = { 1.0,1.0,1.0,1.0 };
GLfloat darkColor[] = { 0.4,0.4,0.4,1 };
GLfloat specColor[] = { 1,1,1,1 };
GLfloat lightColor[] = { 1,1,1,1 };
GLfloat globalAmbient[] = { 0.2,0.2,0.2,1.0 };
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, globalAmbient);
glLightfv(GL_LIGHT1, GL_AMBIENT, darkColor);
glLightfv(GL_LIGHT1, GL_DIFFUSE, lightColor);
glLightfv(GL_LIGHT1, GL_SPECULAR, specColor);
glLightfv(GL_LIGHT1, GL_POSITION, light1PosType);
}
void Scene::initializePhysics(void)
{
// database record for scene location
database::LocationInfo* locationInfo = database::LocationInfo::getRecord( _location->getDatabaseId() );
// find collision geometry
engine::IClump* collisionClump = NULL;
callback::ClumpL clumpL;
_extrasAsset->forAllClumps( callback::enumerateClumps, &clumpL );
for( callback::ClumpI clumpI=clumpL.begin(); clumpI!=clumpL.end(); clumpI++ )
{
if( strcmp( (*clumpI)->getName(), "CollisionGeometry" ) == 0 )
{
collisionClump = (*clumpI);
break;
}
}
assert( collisionClump != NULL );
collisionClump->getFrame()->translate( Vector3f( 0,0,0 ) );
collisionClump->getFrame()->getLTM();
// determine physics scene bounds by collision geometry
callback::AtomicL atomicL;
collisionClump->forAllAtomics( callback::enumerateAtomics, &atomicL );
assert( atomicL.size() == 1 );
_collisionGeometry = *atomicL.begin();
Vector3f sceneInf = _collisionGeometry->getAABBInf();
Vector3f sceneSup = _collisionGeometry->getAABBSup();
_phSceneBounds = PxBounds3 (PxVec3(sceneInf[0], sceneInf[1], sceneInf[2]),
PxVec3(sceneSup[0], sceneSup[1], sceneSup[2]));
// determine limits of scene
_phSceneLimits.maxNbActors = locationInfo->physicsLimits.numActors;
_phSceneLimits.maxNbBodies = locationInfo->physicsLimits.numBodies;
//_phSceneLimits.maxNbJoints = locationInfo->physicsLimits.numJoints;
_phSceneLimits.maxNbDynamicShapes = locationInfo->physicsLimits.numDynamicShapes;
_phSceneLimits.maxNbStaticShapes = locationInfo->physicsLimits.numStaticShapes;
// initialize physics scene
PxSceneDesc _phSceneDesc(PxGetPhysics().getTolerancesScale());
_phSceneDesc.gravity = PxVec3(0.0f, -9.81f, 0.0f);
_phSceneDesc.broadPhaseType = PxBroadPhaseType::eSAP;
//PHYSX3 fix collision filters
//_phSceneDesc.userNotify = NULL;
//_phSceneDesc.userTriggerReport = this;
//_phSceneDesc.userContactReport = this;
//_phSceneDesc.maxTimestep = simulationStepTime;
//_phSceneDesc.maxIter = 1;
//_phSceneDesc.timeStepMethod = NX_TIMESTEP_VARIABLE;
//_phSceneDesc.groundPlane = false;
//_phSceneDesc.boundsPlanes = false;
//_phSceneDesc.collisionDetection = true;
_phSceneDesc.userData = this;
// create scene
//mNbThreads = PxMax(PxI32(shdfnd::Thread::getNbPhysicalCores())-1, 0);
//#ifdef PX_PS3
// mNbThreads = 1; // known issue, 0 worker threads and SPU batched query can deadlock.
//#endif
//PHYSX3
mNbThreads = 1;
if(!_phSceneDesc.cpuDispatcher) {
mCpuDispatcher = PxDefaultCpuDispatcherCreate(mNbThreads);
//PHYSX3
//if(!mCpuDispatcher)
// fatalError("PxDefaultCpuDispatcherCreate failed!");
_phSceneDesc.cpuDispatcher = mCpuDispatcher;
}
if(!_phSceneDesc.filterShader)
_phSceneDesc.filterShader = gDefaultFilterShader;
#ifdef PX_WINDOWS
if(!_phSceneDesc.gpuDispatcher && mCudaContextManager) {
_phSceneDesc.gpuDispatcher = mCudaContextManager->getGpuDispatcher();
}
#endif
_phScene = PxGetPhysics().createScene(_phSceneDesc);
assert( _phScene );
// post-creation scene settings
_phScene->setVisualizationCullingBox(_phSceneBounds);
_phScene->setLimits(_phSceneLimits);
// default material
PxMaterial* defaultMaterial = PxGetPhysics().createMaterial(0.25f, 0.25f, 0.5f);
// add ground plane
PxRigidStatic* groundPlane = PxCreatePlane(PxGetPhysics(), PxPlane(0,1,0,0), *defaultMaterial);
_phScene->addActor(*groundPlane);
// fixed flesh material
_phFleshMaterial = PxGetPhysics().createMaterial(0.75f, 0.75f, 0.25f);
_phFleshMaterial->setFrictionCombineMode(PxCombineMode::eMAX);
_phFleshMaterial->setRestitutionCombineMode(PxCombineMode::eMULTIPLY);
assert( _phFleshMaterial );
// moving flesh material
_phMovingFleshMaterial = PxGetPhysics().createMaterial(0.25f, 0.25f, 0.125f);
_phMovingFleshMaterial->setFrictionCombineMode(PxCombineMode::eMAX);
_phMovingFleshMaterial->setRestitutionCombineMode(PxCombineMode::eMULTIPLY);
assert( _phMovingFleshMaterial );
// cloth material
_phClothMaterial = PxGetPhysics().createMaterial(0.995f, 0.995f, 0.05f);
_phClothMaterial->setFrictionCombineMode(PxCombineMode::eMAX);
_phClothMaterial->setRestitutionCombineMode(PxCombineMode::eMULTIPLY);
assert( _phClothMaterial );
// build terrain mesh data
Matrix4f collisionGeometryLTM = _collisionGeometry->getFrame()->getLTM();
Vector3f worldVertex;
engine::Mesh* mesh = _collisionGeometry->getGeometry()->createMesh();
_phTerrainVerts = new PxVec3[mesh->numVertices];
_phTerrainTriangles = new PxU32[3*mesh->numTriangles];
//PHYSX3
//_phTerrainMaterials = new NxMaterialIndex[mesh->numTriangles];
unsigned int i;
for( i=0; i<mesh->numVertices; i++ )
{
worldVertex = Gameplay::iEngine->transformCoord( mesh->vertices[i], collisionGeometryLTM );
_phTerrainVerts[i] = wrap( worldVertex );
}
for( i=0; i<mesh->numTriangles; i++ )
{
_phTerrainTriangles[i*3+0] = mesh->triangles[i].vertexId[0];
_phTerrainTriangles[i*3+1] = mesh->triangles[i].vertexId[1];
_phTerrainTriangles[i*3+2] = mesh->triangles[i].vertexId[2];
//PHYSX3
//_phTerrainMaterials[i] = 0;
}
// initialize terrain descriptor
_phTerrainDesc.points.count = mesh->numVertices;
_phTerrainDesc.points.data = _phTerrainVerts;
_phTerrainDesc.points.stride = sizeof(PxVec3);
_phTerrainDesc.triangles.count = mesh->numTriangles;
_phTerrainDesc.triangles.data = _phTerrainTriangles;
_phTerrainDesc.triangles.stride = 3 * sizeof(PxU32);
//PHYSX3
//_phTerrainDesc.materialIndexStride = sizeof( PxMaterialIndex );
//_phTerrainDesc.materialIndices = _phTerrainMaterials;
//_phTerrainDesc.heightFieldVerticalAxis = NX_NOT_HEIGHTFIELD;
//_phTerrainDesc.heightFieldVerticalExtent = -1000;
// cook terrain
_phTerrainMesh = Gameplay::pxCooking->createTriangleMesh(_phTerrainDesc, PxGetPhysics().getPhysicsInsertionCallback());
assert (_phTerrainMesh);
_phTerrain = PxGetPhysics().createRigidStatic(PxTransform(PxVec3(0.0f, 1.0f, 0.0f), PxQuat(PxHalfPi / 60.0f, PxVec3(0.0f, 1.0f, 0.0f))));
assert (_phTerrain);
PxTriangleMeshGeometry triGeom(_phTerrainMesh);
PxShape* triangleMeshShape = _phTerrain->createShape(triGeom, *defaultMaterial);
assert (triangleMeshShape);
_phScene->addActor(*_phTerrain);
//PHYSX3
// retrieve terrain shape
_phTerrain->getShapes(&_phTerrainShape, 1);
assert( _phTerrainShape );
Gameplay::iEngine->releaseMesh( mesh );
}
