Pages: 1 2

 

#0 

02-10-2006 22:07:55

Copland
Modérateur
Lieu: ZarbiLand
Date d'inscription: 22-09-2006
Messages: 657
Site web

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 @++ smile

Config : I5 2400, ATI HD6870 1Go DDR5, 4Go DDR3.
Single Boot : Windows Seven.

Hors ligne


#1 

02-10-2006 22:09:16

DeusXL
Abonné
Lieu: Paris
Date d'inscription: 27-09-2006
Messages: 174

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

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

Dernière modification par DeusXL (02-10-2006 22:12:12)

Fanatique d'Irrlicht + Fanatique de Mono + Fanatique de Linux => Créateur d'Irrlicht .NET CP bien sûr !
Version actuelle d'Irrlicht .NET CP : 0.8, Version en test : 0.9.

Hors ligne


#2 

03-10-2006 12:52:59

izguit
Administrateur
Lieu: 127.0.0.1
Date d'inscription: 14-09-2006
Messages: 306
Site web

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 smile la classe smile

Athlon 64 3000+ // 1Go RAM // Geforce 6600GT 128Mo
Turion 64 X2 // 1Go RAM // ATI X1250

Hors ligne


#3 

03-10-2006 13:17:36

Copland
Modérateur
Lieu: ZarbiLand
Date d'inscription: 22-09-2006
Messages: 657
Site web

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

Config : I5 2400, ATI HD6870 1Go DDR5, 4Go DDR3.
Single Boot : Windows Seven.

Hors ligne


#4 

04-10-2006 21:56:27

kedu
Modérateur
Date d'inscription: 23-09-2006
Messages: 155

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

Hors ligne


#5 

12-10-2006 17:43:57

Squarch
Petit nouveau
Date d'inscription: 11-10-2006
Messages: 4

c'est tres reussi bravo wink

www.af-3d-studio.info

Hors ligne


#6 

12-10-2006 19:23:45

Aranoth
Abonné
Lieu: Toulouse
Date d'inscription: 25-09-2006
Messages: 242
Site web

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 !

Planet-DEV, où on parle d'informatique, de développement et de création de jeux vidéo

Hors ligne


#7 

22-10-2006 22:39:55

Dekron
Membre
Lieu: Orléans
Date d'inscription: 21-10-2006
Messages: 46
Site web

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

Visitez Arcis : MMORPG ammateur utilisant irrlicht !
Etudiant ingénieur, maitrise C++, connaissances python & php.

Hors ligne


#8 

22-10-2006 22:47:00

Dekron
Membre
Lieu: Orléans
Date d'inscription: 21-10-2006
Messages: 46
Site web

"Simson, sur irrlicht.sourceforge.org" :

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.


Besoin d'aide ?

Visitez Arcis : MMORPG ammateur utilisant irrlicht !
Etudiant ingénieur, maitrise C++, connaissances python & php.

Hors ligne


#9 

23-10-2006 00:08:57

Copland
Modérateur
Lieu: ZarbiLand
Date d'inscription: 22-09-2006
Messages: 657
Site web

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

Config : I5 2400, ATI HD6870 1Go DDR5, 4Go DDR3.
Single Boot : Windows Seven.

Hors ligne


#10 

23-10-2006 11:22:54

Dekron
Membre
Lieu: Orléans
Date d'inscription: 21-10-2006
Messages: 46
Site web

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 ...

Visitez Arcis : MMORPG ammateur utilisant irrlicht !
Etudiant ingénieur, maitrise C++, connaissances python & php.

Hors ligne


#11 

10-12-2006 20:16:28

N10
Membre
Date d'inscription: 27-10-2006
Messages: 46

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

Hors ligne


#12 

10-12-2006 23:55:07

Jerry Kan
Habitué
Date d'inscription: 21-11-2006
Messages: 265

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

Dernière modification par Jerry Kan (10-12-2006 23:55:39)

Hors ligne


#13 

30-12-2006 16:26:46

Copland
Modérateur
Lieu: ZarbiLand
Date d'inscription: 22-09-2006
Messages: 657
Site web

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

CEffects.cpp:

Code:

/*-----------------------------------------
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 : [email protected]
-----------------------------------------*/

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

CEffects.h:

Code:

/*-----------------------------------------
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 : [email protected]
-----------------------------------------*/

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();
Config : I5 2400, ATI HD6870 1Go DDR5, 4Go DDR3.
Single Boot : Windows Seven.

Hors ligne


#14 

30-12-2006 18:49:37

Aranoth
Abonné
Lieu: Toulouse
Date d'inscription: 25-09-2006
Messages: 242
Site web

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

Planet-DEV, où on parle d'informatique, de développement et de création de jeux vidéo

Hors ligne


#15 

30-12-2006 20:03:58

Copland
Modérateur
Lieu: ZarbiLand
Date d'inscription: 22-09-2006
Messages: 657
Site web

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

Config : I5 2400, ATI HD6870 1Go DDR5, 4Go DDR3.
Single Boot : Windows Seven.

Hors ligne


#16 

31-12-2006 13:52:38

smeagol
Membre
Date d'inscription: 30-10-2006
Messages: 34

Le code est-il compilable sous nunux.

Hors ligne


#17 

31-12-2006 14:11:57

Copland
Modérateur
Lieu: ZarbiLand
Date d'inscription: 22-09-2006
Messages: 657
Site web

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

Config : I5 2400, ATI HD6870 1Go DDR5, 4Go DDR3.
Single Boot : Windows Seven.

Hors ligne


#18 

31-12-2006 14:40:27

Jerry Kan
Habitué
Date d'inscription: 21-11-2006
Messages: 265

smeagol :

Le code est-il compilable sous nunux.


chez moi ca compile (en ligne de commande, sans ide, fedora code 4), mais j'ai du faire les modif dont j'ai parlé précédemment :

remplacer <CEffets.h> par "CEffects.h" et encader les code du .h par #ifndef Machin88 #define  Machin88  .... #endif

Hors ligne


#19 

12-02-2007 18:34:10

Copland
Modérateur
Lieu: ZarbiLand
Date d'inscription: 22-09-2006
Messages: 657
Site web

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

Code:

/*-----------------------------------------
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 : [email protected]
-----------------------------------------*/

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

CEffects.h

Code:

/*-----------------------------------------
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 : [email protected]
-----------------------------------------*/

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

Voilou, en espérant que vous y apporterez des améliorations, ça serai sympa smile.
@+

Config : I5 2400, ATI HD6870 1Go DDR5, 4Go DDR3.
Single Boot : Windows Seven.

Hors ligne


#20 

28-02-2007 17:14:39

alikettab
Petit nouveau
Date d'inscription: 28-02-2007
Messages: 3

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

Hors ligne


#21 

30-12-2007 13:34:00

gp2mv3
Abonné
Date d'inscription: 27-06-2007
Messages: 103
Site web

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

Mon projet sous Irrlicht : RoM : Rebuilding on Mars
N'hésitez pas à y faire un tour wink

Hors ligne


#22 

30-12-2007 15:54:10

Magun
SleekThink Producer
Lieu: Punakha
Date d'inscription: 18-11-2007
Messages: 910
Corrections: 2
Site web

remplace

ISceneNode::OnRender();

par

ISceneNode::OnRegisterSceneNode();

wink

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

Project: ImmortalGalaxy, portfolio, github, Agence DRIAD

Hors ligne


#23 

30-12-2007 16:00:03

gp2mv3
Abonné
Date d'inscription: 27-06-2007
Messages: 103
Site web

Ok, merci, je vais essayer.

Mon projet sous Irrlicht : RoM : Rebuilding on Mars
N'hésitez pas à y faire un tour wink

Hors ligne


#24 

30-12-2007 16:03:34

gp2mv3
Abonné
Date d'inscription: 27-06-2007
Messages: 103
Site web

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.

Mon projet sous Irrlicht : RoM : Rebuilding on Mars
N'hésitez pas à y faire un tour wink

Hors ligne


 

Pages: 1 2

Options Liens officiels Caractéristiques Statistiques Communauté
Corrections
 irrlicht
irrklang
irredit
irrxml
 xhtml 1.0
css 2.1
Propulsé par FluxBB
Traduit par FluxBB.fr
 882 membres
1429 sujets
11119 messages
 Dernier membre inscrit: LiseBuisson96
53 invités en ligne
Aucun membre connecté
RSS Feed