device->SetMaterial( material ); // les différentes couleurs (Amb, Dif, Spec, Em, power) liées au mesh à rendre
 device->SetTexture( chanel, image);  // envoie sur l'un des canaux de la CG d'une texture.  
 device->drawPrimitive( buffers...);  // envoie des buffers qui vont biens vers le pipeline de rendu.

ITexture * tex_refrac = 0; // texture de rendu pour la réfraction
plane3df refraction.setPlane(const vector3df &point1, const vector3df &point2, const vector3df &point3); // à remplacer par les valeurs. 
refraction.Normal = vector3df(x,y,z); // normale du plan
//refraction.D = valeur; // ?
driver->setClipPlane(1,refraction,false); // on créé le clipping plane désactivé
// on met la texture dans le materiaux du waterscenenode
node->setMaterialTexture(2, tex_refract);

while ( device->run() )
{
if ( device->isWindowActive() )
{
     driver->beginScene(true, true, SColor(255,128,128,128));
     // texture pour la refraction
     driver->enableClipPlane(1, true);
     driver->setRenderTarget(tex_refrac);
     driver->enableClipPlane(1, false);
     // on dessine la scene
     smgr->drawAll();
     driver->endScene();
}
}

plane3df refraction ( vector3df( 0 , 0 , 0 ) , vector3df ( 0 , -1 , 0 ) );
plane3df reflexion ( vector3df( 0 , 0 , 0 ) , vector3df ( 0 , 1 , 0 ) );

     driver->beginScene(true, true, SColor(255,128,128,128));

     // texture pour la refraction
     driver->enableClipPlane(1, true);
     driver->setRenderTarget(tex_refrac);

smgr->drawAll();

driver->setRenderTarget(0, true, true, 0);

     driver->enableClipPlane(1, false);
     // on met la texture dans le materiaux du waterscenenode
     node->setMaterialTexture(2, tex_refract);
     // on dessine la scene
     smgr->drawAll();
     driver->endScene();

#include <irrlicht.h>
#include <iostream>
using namespace irr;


#include "MyShaderCallBack.h"



int main ( int argc , char** argv )
{
 
    // Initialise Irrlicht
    IrrlichtDevice* device = createDevice ( video::EDT_OPENGL , core::dimension2d<s32>(640, 480) );
    video::IVideoDriver* driver = device->getVideoDriver();
    scene::ISceneManager* smgr = device->getSceneManager();
    gui::IGUIEnvironment* gui = device->getGUIEnvironment();


    
    // Verifie le support des shaders
    bool pixel_shader_support = ( driver->queryFeature ( video::EVDF_PIXEL_SHADER_1_1 ) || driver->queryFeature ( video::EVDF_ARB_FRAGMENT_PROGRAM_1 ) );
    bool vertex_shader_support = ( driver->queryFeature ( video::EVDF_VERTEX_SHADER_1_1 ) || driver->queryFeature ( video::EVDF_ARB_VERTEX_PROGRAM_1 ) );
    if ( !pixel_shader_support || !vertex_shader_support )
    {
        std::cerr << "Les shaders 1.1 ne sont pas supportés !" << std::endl;
    }
    
    
    // Creer le shader
    video::IGPUProgrammingServices* gpu = driver->getGPUProgrammingServices();
    
    // L'ID du matériau personnalisé
    s32 newMaterialType = 0;
    
    if (gpu)
    {
    
        // On instancie notre callback
        MyShaderCallBack* shader_callback = new MyShaderCallBack ( device );

        
        // On créer un nouveau matériau à partir du shader
        newMaterialType = gpu->addHighLevelShaderMaterialFromFiles(
                "vertex_shader.vert", "main", video::EVST_VS_1_1,
                "pixel_shader.frag", "main" , video::EPST_PS_1_1,
                shader_callback, video::EMT_SOLID);


        shader_callback->drop();
    }
    
    
    
    // Ajoute un plan d'eau
    scene::IAnimatedMesh* water_mesh = smgr->addHillPlaneMesh("myHill",
                core::dimension2d<f32>(1000,1000),
                core::dimension2d<u32>(2,2), 0, 0,
                core::dimension2d<f32>(0,0),
                core::dimension2d<f32>(1,1));
    
    
    scene::ISceneNode* water_node = smgr->addMeshSceneNode ( water_mesh->getMesh(0) );
    water_node->setMaterialTexture ( 0 , driver->getTexture ( "Water2.jpg" ) );
    water_node->setMaterialTexture ( 1 , driver->getTexture ( "waves.jpg" ) );
    water_node->setMaterialFlag ( video::EMF_LIGHTING , false );
    water_node->setMaterialType ( (video::E_MATERIAL_TYPE)newMaterialType );
    
    
    
    // Ajoute un cube texturé et lui assigne le shader
    scene::ISceneNode* node = smgr->addCubeSceneNode(50);
    node->setPosition ( core::vector3df ( 0 , 10.0f , 0 ) );
    node->setMaterialTexture ( 0 , driver->getTexture ( "chess.jpg" ) );
    node->setMaterialFlag ( video::EMF_LIGHTING , false );
    
    
    // Fait tourner le cube sur lui même
    scene::ISceneNodeAnimator* anim = smgr->createRotationAnimator ( core::vector3df ( 1.0f , 0.3f , 1.0f ) );
    node->addAnimator ( anim );
    anim->drop();
    
    
    
    // Ajoute une caméra à la scène
    scene::ICameraSceneNode* cam = smgr->addCameraSceneNodeFPS(0, 100.0f, 100.0f);
    cam->setPosition(core::vector3df(-100,50,100));
    cam->setTarget(core::vector3df(0,0,0));
    

    
    // Créer les textures pour le RTT (la moitié de la résolution réelle suffira)
    video::ITexture* refraction_texture = driver->createRenderTargetTexture ( core::dimension2d<s32>( 320 , 240 ) );
    video::ITexture* reflexion_texture  = driver->createRenderTargetTexture ( core::dimension2d<s32>( 320 , 240 ) );
    
    
    // Créer les plans de clipping
    core::plane3df refraction ( core::vector3df( 0 , 0 , 0 ) , core::vector3df ( 0 , -1 , 0 ) );
    core::plane3df reflexion  ( core::vector3df( 0 , 0 , 0 ) , core::vector3df ( 0 , 1 , 0 ) );
    driver->setClipPlane( 1 , refraction , false );
    driver->setClipPlane( 2 , reflexion  , false );
    
    
    
    // Boucle du jeu
    while ( device->run() )
    {
        if ( device->isWindowActive() )
        {
            driver->beginScene(true, true, video::SColor(255,128,128,128));
            
            
            // Refracion
            driver->enableClipPlane ( 1 , true );
            driver->setRenderTarget ( refraction_texture );
            water_node->setVisible ( false );
            smgr->drawAll();
            driver->enableClipPlane ( 1 , false );

            
            // Reflexion
            driver->enableClipPlane ( 2 , true );
            driver->setRenderTarget ( reflexion_texture );
            smgr->drawAll();    
            driver->enableClipPlane ( 2 , false );
            
            
            // Reel
            driver->setRenderTarget( 0 , true , true , 0 );
            water_node->setVisible ( true );
            water_node->setMaterialTexture ( 2 , refraction_texture );
            water_node->setMaterialTexture ( 3 , reflexion_texture  );
            smgr->drawAll();

            
            // Pour tester : affiche les deux textures en haut de l'écran
            //driver->draw2DImage ( refraction_texture , core::position2di ( 0 , 0 ) );
            //driver->draw2DImage ( reflexion_texture  , core::position2di ( 320 , 0 ) );
            
            driver->endScene();
        }
    }

    device->drop();
    
    return 0;
}

#include <irrlicht.h>

using namespace irr;
using namespace core;
using namespace scene;
using namespace video;

/*
    librairies
*/
#ifdef _IRR_WINDOWS_
    #pragma comment(lib, "Irrlicht.lib")
#endif

/*
    données globales
*/
bool _bExit = false;
IVideoDriver* driver;
ISceneNode* node1;
ISceneNode* node2;
ISceneNode* node3;

/*
 surcharge de la classe IEventReceiver, pour la gestion
 des entrés clavier dans notre  cas.
*/
class MyEventReceiver : public IEventReceiver
{
public:
    virtual bool OnEvent(const SEvent& event)
    {
        if (event.EventType == irr::EET_KEY_INPUT_EVENT  && !event.KeyInput.PressedDown)
        {
            switch(event.KeyInput.Key)
            {
                case KEY_ESCAPE:
                {
                    _bExit = true;
                    return true;
                }
                case KEY_KEY_S:
                {
                    core::plane3df reflexion  ( core::vector3df( 0 , 10 , 0 ) , core::vector3df ( 0 , 1 , 0 ) );
                    driver->setClipPlane( 1 , reflexion  , false );
                    return true;
                }
            }
        }
        return false;
    }
};
/*
procedure 'main', point d'entrée du programme commun à toute les
plateformes.
*/
int main()
{
    static int oldTime;
    // définition de notre classe dérivé, pour la gestion
    // des entrées clavier
    MyEventReceiver _EventReceiver;

    // let user select driver type

    video::E_DRIVER_TYPE driverType = EDT_DIRECT3D9;
    IrrlichtDevice *device = createDevice( driverType, 
                                            dimension2d<s32>(800, 600), 
                                            32,
                                            false, 
                                            false, 
                                            true, 
                                            &_EventReceiver);
    


        /*
            video driver, SceneManager et gui.
        */
    driver                    = device->getVideoDriver();
    ISceneManager* smgr        = device->getSceneManager();
    ITimer *timer            = device->getTimer();

        /*
            mes nodes
        */
    node1 = smgr->addCubeSceneNode(15.0f);
    node2 = smgr->addSphereSceneNode(7.0f);
    node2->setPosition( vector3df(10,20,0));
    node3 = smgr->addSphereSceneNode(7.0f);
    node3->setPosition( vector3df(-10,10,0));

        /*
            textures et light=false
        */
    if (node1)
    {    node1->setMaterialTexture(0, driver->getTexture("../../media/wall.bmp"));
        node1->setMaterialFlag ( video::EMF_LIGHTING , false );    }
    if (node2)
    {    node2->setMaterialTexture( 0, driver->getTexture("../../media/fire.bmp") );
        node2->setMaterialFlag ( video::EMF_LIGHTING , false );    } 
    if (node3)
    {    node3->setMaterialTexture( 0, driver->getTexture("../../media/fire.bmp") );
        node3->setMaterialFlag ( video::EMF_LIGHTING , false );    }

    /*
     définition des touches de controle de notre futur camera.
    */
    SKeyMap keyMap[4] = 
    {
        {EKA_MOVE_FORWARD,    KEY_UP},
        {EKA_MOVE_BACKWARD,    KEY_DOWN},
        {EKA_STRAFE_LEFT,    KEY_LEFT},
        {EKA_STRAFE_RIGHT,    KEY_RIGHT},
    };
    /*
        nous définissons une camera, dans un mode FPS.
        Nous la positionnons et ont définit la direction vers laquelle elle
        va pointer.
        */
    smgr->addCameraSceneNodeFPS( NULL , 100.0f, 310.0f, -1, keyMap, 4);
    smgr->getActiveCamera()->setPosition(core::vector3df(0,20,-30));
    smgr->getActiveCamera()->setTarget(core::vector3df(0,5,0) );
    

    // Créer les plans de clipping
    core::plane3df reflexion  ( core::vector3df( 0 , 4 , 0 ) , core::vector3df ( 0 , 1 , 0 ) );
    driver->setClipPlane( 1 , reflexion  , false );

        /*
        maintenant que tout les éléments sont en place, place à la boucle
        principale, pour dessiner tout cela.
        Pour quiter, deux solutions, soit un petit coups de ALT+F4, ou
        alors la touche ESC que nous avons définit dans notre boucle de
        traitement des événements (impliquant le changement d'état de notre
        flag _bExit).
        */
    int lastFPS = -1;
    while(device->run() & !_bExit)
    {
            /*
            Tout ce qui doit être dessiné doit l'être entre les deux instructions
            beginScene() and an endScene().
            L'instruction 'beginScene' effece l'ecran avec la couleur de notre
            choix.
            */
        driver->beginScene(true, true, SColor(255,100,101,140));
            driver->enableClipPlane ( 1 , true );
            smgr->drawAll();
        driver->endScene();


        node1->setRotation( node1->getRotation() + vector3df(0,1.0f,0) );
        
        // calcul du fps 
        int fps = driver->getFPS();
        if (lastFPS != fps)
        {
            lastFPS = fps;
        }
        // affichage de quelques informations dans la barre de titre
        // de la fenetre, avec timer pour éviter le scintillement.
        int time = timer->getRealTime();
        if((time - oldTime) >100 )
        {
            core::stringw str = L"Tuto 3 - Troisième essais";
            str += " FPS:";
            str += fps;
            str += "   ESC=sortir";
            device->setWindowCaption(str.c_str());
            oldTime = time;
        }
    }

        /*
        Une  fois sortie, c'est la fin, avec la libération de toutes les 
        ressources créées par 'createDevice'.
        */
    device->drop();

    return 0;
}