//---------------------------------------------------------------
#endregion
//---------------------------------------------------------------
//---------------------------------------------------------------
#region Initialisation
//---------------------------------------------------------------
/// <summary>
/// Creates a new model.
/// </summary>
/// <param name="mesh">Mesh to use for model.</param>
/// <param name="skeleton">Skeleton to use for the model or null.</param>
public Model(IAnimatedMesh mesh, Skeleton skeleton)
{
this.mesh = mesh;
Skeleton = skeleton;
}
static void Main(string[] args)
{
/*
* 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
DriverType driverType;
// Ask user to select driver:
StringBuilder sb = new StringBuilder();
sb.AppendLine("Please select the driver you want for this example:");
sb.AppendLine("(a) Direct3D 9.0c\n(b) Direct3D 8.1\n(c) OpenGL 1.5");
sb.AppendLine("(d) Software Renderer\nApfelbaum Software Renderer");
sb.AppendLine("(f) Null Device\n(otherKey) exit\n\n");
// Get the user's input:
TextReader tIn = Console.In;
TextWriter tOut = Console.Out;
tOut.Write(sb.ToString());
string input = tIn.ReadLine();
// Select device based on user's input:
switch (input)
{
case "a":
driverType = DriverType.DIRECT3D9;
break;
case "b":
driverType = DriverType.DIRECT3D8;
break;
case "c":
driverType = DriverType.OPENGL;
break;
case "d":
driverType = DriverType.SOFTWARE;
break;
case "e":
driverType = DriverType.SOFTWARE2;
break;
case "f":
driverType = DriverType.NULL_DRIVER;
break;
default:
return;
}
// Create device and exit if creation fails:
IrrlichtDevice device = new IrrlichtDevice(driverType, new Dimension2D(1024, 768), 32, true, true, true);
if (device == null)
{
tOut.Write("Device creation failed.");
return;
}
/*
* Get a pointer to the video driver and the SceneManager so that
* we do not always have to write device->getVideoDriver() and
* device->getSceneManager().
*/
// I just left these lines here for example purposes:
//irrv.IVideoDriver driver = device.VideoDriver;
//irrs.ISceneManager smgr = device.SceneManager;
/*
* 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.
*/
// I changed this to make it more obvious where to put the media files.
device.FileSystem.AddZipFileArchive(Application.StartupPath + "\\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.
*/
// I changed this to make it more obvious where to put the media files.
IAnimatedMesh mesh = device.SceneManager.GetMesh("20kdm2.bsp");
ISceneNode node = null;
if (mesh != null)
{
node = device.SceneManager.AddOctTreeSceneNode(mesh, null, 0);
}
/*
* Because the level was modelled not around the origin (0,0,0), we translate
* the whole level a little bit.
*/
if (node != null)
{
node.Position = (new Vector3D(-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).
*/
device.SceneManager.AddCameraSceneNodeFPS();
/*
* The mouse cursor needs not to be visible, so we make it invisible.
*/
device.CursorControl.Visible = 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())
{
if (device.WindowActive)
{
device.VideoDriver.BeginScene(true, true, new Color(0, 200, 200, 200));
device.SceneManager.DrawAll();
device.VideoDriver.EndScene();
int fps = device.VideoDriver.FPS;
if (lastFPS != fps)
{
device.WindowCaption = "Irrlicht Engine - Quake 3 Map example [" +
device.VideoDriver.Name + "] FPS:" + fps.ToString();
lastFPS = fps;
}
}
}
/*
* In the end, delete the Irrlicht device.
*/
// Instead of device->drop, we'll use:
GC.Collect();
}
public void runIndoorTest()
{
device = new IrrlichtDevice(SelectedDriverType,
new Dimension2D(800, 600), 16, false, true, false);
device.EventReceiver = this;
device.ResizeAble = true;
device.WindowCaption = "Irrlicht.NET indoor test";
// load some textures and meshes
ITexture texSydney = device.VideoDriver.GetTexture(@"..\..\media\sydney.bmp");
ITexture texWall = device.VideoDriver.GetTexture(@"..\..\media\wall.jpg");
ITexture texLogo = device.VideoDriver.GetTexture(@"..\..\media\irrlichtlogoaligned.jpg");
Irrlicht.Scene.IAnimatedMesh mesh =
device.SceneManager.GetMesh(@"..\..\media\sydney.md2");
if (mesh == null)
{
System.Windows.Forms.MessageBox.Show(
@"Could not load mesh ..\..\media\sydney.md2, exiting.",
"Problem starting program");
return;
}
// add a cube to the scene
ISceneNode node = device.SceneManager.AddCubeSceneNode(15,
null, -1, new Vector3D(30, -15, 0));
node.SetMaterialTexture(0, texWall);
node.SetMaterialFlag(Irrlicht.Video.MaterialFlag.LIGHTING, false);
// add an animator to the cube to make it rotate
ISceneNodeAnimator anim = device.SceneManager.CreateRotationAnimator(new Vector3D(0.2f, 0.2f, 0));
node.AddAnimator(anim);
// add animated mesh
IAnimatedMeshSceneNode anode = device.SceneManager.AddAnimatedMeshSceneNode(mesh, null, -1);
anode.SetMaterialTexture(0, texSydney);
anode.SetMaterialFlag(MaterialFlag.LIGHTING, false);
anode.Scale = new Vector3D(2, 2, 2);
anode.Position = new Vector3D(0, -20, 0);
// add a shadow
Shadow = anode.AddShadowVolumeSceneNode();
if (Shadow != null)
{
Shadow.Visible = false;
}
// where no light there no shadow
device.SceneManager.AddLightSceneNode(null, new Vector3D(20, 100, -50),
new Colorf(255, 0, 0), 200, -1);
// add quake 3 level
device.FileSystem.AddZipFileArchive("../../media/map-20kdm2.pk3");
IAnimatedMesh q3levelmesh = device.SceneManager.GetMesh("20kdm2.bsp");
ISceneNode q3node = device.SceneManager.AddOctTreeSceneNode(q3levelmesh, null, -1);
q3node.Position = new Vector3D(-1370, -130, -1400);
// create octtree triangle selector for q3 mesh
ITriangleSelector selector = device.SceneManager.CreateOctTreeTriangleSelector(
q3levelmesh.GetMesh(0), q3node, 128);
// add billboard
IBillboardSceneNode bill = device.SceneManager.AddBillboardSceneNode(null,
new Dimension2Df(20, 20), new Vector3D(0, 0, 0), -1);
bill.SetMaterialType(MaterialType.TRANSPARENT_ADD_COLOR);
bill.SetMaterialTexture(0, device.VideoDriver.GetTexture("../../media/particle.bmp"));
bill.SetMaterialFlag(MaterialFlag.LIGHTING, false);
bill.SetMaterialFlag(MaterialFlag.ZBUFFER, false);
// create camera
ICameraSceneNode cam =
device.SceneManager.AddCameraSceneNodeFPS(null, 100, 300, -1);
cam.Position = new Vector3D(20, 300, -50);
// make cursor invisible
device.CursorControl.Visible = false;
// create collision animator and add it to the camera
ISceneNodeAnimator collAnim = device.SceneManager.CreateCollisionResponseAnimator(
selector, cam,
new Vector3D(30, 50, 30), // size of ellipsoid around camera
new Vector3D(0, -3, 0), // gravity
new Vector3D(0, 50, 0), // translation
0.0005f); // sliding value
cam.AddAnimator(collAnim);
// load some font and set it into the skin
IGUIFont font = device.GUIEnvironment.GetFont("../../media/fonthaettenschweiler.bmp");
device.GUIEnvironment.Skin.Font = font;
// add some gui stuff
device.GUIEnvironment.AddMessageBox("Hello World",
"I'm a Irrlicht.NET MessageBox. Please press SPACE to close me.", true,
MessageBoxFlag.OK | MessageBoxFlag.CANCEL, null, -1);
// start drawing loop
int fps = 0;
while (device.Run())
{
if (device.WindowActive)
{
device.VideoDriver.BeginScene(true, true, new Color(255, 0, 0, 50));
// draw scene
device.SceneManager.DrawAll();
device.GUIEnvironment.DrawAll();
// do some collision testing
Line3D line = new Line3D();
line.start = cam.Position;
line.end = ((cam.Target - line.start).Normalize() * 1000.0f) + line.start;
Vector3D intersection = new Vector3D();
Triangle3D tri = new Triangle3D();
if (device.SceneManager.SceneCollisionManager.GetCollisionPoint(
line, selector, out intersection, out tri))
{
bill.Position = intersection;
Material mat = new Material();
mat.Lighting = false;
device.VideoDriver.SetTransform(TransformationState.WORLD, new Matrix4());
device.VideoDriver.SetMaterial(mat);
device.VideoDriver.Draw3DTriangle(tri, new Color(0, 255, 0, 0));
}
// draw 2d logo
device.VideoDriver.Draw2DImage(
texLogo, new Position2D(10, 10),
new Rect(0, 0, 88, 31),
new Rect(new Position2D(0, 0), device.VideoDriver.ScreenSize),
new Color(0xffffff), false);
// draw some text
font.Draw("Press 'S' to toggle the visibility of the realtime shadow.",
new Position2D(120, 20), new Color(100, 150, 200, 200));
device.VideoDriver.EndScene();
if (fps != device.VideoDriver.FPS)
{
fps = device.VideoDriver.FPS;
device.WindowCaption = "Irrlicht.NET test (primitives:" +
device.VideoDriver.PrimitiveCountDrawn + ") fps:" + fps;
}
}
}
}
public void run()
{
/* At first, we let the user select the driver type,
* then start up the engine, set a caption, and get a
* pointer to the video driver.
*/
// ask user for driver
DriverType driverType;
// Ask user to select driver:
StringBuilder sb = new StringBuilder();
sb.Append("Please select the driver you want for this example:\n");
sb.Append("\n(a) Direct3D 9.0c\n(b) Direct3D 8.1\n(c) OpenGL 1.5");
sb.Append("\n(d) Software Renderer\n(e) Apfelbaum Software Renderer");
sb.Append("\n(f) Null Device\n(otherKey) exit\n\n");
// Get the user's input:
TextReader tIn = Console.In;
TextWriter tOut = Console.Out;
tOut.Write(sb.ToString());
string input = tIn.ReadLine();
// Select device based on user's input:
switch (input)
{
case "a":
driverType = DriverType.DIRECT3D9;
break;
case "b":
driverType = DriverType.DIRECT3D8;
break;
case "c":
driverType = DriverType.OPENGL;
break;
case "d":
driverType = DriverType.SOFTWARE;
break;
case "e":
driverType = DriverType.SOFTWARE2;
break;
case "f":
driverType = DriverType.NULL_DRIVER;
break;
default:
return;
}
// Create device and exit if creation fails:
device = new IrrlichtDevice(driverType, new Dimension2D(1024, 768), 32, false, true, true);
if (device == null)
{
tOut.Write("Device creation failed.");
return;
}
/*
* Get a pointer to the video driver and the SceneManager so that
* we do not always have to write device->getVideoDriver() and
* device->getSceneManager().
*/
ISceneManager smgr = device.SceneManager;
IVideoDriver driver = device.VideoDriver;
device.FileSystem.AddZipFileArchive(path + "map-20kdm2.pk3");
IAnimatedMesh q3levelmesh = smgr.GetMesh("20kdm2.bsp");
ISceneNode q3node = null;
if (q3levelmesh != null)
{
q3node = smgr.AddOctTreeSceneNode(q3levelmesh.GetMesh(0), null, 0);
}
/*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
* OctTreeTriangleSelector, 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.*/
ITriangleSelector selector = null;
if (q3node != null)
{
q3node.Position = new Vector3D(-1370, -130, -1400);
selector = smgr.CreateOctTreeTriangleSelector(
q3levelmesh.GetMesh(0), q3node, 128);
// not implemented but not necessary
//q3node.TriangleSelector=selector;
}
/*We add a first person shooter camera to the scene for being able to 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 thing modifies
* the scene node to which it is attached to in that way, that it may no
* more move through walls and is affected by gravity. The only thing we have
* to tell the animator is how the world looks like, how big the scene node is,
* how gravity 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 automaticly, all other collision detection code below is
* for picking. And please note another cool feature: The collsion 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, 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. 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.
*/
ICameraSceneNode camera = smgr.AddCameraSceneNodeFPS(null, 100, 300, 0);
camera.Position = new Vector3D(-100, 50, -150);
ISceneNodeAnimator anim = smgr.CreateCollisionResponseAnimator(
selector, camera, new Vector3D(30, 50, 30),
new Vector3D(0, -3, 0), new Vector3D(0, 50, 0), 0);
camera.AddAnimator(anim);
/*Because collision detection is no big deal in irrlicht, I'll describe how
* to do two different types of picking in the next section. But before this,
* I'll prepare the scene a little. I need three animated characters which we
* could pick later, a dynamic light for lighting them, a billboard for drawing
* where we found an intersection, and, yes, I need to get rid of this mouse
* cursor. :)*/
//disable mouse cursor
device.CursorControl.Visible = false;
// add billboard
IBillboardSceneNode bill = smgr.AddBillboardSceneNode(
null, new Dimension2Df(20, 20), new Vector3D(), 0);
bill.SetMaterialType(MaterialType.TRANSPARENT_ADD_COLOR);
bill.SetMaterialTexture(0, driver.GetTexture(
path + "particle.bmp"));
bill.SetMaterialFlag(MaterialFlag.LIGHTING, false);
bill.SetMaterialFlag(MaterialFlag.ZBUFFER, false);
Material material = new Material();
material.Texture1 = driver.GetTexture(
path + "faerie2.bmp");
material.Lighting = true;
IAnimatedMeshSceneNode node = null;
IAnimatedMesh faerie = smgr.GetMesh(
path + "faerie.md2");
if (faerie != null)
{
node = smgr.AddAnimatedMeshSceneNode(faerie, null, 0);
node.Position = new Vector3D(-70, 0, -90);
node.SetMD2Animation(MD2AnimationType.RUN);
node.SetMaterial(0, material);
node = smgr.AddAnimatedMeshSceneNode(faerie, null, 0);
node.Position = new Vector3D(-70, 0, -30);
node.SetMD2Animation(MD2AnimationType.SALUTE);
node.SetMaterial(0, material);
node = smgr.AddAnimatedMeshSceneNode(faerie, null, 0);
node.Position = new Vector3D(-70, 0, -60);
node.SetMD2Animation(MD2AnimationType.JUMP);
node.SetMaterial(0, material);
}
material.Texture1 = null;
material.Lighting = false;
//Add a light
smgr.AddLightSceneNode(null, new Vector3D(-60, 100, 400),
new Colorf(1.0f, 1.0f, 1.0f, 1.0f), 600, 0);
/*For not making it too complicated, I'm doing picking inside the drawing
* loop. We take two pointers for storing the current and the last selected
* scene node and start the loop.*/
ISceneNode selectedSceneNode = null;
ISceneNode lastSelectedSceneNode = null;
int lastFPS = -1;
while (device.Run())
{
if (device.WindowActive)
{
device.VideoDriver.BeginScene(true, true, new Color(0, 200, 200, 200));
device.SceneManager.DrawAll();
/*After we've drawn the whole scene whit smgr->drawAll(), we'll do the
* first picking: We want to know which triangle of the world we are
* looking at. In addition, we want the exact point of the quake 3
* level we are looking at. For this, we create a 3d line starting at
* the position of the camera and going through the lookAt-target of it.
* Then we ask the collision manager if this line collides with a
* triangle of the world stored in the triangle selector. If yes, we draw
* the 3d triangle and set the position of the billboard to the intersection
* point.*/
Line3D line = new Line3D();
line.start = camera.Position;
line.end = line.start +
(camera.Target - line.start).Normalize() * 1000;
Vector3D intersection;
Triangle3D tri;
if (smgr.SceneCollisionManager.GetCollisionPoint(
line, selector, out intersection, out tri))
{
bill.Position = intersection;
driver.SetTransform(TransformationState.WORLD, new Matrix4());
driver.SetMaterial(material);
driver.Draw3DTriangle(tri, new Color(0, 255, 0, 0));
}
/*Another type of picking supported by the Irrlicht Engine is scene node
* picking based on bouding boxes. Every scene node has got a bounding box,
* and because of that, it's very fast for example to get the scene node
* which the camera looks at. Again, we ask the collision manager for this,
* and if we've got a scene node, we highlight it by disabling Lighting in
* its material, if it is not the billboard or the quake 3 level.*/
selectedSceneNode = smgr.SceneCollisionManager.
GetSceneNodeFromCameraBB(camera, 0);
if (lastSelectedSceneNode != null)
{
lastSelectedSceneNode.SetMaterialFlag(
MaterialFlag.LIGHTING, true);
}
if (selectedSceneNode == q3node ||
selectedSceneNode == bill)
{
selectedSceneNode = null;
}
if (selectedSceneNode != null)
{
selectedSceneNode.SetMaterialFlag(
MaterialFlag.LIGHTING, false);
}
lastSelectedSceneNode = selectedSceneNode;
/*That's it, we just have to finish drawing.*/
driver.EndScene();
int fps = device.VideoDriver.FPS;
if (lastFPS != fps)
{
device.WindowCaption = "Irrlicht Engine - Quake 3 Map example [" +
device.VideoDriver.Name + "] FPS:" + fps.ToString();
lastFPS = fps;
}
}
}
/*
* In the end, delete the Irrlicht device.
*/
// Instead of device->drop, we'll use:
GC.Collect();
}
public void run()
{
/* At first, we let the user select the driver type,
* then start up the engine, set a caption, and get a
* pointer to the video driver.
*/
// ask user for driver
DriverType driverType;
// Ask user to select driver:
StringBuilder sb = new StringBuilder();
sb.Append("Please select the driver you want for this example:\n");
sb.Append("\n(a) Direct3D 9.0c\n(b) Direct3D 8.1\n(c) OpenGL 1.5");
sb.Append("\n(d) Software Renderer\n(e) Apfelbaum Software Renderer");
sb.Append("\n(f) Null Device\n(otherKey) exit\n\n");
// Get the user's input:
TextReader tIn = Console.In;
TextWriter tOut = Console.Out;
string input = string.Empty;
bool shadows = false;
tOut.Write("Do you want to use realtime shadows? (y/n)");
input = tIn.ReadLine();
if (input == "y")
{
shadows = true;
}
tOut.Write(sb.ToString());
input = tIn.ReadLine();
// Select device based on user's input:
switch (input)
{
case "a":
driverType = DriverType.DIRECT3D9;
break;
case "b":
driverType = DriverType.DIRECT3D8;
break;
case "c":
driverType = DriverType.OPENGL;
break;
case "d":
driverType = DriverType.SOFTWARE;
break;
case "e":
driverType = DriverType.SOFTWARE2;
break;
case "f":
driverType = DriverType.NULL_DRIVER;
break;
default:
return;
}
/* We start like in some tutorials before. Please note that this time, the
* 'shadows' flag in createDevice() is set to true, for we want to have a
* dynamic shadow casted from an animated character. If your this example
* runs to slow, set it to false. The Irrlicht Engine checks if your hardware
* doesn't support the stencil buffer, and disables shadows by itself, but
* just in case the demo runs slow on your hardware.*/
/*
* From the unmanaged API documentation:
* stencilbuffer:
* Specifies if the stencil buffer should be enabled.
* Set this to true, if you want the engine be able to draw stencil buffer shadows.
* Note that not all devices are able to use the stencil buffer.
* If they don't no shadows will be drawn.
*/
device = new IrrlichtDevice(driverType, new Dimension2D(1024, 768), 32, false, shadows, true);
if (device == null)
{
tOut.Write("Device creation failed.");
return;
}
ISceneManager smgr = device.SceneManager;
IVideoDriver driver = device.VideoDriver;
/* For our environment, we load a .3ds file. It is a small room I modelled with
* Anim8or and exported it into the 3ds format because the Irrlicht Engine did
* not support the .an8 format when I wrote this tutorial. I am a very bad 3d
* graphic artist, and so the texture mapping is not very nice in this model.
* Luckily I am a better programmer than artist, and so the Irrlicht Engine is
* able to create a cool texture mapping for me: Just use the mesh manipulator
* and create a planar texture mapping for the mesh. If you want to see the
* mapping I made with Anim8or, uncomment this line. I also did not figure out
* how to set the material right in Anim8or, it has an emissive light color
* which I don't really like. I'll switch it off too with this code.*/
IAnimatedMesh mesh = smgr.GetMesh(
path + "room.3ds");
smgr.MeshManipulator.MakePlanarTextureMapping(
mesh.GetMesh(0), 0.008f);
ISceneNode node = smgr.AddAnimatedMeshSceneNode(mesh, null, 0);
node.SetMaterialTexture(
0, driver.GetTexture(path + "wall.jpg"));
node.GetMaterial(0).EmissiveColor.Set(0, 0, 0, 0);
// Add a shadow to the room if it is not dark enough
/* The result is interesting but not exactly what I was expecting!
* Try for yourself... I think this could be a little problem in the
* Irrlicht.NET wrapper but I promise I will investigate further to see
* if I can make it work as intended
* Forum Article (http://irrlicht.sourceforge.net/phpBB2/viewtopic.php?t=10584)
*/
// IAnimatedMeshSceneNode xnode = (IAnimatedMeshSceneNode)node;
// xnode.AddShadowVolumeSceneNode();
//
/*Now, for the first special effect: Animated water. It works like this: The
* WaterSurfaceSceneNode takes a mesh as input and makes it wave like a water
* surface. And if we let this scene node use a nice material like the
* MT_REFLECTION_2_LAYER, it looks really cool. We are doing this with the
* next few lines of code. As input mesh, we create a hill plane mesh, without
* hills. But any other mesh could be used for this, you could even use the
* room.3ds (which would look really strange) if you wanted to.*/
mesh = smgr.AddHillPlaneMesh("myHill",
new Dimension2Df(20, 20),
new Dimension2D(40, 40), new Material(), 0,
new Dimension2Df(0, 0),
new Dimension2Df(10, 10));
node = smgr.AddWaterSurfaceSceneNode(mesh.GetMesh(0), 3.0f, 300.0f, 30.0f, null, 0);
node.Position = new Vector3D(0, 7, 0);
node.SetMaterialTexture(0, driver.GetTexture(path + "water.jpg"));
node.SetMaterialTexture(1, driver.GetTexture(path + "stones.jpg"));
node.SetMaterialType(MaterialType.REFLECTION_2_LAYER);
/*The second special effect is very basic, I bet you saw it already in some
* Irrlicht Engine demos: A transparent billboard combined with a dynamic light.
* We simply create a light scene node, let it fly around, an to make it look
* more cool, we attach a billboard scene node to it.*/
// create light
node = smgr.AddLightSceneNode(null, new Vector3D(0, 0, 0),
new Colorf(1.0f, 0.6f, 0.7f, 1.0f), 600.0f, 0);
ISceneNodeAnimator anim = smgr.CreateFlyCircleAnimator(new Vector3D(0, 150, 0), 250.0f, 0.0005f);
node.AddAnimator(anim);
// attach billboard to light
node = smgr.AddBillboardSceneNode(node, new Dimension2Df(50, 50), new Vector3D(), 0);
node.SetMaterialFlag(MaterialFlag.LIGHTING, false);
node.SetMaterialType(MaterialType.TRANSPARENT_ADD_COLOR);
node.SetMaterialTexture(0,
driver.GetTexture(path + "particlewhite.bmp"));
/* The next special effect is a lot more interesting: A particle system. The
* particle system in the Irrlicht Engine is quit modular and extensible and
* yet easy to use. There is a particle system scene node into which you can
* put particle emitters, which make particles come out of nothing. These
* emitters are quite flexible and usually have lots of parameters like
* direction, amount and color of the particles they should create.
* There are different emitters, for example a point emitter which lets
* particles pop out at a fixed point. If the particle emitters available
* in the engine are not enough for you, you can easily create your own ones,
* you'll simply have to create a class derived from the IParticleEmitter
* interface and attach it to the particle system using setEmitter().
* In this example we create a box particle emitter, which creates particles
* randomly inside a box. The parameters define the box, direction of the
* articles, minimal and maximal new particles per second, color and minimal
* and maximal livetime of the particles. Because only with emitters particle
* system would be a little bit boring, there are particle affectors, which
* modify particles during they fly around. They can be added to the particle
* system, simulating additional effects like gravity or wind. The particle
* affector we use in this example is an affector, which modifies the color
* of the particles: It lets them fade out. Like the particle emitters,
* additional particle affectors can also be implemented by you, simply derive
* a class from IParticleAffector and add it with addAffector(). After we set
* a nice material to the particle system, we have a cool looking camp fire.
* By adjusting material, texture, particle emitter and affector parameters,
* it is also easily possible to create smoke, rain, explosions, snow, and
* so on.*/
IParticleSystemSceneNode ps = smgr.AddParticleSystemSceneNode(
false, null, 0, new Vector3D(-70, 60, 40), new Vector3D(), new Vector3D(2, 2, 2));
ps.ParticleSize = new Dimension2Df(20, 10);
IParticleEmitter em = ps.CreateBoxEmitter(
new Box3D(-7, 0, -7, 7, 1, 7), new Vector3D(0.0f, 0.03f, 0.0f),
80, 100,
new Color(0, 255, 255, 255), new Color(0, 255, 255, 255),
800, 2000, 0);
ps.SetEmitter(em);
IParticleAffector paf =
ps.CreateFadeOutParticleAffector(new Color(), 1500);
ps.AddAffector(paf);
ps.SetMaterialFlag(MaterialFlag.LIGHTING, false);
ps.SetMaterialTexture(0,
driver.GetTexture(path + "particle.bmp"));
ps.SetMaterialType(MaterialType.TRANSPARENT_VERTEX_ALPHA);
/*As our last special effect, we want a dynamic shadow be casted from an animated
* character. For this we load a quake 2 .md2 model and place it into our world.
* For creating the shadow, we simply need to call addShadowVolumeSceneNode(). The
* color of shadows is only adjustable globally for all shadows, by calling
* ISceneManager::setShadowColor(). Voila, here is our dynamic shadow. Because
* the character is a little bit too small for this scene, we make it bigger
* using setScale(). And because the character is lighted by a dynamic light,
* we need to normalize the normals to make the lighting on it correct. This
* is always necessary if the scale of a dynamic lighted model is not (1,1,1).
* Otherwise it would get too dark or too bright because the normals will be
* scaled too.*/
mesh = smgr.GetMesh(path + "faerie.md2");
IAnimatedMeshSceneNode anode = smgr.AddAnimatedMeshSceneNode(mesh, null, 0);
anode.Position = new Vector3D(-50, 45, -60);
anode.SetMD2Animation(MD2AnimationType.STAND);
anode.SetMaterialTexture(0,
driver.GetTexture(path + "Faerie5.BMP"));
// add shadow
anode.AddShadowVolumeSceneNode();
smgr.ShadowColor = new Color(220, 0, 0, 0);
// make the model a little bit bigger and normalize its normals
// because of this for correct lighting
anode.Scale = new Vector3D(2, 2, 2);
anode.SetMaterialFlag(MaterialFlag.NORMALIZE_NORMALS, true);
/*Finally we simply have to draw everything, that's all.*/
ICameraSceneNode camera = smgr.AddCameraSceneNodeFPS();
camera.Position = new Vector3D(-50, 50, -150);
// Remove the mouse cursor:
device.CursorControl.Visible = false;
int lastFPS = -1;
while (device.Run())
{
if (device.WindowActive)
{
device.VideoDriver.BeginScene(true, true, new Color(0, 200, 200, 200));
device.SceneManager.DrawAll();
device.VideoDriver.EndScene();
int fps = device.VideoDriver.FPS;
if (lastFPS != fps)
{
device.WindowCaption = "Irrlicht Engine - SpecialFX tutorial [" +
device.VideoDriver.Name + "] FPS:" + fps.ToString();
lastFPS = fps;
}
}
}
/*
* In the end, delete the Irrlicht device.
*/
// Instead of device->drop, we'll use:
GC.Collect();
}
