Tutoriel Irrlicht 20

#include <irrlicht.h>
#include "driverChoice.h"

using namespace irr;
using namespace core;

#if defined(_MSC_VER)
#pragma comment(lib, "Irrlicht.lib")
#endif // MSC_VER

class CMyLightManager : public scene::ILightManager, public IEventReceiver
{
    typedef enum
    {
        NO_MANAGEMENT,
        LIGHTS_NEAREST_NODE,
        LIGHTS_IN_ZONE
    }
    LightManagementMode;

    LightManagementMode Mode;
    LightManagementMode RequestedMode;

    // Ces données représentent les informations sur l'état qui intéressent ce gestionnaire de lumière.
    scene::ISceneManager * SceneManager;
    core::array<scene::ISceneNode*> * SceneLightList;
    scene::E_SCENE_NODE_RENDER_PASS CurrentRenderPass;
    scene::ISceneNode * CurrentSceneNode;

public:
    CMyLightManager(scene::ISceneManager* sceneManager)
        : Mode(NO_MANAGEMENT), RequestedMode(NO_MANAGEMENT),
        SceneManager(sceneManager), SceneLightList(0),
        CurrentRenderPass(scene::ESNRP_NONE), CurrentSceneNode(0)
    { }

    // L'interface d'entrée d'événement, qui change juste la stratégie du gestionnaire de lumière.
    bool OnEvent(const SEvent & event)
    {
        bool handled = false;

        if (event.EventType == irr::EET_KEY_INPUT_EVENT && event.KeyInput.PressedDown)
        {
            handled = true;
            switch(event.KeyInput.Key)
            {
            case irr::KEY_KEY_1:
                RequestedMode = NO_MANAGEMENT;
                break;
            case irr::KEY_KEY_2:
                RequestedMode = LIGHTS_NEAREST_NODE;
                break;
            case irr::KEY_KEY_3:
                RequestedMode = LIGHTS_IN_ZONE;
                break;
            default:
                handled = false;
                break;
            }

            if(NO_MANAGEMENT == RequestedMode)
                SceneManager->setLightManager(0); // Montre que c'est sûr d'enregistrer le gestionnaire de lumière.
            else
                SceneManager->setLightManager(this);
        }

        return handled;
    }


    // Ceci est appelé avant que le premier nœud de scène ne soit dessiné.
    virtual void OnPreRender(core::array<scene::ISceneNode*> & lightList)
    {
        // Met à jour le mode ; le changer ici permet de s'assurer qu'on reste cohérent tout au long du rendu
        Mode = RequestedMode;

        // Stocke la liste de lumières. Je suis libre de changer cette liste jusqu'à la fin de OnPostRender().
        SceneLightList = &lightList;
    }

    // Appelé après que le dernier nœud de scène a été dessiné
    virtual void OnPostRender()
    {
        // Comme le gestionnaire de lumière a pu être éteint dans le gestionnaire d'événements, nous allumerons toutes les lumières
        // pour nous assurer qu'elles sont dans un état cohérent. Normalement, vous n'aurez pas à le faire quand vous utilisez un gestionnaire de lumière,
        // puisque vous continuez à faire vous-même la gestion des lumières.
        for (u32 i = 0; i < SceneLightList->size(); i++)
            (*SceneLightList)[i]->setVisible(true);
    }

    virtual void OnRenderPassPreRender(scene::E_SCENE_NODE_RENDER_PASS renderPass)
    {
        // Je n'ai rien à faire ici sauf me souvenir dans quelle passe de dessin je suis.
        CurrentRenderPass = renderPass;
    }

    virtual void OnRenderPassPostRender(scene::E_SCENE_NODE_RENDER_PASS renderPass)
    {
        // Je veux seulement que les nœuds solides soient allumés, donc après la passe solide, j'éteins toutes les lumières.
        if (scene::ESNRP_SOLID == renderPass)
        {
            for (u32 i = 0; i < SceneLightList->size(); ++i)
                (*SceneLightList)[i]->setVisible(false);
        }
    }

    // Ceci est appelé avant qu'un nœud de scène spécifique ne soit dessiné.
    virtual void OnNodePreRender(scene::ISceneNode* node)
    {
        CurrentSceneNode = node;

        // Ce gestionnaire de lumière ne prend en compte que les objets solides, mais vous êtes libre de manipuler les lumières pendant n'importe quelle phase, 
        //selon vos besoins.
        if (scene::ESNRP_SOLID != CurrentRenderPass)
            return;

        // En fait dans cet exemple, je veux seulement prendre en compte l'éclairage pour les nœuds de scène cubes.
        // Vous voudrez probablement vous occuper de l'éclairage pour (au moins) les nœuds de scènes de mesh animés ou non de la même manière.
        if (node->getType() != scene::ESNT_CUBE)
            return;

        if (LIGHTS_NEAREST_NODE == Mode)
        {
            // Ceci est une implémentation naïve qui donne une priorité à chaque lumière de la scène selon sa proximité au nœud en train d'être dessiné.
            // Cela produit quelques clignotements quand l'orbite de la lumière est plus proche d'un cube que sa 'zone' de lumière.
            const vector3df nodePosition = node->getAbsolutePosition();

            // Trie la liste de lumières par priorité basée sur leur distance avec le nœud qui est en train d'être dessiné.
            array<LightDistanceElement> sortingArray;
            sortingArray.reallocate(SceneLightList->size());

            u32 i;
            for(i = 0; i < SceneLightList->size(); ++i)
            {
                scene::ISceneNode* lightNode = (*SceneLightList)[i];
                const f64 distance = lightNode->getAbsolutePosition().getDistanceFromSQ(nodePosition);
                sortingArray.push_back(LightDistanceElement(lightNode, distance));
            }

            sortingArray.sort();

            // La liste est maintenant triée par distance avec le nœud.
            // Allume les trois lumières les plus proches et éteint les autres.
            for(i = 0; i < sortingArray.size(); ++i)
                sortingArray[i].node->setVisible(i < 3);
        }
        else if(LIGHTS_IN_ZONE == Mode)
        {
            // Des nœuds de scènes vides sont utilisés pour représenter des 'zones'.  Pour chaque mesh solide qui
            // est en train d'être dessiné, éteint toutes les lumières puis cherche sa 'zone' parente et allume
            // toutes les lumières qui sont trouvées sous ce nœud dans le graphe de scène.
            // Ceci est un algorithme général dont le but est de ne nécessiter aucune connaissance
            // spéciale sur la manière dont ce graphe de scène particulier est organisé.
            for (u32 i = 0; i < SceneLightList->size(); ++i)
            {
                if ((*SceneLightList)[i]->getType() != scene::ESNT_LIGHT)
                    continue;
                scene::ILightSceneNode* lightNode = static_cast<scene::ILightSceneNode*>((*SceneLightList)[i]);
                video::SLight & lightData = lightNode->getLightData();

                if (video::ELT_DIRECTIONAL != lightData.Type)
                    lightNode->setVisible(false);
            }

            scene::ISceneNode * parentZone = findZone(node);
            if (parentZone)
                turnOnZoneLights(parentZone);
        }
    }

    // Appelé après que le nœud de scène spécifié est dessiné.
    virtual void OnNodePostRender(scene::ISceneNode* node)
    {
        // Je n'ai besoin de rien faire sur les lumières après les dessins individuels de nœuds.
    }

private:

    // Trouve le nœud de scène vide qui est le parent du nœud de scène spécifié
    scene::ISceneNode * findZone(scene::ISceneNode * node)
    {
        if (!node)
            return 0;

        if (node->getType() == scene::ESNT_EMPTY)
            return node;

        return findZone(node->getParent());
    }

    // Allume toutes les lumières qui sont fils (directement ou indirectement) du nœud de scène spécifié.
    void turnOnZoneLights(scene::ISceneNode * node)
    {
        core::list<scene::ISceneNode*> const & children = node->getChildren();
        for (core::list<scene::ISceneNode*>::ConstIterator child = children.begin();
            child != children.end(); ++child)
        {
            if ((*child)->getType() == scene::ESNT_LIGHT)
                (*child)->setVisible(true);
            else // Suppose que les lumières ne possèdent pas d'enfant qui soient des lumières
                turnOnZoneLights(*child);
        }
    }


    // Une classe utile pour aider à trier les nœuds de scènes avec un ordre de distance
    class LightDistanceElement
    {
    public:
        LightDistanceElement() {};

        LightDistanceElement(scene::ISceneNode* n, f64 d)
            : node(n), distance(d) { }

        scene::ISceneNode* node;
        f64 distance;

        // Les éléments ayant une plus petite distance sont au début du tableau.
        bool operator < (const LightDistanceElement& other) const
        {
            return (distance < other.distance);
        }
    };
};

int main(int argumentCount, char * argumentValues[])
{
    // Demande un pilote à l'utilisateur
    video::E_DRIVER_TYPE driverType=driverChoiceConsole();
    if (driverType==video::EDT_COUNT)
        return 1;

    IrrlichtDevice *device = createDevice(driverType,
            dimension2d<u32>(640, 480), 32);

    if(!device)
        return -1;

    f32 const lightRadius = 60.f; // Assez pour atteindre le côté éloigné de chaque 'zone'.

    video::IVideoDriver* driver = device->getVideoDriver();
    scene::ISceneManager* smgr = device->getSceneManager();
    gui::IGUIEnvironment* guienv = device->getGUIEnvironment();

    gui::IGUISkin* skin = guienv->getSkin();
    if (skin)
    {
        skin->setColor(gui::EGDC_BUTTON_TEXT, video::SColor(255, 255, 255, 255));
        gui::IGUIFont* font = guienv->getFont("../../media/fontlucida.png");
        if(font)
            skin->setFont(font);
    }

    guienv->addStaticText(L"1 - No light management", core::rect<s32>(10,10,200,30));
    guienv->addStaticText(L"2 - Closest 3 lights", core::rect<s32>(10,30,200,50));
    guienv->addStaticText(L"3 - Lights in zone", core::rect<s32>(10,50,200,70));

    for(f32 zoneX = -100.f; zoneX <= 100.f; zoneX += 50.f)
        for(f32 zoneY = -60.f; zoneY <= 60.f; zoneY += 60.f)
        {
            //Commence avec un nœud de scène vide qui nous utiliserons pour représenter une zone.
            scene::ISceneNode * zoneRoot = smgr->addEmptySceneNode();
            zoneRoot->setPosition(vector3df(zoneX, zoneY, 0));

            // Chaque zone contient un cube tournant sur lui-même.
            scene::IMeshSceneNode * node = smgr->addCubeSceneNode(15, zoneRoot);
            scene::ISceneNodeAnimator * rotation = smgr->createRotationAnimator(vector3df(0.25f, 0.5f, 0.75f));
            node->addAnimator(rotation);
            rotation->drop();

            // Chaque cube a trois lumières qui lui sont attachées. Les lumières sont attachées à un panneau donc
            // nous pouvons voir où elles sont. Le panneau est attaché au cube ainsi les 
            // lumières sont, comme le cube, des descendantes indirectes du même nœud de scène vide.
            scene::IBillboardSceneNode * billboard = smgr->addBillboardSceneNode(node);
            billboard->setPosition(vector3df(0, -14, 30));
            billboard->setMaterialType(video::EMT_TRANSPARENT_ADD_COLOR );
            billboard->setMaterialTexture(0, driver->getTexture("../../media/particle.bmp"));
            billboard->setMaterialFlag(video::EMF_LIGHTING, false);
            smgr->addLightSceneNode(billboard, vector3df(0, 0, 0), video::SColorf(1, 0, 0), lightRadius);

            billboard = smgr->addBillboardSceneNode(node);
            billboard->setPosition(vector3df(-21, -14, -21));
            billboard->setMaterialType(video::EMT_TRANSPARENT_ADD_COLOR );
            billboard->setMaterialTexture(0, driver->getTexture("../../media/particle.bmp"));
            billboard->setMaterialFlag(video::EMF_LIGHTING, false);
            smgr->addLightSceneNode(billboard, vector3df(0, 0, 0), video::SColorf(0, 1, 0), lightRadius);

            billboard = smgr->addBillboardSceneNode(node);
            billboard->setPosition(vector3df(21, -14, -21));
            billboard->setMaterialType(video::EMT_TRANSPARENT_ADD_COLOR );
            billboard->setMaterialTexture(0, driver->getTexture("../../media/particle.bmp"));
            billboard->setMaterialFlag(video::EMF_LIGHTING, false);
            smgr->addLightSceneNode(billboard, vector3df(0, 0, 0), video::SColorf(0, 0, 1), lightRadius);

            // Chaque cube a aussi un petit cube plus petit tournant autour pour montrer que les cubes sont allumés par les lumières de leur 'zone' pas seulement par les lumières qui sont leurs enfants directs.
            node = smgr->addCubeSceneNode(5, node);
            node->setPosition(vector3df(0, 21, 0));
        }

    smgr->addCameraSceneNode(0, vector3df(0,0,-130), vector3df(0,0,0));

    CMyLightManager * myLightManager = new CMyLightManager(smgr);
    smgr->setLightManager(0); // Ceci est le comportement par défaut : nous ne géreront pas les lumières tant qu'on ne nous dira pas de le faire
    device->setEventReceiver(myLightManager);

    int lastFps = -1;

    while(device->run())
    {
        driver->beginScene(true, true, video::SColor(255,100,101,140));
        smgr->drawAll();
        guienv->drawAll();
        driver->endScene();

        int fps = driver->getFPS();
        if(fps != lastFps)
        {
            lastFps = fps;
            core::stringw str = L"Managed Lights [";
            str += driver->getName();
            str += "] FPS:";
            str += fps;
            device->setWindowCaption(str.c_str());
        }
    }

    myLightManager->drop(); // Jette ma référence implicite
    device->drop();
    return 0;
}