From 7028cbe09c688437910a25623098762bf0fa592d Mon Sep 17 00:00:00 2001 From: David Walter Seikel Date: Mon, 28 Mar 2016 22:28:34 +1000 Subject: Move Irrlicht to src/others. --- .../irrlicht-1.8.1/examples/07.Collision/main.cpp | 330 +++++++++++++++++++++ 1 file changed, 330 insertions(+) create mode 100644 src/others/irrlicht-1.8.1/examples/07.Collision/main.cpp (limited to 'src/others/irrlicht-1.8.1/examples/07.Collision/main.cpp') diff --git a/src/others/irrlicht-1.8.1/examples/07.Collision/main.cpp b/src/others/irrlicht-1.8.1/examples/07.Collision/main.cpp new file mode 100644 index 0000000..8387c49 --- /dev/null +++ b/src/others/irrlicht-1.8.1/examples/07.Collision/main.cpp @@ -0,0 +1,330 @@ +/** Example 007 Collision + +We will describe 2 methods: Automatic collision detection for moving through +3d worlds with stair climbing and sliding, and manual scene node and triangle +picking using a ray. In this case, we will use a ray coming out from the +camera, but you can use any ray. + +To start, we take the program from tutorial 2, which loads and displays a +quake 3 level. We will use the level to walk in it and to pick triangles from. +In addition we'll place 3 animated models into it for triangle picking. The +following code starts up the engine and loads the level, as per tutorial 2. +*/ +#include +#include "driverChoice.h" + +using namespace irr; + +#ifdef _MSC_VER +#pragma comment(lib, "Irrlicht.lib") +#endif + +enum +{ + // I use this ISceneNode ID to indicate a scene node that is + // not pickable by getSceneNodeAndCollisionPointFromRay() + ID_IsNotPickable = 0, + + // I use this flag in ISceneNode IDs to indicate that the + // scene node can be picked by ray selection. + IDFlag_IsPickable = 1 << 0, + + // I use this flag in ISceneNode IDs to indicate that the + // scene node can be highlighted. In this example, the + // homonids can be highlighted, but the level mesh can't. + IDFlag_IsHighlightable = 1 << 1 +}; + +int main() +{ + // ask user for driver + video::E_DRIVER_TYPE driverType=driverChoiceConsole(); + if (driverType==video::EDT_COUNT) + return 1; + + // create device + + IrrlichtDevice *device = + createDevice(driverType, core::dimension2d(640, 480), 16, false); + + if (device == 0) + return 1; // could not create selected driver. + + video::IVideoDriver* driver = device->getVideoDriver(); + scene::ISceneManager* smgr = device->getSceneManager(); + + device->getFileSystem()->addFileArchive("../../media/map-20kdm2.pk3"); + + scene::IAnimatedMesh* q3levelmesh = smgr->getMesh("20kdm2.bsp"); + scene::IMeshSceneNode* q3node = 0; + + // The Quake mesh is pickable, but doesn't get highlighted. + if (q3levelmesh) + q3node = smgr->addOctreeSceneNode(q3levelmesh->getMesh(0), 0, IDFlag_IsPickable); + + /* + So far so good, we've loaded the quake 3 level like in tutorial 2. Now, + here comes something different: We create a triangle selector. A + triangle selector is a class which can fetch the triangles from scene + nodes for doing different things with them, for example collision + detection. There are different triangle selectors, and all can be + created with the ISceneManager. In this example, we create an + OctreeTriangleSelector, which optimizes the triangle output a little + bit by reducing it like an octree. This is very useful for huge meshes + like quake 3 levels. After we created the triangle selector, we attach + it to the q3node. This is not necessary, but in this way, we do not + need to care for the selector, for example dropping it after we do not + need it anymore. + */ + + scene::ITriangleSelector* selector = 0; + + if (q3node) + { + q3node->setPosition(core::vector3df(-1350,-130,-1400)); + + selector = smgr->createOctreeTriangleSelector( + q3node->getMesh(), q3node, 128); + q3node->setTriangleSelector(selector); + // We're not done with this selector yet, so don't drop it. + } + + + /* + We add a first person shooter camera to the scene so that we can see and + move in the quake 3 level like in tutorial 2. But this, time, we add a + special animator to the camera: A Collision Response animator. This + animator modifies the scene node to which it is attached to in order to + prevent it moving through walls, and to add gravity to it. The + only thing we have to tell the animator is how the world looks like, + how big the scene node is, how much gravity to apply and so on. After the + collision response animator is attached to the camera, we do not have to do + anything more for collision detection, anything is done automatically. + The rest of the collision detection code below is for picking. And please + note another cool feature: The collision response animator can be + attached also to all other scene nodes, not only to cameras. And it can + be mixed with other scene node animators. In this way, collision + detection and response in the Irrlicht engine is really easy. + + Now we'll take a closer look on the parameters of + createCollisionResponseAnimator(). The first parameter is the + TriangleSelector, which specifies how the world, against collision + detection is done looks like. The second parameter is the scene node, + which is the object, which is affected by collision detection, in our + case it is the camera. The third defines how big the object is, it is + the radius of an ellipsoid. Try it out and change the radius to smaller + values, the camera will be able to move closer to walls after this. The + next parameter is the direction and speed of gravity. We'll set it to + (0, -10, 0), which approximates to realistic gravity, assuming that our + units are metres. You could set it to (0,0,0) to disable gravity. And the + last value is just a translation: Without this, the ellipsoid with which + collision detection is done would be around the camera, and the camera would + be in the middle of the ellipsoid. But as human beings, we are used to have our + eyes on top of the body, with which we collide with our world, not in + the middle of it. So we place the scene node 50 units over the center + of the ellipsoid with this parameter. And that's it, collision + detection works now. + */ + + // Set a jump speed of 3 units per second, which gives a fairly realistic jump + // when used with the gravity of (0, -10, 0) in the collision response animator. + scene::ICameraSceneNode* camera = + smgr->addCameraSceneNodeFPS(0, 100.0f, .3f, ID_IsNotPickable, 0, 0, true, 3.f); + camera->setPosition(core::vector3df(50,50,-60)); + camera->setTarget(core::vector3df(-70,30,-60)); + + if (selector) + { + scene::ISceneNodeAnimator* anim = smgr->createCollisionResponseAnimator( + selector, camera, core::vector3df(30,50,30), + core::vector3df(0,-10,0), core::vector3df(0,30,0)); + selector->drop(); // As soon as we're done with the selector, drop it. + camera->addAnimator(anim); + anim->drop(); // And likewise, drop the animator when we're done referring to it. + } + + // Now I create three animated characters which we can pick, a dynamic light for + // lighting them, and a billboard for drawing where we found an intersection. + + // First, let's get rid of the mouse cursor. We'll use a billboard to show + // what we're looking at. + device->getCursorControl()->setVisible(false); + + // Add the billboard. + scene::IBillboardSceneNode * bill = smgr->addBillboardSceneNode(); + bill->setMaterialType(video::EMT_TRANSPARENT_ADD_COLOR ); + bill->setMaterialTexture(0, driver->getTexture("../../media/particle.bmp")); + bill->setMaterialFlag(video::EMF_LIGHTING, false); + bill->setMaterialFlag(video::EMF_ZBUFFER, false); + bill->setSize(core::dimension2d(20.0f, 20.0f)); + bill->setID(ID_IsNotPickable); // This ensures that we don't accidentally ray-pick it + + /* Add 3 animated hominids, which we can pick using a ray-triangle intersection. + They all animate quite slowly, to make it easier to see that accurate triangle + selection is being performed. */ + scene::IAnimatedMeshSceneNode* node = 0; + + video::SMaterial material; + + // Add an MD2 node, which uses vertex-based animation. + node = smgr->addAnimatedMeshSceneNode(smgr->getMesh("../../media/faerie.md2"), + 0, IDFlag_IsPickable | IDFlag_IsHighlightable); + node->setPosition(core::vector3df(-90,-15,-140)); // Put its feet on the floor. + node->setScale(core::vector3df(1.6f)); // Make it appear realistically scaled + node->setMD2Animation(scene::EMAT_POINT); + node->setAnimationSpeed(20.f); + material.setTexture(0, driver->getTexture("../../media/faerie2.bmp")); + material.Lighting = true; + material.NormalizeNormals = true; + node->getMaterial(0) = material; + + // Now create a triangle selector for it. The selector will know that it + // is associated with an animated node, and will update itself as necessary. + selector = smgr->createTriangleSelector(node); + node->setTriangleSelector(selector); + selector->drop(); // We're done with this selector, so drop it now. + + // And this B3D file uses skinned skeletal animation. + node = smgr->addAnimatedMeshSceneNode(smgr->getMesh("../../media/ninja.b3d"), + 0, IDFlag_IsPickable | IDFlag_IsHighlightable); + node->setScale(core::vector3df(10)); + node->setPosition(core::vector3df(-75,-66,-80)); + node->setRotation(core::vector3df(0,90,0)); + node->setAnimationSpeed(8.f); + node->getMaterial(0).NormalizeNormals = true; + node->getMaterial(0).Lighting = true; + // Just do the same as we did above. + selector = smgr->createTriangleSelector(node); + node->setTriangleSelector(selector); + selector->drop(); + + // This X files uses skeletal animation, but without skinning. + node = smgr->addAnimatedMeshSceneNode(smgr->getMesh("../../media/dwarf.x"), + 0, IDFlag_IsPickable | IDFlag_IsHighlightable); + node->setPosition(core::vector3df(-70,-66,-30)); // Put its feet on the floor. + node->setRotation(core::vector3df(0,-90,0)); // And turn it towards the camera. + node->setAnimationSpeed(20.f); + node->getMaterial(0).Lighting = true; + selector = smgr->createTriangleSelector(node); + node->setTriangleSelector(selector); + selector->drop(); + + + // And this mdl file uses skinned skeletal animation. + node = smgr->addAnimatedMeshSceneNode(smgr->getMesh("../../media/yodan.mdl"), + 0, IDFlag_IsPickable | IDFlag_IsHighlightable); + node->setPosition(core::vector3df(-90,-25,20)); + node->setScale(core::vector3df(0.8f)); + node->getMaterial(0).Lighting = true; + node->setAnimationSpeed(20.f); + + // Just do the same as we did above. + selector = smgr->createTriangleSelector(node); + node->setTriangleSelector(selector); + selector->drop(); + + material.setTexture(0, 0); + material.Lighting = false; + + // Add a light, so that the unselected nodes aren't completely dark. + scene::ILightSceneNode * light = smgr->addLightSceneNode(0, core::vector3df(-60,100,400), + video::SColorf(1.0f,1.0f,1.0f,1.0f), 600.0f); + light->setID(ID_IsNotPickable); // Make it an invalid target for selection. + + // Remember which scene node is highlighted + scene::ISceneNode* highlightedSceneNode = 0; + scene::ISceneCollisionManager* collMan = smgr->getSceneCollisionManager(); + int lastFPS = -1; + + // draw the selection triangle only as wireframe + material.Wireframe=true; + + while(device->run()) + if (device->isWindowActive()) + { + driver->beginScene(true, true, 0); + smgr->drawAll(); + + // Unlight any currently highlighted scene node + if (highlightedSceneNode) + { + highlightedSceneNode->setMaterialFlag(video::EMF_LIGHTING, true); + highlightedSceneNode = 0; + } + + // All intersections in this example are done with a ray cast out from the camera to + // a distance of 1000. You can easily modify this to check (e.g.) a bullet + // trajectory or a sword's position, or create a ray from a mouse click position using + // ISceneCollisionManager::getRayFromScreenCoordinates() + core::line3d ray; + ray.start = camera->getPosition(); + ray.end = ray.start + (camera->getTarget() - ray.start).normalize() * 1000.0f; + + // Tracks the current intersection point with the level or a mesh + core::vector3df intersection; + // Used to show with triangle has been hit + core::triangle3df hitTriangle; + + // This call is all you need to perform ray/triangle collision on every scene node + // that has a triangle selector, including the Quake level mesh. It finds the nearest + // collision point/triangle, and returns the scene node containing that point. + // Irrlicht provides other types of selection, including ray/triangle selector, + // ray/box and ellipse/triangle selector, plus associated helpers. + // See the methods of ISceneCollisionManager + scene::ISceneNode * selectedSceneNode = + collMan->getSceneNodeAndCollisionPointFromRay( + ray, + intersection, // This will be the position of the collision + hitTriangle, // This will be the triangle hit in the collision + IDFlag_IsPickable, // This ensures that only nodes that we have + // set up to be pickable are considered + 0); // Check the entire scene (this is actually the implicit default) + + // If the ray hit anything, move the billboard to the collision position + // and draw the triangle that was hit. + if(selectedSceneNode) + { + bill->setPosition(intersection); + + // We need to reset the transform before doing our own rendering. + driver->setTransform(video::ETS_WORLD, core::matrix4()); + driver->setMaterial(material); + driver->draw3DTriangle(hitTriangle, video::SColor(0,255,0,0)); + + // We can check the flags for the scene node that was hit to see if it should be + // highlighted. The animated nodes can be highlighted, but not the Quake level mesh + if((selectedSceneNode->getID() & IDFlag_IsHighlightable) == IDFlag_IsHighlightable) + { + highlightedSceneNode = selectedSceneNode; + + // Highlighting in this case means turning lighting OFF for this node, + // which means that it will be drawn with full brightness. + highlightedSceneNode->setMaterialFlag(video::EMF_LIGHTING, false); + } + } + + // We're all done drawing, so end the scene. + driver->endScene(); + + int fps = driver->getFPS(); + + if (lastFPS != fps) + { + core::stringw str = L"Collision detection example - Irrlicht Engine ["; + str += driver->getName(); + str += "] FPS:"; + str += fps; + + device->setWindowCaption(str.c_str()); + lastFPS = fps; + } + } + + device->drop(); + + return 0; +} + +/* +**/ + -- cgit v1.1