bonjour à tous

Je suis en train d'essayer de faire de la stereoscopie avec irrlicht.
Bon pour l'instant c pas super concluant mais bon il faut que je fasse des tests.
Je fait de la stéréoscopie en vue libre se qui signifie qu'il faut 2 fenetres avec sur les 2 une camera qui point les même choses mais avec un leger décalage.
Pour avoir deux fentres je fait un fork en debut de programme mais je pense pas que sa soit la meilleur solution. Je voulais savoir ce qui vous en pensier.
Le mieu pour economiser du FPS, se serait de pouvoir mettre 2 cameras et recuperer séparement leurs images et ensuite de les dessiners dans une même fenetre. Est ce que vous penser que c'est possible?
Plutot que fair un fork ne vaut-il pas mieu instancié 2 fois irrlichrt dans le même processus?

Sinon je voulais savoir aussi si on pouvait deplacer la fenetre irrlicht a partir du code?(sous linux)

merci à tt la communauté(on le dit jamais assez) pour son aide et son existence

dark calculator

salut

voila je remonte ce sujet qui n'a pas eu beaucoup de succès

J'ai découver il y a peu l'exemple d'irrlicht rendertotexture se qui m'a permis de comprendre le fonctionnement de la fonction eponyme. Donc j'ai mes 2 rendues dans la même fenetre, c parfait mais j'ai plusieurs probleme. Le premier est que quand je fait du rendertotexture avec opengl j'ai tout en bleuté(encore sa c pas grave et c lié au fait que je sois sous linux) et surtout j'ai la texture renversé : le haut en bas. Je me demandais, un pourquoi ? et un second comment faire pivoter une ITexture ?
Je suis passé sous windows pour tester le rendu directx mais la il me dit que la taille de sortie est plus grande que le frame buffer ou quelque chosec comme ca. J'ai testé et sa marche uniqquement si je mets une taille de texture inférieur à 200*200. EN revanche le meme code en SOFTWARE2 passe tres bien.

Voila si quelqu'un comprend quelque chose...

Bon comme d'hab je n'est pas du etre claire donc je vous dis se que je veut clairement :
Un double rendertotexture de preference opengl dans une même fenetre. Je précise que j'utilise un IGUIImage mais je sais pas si ca a une importance.

davyg

Yop !

bon, déjà je sais, du peux d'expérience que j'ai de l'API OpenGL que lorsque tu charge une texture, celle-çi est inversée par défaut, il faut, par le biais d'un algo pas très compliqué, replacer chaque pixels au bon endroit dans une nouvelle texture.
Je ne peu pas te donner un code d'exemple pour irrlicht car je combinais SDL/OpenGl, en revanche je peux te dire en gros comment faire :
tu crée une surface tampon, tu lui attribut tout les param de l'autre surface: dimensions (et différents mask quand on manipule OpenGL), puis tu boucle sur chaques lignes et tu attribut le pixel du bout de l'image originale au premier pixel de l'image tampon, et ainsi de suite en incrémentant le compteur pour l'image "flippée" et en décrémentant celui de l'image originale.Tu te fait ainsi toutes les lignes. Tu réalise donc un miroir centré vertical de la texture. Si ton image est inversée horizontalement, tu fait pareil mais avec les colonnes... bref le plus dure reste à faire car je ne sais absolument pas comment appliquer ça avec irrlicht xD
(a merde, je viens de voir que c'est un renversement haut bas dont tu parle, le boulet ><)

pour ce qui est du frame buffer, je pense que la stéréoscopie doit bouffer à mort de mémoire et une carte graphique, à moins d'avoir 512 ou 1024 mo de DDR3, bas ça vas vite déborder du buffer, de la "mémoire", alors que en rendu software, tu utilise la ram du pc, et là t'en as beaucoup plus normalement, donc ça marche. C'est comme si tu balançais ton rendu sur un LCD d'une réso de 1600/1200 avec une geforce 3 xD (Il se peut que je raconte des conneries ).

Dernière modification par bebe (15-03-2008 22:29:54)

salut

Pour le renversement de l'image je vais essayer de suivre se que t'a dit mais c pas gagner. En revanche pour le framebuffuer c quand même bizarre que sous opengl sa marche impec quelque soit la résolution alors que sous directx sa marche pas et puis 200*200 meme doubler on est loin des 1440*900 que m'affiche irrlicht normalement. D'ailluer g une geforce3mx440 j'arrive a avoir une résolution de 1440*900 bon sa doit laguer un peu je te l'accorde mais bon sa ne plante pas. Donc c'est quand même bizarre mais je suppose que le rendertotexture n'est peut etre pas non plus des plus opérationels.

bon je me mets au travail

a+ et merci d'avoir repondu

dark calculator

rebonjour

voila j'ai fait ma petite routine qui a l'air de marcher pour une texture classique en revanche je sais pas comment faire pour une texture rendertotarget car lock renvoie 0.

int flip(ITexture* tex)
{
    char* buf = (char*) tex->lock();
    if (buf==0)
        printf("probleme\n");
    int tp = 0;
    switch (tex->getColorFormat())
    {
        case ECF_A1R5G5B5    : tp = 2;
        case ECF_R5G6B5        : tp = 2;
        case ECF_R8G8B8        : tp = 3;
        case ECF_A8R8G8B8    : tp = 4;
    }
    int size = tex->getSize().Height * tex->getSize().Width * tp;
    char *temp = new char [size];
    for (int i=0;i<size;i++)
        temp[i] = buf[i];
    for (int i=0;i<tex->getSize().Width;i++)
        for (int j=0;j<tex->getSize().Height;j++)
            memcpy(buf + i*tp+j*tex->getSize().Width*tp, temp + i*tp+(tex->getSize().Height-j)*tp*tex->getSize().Width, tp);
    tex->unlock();
}

Donc si quelqu'un a une idée qu'il fasse signe.
Si j'ai le temps je metterait la routine dans la wiki

dark calculator

Dernière modification par dark calculator (15-03-2008 23:47:17)

Hello,
Il te faut tout simplement retourner ta camera avant de capturer ton rendu en texture.
Sinon pour les Rendu En Texture, en directx ils ne doivent pas dépasser la résolution de ton affichage, vu que là tu split la surface d'affichage si j'ai bien compris, il est tout à fait normal que tu ne puisses pas dépasser une certaine taille en pixel.

Il me suffit de faire un setrotation sur la camera et c'est bon ?
Je vais tout de suite aller tester

Pour directx je comprend pas tout ce que t'a dit : c'est quoi la résolution d'affichage ?
Pour moi c'est se qu'on passe en argument à createdevice donc je ppasse par exemple 600*300 si je mets 2 render to texture de 300*300 et 300*300 je comprend pas pk sa marche pas ?

[edit]
Bon j'esssayer de faire une rotation directement sur la camera sa n'a pas marcher alors du coup je suis passer par la matrice de projection et je fait :

matrix4 mat = fixedCam->getProjectionMatrix();
mat.setRotationDegrees(mat.getRotationDegrees()+vector3df(0,0,180));
fixedCam->setProjectionMatrix(mat);

Alors je suis bien a l'endroit de haut en bas mais du coup je suis a l'envers de gauche a droite ce qui n'est pas vraiment une amélioration. Je me suis dit que jallais faire une rotation sur l'axe dex X de 180, normalement sa devrait marcher mais je n'en suis pas sur mais de toute maniere quand je le fait je me retrouve avec un ecran vide(juste la couleur de fond du driver)  Donc peut etre qu'il ne faut pas utiliser la matrice de projection ou bien la modifier différement. Je suis pas un expert en matrice de projection mais je me dit que peut etre qu'un -1 bien placer devrai suffire. Je vais chercher de ce coté la.

Dernière modification par dark calculator (16-03-2008 08:17:24)

Autre chose d'important, ton rendu en texture doit être obligatoirement dans la norme 64,128,256,512 etc ne jamais utiliser des tailles non standard pour se genre de rendu sinon bien souvent ça bug .
Ce qui m'étonne c'est qu'en openGL ils ont corrigés la texture à l'envers sur les dernières versions d'irrlicht, tu utilises laquelle et tu effectus ton rendu de quelle manière ?

Oups effectivement je suis a la version 1.3.1 je n'avais même pas fait gaffe mais je change regulierement d'ordinateur donc je ne sais jamais trop ou j'en suis je vais de se pas tester avec la 1.4 et je vais mettre des rendus en puissance de 2.

merci de ton aide

dark calculator

Je vient de tester avec la 1.4 et c'est toujours a l'envers donc je ne vois plut trop quoi faire. J'ai bien mis des puissance de 2 sa n'a rien changé a part faire une rotation à la texture ou a la camera je ne vois pas mais je n'est reussi aucun des deux.

Donc si vous avez une idéee... C'est dommage car sa devrait donner un truc pas mal.

dark calculator

Salut,

/**********************************************************************/
/***************************** stereo.hpp *****************************/
/**********************************************************************/
/* Permet le double rendu d'une scene irrlicht pour pouvoir voir la   */
/* La scène en relief(stéréoscopie). On utilise les viewports pour    */
/* Rendre deux fois la scène.                                         */
/**********************************************************************/
/**********************************************************************/

//Déclaration de la classe
class stereo
{
public:
    stereo(IrrlichtDevice *);//Constructeur
    ~stereo();//Destructeur
    
    int init(scene::ICameraSceneNode* = 0);//initialise les cameras
    int draw();//Effectue le rendu

    scene::ICameraSceneNode* camera;//Camera FPS
    scene::ICameraSceneNode* fixedCam;//Camera fixe

    video::IVideoDriver* driver;

    scene::ISceneManager* smgr;
};

//Constructeur qui recupere l'IrrlichtDevice pour avoir les pointeurs vers le driver et la scene
stereo::stereo(IrrlichtDevice *device)
{
    driver = device->getVideoDriver();

    smgr = device->getSceneManager();
}

//ajoute les deux cameras (une seul si la fps est passé en argument)
int stereo::init(scene::ICameraSceneNode* cam)
{
    if (!cam)//regarde si cam est définit
        camera = smgr->addCameraSceneNodeFPS();//Camera FPS
    else
        camera = cam;
    fixedCam = smgr->addCameraSceneNode();//Camera fixe qui sera placer a coté de l'autre'

    fixedCam->setFarValue(12000.0f);//change le farvalue de la fixe pour qu'elle voit aussi loin que la fps
}

//Destructeur qui ne detruit rien
stereo::~stereo()
{
    
}

int stereo::draw()
{
    core::dimension2d<s32> s = driver->getScreenSize();//recupere les dimensions de "l'ecran"

    core::vector3df norm = camera->getTarget() - camera->getPosition();//Creée un verteur orthogonal au plan de projection de la camera
    norm.rotateXZBy(-90,core::vector3df(0,0,0));//Fait une rotation de 90° pour avoir un vecteur dans la direction d'ou sera la camera
    norm.normalize();//Mets à 1 la longeur du vecteur pour pouvoir choisir la bonne distance sans toucher a la direction
    norm *= 50;//Multiplie toute les composantes du vecteur par un nombre constant pour changer la distance
    fixedCam->setPosition(camera->getPosition() + norm);//Mets a jour la position de la camera fixe en translatant la posittion de la FPS avec le veteur norm
    fixedCam->setRotation(camera->getRotation());//Place la même rotation
    fixedCam->setTarget(camera->getTarget()+ norm);//Mets a jour le target comme on a mis a jour la position

    driver->setViewPort(core::rect<s32>(0,0,s.Width/2,s.Height/2));//Premier viewport
    smgr->setActiveCamera(fixedCam);//Séléctionne la première caméra
    smgr->drawAll();//Dessine le premier rendu

    driver->setViewPort(core::rect<s32>(s.Width/2,0,s.Width,s.Height/2));//Second viewport
    smgr->setActiveCamera(camera);//Séléctionne la seconde caméra
    smgr->drawAll();//Dessine le second rendu
}

Voila j'ai fait une petite classe qui gere la stereoscopie il suffit de faire :

#include "stereo.hpp"

(...)

stereo s;
s.init();

(...)

//Dans la boucle de rendu
s.draw();

Pour pouvoir avoir la stereoscopie. Evidement la taille de l'ecran sera deux fois plus petit que la taille normal.
Sinon je me demandais si il etait possible de creer une class derivant de ISceneManager pour rendre la steroscopie totalement transparente?
Je ne sais si c'est "bien" comme système ou il vaut mieu faire comme j'ai fait avec une classe a part mais qui je trouve est moin pratique et un bordelique.

Sinon sa marche bien(enfin je trouve), le seul probleme sont quand on fait appelle directement a des fonctions draw du device qui va alors dessiner que sur le dernier viewport.



dark calculator

Dernière modification par dark calculator (24-04-2008 11:12:58)

Sinon je me demandais si il etait possible de creer une class derivant de ISceneManager pour rendre la steroscopie totalement transparente?
Je ne sais si c'est "bien" comme système ou il vaut mieu faire comme j'ai fait avec une classe a part mais qui je trouve est moin pratique et un bordelique.

Oui, c'est possible. Ton scene manager contiendra ta seconde caméra et s'occupera de rendre la scène deux fois, comme un grand.

Sinon sa marche bien(enfin je trouve), le seul probleme sont quand on fait appelle directement a des fonctions draw du device qui va alors dessiner que sur le dernier viewport.

Tu vas être obligé d'afficher deux fois ta gui, une fois par viewport


Bon, maintenant il te restes plus qu'a nous faire la vue "3D vert-rouge"
Là le must est d'utiliser deux Render to Texture avec un shader qui va bien

Aranoth :

Bon, maintenant il te restes plus qu'a nous faire la vue "3D vert-rouge"
Là le must est d'utiliser deux Render to Texture avec un shader qui va bien

Je l'avais fait mais etant sans lunette je n'est jamais pu vraiment tester.
Quand au shader je sais a peine se que c'est reelement et le rendertotexture marche plus que tres mal mais peut etre que se sera mieu standardiser dans une future version

dark calculator

dark calculator :

[quote=Aranoth]Bon, maintenant il te restes plus qu'a nous faire la vue "3D vert-rouge"
Là le must est d'utiliser deux Render to Texture avec un shader qui va bien

Je l'avais fait mais etant sans lunette je n'est jamais pu vraiment tester.
Quand au shader je sais a peine se que c'est reelement et le rendertotexture marche plus que tres mal mais peut etre que se sera mieu standardiser dans une future version

dark calculator[/quote]
Je n'ai jamais eu aucun problème avec les Render to Texture, c'est quelque chose de parfaitement utilisable avec Irrlicht, je te l'assures !
Le principe est de rendre ta scène dans deux textures différentes à partir des deux caméras, et dans le shader d'appliquer les filtres rouge et vert et de "mixer" l'image

Ben personnelement a chaque fois que j'ai fait un rendertotexture sa n'a pas marche :
sous opengl : c'est a l'envers et la couleur est bizarre.
sous directx la taille maximal est de 300*300
Donc c'est vraiment bizarre si tu dis que sa marche. Mais bon c'est pas fait pour faire le rendu final et je ne sais peut etre pas bien m'en servir.
Sinon je me demandais si le rendu sur viewport etait filtrabe, je pense pas mais bon on sait jamais

dark calculator

sous opengl : c'est a l'envers et la couleur est bizarre.
sous directx la taille maximal est de 300*300

Sous OpenGL normal que ce soit à " l'envers ", c'est juste une histoire de coordonnées de texture.
Pour la couleur et la taille maxi, a mon avis ça vient de ta carte graphique.

Sinon je me demandais si le rendu sur viewport etait filtrabe, je pense pas mais bon on sait jamais

Par filtrable tu entends appliquer un filtre de couleur ? Si oui c'est impossible sans Render to Texture (ou alors faut jouer directement sur le color buffer, à la main, mais ça va être super long et ça raaaaamera)
Bref RTT + shader pour ça. C'est fait pour.

Sous OpenGL normal que ce soit à " l'envers ", c'est juste une histoire de coordonnées de texture.

Ils étaient quand même censé l'avoir corrigé se problème de rtt à l'envers, je suis étonné que ça ressorte encore :s.
Ca a dû être fixé à la version 1.4 du 30/11/2007 d'après leur changelog :

- OpenGL render targets now the same way up as the other drivers. If you have
   written opengl shaders that use render targets then you'll need to change your
   texture coordinates accordingly.