Hello,
Comme promis voici la release de mon code de fake glow,dream et night vision.
Au risque de me répéter, je ne programme pas en C++, j'apprends donc ne me ratatinez pas si vous voyez des erreurs ... il doit probablement y avoir des choses pas très belle dans mon code mais le résultat et l'idée sont là !
j'insiste encore sur le fait que se sont des FAKE effets et non pas de réel glow ou autre à base de shader.

Voici quelques screenshots pour illustrer se code :

Ici il n'y a aucun effet :


Effet de Night Vision :


Effet de Glow :


Effet de Dream :


Et ici vous pourrez télécharger le code et l'exe compilé avec la dll que j'utilise :
http://www.tv3dfr.com/irrlicht/Demo_N3.rar

Voilou @++

Sweet !
Je vais voir ce que je peux faire avec ça (voire le convertir comme scene node du wrapper ).

[Edit : Marche sous wine@Ubuntu 6.06, 90 fps avec le glow effect c'est pas mal du tout ]

très réussi !
J'ai un plantage méchant en OpenGL, ca me le fait aussi dès que je veux loader une map quake 3 avec la dll de DeusXL, donc ca doit venir de ma daube de chip
j'adore l'effet dream la classe

Bon lol, moi qui esperait avoir des retours de chez les anglais c'est mal partie .
je vous laisse l'url du post us aussi si vous voulez suivre on sait jamais :
http://irrlicht.sourceforge.net/phpBB2/viewtopic.php?t=16049

Et bien bravo, tu as eu finalement ton petit succès... Vive la French Touch ^^

c'est tres reussi bravo

J'adore, vraiment.

Malheureusement j'utilise dans mon projet une camera classique, liée à un node, et du coup ça rend vraiment mal.
J'ai un peu cherché dans les sources sans trop voir où se situait le problème avec la caméra dont tu parlais dans l'autre post.

Dommage, j'aurais bien aimé utiliser le glow :p

Bonne continuation !

très "fable" cet effet dream, j'apprécie. Je file voir le code.

"Simson, sur irrlicht.sourceforge.org" Ecris:

It's limited at Camera FPS because my level in maths is low and i don't know how to get the camera rotation.
If you find the solution, don't hesitate to post the code Smile.

Hehe oui si tu trouves une solution je suis preneur .
Il faut arriver à récupérer l'angle de rotation de la camera(x,y,z) pour pivoter les quad...

ca concerne plus la prog que des maths, de la facon dont tu l'exprime.

enfoi envoye un petit mail ( ou poste ici meme ) pour expliquer plus clairement la chose, genre ou est ce que ca te pose probleme etc ...

cela me semble très intéressant je le test tous de suite

je viens de tester, ca donne vachement bien ! [ sur mon linux, Fedora Core 4 ]

(j'ai du faire quelques modif pour compiler comme remplacer <CEffets.h> par "CEffects.h" et encader les code du .h par #ifndef Machin88 #define Machin88 .... #endif )


Merci pour ce code, je vais voir de l'integrer dans mes bidouillages

J'ai effectué une petite mise à jour afin que cela fonctionne mieux sous Irrlicht 1.2.
Voici le code :

CEffects.cpp:

/*-----------------------------------------
Programmed by Fabre Cédric 
(Copland/simson) 02/10/2006
Thanks to the Irrlicht team  
for this good 3D engine !
This code has not been tested under Linux.
If you find any errors or corrections,
in advance thanks you for any feedbacks.
-------------------------------------------
Contact : simson2004@wanadoo.fr
-----------------------------------------*/

#include <irrlicht.h>
#include <CEffects.h>

using namespace irr;

CQuadSceneNode::CQuadSceneNode(scene::ISceneNode* parent,scene::ISceneManager* mgr,s32 id): scene::ISceneNode(parent, mgr, id)
{
	Material.DiffuseColor = video::SColor(0,0,0,0);
	Material.EmissiveColor = video::SColor(0,0,0,0);
	Material.SpecularColor = video::SColor(0,0,0,0);
	Material.ZBuffer = false;
	Material.Wireframe = false;
	Material.PointCloud = false;
	Material.Lighting = false;
	Material.BackfaceCulling = false;
	Material.FogEnable = false;
	Material.GouraudShading = false;
	Material.NormalizeNormals = true;
	Material.MaterialType = video::EMT_TRANSPARENT_VERTEX_ALPHA;

	irr::video::E_DRIVER_TYPE dr = mgr->getVideoDriver()->getDriverType();

	if (dr != video::EDT_OPENGL)
	{
		video::SColor Color = video::SColor(4,40,40,40);
		VertexQuad[0]=video::S3DVertex(-1,1,0,0,0,0,Color,0,0);
		VertexQuad[1]=video::S3DVertex(1,1,0,0,0,0,Color,1,0);
		VertexQuad[2]=video::S3DVertex(-1,-1,0,0,0,0,Color,0,1);
		VertexQuad[3]=video::S3DVertex(1,-1,0,0,0,0,Color,1,1);
	}
	else
	{
		video::SColor Color = video::SColor(4,34,34,34);
		VertexQuad[0]=video::S3DVertex(-1,1,0,0,0,0,Color,0,1);
		VertexQuad[1]=video::S3DVertex(1,1,0,0,0,0,Color,1,1);
		VertexQuad[2]=video::S3DVertex(-1,-1,0,0,0,0,Color,0,0);
		VertexQuad[3]=video::S3DVertex(1,-1,0,0,0,0,Color,1,0);
	}

	Box.reset(VertexQuad[0].Pos);

	for (s32 i=1; i<4; ++i)
	{
		Box.addInternalPoint(VertexQuad[i].Pos);
	}
}

void CQuadSceneNode::OnPreRender()
{
	if (IsVisible)
		SceneManager->registerNodeForRendering(this);
	ISceneNode::OnPreRender();
}

void CQuadSceneNode::render()
{
	u16 indices[] = {	0,1,2, 3,2,1	};
	video::IVideoDriver* driver = SceneManager->getVideoDriver();

	driver->setMaterial(Material);
	driver->setTransform(video::ETS_WORLD, AbsoluteTransformation);
	driver->drawIndexedTriangleList(&VertexQuad[0], 4, &indices[0], 2);
}

const core::aabbox3d<f32>& CQuadSceneNode::getBoundingBox() const
{
	return Box;
}

s32 CQuadSceneNode::getMaterialCount()
{
	return 1;
}

video::SMaterial& CQuadSceneNode::getMaterial(s32 i)
{
	return Material;
}


//Déclaration de RTexGlow;
video::ITexture* RTexGlow=0;
video::ITexture* RTexDream=0;
video::ITexture* RTexNV=0;

//Déclaration d'un CQuadSceneNode (Node personnalisé pour créer un Quad)
CQuadSceneNode* Quad[11];

//Méthode de création du Glow
void CreateGlow(scene::ICameraSceneNode* CamGlow,scene::ISceneManager* smgr,video::IVideoDriver* driver,s32 GlowSize=64)
{
	//On vérifi que la carte vidéo soit cappable d'utiliser le Render To Texture
	if (driver->queryFeature(video::EVDF_RENDER_TO_TARGET))
	{
		//Ici on creer notre Render Texture
		RTexGlow=driver->createRenderTargetTexture(core::dimension2d<s32>(GlowSize,GlowSize));

		f32 resultat = cos((CamGlow->getFOV()/2));
		resultat = 1.09f/resultat;
		resultat = (resultat*resultat) - (1.09f*1.09f);
		resultat = sqrt(resultat);
		f32 SizeY = resultat;
		f32 ScaleX = resultat * CamGlow->getAspectRatio();

		//Ici on va créer plusieurs quad pour simuler un effet de Blur
		for (int nbquad=0;nbquad<=3;nbquad++)
		{
			Quad[nbquad] = new CQuadSceneNode(smgr->getRootSceneNode(), smgr, 0);
			Quad[nbquad]->setParent(CamGlow);
			Quad[nbquad]->setPosition(irr::core::vector3df(-0.003f+(nbquad/300),-0.001f+(nbquad/300),1.09f));
			Quad[nbquad]->setScale(irr::core::vector3df(ScaleX+((float)nbquad/300),SizeY+((float)nbquad/300),1));
			Quad[nbquad]->setMaterialTexture(0,RTexGlow);
			Quad[nbquad]->drop();
		}
	}
}

//Méthode de rendu du Glow
void RenderGlow(scene::ISceneManager* smgr,video::IVideoDriver* driver,s32 gA=0,s32 gR=0,s32 gG=0,s32 gB=0)
{
	//On test si le Render Texture existe bien
	if (RTexGlow)
	{
		for (int i=0;i<=10;i++)
		{
			if (Quad[i] != NULL)
			{
				if (i==0 || i >=4){Quad[i]->setVisible(false);}else{Quad[i]->setVisible(true);}
			}
		}

		//On affiche notre scene
		driver->setRenderTarget(RTexGlow, true, true, video::SColor(gA,gR,gG,gB));
		smgr->drawAll();
		driver->setRenderTarget(0);
		
		//On affiche nos quads
		Quad[0]->setVisible(true);

		for (int i=0;i<=10;i++)
		{
			if (Quad[i] != NULL){Quad[i]->updateAbsolutePosition();}
		}
	}
}


//Méthode de création de l'effet Dream Filter
void CreateDreamFilter(scene::ICameraSceneNode* CamDream,scene::ISceneManager* smgr,video::IVideoDriver* driver,f32 EffectSize=1.0f,s32 DreamSize=64)
{
	//On vérifi que la carte vidéo soit cappable d'utiliser le Render To Texture
	if (driver->queryFeature(video::EVDF_RENDER_TO_TARGET))
	{
		//Ici on creer notre Render Texture
		RTexDream=driver->createRenderTargetTexture(core::dimension2d<s32>(DreamSize,DreamSize));

		f32 resultat = cos((CamDream->getFOV()/2));
		resultat = 1.09f/resultat;
		resultat = (resultat*resultat) - (1.09f*1.09f);
		resultat = sqrt(resultat);
		f32 SizeY = resultat;
		f32 ScaleX = resultat * CamDream->getAspectRatio();

		//Alors ici on va en créer plusieurs pour simuler un effet de Blur
		for (int nbquad=4;nbquad<=7;nbquad++)
		{
			Quad[nbquad] = new CQuadSceneNode(smgr->getRootSceneNode(), smgr, 0);
			Quad[nbquad]->setParent(CamDream);
			Quad[nbquad]->setPosition(irr::core::vector3df(-0.001f,-0.001f,1.09f));
			Quad[nbquad]->setScale(irr::core::vector3df((ScaleX+((float)nbquad/20)*EffectSize),(SizeY+((float)nbquad/20)*EffectSize),1));
			Quad[nbquad]->setMaterialTexture(0,RTexDream);
			Quad[nbquad]->drop();
		}
	}
}

//Méthode de rendu du DreamFilter
void RenderDreamFilter(scene::ISceneManager* smgr,video::IVideoDriver* driver,s32 dA=0,s32 dR=0,s32 dG=0,s32 dB=0)
{
	//On test si le Render Texture existe bien
	if (RTexDream)
	{
		for (int i=0;i<=10;i++)
		{
			if (Quad[i] != NULL){Quad[i]->setVisible(false);}
		}
		
		Quad[5]->setVisible(true);
		Quad[6]->setVisible(true);
		Quad[7]->setVisible(true);

		//On affiche notre scene
		driver->setRenderTarget(RTexDream, true, true, video::SColor(dA,dR,dG,dB));
		smgr->drawAll();
		driver->setRenderTarget(0);

		Quad[4]->setVisible(true);
		
		for (int i=0;i<=10;i++)
		{
			if (Quad[i] != NULL){Quad[i]->updateAbsolutePosition();}
		}
	}
}

//Méthode de création de l'effet NightVision
void CreateNightVision(scene::ICameraSceneNode* CamNightVision,scene::ISceneManager* smgr,video::IVideoDriver* driver,irr::c8* NoiseFile,s32 NightVisionSize=64)
{
	//On vérifi que la carte vidéo soit cappable d'utiliser le Render To Texture
	if (driver->queryFeature(video::EVDF_RENDER_TO_TARGET))
	{
		irr::video::E_DRIVER_TYPE dr = smgr->getVideoDriver()->getDriverType();
		irr::video::ITexture* NoiseTexture = driver->getTexture(NoiseFile);

		//Ici on creer notre Render Texture
		RTexNV=driver->createRenderTargetTexture(core::dimension2d<s32>(NightVisionSize,NightVisionSize));

		f32 resultat = cos((CamNightVision->getFOV()/2));
		resultat = 1.09f/resultat;
		resultat = (resultat*resultat) - (1.09f*1.09f);
		resultat = sqrt(resultat);
		f32 SizeY = resultat;
		f32 ScaleX = resultat * CamNightVision->getAspectRatio();

		for (int nbquad=8;nbquad<=10;nbquad++)
		{
			Quad[nbquad]= new CQuadSceneNode(smgr->getRootSceneNode(), smgr, 0);
			Quad[nbquad]->setParent(CamNightVision);
			Quad[nbquad]->setPosition(irr::core::vector3df(-0.001f,0.001f,1.09f));
			Quad[nbquad]->setScale(irr::core::vector3df(ScaleX,SizeY,1));

			for (int i =0;i<=Quad[nbquad]->getMaterialCount()-1;i++)
			{
				if(nbquad!=10)
				{
					//On test si on est en directx ou autre pour gérer les coloris
					if (dr !=  video::EDT_OPENGL)
					{
						Quad[nbquad]->getMaterial(i).MaterialType=video::EMT_TRANSPARENT_VERTEX_ALPHA;
						Quad[nbquad]->getMaterial(i).DiffuseColor = video::SColor(10,20,150,20);
						Quad[nbquad]->getMaterial(i).EmissiveColor = video::SColor(10,20,150,20);
						Quad[nbquad]->getMaterial(i).AmbientColor = video::SColor(10,20,150,20);
						Quad[nbquad]->getMaterial(i).SpecularColor = video::SColor(10,20,150,20);
						Quad[nbquad]->getMaterial(i).Lighting=true;
					}
					else
					{
						Quad[nbquad]->getMaterial(i).MaterialType=video::EMT_TRANSPARENT_VERTEX_ALPHA;
						Quad[nbquad]->getMaterial(i).DiffuseColor = video::SColor(10,10,120,10);
						Quad[nbquad]->getMaterial(i).EmissiveColor = video::SColor(10,10,120,10);
						Quad[nbquad]->getMaterial(i).AmbientColor = video::SColor(10,10,120,10);
						Quad[nbquad]->getMaterial(i).SpecularColor = video::SColor(10,10,120,10);
						Quad[nbquad]->getMaterial(i).Lighting=true;
					}
				}
			}

			if (nbquad!=10)
			{
				Quad[nbquad]->setMaterialTexture(0,RTexNV);
			}
			else
			{
				core::vector3df vec = Quad[nbquad]->getPosition();
				vec.Z = 1.05f;
				scene::ISceneNodeAnimator* noiseAnim = smgr->createFlyCircleAnimator(vec,0.03f,0.7f);
				Quad[nbquad]->setScale(irr::core::vector3df(ScaleX+0.05f,SizeY+0.05f,1));
				Quad[nbquad]->addAnimator(noiseAnim);
				Quad[nbquad]->setMaterialTexture(0,NoiseTexture);
			}

			Quad[nbquad]->drop();
		}
	}
}

//Méthode de rendu de l'effet NightVision
void RenderNightVision(scene::ISceneManager* smgr,video::IVideoDriver* driver)
{
	//On test si le Render Texture existe bien
	if (RTexNV)
	{
		for (int i=0;i<=10;i++)
		{
			if (Quad[i] != NULL)
			{
				if (i<=8){Quad[i]->setVisible(false);}else{Quad[i]->setVisible(true);}
			}
		}

		//On affiche notre scene
		driver->setRenderTarget(RTexNV, true, true, video::SColor(0,0,0,0));
		smgr->drawAll();
		driver->setRenderTarget(0);

		Quad[8]->setVisible(true);

		for (int i=0;i<=10;i++)
		{
			if (Quad[i] != NULL){Quad[i]->updateAbsolutePosition();}
		}
	}
}

//Méthode si l'on ne veut plus rien afficher
void RenderNothing()
{
	for (int i =0;i<=10;i++)
	{
		if (Quad[i]!= NULL){Quad[i]->setVisible(false);}
	}
}

//Méthode de suppression du Glow
void DeleteGlow()
{
	if (RTexGlow){RTexGlow->drop();}
	for (int i=0;i<=3;i++)
	{
		if (Quad[i] != NULL){Quad[i]->remove();}
	}
}

//Méthode de suppression du DreamFilter
void DeleteDream()
{
	if (RTexDream){RTexDream->drop();}
	for (int i=4;i<=7;i++)
	{
		if (Quad[i] != NULL){Quad[i]->remove();}
	}
}

//Méthode de suppression du Night Vision
void DeleteNightVision()
{
	if (RTexNV){RTexNV->drop();}
	for (int i=8;i<=10;i++)
	{
		if (Quad[i] != NULL){Quad[i]->remove();}
	}
}

//Méthode de suppression
void DeleteEffects()
{
	//On test si notre Render Texture existe bien et on supprime
	if (RTexGlow){RTexGlow->drop();}
	if (RTexDream){RTexDream->drop();}
	if (RTexNV){RTexNV->drop();}

	for (int i=0;i<=10;i++)
	{
		if (Quad[i] != NULL){Quad[i]->remove();}
	}
}

/*-----------------------------------------
Programmed by Fabre Cédric 
(Copland/simson) 02/10/2006
Thanks to the Irrlicht team  
for this good 3D engine !
This code has not been tested under Linux.
If you find any errors or corrections,
in advance thanks you for any feedbacks.
-------------------------------------------
Contact : simson2004@wanadoo.fr
-----------------------------------------*/

using namespace irr;

//Classe QuadSceneNode pour dessiner un Quad perso
class CQuadSceneNode : public scene::ISceneNode
{
public:
	CQuadSceneNode(scene::ISceneNode* parent, scene::ISceneManager* mgr, s32 id);
	virtual void OnPreRender();
	virtual void render();
	virtual const core::aabbox3d<f32>& getBoundingBox() const;
	s32 getMaterialCount();
	virtual video::SMaterial& getMaterial(s32 i);
private :
	core::aabbox3d<f32> Box;
	video::S3DVertex VertexQuad[4];
	video::SMaterial Material;
};

void CreateGlow(scene::ICameraSceneNode* CamGlow,scene::ISceneManager* smgr,video::IVideoDriver* driver,s32 GlowSize);
void RenderGlow(scene::ISceneManager* smgr,video::IVideoDriver* driver,s32 gA,s32 gR,s32 gG,s32 gB);

void CreateDreamFilter(scene::ICameraSceneNode* CamDream,scene::ISceneManager* smgr,video::IVideoDriver* driver,f32 EffectSize,s32 DreamSize);
void RenderDreamFilter(scene::ISceneManager* smgr,video::IVideoDriver* driver,s32 dA,s32 dR,s32 dG,s32 dB);

void CreateNightVision(scene::ICameraSceneNode* CamNightVision,scene::ISceneManager* smgr,video::IVideoDriver* driver,irr::c8* NoiseFile,s32 NightVisionSize);
void RenderNightVision(scene::ISceneManager* smgr,video::IVideoDriver* driver);

void RenderNothing();

void DeleteGlow();
void DeleteDream();
void DeleteNightVision();

void DeleteEffects();

As-tu réglé ton problème avec les caméras "statiques" (comprendre non FPS et non Maya) ?

Bein non, et je ne pense pas le régler à grand coup de baguette magique malheureusement .
Je pense qu'il faudrait directement modifier le code d'irrlicht dans les Cameras pour corriger se problème....

Le code est-il compilable sous nunux.

Il est écrit comme "non testé sous linux", mais en fait je l'ai testé sous Code::Blocks Linux Ubuntu et ça marche bien .

smeagol Ecris:

Le code est-il compilable sous nunux.

Une petite mise à jour pour que cela fonctionne théoriquement avec les autres caméras...A tester donc.
CEffects.cpp :

/*-----------------------------------------
Programmed by Fabre Cédric 
(Copland/simson) 02/10/2006
Thanks to the Irrlicht team  
for this good 3D engine !
This code has not been tested under Linux.
If you find any errors or corrections,
in advance thanks you for any feedbacks.
-------------------------------------------
Contact : simson2004@wanadoo.fr
-----------------------------------------*/

#include <irrlicht.h>
#include <CEffects.h>

using namespace irr;

namespace EffectsLibrary
{
	CQuadSceneNode::CQuadSceneNode(scene::ISceneNode* parent,scene::ISceneManager* mgr,s32 id): scene::ISceneNode(parent, mgr, id)
	{
		Material.DiffuseColor = video::SColor(0,0,0,0);
		Material.EmissiveColor = video::SColor(0,0,0,0);
		Material.SpecularColor = video::SColor(0,0,0,0);
		Material.ZBuffer = false;
		Material.ZWriteEnable = false;
		Material.Wireframe = false;
		Material.PointCloud = false;
		Material.Lighting = false;
		Material.BackfaceCulling = false;
		Material.FogEnable = false;
		Material.GouraudShading = false;
		Material.NormalizeNormals = true;
		Material.MaterialType = video::EMT_TRANSPARENT_VERTEX_ALPHA;

		irr::video::E_DRIVER_TYPE dr = mgr->getVideoDriver()->getDriverType();

		if (dr != video::EDT_OPENGL)
		{
			video::SColor Color = video::SColor(4,40,40,40);
			VertexQuad[0]=video::S3DVertex(-1,1,0,0,0,0,Color,0,0);
			VertexQuad[1]=video::S3DVertex(1,1,0,0,0,0,Color,1,0);
			VertexQuad[2]=video::S3DVertex(-1,-1,0,0,0,0,Color,0,1);
			VertexQuad[3]=video::S3DVertex(1,-1,0,0,0,0,Color,1,1);
		}
		else
		{
			video::SColor Color = video::SColor(4,34,34,34);
			VertexQuad[0]=video::S3DVertex(-1,1,0,0,0,0,Color,0,1);
			VertexQuad[1]=video::S3DVertex(1,1,0,0,0,0,Color,1,1);
			VertexQuad[2]=video::S3DVertex(-1,-1,0,0,0,0,Color,0,0);
			VertexQuad[3]=video::S3DVertex(1,-1,0,0,0,0,Color,1,0);
		}

		Box.reset(VertexQuad[0].Pos);

		for (s32 i=1; i<4; ++i)
		{
			Box.addInternalPoint(VertexQuad[i].Pos);
		}
	}

	void CQuadSceneNode::OnPreRender()
	{
		if (IsVisible)
			SceneManager->registerNodeForRendering(this);
		ISceneNode::OnPreRender();
	}

	void CQuadSceneNode::render()
	{
		u16 indices[] = {	0,1,2, 3,2,1	};
		video::IVideoDriver* driver = SceneManager->getVideoDriver();
		driver->setMaterial(Material);
		core::matrix4 Mat;
		Mat.makeIdentity();
		
		//On sauvegarde les matrices
		core::matrix4 MatrixWorld = driver->getTransform(video::ETS_WORLD);
		core::matrix4 MatrixView = driver->getTransform(video::ETS_VIEW);
		
		//On applique les matrices de monde et de vue
		driver->setTransform(video::ETS_WORLD, AbsoluteTransformation);
		driver->setTransform(video::ETS_VIEW,Mat);
		//On dessine nos Quad ici
		driver->drawIndexedTriangleList(&VertexQuad[0], 4, &indices[0], 2);
		
		//On restaure les matrices
		driver->setTransform(video::ETS_VIEW,MatrixView);
		driver->setTransform(video::ETS_WORLD,MatrixWorld);
	}

	const core::aabbox3d<f32>& CQuadSceneNode::getBoundingBox() const
	{
		return Box;
	}

	u32 CQuadSceneNode::getMaterialCount()
	{
		return 1;
	}

	video::SMaterial& CQuadSceneNode::getMaterial(u32 i)
	{
		return Material;
	}


	//Déclaration de RTexGlow;
	video::ITexture* RTexGlow=0;
	video::ITexture* RTexDream=0;
	video::ITexture* RTexNV=0;

	//Déclaration d'un CQuadSceneNode (Node personnalisé pour créer un Quad)
	CQuadSceneNode* Quad[11];

	//Méthode de création du Glow
	void CreateGlow(scene::ICameraSceneNode* CamGlow,scene::ISceneManager* smgr,s32 GlowSize=64)
	{
		//On vérifi que la carte vidéo soit cappable d'utiliser le Render To Texture
		if (smgr->getVideoDriver()->queryFeature(video::EVDF_RENDER_TO_TARGET))
		{
			//Ici on creer notre Render Texture
			RTexGlow = smgr->getVideoDriver()->createRenderTargetTexture(core::dimension2d<s32>(GlowSize,GlowSize));

			f32 resultat = cos((CamGlow->getFOV()/2));
			resultat = 1.09f/resultat;
			resultat = (resultat*resultat) - (1.09f*1.09f);
			resultat = sqrt(resultat);
			f32 SizeY = resultat;
			f32 ScaleX = resultat * CamGlow->getAspectRatio();

			//Ici on va créer plusieurs quad pour simuler un effet de Blur
			for (int nbquad=0;nbquad<=3;nbquad++)
			{
				Quad[nbquad] = new CQuadSceneNode(smgr->getRootSceneNode(), smgr, 0);
				//Quad[nbquad]->setAutomaticCulling(false);
				Quad[nbquad]->setPosition(irr::core::vector3df(-0.003f+(nbquad/300),-0.001f+(nbquad/300),1.09f));
				Quad[nbquad]->setScale(irr::core::vector3df(ScaleX+((float)nbquad/300),SizeY+((float)nbquad/300),1));
				Quad[nbquad]->setMaterialTexture(0,RTexGlow);
				Quad[nbquad]->drop();
			}
		}
	}

	//Méthode de rendu du Glow
	void RenderGlow(scene::ISceneManager* smgr,s32 gA=0,s32 gR=0,s32 gG=0,s32 gB=0,u32 NbsOfPass=0)
	{
		//On test si le Render Texture existe bien
		if (RTexGlow)
		{
			for (int i=0;i<=10;i++)
			{
				if (Quad[i] != NULL)
				{
					if (i==0 || i >=4){Quad[i]->setVisible(false);}else{Quad[i]->setVisible(true);}
				}
			}

			//On affiche notre scene
			smgr->getVideoDriver()->setRenderTarget(RTexGlow, true, true, video::SColor(gA,gR,gG,gB));
			smgr->drawAll();
			smgr->getVideoDriver()->setRenderTarget(0);

			switch (NbsOfPass)
			{
				case 1:
					Quad[1]->setVisible(false);
					Quad[2]->setVisible(false);
					Quad[3]->setVisible(false);
					break;
				case 2:
					Quad[1]->setVisible(false);
					Quad[2]->setVisible(false);
					break;
				case 3:
					Quad[1]->setVisible(false);
					break;
			}

			//On affiche nos quads
			Quad[0]->setVisible(true);
		}
	}


	//Méthode de création de l'effet Dream Filter
	void CreateDreamFilter(scene::ICameraSceneNode* CamDream,scene::ISceneManager* smgr,f32 EffectSize=1.0f,s32 DreamSize=64)
	{
		//On vérifi que la carte vidéo soit cappable d'utiliser le Render To Texture
		if (smgr->getVideoDriver()->queryFeature(video::EVDF_RENDER_TO_TARGET))
		{
			//Ici on creer notre Render Texture
			RTexDream=smgr->getVideoDriver()->createRenderTargetTexture(core::dimension2d<s32>(DreamSize,DreamSize));

			f32 resultat = cos((CamDream->getFOV()/2));
			resultat = 1.09f/resultat;
			resultat = (resultat*resultat) - (1.09f*1.09f);
			resultat = sqrt(resultat);
			f32 SizeY = resultat;
			f32 ScaleX = resultat * CamDream->getAspectRatio();

			//Alors ici on va en créer plusieurs pour simuler un effet de Blur
			for (int nbquad=4;nbquad<=7;nbquad++)
			{
				Quad[nbquad] = new CQuadSceneNode(smgr->getRootSceneNode(), smgr, 0);
				//Quad[nbquad]->setAutomaticCulling(false);
				Quad[nbquad]->setPosition(irr::core::vector3df(-0.001f,-0.001f,1.09f));
				Quad[nbquad]->setScale(irr::core::vector3df((ScaleX+((float)nbquad/20)*EffectSize),(SizeY+((float)nbquad/20)*EffectSize),1));
				Quad[nbquad]->setMaterialTexture(0,RTexDream);
				Quad[nbquad]->drop();
			}
		}
	}

	//Méthode de rendu du DreamFilter
	void RenderDreamFilter(scene::ISceneManager* smgr,s32 dA=0,s32 dR=0,s32 dG=0,s32 dB=0)
	{
		//On test si le Render Texture existe bien
		if (RTexDream)
		{
			for (int i=0;i<=10;i++)
			{
				if (Quad[i] != NULL){Quad[i]->setVisible(false);}
			}

			Quad[5]->setVisible(true);
			Quad[6]->setVisible(true);
			Quad[7]->setVisible(true);

			//On affiche notre scene
			smgr->getVideoDriver()->setRenderTarget(RTexDream, true, true, video::SColor(dA,dR,dG,dB));
			smgr->drawAll();
			smgr->getVideoDriver()->setRenderTarget(0);

			Quad[4]->setVisible(true);
		}
	}

	//Méthode de création de l'effet NightVision
	void CreateNightVision(scene::ICameraSceneNode* CamNightVision,scene::ISceneManager* smgr,irr::c8* NoiseFile,s32 NightVisionSize=64)
	{
		//On vérifi que la carte vidéo soit cappable d'utiliser le Render To Texture
		if (smgr->getVideoDriver()->queryFeature(video::EVDF_RENDER_TO_TARGET))
		{
			irr::video::E_DRIVER_TYPE dr = smgr->getVideoDriver()->getDriverType();
			irr::video::ITexture* NoiseTexture = smgr->getVideoDriver()->getTexture(NoiseFile);

			//Ici on creer notre Render Texture
			RTexNV=smgr->getVideoDriver()->createRenderTargetTexture(core::dimension2d<s32>(NightVisionSize,NightVisionSize));

			f32 resultat = cos((CamNightVision->getFOV()/2));
			resultat = 1.09f/resultat;
			resultat = (resultat*resultat) - (1.09f*1.09f);
			resultat = sqrt(resultat);
			f32 SizeY = resultat;
			f32 ScaleX = resultat * CamNightVision->getAspectRatio();

			for (int nbquad=8;nbquad<=10;nbquad++)
			{
				Quad[nbquad]= new CQuadSceneNode(smgr->getRootSceneNode(), smgr, 0);
				//Quad[nbquad]->setAutomaticCulling(false);
				Quad[nbquad]->setPosition(irr::core::vector3df(-0.001f,0.001f,1.09f));
				Quad[nbquad]->setScale(irr::core::vector3df(ScaleX,SizeY,1));

				for (u32 i =0;i<=Quad[nbquad]->getMaterialCount()-1;i++)
				{
					if(nbquad!=10)
					{
						//On test si on est en directx ou autre pour gérer les coloris
						if (dr !=  video::EDT_OPENGL)
						{
							Quad[nbquad]->getMaterial(i).MaterialType=video::EMT_TRANSPARENT_VERTEX_ALPHA;
							Quad[nbquad]->getMaterial(i).DiffuseColor = video::SColor(10,20,150,20);
							Quad[nbquad]->getMaterial(i).EmissiveColor = video::SColor(10,20,150,20);
							Quad[nbquad]->getMaterial(i).AmbientColor = video::SColor(10,20,150,20);
							Quad[nbquad]->getMaterial(i).SpecularColor = video::SColor(10,20,150,20);
							Quad[nbquad]->getMaterial(i).Lighting=true;
						}
						else
						{
							Quad[nbquad]->getMaterial(i).MaterialType=video::EMT_TRANSPARENT_VERTEX_ALPHA;
							Quad[nbquad]->getMaterial(i).DiffuseColor = video::SColor(10,10,120,10);
							Quad[nbquad]->getMaterial(i).EmissiveColor = video::SColor(10,10,120,10);
							Quad[nbquad]->getMaterial(i).AmbientColor = video::SColor(10,10,120,10);
							Quad[nbquad]->getMaterial(i).SpecularColor = video::SColor(10,10,120,10);
							Quad[nbquad]->getMaterial(i).Lighting=true;
						}
					}
				}

				if (nbquad!=10)
				{
					Quad[nbquad]->setMaterialTexture(0,RTexNV);
				}
				else
				{
					core::vector3df vec = Quad[nbquad]->getPosition();
					vec.Z = 1.05f;
					scene::ISceneNodeAnimator* noiseAnim = smgr->createFlyCircleAnimator(vec,0.03f,0.7f);
					Quad[nbquad]->setScale(irr::core::vector3df(ScaleX+0.05f,SizeY+0.05f,1));
					Quad[nbquad]->addAnimator(noiseAnim);
					Quad[nbquad]->setMaterialTexture(0,NoiseTexture);
				}

				Quad[nbquad]->drop();
			}
		}
	}

	//Méthode de rendu de l'effet NightVision
	void RenderNightVision(scene::ISceneManager* smgr)
	{
		//On test si le Render Texture existe bien
		if (RTexNV)
		{
			for (int i=0;i<=10;i++)
			{
				if (Quad[i] != NULL)
				{
					if (i<=8){Quad[i]->setVisible(false);}else{Quad[i]->setVisible(true);}
				}
			}

			//On affiche notre scene
			smgr->getVideoDriver()->setRenderTarget(RTexNV, true, true, video::SColor(0,0,0,0));
			smgr->drawAll();
			smgr->getVideoDriver()->setRenderTarget(0);

			Quad[8]->setVisible(true);
		}
	}

	//Méthode si l'on ne veut plus rien afficher
	void RenderNothing()
	{
		for (int i =0;i<=10;i++)
		{
			if (Quad[i]!= NULL){Quad[i]->setVisible(false);}
		}
	}

	//Méthode de suppression du Glow
	void DeleteGlow()
	{
		if (RTexGlow){RTexGlow->drop();}
		for (int i=0;i<=3;i++)
		{
			if (Quad[i] != NULL){Quad[i]->remove();}
		}
	}

	//Méthode de suppression du DreamFilter
	void DeleteDream()
	{
		if (RTexDream){RTexDream->drop();}
		for (int i=4;i<=7;i++)
		{
			if (Quad[i] != NULL){Quad[i]->remove();}
		}
	}

	//Méthode de suppression du Night Vision
	void DeleteNightVision()
	{
		if (RTexNV){RTexNV->drop();}
		for (int i=8;i<=10;i++)
		{
			if (Quad[i] != NULL){Quad[i]->remove();}
		}
	}

	//Méthode de suppression
	void DeleteEffects()
	{
		//On test si notre Render Texture existe bien et on supprime
		if (RTexGlow){RTexGlow->drop();}
		if (RTexDream){RTexDream->drop();}
		if (RTexNV){RTexNV->drop();}

		for (int i=0;i<=10;i++)
		{
			if (Quad[i] != NULL){Quad[i]->remove();}
		}
	}
}

/*-----------------------------------------
Programmed by Fabre Cédric 
(Copland/simson) 02/10/2006
Thanks to the Irrlicht team  
for this good 3D engine !
This code has not been tested under Linux.
If you find any errors or corrections,
in advance thanks you for any feedbacks.
-------------------------------------------
Contact : simson2004@wanadoo.fr
-----------------------------------------*/

using namespace irr;

namespace EffectsLibrary
{
	class CQuadSceneNode : public scene::ISceneNode
	{
	public:
		CQuadSceneNode(scene::ISceneNode* parent, scene::ISceneManager* mgr, s32 id);
		virtual void OnPreRender();
		virtual void render();
		virtual const core::aabbox3d<f32>& getBoundingBox() const;
		u32 getMaterialCount();
		virtual video::SMaterial& getMaterial(u32 i);
	private :
		core::aabbox3d<f32> Box;
		video::S3DVertex VertexQuad[4];
		video::SMaterial Material;
	};

	void CreateGlow(scene::ICameraSceneNode* CamGlow,scene::ISceneManager* smgr,s32 GlowSize);
	void RenderGlow(scene::ISceneManager* smgr,s32 gA,s32 gR,s32 gG,s32 gB,u32 NbsOfPass);

	void CreateDreamFilter(scene::ICameraSceneNode* CamDream,scene::ISceneManager* smgr,f32 EffectSize,s32 DreamSize);
	void RenderDreamFilter(scene::ISceneManager* smgr,s32 dA,s32 dR,s32 dG,s32 dB);

	void CreateNightVision(scene::ICameraSceneNode* CamNightVision,scene::ISceneManager* smgr,irr::c8* NoiseFile,s32 NightVisionSize);
	void RenderNightVision(scene::ISceneManager* smgr);

	void RenderNothing();

	void DeleteGlow();
	void DeleteDream();
	void DeleteNightVision();

	void DeleteEffects();
}

Je vais tester ca, puis je vous en dit mon avis.

Salut,
J'ai essayé ton code mais j'ai un problème au niveau de la ligne 67 de CEffects.cpp.
Voici la ligne :
ISceneNode::OnRender();

Je suis sous Irrlicht 1.4 et j'ai cherché un membre du style de celui-là mais je n'en trouve pas.
Existe t'il un membre du même type ?

Merci d'avance.

Gp2mv3

remplace

ISceneNode::OnRender();

par

ISceneNode::OnRegisterSceneNode();



Edit : OnRender ses pour les version enterieur de irrlicht ( 1.0 à 1.2 ) pour les nouvelle versin ses OnRegisterSceneNode ^^

Ok, merci, je vais essayer.

J'ai une erreur dans mon compilateur :
No space left on device
Assembler messages:
No space left on device

Enfin, c'est vraisemblablement l'assembleur qui plante.