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
