scene::ISceneNode * node = smgr->addSphereSceneNode();
        if (node)
        {
                node->setPosition(core::vector3df(0,0,30));
                node->setMaterialTexture(0, driver->getTexture("../../media/wall.bmp"));
                node->setMaterialFlag(video::EMF_LIGHTING, false);
        }

IAnimatedMesh* mesh = smgr->getMesh("../../media/deinedatei.md2"); 
IAnimatedMeshSceneNode* node = smgr->addAnimatedMeshSceneNode( mesh );

#ifdef _MSC_VER
// We'll also define this to stop MSVC complaining about sprintf().
#define _CRT_SECURE_NO_WARNINGS
#pragma comment(lib, "Irrlicht.lib")
#endif

#include <irrlicht.h>
#include <iostream>

using namespace irr;
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];
};
int main()
{
        // let user select driver type

        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) Burning's 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_BURNINGSVIDEO;break;
                case 'f': driverType = video::EDT_NULL;     break;
                default: return 0;
        }       

        // create device
        MyEventReceiver receiver;

        IrrlichtDevice* device = createDevice(driverType,
                        core::dimension2d<s32>(640, 480), 16, false, false, false, &receiver);

        if (device == 0)
                return 1; // could not create selected driver.

        video::IVideoDriver* driver = device->getVideoDriver();
        scene::ISceneManager* smgr = device->getSceneManager();
        scene::ISceneNode * node = smgr->addSphereSceneNode();
        if (node)
        {
                node->setPosition(core::vector3df(0,0,30));
                node->setMaterialTexture(0, driver->getTexture("wall.bmp"));
                node->setMaterialFlag(video::EMF_LIGHTING, false);
        }
        scene::ISceneNode* n = smgr->addCubeSceneNode();

        if (n)
        {
                n->setMaterialTexture(0, driver->getTexture("t351sml.jpg"));
                n->setMaterialFlag(video::EMF_LIGHTING, false);
                scene::ISceneNodeAnimator* anim =
                        smgr->createFlyCircleAnimator(core::vector3df(0,0,30), 20.0f);
                if (anim)
                {
                        n->addAnimator(anim);
                        anim->drop();
                }
        }
        scene::IAnimatedMesh* mesh = smgr->getMesh("Noppe4_objekt.obj");
               IAnimatedMeshSceneNode* node = smgr->addAnimatedMeshSceneNode( mesh );

        if (anms)
        {
                scene::ISceneNodeAnimator* anim =
                        smgr->createFlyStraightAnimator(core::vector3df(100,0,60),
                        core::vector3df(-100,0,60), 3500, true);
                if (anim)
                {
                        anms->addAnimator(anim);
                        anim->drop();
                }
                anms->setMaterialFlag(video::EMF_LIGHTING, false);

                anms->setFrameLoop(0, 14);
                anms->setAnimationSpeed(15);
//              anms->setMD2Animation(scene::EMAT_RUN);

                anms->setScale(core::vector3df(2.f,2.f,2.f));
                anms->setRotation(core::vector3df(0,-90,0));
//              anms->setMaterialTexture(0, driver->getTexture("../../media/sydney.bmp"));

        }
        smgr->addCameraSceneNodeFPS(0, 100.0f, .1f);
        device->getCursorControl()->setVisible(false);
        device->getGUIEnvironment()->addImage(
                driver->getTexture("irrlichtlogoalpha2.tga"),
                core::position2d<s32>(10,20));

        gui::IGUIStaticText* diagnostics = device->getGUIEnvironment()->addStaticText(
                L"", core::rect<s32>(10, 10, 400, 20));
        diagnostics->setOverrideColor(video::SColor(255, 255, 255, 0));
        int lastFPS = -1;

        // In order to do framerate independent movement, we have to know
        // how long it was since the last frame
        u32 then = device->getTimer()->getTime();

        // This is the movemen speed in units per second.
        const f32 MOVEMENT_SPEED = 5.f;

        while(device->run())
        {
                // Work out a frame delta time.
                const u32 now = device->getTimer()->getTime();
                const f32 frameDeltaTime = (f32)(now - then) / 1000.f; // Time in seconds
                then = now;
                core::vector3df nodePosition = node->getPosition();

                if(receiver.IsKeyDown(irr::KEY_KEY_W))
                        nodePosition.Y += MOVEMENT_SPEED * frameDeltaTime;
                else if(receiver.IsKeyDown(irr::KEY_KEY_S))
                        nodePosition.Y -= MOVEMENT_SPEED * frameDeltaTime;

                if(receiver.IsKeyDown(irr::KEY_KEY_A))
                        nodePosition.X -= MOVEMENT_SPEED * frameDeltaTime;
                else if(receiver.IsKeyDown(irr::KEY_KEY_D))
                        nodePosition.X += MOVEMENT_SPEED * frameDeltaTime;

                node->setPosition(nodePosition);

                driver->beginScene(true, true, video::SColor(255,113,113,133));

                smgr->drawAll(); // draw the 3d scene
                device->getGUIEnvironment()->drawAll(); // draw the gui environment (the logo)

                driver->endScene();

                int fps = driver->getFPS();

                if (lastFPS != fps)
                {
                        core::stringw tmp(L"Movement Example - Irrlicht Engine [");
                        tmp += driver->getName();
                        tmp += L"] fps: ";
                        tmp += fps;

                        device->setWindowCaption(tmp.c_str());
                        lastFPS = fps;
                }
        }
        device->drop();
        
        return 0;
}