Lets start like the HelloWorld example: We include the
irrlicht header files and an additional file to be able
to ask the user for a driver type using the console.
#include <irrlicht.h>
#include <iostream>
|
As already written in the HelloWorld example, in the Irrlicht
Engine, everything can be found in the namespace 'irr'.
To get rid of the irr:: in front of the name of every class,
we tell the compiler that we use that namespace from now
on, and we will not have to write that 'irr::'.
There are 5 other sub namespaces 'core', 'scene', 'video',
'io' and 'gui'. Unlike in the HelloWorld example, we do
not a 'using namespace' for these 5 other namespaces because
in this way you will see what can be found in which namespace.
But if you like, you can also include the namespaces like
in the previous example. Code just like you want to.
Again, to be able to use the Irrlicht.DLL file, we need
to link with the Irrlicht.lib. We could set this option
in the project settings, but to make it easy, we use a pragma
comment lib:
#pragma comment(lib, "Irrlicht.lib") |
Ok, lets start. Again, we use the main() method as start,
not the WinMain(), because its shorter to write.
Like in the HelloWorld example, we create an IrrlichtDevice
with createDevice(). The difference now is that we ask the
user to select which hardware accelerated driver to use. The
Software device would be too slow to draw a huge Quake 3 map,
but just for the fun of it, we make this decision possible
too.
// ask user for driver
video::E_DRIVER_TYPE driverType = video::EDT_DIRECT3D9;
printf("Please select the driver you want for this example:\n"\
" (a) Direct3D 9.0c\n (b) Direct3D 8.1\n (c) OpenGL 1.5\n"\
" (d) Software Renderer\n (e) Apfelbaum Software Renderer\n"\
" (f) NullDevice\n (otherKey) exit\n\n");
char i;
std::cin >> i;
switch(i)
{
case 'a': driverType = video::EDT_DIRECT3D9;break;
case 'b': driverType = video::EDT_DIRECT3D8;break;
case 'c': driverType = video::EDT_OPENGL; break;
case 'd': driverType = video::EDT_SOFTWARE; break;
case 'e': driverType = video::EDT_SOFTWARE2;break;
case 'f': driverType = video::EDT_NULL; break;
default: return 1;
}
// create device and exit if creation failed
IrrlichtDevice *device =
createDevice(driverType, core::dimension2d<s32>(640, 480));
if (device == 0)
return 1; |
Get a pointer to the video driver and the SceneManager so
that we do not always have to write device->getVideoDriver()
and device->getSceneManager().
video::IVideoDriver* driver = device->getVideoDriver();
scene::ISceneManager* smgr = device->getSceneManager(); |
To display the Quake 3 map, we first need to load it. Quake
3 maps are packed into .pk3 files wich are nothing other than
.zip files. So we add the .pk3 file to our FileSystem. After
it was added, we are able to read from the files in that archive
as they would directly be stored on disk.
device->getFileSystem()->addZipFileArchive("../../media/map-20kdm2.pk3"); |
Now we can load the mesh by calling getMesh(). We get a pointer
returned to a IAnimatedMesh. As you know, Quake 3 maps are
not really animated, they are only a huge chunk of static
geometry with some materials attached. Hence the IAnimated
mesh consists of only one frame,
so we get the "first frame" of the "animation",
which is our quake level and create an OctTree scene node
with it, using addOctTreeSceneNode(). The OctTree optimizes
the scene a little bit, trying to draw only geometry which
is currently visible. An alternative to the OctTree would
be a AnimatedMeshSceneNode, which would draw always the complete
geometry of the mesh, without optimization. Try it out: Write
addAnimatedMeshSceneNode instead of addOctTreeSceneNode and
compare the primitives drawed by the video driver. (There
is a getPrimitiveCountDrawed() method in the IVideoDriver
class). Note that this optimization with the Octree is only
useful when drawing huge meshes consiting of lots of geometry.
scene::IAnimatedMesh* mesh = smgr->getMesh("20kdm2.bsp");
scene::ISceneNode* node = 0;
if (mesh)
node = smgr->addOctTreeSceneNode(mesh->getMesh(0)); |
Because the level was modelled not around the origin (0,0,0),
we translate the whole level a little bit.
if (node)
node->setPosition(core::vector3df(-1300,-144,-1249)); |
Now we only need a Camera to look at the Quake 3 map. And
we want to create a user controlled camera. There are some
different cameras available in the Irrlicht engine. For example
the Maya Camera which can be controlled compareable to the
camera in Maya: Rotate with left mouse button pressed, Zoom
with both buttons pressed,
translate with right mouse button pressed. This could be created
with addCameraSceneNodeMaya(). But for this example, we want
to create a camera which behaves like the ones in first person
shooter games (FPS):
smgr->addCameraSceneNodeFPS(); |
The mouse cursor needs not to be visible, so we make it invisible.
device->getCursorControl()->setVisible(false); |
We have done everything, so lets draw it. We also write the
current frames per second and the drawn primitives to the
caption of the window. The 'if (device->isWindowActive())'
line is optional, but prevents the engine render to set the
position of the mouse cursor after task switching when other
program are active.
int lastFPS = -1; while(device->run())
{
driver->beginScene(true, true, video::SColor(0,200,200,200));
smgr->drawAll();
driver->endScene(); int fps = driver->getFPS();
if (lastFPS != fps)
{
core::stringw str = L"Irrlicht Engine - Quake 3 Map example [";
str += driver->getName();
str += "] FPS:";
str += fps;
device->setWindowCaption(str.c_str());
lastFPS = fps;
}
}
|
In the end, delete the Irrlicht device.
device->drop();
return 0;
} |
That's it. Compile and play around with the program.
