// render skyboxes
	{
		IRR_PROFILE(CProfileScope psSkyBox(EPID_SM_RENDER_SKYBOXES);)
		CurrentRenderPass = ESNRP_SKY_BOX;
		Driver->getOverrideMaterial().Enabled = ((Driver->getOverrideMaterial().EnablePasses & CurrentRenderPass) != 0);

		if (LightManager)
		{
			LightManager->OnRenderPassPreRender(CurrentRenderPass);
			for (i=0; i<SkyBoxList.size(); ++i)
			{
				ISceneNode* node = SkyBoxList[i];
				LightManager->OnNodePreRender(node);
				node->render();
				LightManager->OnNodePostRender(node);
			}
		}
		else
		{
			for (i=0; i<SkyBoxList.size(); ++i)
				SkyBoxList[i]->render();
		}

		SkyBoxList.set_used(0);

		if (LightManager)
			LightManager->OnRenderPassPostRender(CurrentRenderPass);
	}

 
void CMapSkyColor::apply_sky_fog()
{
    SMaterial *SkyMaterial= &ColoredSkyNode->getMaterial(0);
    SkyMaterial->FogEnable      = FOGEnd;
    SkyMaterial->Lighting       = true;
    SkyMaterial->EmissiveColor  = FOGDiffuse;

    FOGSky = SColor(1, FOGRed,FOGGreen,FOGBlue);

    driver->setFog( FOGSky,
                    EFT_FOG_LINEAR,
                    FOGStart,
                    FOGEnd,
                    FOGStrength,
                    false,
                    true);
}

 
uniform sampler2D Texture1;
uniform float fRed;
uniform float fGreen;
uniform float fBlue;

void main ( void )
{
	vec4 color = texture2D ( Texture1 , gl_TexCoord[0] );
	color = vec4 ( fRed , fGreen , fBlue , 0.0 );
	gl_FragColor = color;
}

 
virtual void OnSetConstants ( video::IMaterialRendererServices* services , s32 userData )
{
          float red = 0.2f;
          float green = 0.9f;
          float blue = 1.0f;
          services->setVertexShaderConstant("fRed", &red, 1);
          services->setVertexShaderConstant("fGreen", &green, 1);
          services->setVertexShaderConstant("fBlue", &blue, 1);
}

uniform float fRed;
uniform float fGreen;
uniform float fBlue;

uniform vec4 background;

    vec4 color = texture2D ( Texture1 , gl_TexCoord[0] );
    gl_FragColor = color * background; 

 //          irr::video::SColorf background; // declarer dans la class
virtual void OnSetConstants ( video::IMaterialRendererServices* services , s32 userData )
{
          services->setVertexShaderConstant("background", reinterpret_cast<float*>background, 4);
}

void CColorShader::OnSetConstants(video::IMaterialRendererServices* services, s32 userData)
{
		// Set inverted world matrix
		// if we are using highlevel shaders (the user can select this when
		// starting the program), we must set the constants by name.
		core::matrix4 invWorld = Driver->getTransform(video::ETS_WORLD);
		invWorld.makeInverse();
		services->setVertexShaderConstant("mInvWorld", invWorld.pointer(), 16);

		// Set clip matrix
		core::matrix4 worldViewProj;
		worldViewProj = Driver->getTransform(video::ETS_PROJECTION);
		worldViewProj *= Driver->getTransform(video::ETS_VIEW);
		worldViewProj *= Driver->getTransform(video::ETS_WORLD);
		services->setVertexShaderConstant("mWorldViewProj", worldViewProj.pointer(), 16);

		// Set camera position
		core::vector3df pos = Dev->getSceneManager()->getActiveCamera()->getAbsolutePosition();
		services->setVertexShaderConstant ( "mLightPos" , reinterpret_cast<f32*>( &pos ) , 3 );

		// Set light color
		video::SColorf col(1.0f,1.0f,1.0f,0.0f);
		services->setVertexShaderConstant("mLightColor", reinterpret_cast<f32*>(&col), 4);

		// Set transposed world matrix
		core::matrix4 world = Driver->getTransform(video::ETS_WORLD);
		world = world.getTransposed();
		services->setVertexShaderConstant("mTransWorld", world.pointer(), 16);

// ICI
services->setVertexShaderConstant("background", reinterpret_cast<float*>(&background), 4);
} 

uniform sampler2D Texture1;
uniform vec4 background;

void main ( void )
{
    vec4 color = texture2D ( Texture1 , gl_TexCoord[0] );
    gl_FragColor = color * background;
}

uniform mat4 mWorldViewProj;
uniform mat4 mInvWorld;
uniform mat4 mTransWorld;
uniform vec3 mLightPos;
uniform vec4 mLightColor;

void main ( void )
{
	gl_TexCoord[0] = gl_MultiTexCoord0;
	gl_Position = mWorldViewProj * gl_Vertex;
}

 
enum E_SCENE_NODE_RENDER_PASS { 
  ESNRP_NONE = 0, 
  ESNRP_CAMERA = 1, 
  ESNRP_LIGHT = 2, 
  ESNRP_SKY_BOX = 4, 
  ESNRP_AUTOMATIC = 24,
  ESNRP_SOLID = 8, 
  ESNRP_TRANSPARENT = 16, 
  ESNRP_TRANSPARENT_EFFECT = 32, 
  ESNRP_SHADOW = 64 
}

E_SCENE_NODE_RENDER_PASS CurrentPass;

void CMapWater::OnAnimate(u32 timeMs)
{
          CurrentPass = SceneManager->getSceneNodeRenderPass();

          if((CurrentPass == ESNRP_SOLID ) || (CurrentPass == ESNRP_SKY_BOX ))
          {
             /// Code de la reflexion
          }
}

E_SCENE_NODE_RENDER_PASS CurrentPass;

void CMapWater::OnAnimate(u32 timeMs)
{
          CurrentPass = SceneManager->getSceneNodeRenderPass();

          if((CurrentPass == ESNRP_SOLID ) || (CurrentPass == ESNRP_SKY_BOX ))
          {
             /// ...
            SceneManager->setLightManager(???);
            SceneManager->drawAll();
            SceneManager->setLightManager(0);
            /// ...
          }
}

#pragma once

class CMapReflexion : public scene::ILightManager
{
      public:
        CMapReflexion(scene::ISceneManager* sceneManager)
          :  SceneManager(sceneManager), SceneLightList(0),
             CurrentRenderPass(scene::ESNRP_NONE), CurrentSceneNode(0)
        {
        }

        virtual void OnPreRender(core::array<scene::ISceneNode*> & lightList)
        {
            Mode = RequestedMode;
            SceneLightList = &lightList;
        }

        virtual void OnPostRender()
        {
        }

        virtual void OnRenderPassPreRender(scene::E_SCENE_NODE_RENDER_PASS renderPass)
        {
            CurrentRenderPass = renderPass;
            
            if(renderPass == ESNRP_LIGHT)
            {
                const vector3df nodePosition = smgr->getActiveCamera()->getAbsolutePosition();

                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();

                for(i = 0; i < sortingArray.size(); ++i)
                    sortingArray[i].node->setVisible(i < 3);
            }
        }

        virtual void OnRenderPassPostRender(scene::E_SCENE_NODE_RENDER_PASS renderPass)
        {
        }

        virtual void OnNodePreRender(scene::ISceneNode* node)
        {
            nodeIsVisible = node->isVisible();
            node->setVisible(nodeIsVisible && (CurrentRenderPass == ESNRP_SOLID && CurrentRenderPass == ESNRP_SKY_BOX));
        }

        virtual void OnNodePostRender(scene::ISceneNode* node)
        {
            node->setVisible(nodeIsVisible);
        }

    private:
        bool nodeIsVisible;
        scene::ISceneManager * SceneManager;
        core::array<scene::ISceneNode*> * SceneLightList;
        scene::E_SCENE_NODE_RENDER_PASS CurrentRenderPass;
    private:

        // A utility class to aid in sorting scene nodes into a distance order
        struct LightDistanceElement
        {
            LightDistanceElement() {};

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

            scene::ISceneNode* node;
            f64 distance;

            // Lower distance elements are sorted to the start of the array
            bool operator < (const LightDistanceElement& other) const
            {
              return (distance < other.distance);
            }
        };
};

void CMapWater::OnAnimate(u32 timeMs)
{
    if (IsVisible)
    {
        video::IVideoDriver* Driver = SceneManager->getVideoDriver();

        Driver->setRenderTarget(ReflectionMap,true,true);

        scene::ICameraSceneNode* CurrentCamera=SceneManager->getActiveCamera();
        scene::ICameraSceneNode* newcamera=SceneManager->addCameraSceneNode();

        newcamera->setFarValue(CurrentCamera->getFarValue());
        newcamera->setFOV(CurrentCamera->getFOV());
        newcamera->setAspectRatio(1.33f);

        core::vector3df position=CurrentCamera->getPosition();
        position.Y=-position.Y+2.0f*RelativeTranslation.Y;
        newcamera->setPosition(position);

        core::vector3df target=CurrentCamera->getTarget();
        target.Y=-target.Y+2.0f*RelativeTranslation.Y;
        newcamera->setTarget(target);
        
        f32 last_time = Dev->getTimer()->getRealTime();

        SceneManager->setActiveCamera(newcamera);

            SceneManager->setLightManager(lmgr);
            SceneManager->drawAll();
            SceneManager->setLightManager(0);

        Driver->setRenderTarget(0);

        SceneManager->setActiveCamera(CurrentCamera);

        newcamera->remove();

        ISceneNode::OnAnimate(timeMs);
    }
}