+

A tutorial by geoff.

+

In this tutorial we'll learn how to create custom meshes and deal with them with Irrlicht. We'll create an interesting heightmap with some lighting effects. With keys 1,2,3 you can choose a different mesh layout, which is put into the mesh buffers as desired. All positions, normals, etc. are updated accordingly.

+

Ok, let's start with the headers (I think there's nothing to say about it)

#include <irrlicht.h>
#include "driverChoice.h"
#ifdef _MSC_VER
#pragma comment(lib, "Irrlicht.lib")
#endif
//Namespaces for the engine
using namespace irr;
using namespace video;
using namespace core;
using namespace scene;
using namespace io;
using namespace gui;

This is the type of the functions which work out the colour.

typedef SColor colour_func(f32 x, f32 y, f32 z);

Here comes a set of functions which can be used for coloring the nodes while creating the mesh.

// Greyscale, based on the height.
SColor grey(f32, f32, f32 z)
{
    u32 n = (u32)(255.f * z);
    return SColor(255, n, n, n);
}
// Interpolation between blue and white, with red added in one
// direction and green in the other.
SColor yellow(f32 x, f32 y, f32)
{
    return SColor(255, 128 + (u32)(127.f * x), 128 + (u32)(127.f * y), 255);
}
// Pure white.
SColor white(f32, f32, f32) { return SColor(255, 255, 255, 255); }

The type of the functions which generate the heightmap. x and y range between -0.5 and 0.5, and s is the scale of the heightmap.

typedef f32 generate_func(s16 x, s16 y, f32 s);
// An interesting sample function :-)
f32 eggbox(s16 x, s16 y, f32 s)
{
    const f32 r = 4.f*sqrtf((f32)(x*x + y*y))/s;
    const f32 z = expf(-r * 2) * (cosf(0.2f * x) + cosf(0.2f * y));
    return 0.25f+0.25f*z;
}
// A rather dumb sine function :-/
f32 moresine(s16 x, s16 y, f32 s)
{
    const f32 xx=0.3f*(f32)x/s;
    const f32 yy=12*y/s;
    const f32 z = sinf(xx*xx+yy)*sinf(xx+yy*yy);
    return 0.25f + 0.25f * z;
}
// A simple function
f32 justexp(s16 x, s16 y, f32 s)
{
    const f32 xx=6*x/s;
    const f32 yy=6*y/s;
    const f32 z = (xx*xx+yy*yy);
    return 0.3f*z*cosf(xx*yy);
}

A simple class for representing heightmaps. Most of this should be obvious.

class HeightMap
{
private:
    const u16 Width;
    const u16 Height;
    f32 s;
    core::array<f32> data;
public:
    HeightMap(u16 _w, u16 _h) : Width(_w), Height(_h), s(0.f), data(0)
    {
        s = sqrtf((f32)(Width * Width + Height * Height));
        data.set_used(Width * Height);
    }
    // Fill the heightmap with values generated from f.
    void generate(generate_func f)
    {
        u32 i=0;
        for(u16 y = 0; y < Height; ++y)
            for(u16 x = 0; x < Width; ++x)
                set(i++, calc(f, x, y));
    }
    u16 height() const { return Height; }
    u16 width() const { return Width; }
    f32 calc(generate_func f, u16 x, u16 y) const
    {
        const f32 xx = (f32)x - Width*0.5f;
        const f32 yy = (f32)y - Height*0.5f;
        return f((u16)xx, (u16)yy, s);
    }
    // The height at (x, y) is at position y * Width + x.
    void set(u16 x, u16 y, f32 z) { data[y * Width + x] = z; }
    void set(u32 i, f32 z) { data[i] = z; }
    f32 get(u16 x, u16 y) const { return data[y * Width + x]; }

The only difficult part. This considers the normal at (x, y) to be the cross product of the vectors between the adjacent points in the horizontal and vertical directions.

+

s is a scaling factor, which is necessary if the height units are different from the coordinate units; for example, if your map has heights in metres and the coordinates are in units of a kilometer.

    vector3df getnormal(u16 x, u16 y, f32 s) const
    {
        const f32 zc = get(x, y);
        f32 zl, zr, zu, zd;
        if (x == 0)
        {
            zr = get(x + 1, y);
            zl = zc + zc - zr;
        }
        else if (x == Width - 1)
        {
            zl = get(x - 1, y);
            zr = zc + zc - zl;
        }
        else
        {
            zr = get(x + 1, y);
            zl = get(x - 1, y);
        }
        if (y == 0)
        {
            zd = get(x, y + 1);
            zu = zc + zc - zd;
        }
        else if (y == Height - 1)
        {
            zu = get(x, y - 1);
            zd = zc + zc - zu;
        }
        else
        {
            zd = get(x, y + 1);
            zu = get(x, y - 1);
        }
        return vector3df(s * 2 * (zl - zr), 4, s * 2 * (zd - zu)).normalize();
    }
};

A class which generates a mesh from a heightmap.

class TMesh
{
private:
    u16 Width;
    u16 Height;
    f32 Scale;
public:
    SMesh* Mesh;
    TMesh() : Mesh(0), Width(0), Height(0), Scale(1.f)
    {
        Mesh = new SMesh();
    }
    ~TMesh()
    {
        Mesh->drop();
    }
    // Unless the heightmap is small, it won't all fit into a single
    // SMeshBuffer. This function chops it into pieces and generates a
    // buffer from each one.
    void init(const HeightMap &hm, f32 scale, colour_func cf, IVideoDriver *driver)
    {
        Scale = scale;
        const u32 mp = driver -> getMaximalPrimitiveCount();
        Width = hm.width();
        Height = hm.height();
        
        const u32 sw = mp / (6 * Height); // the width of each piece
        u32 i=0;
        for(u32 y0 = 0; y0 < Height; y0 += sw)
        {
            u16 y1 = y0 + sw;
            if (y1 >= Height)
                y1 = Height - 1; // the last one might be narrower
            addstrip(hm, cf, y0, y1, i);
            ++i;
        }
        if (i<Mesh->getMeshBufferCount())
        {
            // clear the rest
            for (u32 j=i; j<Mesh->getMeshBufferCount(); ++j)
            {
                Mesh->getMeshBuffer(j)->drop();
            }
            Mesh->MeshBuffers.erase(i,Mesh->getMeshBufferCount()-i);
        }
        // set dirty flag to make sure that hardware copies of this
        // buffer are also updated, see IMesh::setHardwareMappingHint
        Mesh->setDirty();
        Mesh->recalculateBoundingBox();
    }
    // Generate a SMeshBuffer which represents all the vertices and
    // indices for values of y between y0 and y1, and add it to the
    // mesh.
    void addstrip(const HeightMap &hm, colour_func cf, u16 y0, u16 y1, u32 bufNum)
    {
        SMeshBuffer *buf = 0;
        if (bufNum<Mesh->getMeshBufferCount())
        {
            buf = (SMeshBuffer*)Mesh->getMeshBuffer(bufNum);
        }
        else
        {
            // create new buffer
            buf = new SMeshBuffer();
            Mesh->addMeshBuffer(buf);
            // to simplify things we drop here but continue using buf
            buf->drop();
        }
        buf->Vertices.set_used((1 + y1 - y0) * Width);
        u32 i=0;
        for (u16 y = y0; y <= y1; ++y)
        {
            for (u16 x = 0; x < Width; ++x)
            {
                const f32 z = hm.get(x, y);
                const f32 xx = (f32)x/(f32)Width;
                const f32 yy = (f32)y/(f32)Height;
                S3DVertex& v = buf->Vertices[i++];
                v.Pos.set(x, Scale * z, y);
                v.Normal.set(hm.getnormal(x, y, Scale));
                v.Color=cf(xx, yy, z);
                v.TCoords.set(xx, yy);
            }
        }
        buf->Indices.set_used(6 * (Width - 1) * (y1 - y0));
        i=0;
        for(u16 y = y0; y < y1; ++y)
        {
            for(u16 x = 0; x < Width - 1; ++x)
            {
                const u16 n = (y-y0) * Width + x;
                buf->Indices[i]=n;
                buf->Indices[++i]=n + Width;
                buf->Indices[++i]=n + Width + 1;
                buf->Indices[++i]=n + Width + 1;
                buf->Indices[++i]=n + 1;
                buf->Indices[++i]=n;
                ++i;
            }
        }
        buf->recalculateBoundingBox();
    }
};

Our event receiver implementation, taken from tutorial 4.

class MyEventReceiver : public IEventReceiver
{
public:
    // This is the one method that we have to implement
    virtual bool OnEvent(const SEvent& event)
    {
        // Remember whether each key is down or up
        if (event.EventType == irr::EET_KEY_INPUT_EVENT)
            KeyIsDown[event.KeyInput.Key] = event.KeyInput.PressedDown;
        return false;
    }
    // This is used to check whether a key is being held down
    virtual bool IsKeyDown(EKEY_CODE keyCode) const
    {
        return KeyIsDown[keyCode];
    }
    MyEventReceiver()
    {
        for (u32 i=0; i<KEY_KEY_CODES_COUNT; ++i)
            KeyIsDown[i] = false;
    }
private:
    // We use this array to store the current state of each key
    bool KeyIsDown[KEY_KEY_CODES_COUNT];
};

Much of this is code taken from some of the examples. We merely set up a mesh from a heightmap, light it with a moving light, and allow the user to navigate around it.

int main(int argc, char* argv[])
{
    // ask user for driver
    video::E_DRIVER_TYPE driverType=driverChoiceConsole();
    if (driverType==video::EDT_COUNT)
        return 1;
    MyEventReceiver receiver;
    IrrlichtDevice* device = createDevice(driverType,
            core::dimension2du(800, 600), 32, false, false, false,
            &receiver);
    if(device == 0)
        return 1;
 
    IVideoDriver *driver = device->getVideoDriver();
    ISceneManager *smgr = device->getSceneManager();
    device->setWindowCaption(L"Irrlicht Example for SMesh usage.");

Create the custom mesh and initialize with a heightmap

TMesh mesh;
HeightMap hm = HeightMap(255, 255);
hm.generate(eggbox);
mesh.init(hm, 50.f, grey, driver);
// Add the mesh to the scene graph
IMeshSceneNode* meshnode = smgr -> addMeshSceneNode(mesh.Mesh);
meshnode->setMaterialFlag(video::EMF_BACK_FACE_CULLING, false);
// light is just for nice effects
ILightSceneNode *node = smgr->addLightSceneNode(0, vector3df(0,100,0),
    SColorf(1.0f, 0.6f, 0.7f, 1.0f), 500.0f);
if (node)
{
    node->getLightData().Attenuation.set(0.f, 1.f/500.f, 0.f);
    ISceneNodeAnimator* anim = smgr->createFlyCircleAnimator(vector3df(0,150,0),250.0f);
    if (anim)
    {
        node->addAnimator(anim);
        anim->drop();
    }
}
ICameraSceneNode* camera = smgr->addCameraSceneNodeFPS();
if (camera)
{
    camera->setPosition(vector3df(-20.f, 150.f, -20.f));
    camera->setTarget(vector3df(200.f, -80.f, 150.f));
    camera->setFarValue(20000.0f);
}

Just a usual render loop with event handling. The custom mesh is a usual part of the scene graph which gets rendered by drawAll.

    while(device->run())
    {
        if(!device->isWindowActive())
        {
            device->sleep(100);
            continue;
        }
        if(receiver.IsKeyDown(irr::KEY_KEY_W))
        {
            meshnode->setMaterialFlag(video::EMF_WIREFRAME, !meshnode->getMaterial(0).Wireframe);
        }
        else if(receiver.IsKeyDown(irr::KEY_KEY_1))
        {
            hm.generate(eggbox);
            mesh.init(hm, 50.f, grey, driver);
        }
        else if(receiver.IsKeyDown(irr::KEY_KEY_2))
        {
            hm.generate(moresine);
            mesh.init(hm, 50.f, yellow, driver);
        }
        else if(receiver.IsKeyDown(irr::KEY_KEY_3))
        {
            hm.generate(justexp);
            mesh.init(hm, 50.f, yellow, driver);
        }
        driver->beginScene(true, true, SColor(0xff000000));
        smgr->drawAll();
        driver->endScene();
    }
    device->drop();
    return 0;
}

That's it! Just compile and play around with the program.

+