Tutorial Básico # 3 – Uso de Cámaras y Viewports en Ogre

En este tutorial estaremos comentando los aspectos básicos del uso de  cámaras  en Ogre 3D, lo cual nos servirá para expandir un poco mas allá nuestros conocimientos sobre el funcionamiento de Ogre, también veremos brevemente el uso de los Viewports (algo así como Puntos de Visión). Sin más que agregar en esta introducción los invito a pasar al tutorial.

.

Prerequisitos

.

Para poder completar satisfactoriamente el tutorial debes dominar el procedimiento para crear un nuevo proyecto basado en el asistente de aplicaciones de Ogre3d, si no sabes como hacer esto dale un vistazo al Tutorial #1 – Guía Paso a Paso para crear nuestra primera aplicación con Ogre3D.

.

Cámaras

.
Una cámara es lo que usamos para ver la escena que hemos creado. Una cámara es un objeto especial que trabaja de una forma similar a los SceneNode. El objeto Cámara tiene las funciones setPosition, yaw, roll y pitch, y es posible asociarla(en los tutoriales anteriores me referia a adjuntar como traducción de attach pero creo que el término asociar deja una idea más clara asi que a partir de ahora lo utilizaré) a un  SceneNode.
Como en los SceneNodes, la posición de las cámaras es relativa a la de los SceneNode padre (se debe respetar siempre a los mayores jaja). Para realizar movimientos y rotaciones se  puede pensar en las cámaras como SceneNodes.

Algo a destacar  y que quizás sea un poco diferente a lo que esté esperando es que solo utilizaremos una cámara a la vez (por el momento ). Es decir, no crearemos una cámara para ver una parte de la escena y otra para ver otra parte e iremos activándolas o desactivándolas en función de lo que deseemos ver. En vez de eso, crearemos SceneNodes que actuaran como puntos donde queremos que la cámara se sitúe. Cuando queramos enfocar una parte en concreto, simplemente asociaremos la cámara a un SceneNode o a otro.

.

Creando una cámara

.

Como hemos estado haciendo en los tutoriales anteriores comenzaremos creando un nuevo proyecto basado en nuestro asistente (para dudas ver los tutoriales anteriores).  Yo he llamado a mi proyecto tutorial3. Como hemos usado el asistente, este ha creado para nosotros una cámara y el respectivo control de la misma por lo que vamos a explicar línea a línea que es lo que se va haciendo en cada momento.

Para eso vamos a nuestro explorador de soluciones y  hacemos doble clic sobre el archivo BaseApplication.cpp.

Entre las líneas 88 y 100 tendremos algo como esto.

void BaseApplication::createCamera(void)
{
// Create the camera
mCamera = mSceneMgr->createCamera(«PlayerCam»);

// Position it at 500 in Z direction
mCamera->setPosition(Ogre::Vector3(0,0,80));
// Look back along -Z
mCamera->lookAt(Ogre::Vector3(0,0,-300));
mCamera->setNearClipDistance(5);

mCameraMan = new OgreBites::SdkCameraMan(mCamera);   // create a default camera controller
}

Con esas sencillas líneas de código tenemos lo suficiente crear y posicionar nuestra cámara.

Vamos a analizar el código línea por línea.

Como las cámaras están vinculadas al SceneManager en el que residen, se usa el objeto SceneManager para crearlas.

mCamera = mSceneMgr->createCamera(«PlayerCam»);

El código anterior crea  una  cámara  con  el  nombre  “PlayerCam”.

Usted puede  usar  la  función getCamera del SceneManager para acceder a cámaras basadas en su nombre y así no tener que mantener un puntero a ellas.

Lo siguiente que analizaremos es como se determina  la posición de la cámara y la dirección a la que está orientada. Situaremos objetos alrededor del origen, por ello pondremos la cámara a una buena distancia en el eje z positivo y orientada hacia el origen.  Esto podemos lograrlo con el siguiente código.

mCamera->setPosition(Ogre::Vector3(0,0,500));
mCamera->lookAt(Ogre::Vector3(0,0,0));

Nótese que se han modificado los valores por defecto que genera el asistente de aplicaciones

La función lookAt es muy útil. Puede enfocar la cámara en la posición que desee en lugar de tener que usar las funciones yaw, rotate y pitch para rotarla. El SceneNode también  tiene  esta  función,  haciendo  en  algunos  casos  más  fácil  configurar  la orientación de las Entitys
Para  finalizar,  configuraremos  el  NearClipDistance a  unas  5  unidades.  El NearClipDistance de la cámara especifica cuan cerca o lejos puede estar algo antes de dejar de verlo. Configurar el NearClipDistance hace que sea mas fácil ver a través de las Entitys cuando estas muy cerca de ellas. La alternativa a esto es que al estar muy cerca de un objeto no veas nada mas en la pantalla que una pequeña porción de este.

También puede configurar el FarClipDistance. Eso detendrá el motor de renderizado de cualquier objeto  que se encuentre más  lejos  del  valor  dado.  Esto  se  usa,  principalmente,  para  incrementar  el framerate  si  está  renderizando  muchas  cosas  en  la  pantalla.  Para  fijar  el NearClipDistance añada esta línea:

mCamera->setNearClipDistance(5);

Una vez hecho esto solamente nos quedaría crear nuestro controlador para la cámara, como es de suponer este también es creado por nuestro asistente. El código es el siguiente.

mCameraMan = new OgreBites::SdkCameraMan(mCamera);

Con esto ya hemos analizado línea a línea el código que amablemente nos ha generado nuestro asistente. Pasemos los Viewports (Puntos de Visión).

.

Viewports

.

Al empezar a tratar con múltiples cámaras, el concepto de la clase Viewport empieza a ser mucho mas útil. Es importante entender como Ogre decide qué cámara usar cuando renderiza una escena. En Ogre es posible tener varios SceneManagers funcionando al mismo tiempo, también es posible dividir la pantalla en varias áreas, y tener diferentes cámaras renderizando diferentes áreas en la pantalla. (por ejemplo la vista dividida en un juego para 2 jugadores).

Ejemplo de uso de dos ViewPorts

Para entender como Ogre renderiza una escena, considere tres de los constructores  de Ogre:  La  cámara,  el  SceneManager,  y  la  RenderWindow.  La  RenderWindow  es básicamente la pantalla donde se muestra todo. El SceneManager crea cámaras para ver la escena y usted debe indicarle a la RenderWindow que cámaras mostrar en la pantalla, y la porción  de  ventana  donde  desea  renderizarlas.  El  área  en  la  que  se  le  indica  a RenderWindow donde mostrar las cámaras es el Viewport. En la mayoría de los usos de Ogre,  generalmente  se  crea  una  única  cámara  y  esta  se  muestra  en  toda  la RenderWindow, necesitando tan solo un Viewport.

Nuestro Asistente de aplicaciones también nos ha generado nuestro Viewport, ahora analizaremos el código línea a línea, este se encuentra en el archivo BaseApplication.cpp.

Entre las líneas 158 y 167 tendremos algo así:

void BaseApplication::createViewports(void)
{
// Create one viewport, entire window
Ogre::Viewport* vp = mWindow->addViewport(mCamera);
vp->setBackgroundColour(Ogre::ColourValue(0,0,0));

// Alter the camera aspect ratio to match the viewport
mCamera->setAspectRatio(
Ogre::Real(vp->getActualWidth()) / Ogre::Real(vp->getActualHeight()));
}

Empecemos a analizar el código.

Ogre::Viewport* vp = mWindow->addViewport(mCamera);

Para  crear  el  Viewport simplemente llamaremos a la función addViewport de RenderWindow  indicando la cámara  que  estamos  usando.  Tenga en cuenta que  el asistente de aplicaciones  ya  ha  incluido  nuestra RenderWindow  a  la  clase  mWindow.

Ahora que tenemos nuestro Viewport podemos  llamar  a  la  función setBackgroundColour para fijar el color que deseemos en el fondo de la escena.  Como en tutoriales anteriores hemos estado trabajando con el Color de Fondo del ViewPort en Negro vamos a cambiarlo un poco para ver como luce. Para esto modificamos la siguiente línea de código.

vp->setBackgroundColour(Ogre::ColourValue(0.5,0,0));

y tendremos a nuestro famoso ogrito en un fondo con una tonalidad rojiza.

Los  parámetros  de  ColourValue  son  la  cantidad  de  color  rojo,  verde  y  azul (respectivamente) que deseamos, con valores entre 0 y 1. Para acabar, la cosa más importante  que  necesitamos  hacer  es  establecer  la  relación  de  aspecto  de  nuestra cámara. Esto lo logramos con lo siguiente:

mCamera->setAspectRatio(
Ogre::Real(vp->getActualWidth()) / Ogre::Real(vp->getActualHeight()));

Con esto ya hemos analizado el código que nuestro asistente nos genera para las cámaras y los viewports. En el próximo tutorial estaremos trabajando con luces y sombras.

Si este tutorial le ha servido de alguna ayuda o piensa que puede servir a otros deje su comentario a modo de agradecimiento.

Un saludo desde Cuba de Cubansephiroth.

Ogre::Viewport* vp = mWindow->addViewport(mCamera);