Bonjour.

J'ai deux écrans (moniteurs).
Je veux afficher sur le premier moniteur la vue FPS depuis un personnage. Sur le deuxième moniteur je veux afficher le même personnage mais depuis une vue externe (à la 2e personne).
Est-ce que quelqu'un qui connait bien la structure d'Irrlicht aurait une idée?

Merci.

Ca dépend de comment marche tes deux écrans.

Avec le Control Panel d'NVidia je peux multiplier la résolution en largeur par 2, et la moitié sera sur l'écran 1, l'autre sur l'écran 2

Il ne te restes plus qu'a faire une application avec Irrlicht de la taille de tes deux écrans (par exemple pour un jeu en 1024*768 tu devras faire du 2048*768) et y mettre deux Viewports, un ( 0 , 0 , 1024 , 768 ) et l'autre ( 1024 , 0 , 1024 , 768 )

J'espère que c'est assez clair ^^

Aranoth :

Il ne te restes plus qu'a faire une application avec Irrlicht de la taille de tes deux écrans (par exemple pour un jeu en 1024*768 tu devras faire du 2048*768) et y mettre deux Viewports, un ( 0 , 0 , 1024 , 768 ) et l'autre ( 1024 , 0 , 1024 , 768)

( 0 , 0 , 1024 , 768 ) et ( 1024 , 0 , 2048 , 768) plutot non ?
Sinon pour dire que j'ai du faire la même chose mais pour faire de la stéréoscopie et que j'ai eu plein de problème(cf topic qui date de quelque semaine) :
avec opengl couleur bizarre et à l'envers
avec directx taille maximum de 200*300. Donc si tu y arrive cela m'interesserait de savoir comment tu a fait.
Sinon je te conseil de regarder l'exemple irrlicht qur le rendu sur texture qui devrait peut etre t'aider.
Apres je suis en train de voir qu'aranoth a parler de viewport je vais voir se que cela signifie reelement.

dark calculator

P.S. : Si tu ve que je te passe mon code demande moi.

Merci beaucoup. Je penses avoir trouvé une solution toute bête. Si sa marche je vous l'exposerai. Dark calculator ton code m'intéresse tout de même. Merci

class stereo
{
public:
    stereo(IrrlichtDevice *);
    ~stereo();
    
    int init(int,int);
    int draw();
private:
    ITexture* rt;
    ITexture* rt2;
    ICameraSceneNode* fixedCam;
    scene::ICameraSceneNode* camera;

    video::IVideoDriver* driver;

    scene::ISceneManager* smgr;

    gui::IGUIEnvironment* env;
};

//Récupère driver, smgr et env a partir du device
stereo::stereo(IrrlichtDevice *device)
{
    driver = device->getVideoDriver();

    smgr = device->getSceneManager();

    env = device->getGUIEnvironment();
}

//initialise les deux images ou seront projeté les deux rendues
int stereo::init(int l,int h)
{
    if (driver->queryFeature(video::EVDF_RENDER_TO_TARGET))//verifie que le driver supporte le rendu vers une texture
    {
        camera = smgr->addCameraSceneNodeFPS();
        rt = driver->createRenderTargetTexture(dimension2d<s32>(l,h));
        env->addImage(rect<s32>(0,0,l,h))->setImage(rt);

        rt2 = driver->createRenderTargetTexture(dimension2d<s32>(l,h));
        env->addImage(rect<s32>(l,0,2*l,h))->setImage(rt2);

        fixedCam = smgr->addCameraSceneNode();

        fixedCam->setFarValue(12000.0f);
    }
}

stereo::~stereo()
{
    
}

//dessine les deux rendus
int stereo::draw()
{
    if (rt)
    {
        driver->setRenderTarget(rt, true, true, video::SColor(0,200,200,200));     
        smgr->setActiveCamera(fixedCam);
        vector3df norm = camera->getTarget() - camera->getPosition();
        norm.rotateXZBy(90,vector3df(0,0,0));
        norm.normalize();
        norm *= 0.01;
        fixedCam->setPosition(camera->getPosition() + norm);
        fixedCam->setRotation(camera->getRotation());
        fixedCam->setTarget(camera->getTarget());
        smgr->drawAll();
        smgr->setActiveCamera(camera);
        driver->setRenderTarget(rt2, true, true, video::SColor(0,200,200,200));
        smgr->drawAll();
        driver->setRenderTarget(0, true, true, video::SColor(0,200,200,200));
    }
//Cette partie est nécessaire pour que le monde continue a tourner, si je peux m'exprimer ainsi.
//Elle permet de faire fonctionner certain éléments comme les animations. Enfin je crois
    smgr->getRootSceneNode()->setVisible(false);
//Il n'est pas nescessaire de rendre les objets donc on les caches
    smgr->drawAll();
    smgr->getRootSceneNode()->setVisible(true);

    env->drawAll();
}

Voila apparament j'avais fait une classe pour gerer sa, je deconseil de l'utiliser comme sa mais sa peut permetter de mieu comprendre. Le but etait de faire de la stereoscopie mais c'est facilement adaptable

dark calculator

P.S. : si vous voulez en savoir plus demander moi

dark calculator :

( 0 , 0 , 1024 , 768 ) et ( 1024 , 0 , 2048 , 768) plutot non ?

Ça dépend si tu définis Position + Dimension (ce que j'ai fais dans cet exemple) ou Bord haut-gauche et Bord bas-droite.

dark calculator :

Apres je suis en train de voir qu'aranoth a parler de viewport je vais voir se que cela signifie reelement.

Les viewport sont en quelque sorte des "sous zones de rendu", c'est ce qu'on utilise entre autre pour faire des écrans splittés dans les jeux consoles (tu sais les écrans partagés en 4, chacun avec une vue différente correspondant à un joueur)


http://irrlicht.sourceforge.net/docu/cl … r.html#a77

Salut

Aranoth :

[quote=dark calculator]( 0 , 0 , 1024 , 768 ) et ( 1024 , 0 , 2048 , 768) plutot non ?

Ça dépend si tu définis Position + Dimension (ce que j'ai fais dans cet exemple) ou Bord haut-gauche et Bord bas-droite.[/quote]
Oups !
Effectivement je n'y avais pas pensé j'ai toujours utilisé les coins se qui est d'ailleur moins pratique mais on a du mal a changé ses habitudes.

Aranoth :

[quote=dark calculator]Apres je suis en train de voir qu'aranoth a parler de viewport je vais voir se que cela signifie reelement.

Les viewport sont en quelque sorte des "sous zones de rendu", c'est ce qu'on utilise entre autre pour faire des écrans splittés dans les jeux consoles (tu sais les écrans partagés en 4, chacun avec une vue différente correspondant à un joueur)


http://irrlicht.sourceforge.net/docu/cl … r.html#a77[/quote]
Sa m'interesse drolement sa.
En gros il suffit  de faire :

driver->setViewPort(rect<s32>(0,0,1024,1024));
smgr->setActiveCamera(cam1);
smgr->drawall();
driver->setViewPort(rect<s32>(1024,0,2048,1024));
smgr->setActiveCamera(cam2);
smgr->drawall();

Pour faire un double rendu ?
Si oui c'est genial, et surtout que sa doit mieu marcher que les render to texture, je crois que je vais  le tester tout a l'heure.

dark calculator

Yep, voilà un vieil exemple que j'avais codé à l'arrache dans le temps :

while(Device->run())
    {
        Driver->setViewPort(rect<s32>(0,0,WinX,WinY));
        Driver->beginScene(true,true,SColor(0,100,100,100));

            for(int i=0; i<4; ++i)
            {
                Player[i].Node->setPosition(Player[i].Cam->getPosition());
                Player[i].Node->setRotation(vector3df(0,Player[i].Cam->getRotation().Y,0));
            }

            Smgr->setActiveCamera(Player[0].Cam);
            Driver->setViewPort(rect<s32>(0,0,WinX/2,WinY/2));
            Player[0].Node->setVisible(false);
            Smgr->drawAll();
            Player[0].Node->setVisible(true);

            Smgr->setActiveCamera(Player[1].Cam);
            Driver->setViewPort(rect<s32>(WinX/2,0,WinX,WinY/2));
            Player[1].Node->setVisible(false);
            Smgr->drawAll();
            Player[1].Node->setVisible(true);

            Smgr->setActiveCamera(Player[2].Cam);
            Driver->setViewPort(rect<s32>(0,WinY/2,WinX/2,WinY));
            Player[2].Node->setVisible(false);
            Smgr->drawAll();
            Player[2].Node->setVisible(true);

            Smgr->setActiveCamera(Player[3].Cam);
            Driver->setViewPort(rect<s32>(WinX/2,WinY/2,WinX,WinY));
            Player[3].Node->setVisible(false);
            Smgr->drawAll();
            Player[3].Node->setVisible(true);

            Driver->setViewPort(rect<s32>(0,0,WinX,WinY));
            Driver->draw2DImage(gui,position2d<s32>(0,0), rect<s32>(0,0,800,600), &rect<s32>(0,0,800,600), SColor(255, 255, 255, 255), true);

            Driver->draw2DImage(Life, rect<s32>(10,10,10+Player[0].Life,10+20),rect<s32>(0,0,100,20));
            Driver->draw2DImage(Life, rect<s32>(410,10,410+Player[1].Life,10+20),rect<s32>(0,0,100,20));
            Driver->draw2DImage(Life, rect<s32>(10,310,10+Player[2].Life,310+20),rect<s32>(0,0,100,20));
            Driver->draw2DImage(Life, rect<s32>(410,310,410+Player[3].Life,310+20),rect<s32>(0,0,100,20));


        Driver->endScene();

Il montre bien le passage d'un Viewport à l'autre, le jeu était une petite démo de FPS à 4 en écran splitté, le but était de la rendre jouable avec la Wiimote (via GlovePIE) pour une soirée ^^
Finalement ça s'est pas fait, mais je suis content de voir que le code peut resservir :p

Dernière modification par Aranoth (23-04-2008 20:16:27)

salut

d'abord merci pour ton aide, sa correspond exactement a se que je chechais depuis longtemps.
Je vais tester sa pour faire de la stereographie mais je n'est aucun doute que sa marche.
Sinon ta petite demo avait l'air bien sympas surtout avec la gestion de la wiimote

Je vous tiens au courant

dark calculator

[EDIT]
Voila c'est fait sa marche impec, quand je pense aux nombres d'heures ou je me suis fait chier avec le rendertotexture alors que c'etait si simple. enfin bon je vous mets un petit screen pour ceux que sa tente de s'escrimer a loucher pendant 10 minutes et d'avoir mal a la tete après. Bon  j'ai juste repris l'exemple des collisions de irrlicht et l'espace entre les deux cameras n'est surement pas optimisé je vais travaillé la dessus mais sa donne déjà quelque chose(pas si flagrant sur la photo que quand on dirige)

[/EDIT]
[EDIT] Pour eviter de continuer a poluer se topic je reprend l'ancien que j'avais creer[/EDIT]

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