En este método, que consiste en avanzar o retroceder sobre el eje dirección, utilizaremos el mismo (m_v3Look) para movernos una cierta cantidad de unidades expresadas por medio del parámetro de entrada al método. Aunque haremos una excepción respecto al eje Y si es que la cámara es terrestre.

El código:


| void Camera::Walk(float fValue)
| {
| // Sólo avanzo sobre el eje Y cuando la cámara es área
| if (m_cameraType == ECT_AIR)
| // Avanzo una cierta cantidad de unidades sobre el eje Y de m_v3Look
| m_v3Pos.y += m_v3Look.y * fValue;
|
| // Avanzo una cierta cantidad de unidades sobre el eje X de m_v3Look
| m_v3Pos.x += m_v3Look.x * fValue;
| // Avanzo una cierta cantidad de unidades sobre el eje Z de m_v3Look
| m_v3Pos.z += m_v3Look.z * fValue;
| }


El método Strafe

En este método, que consiste en avanzar o retroceder sobre el eje derecha, utilizaremos el mismo (m_v3Right) para movernos una cierta cantidad de unidades expresadas por medio del parámetro de entrada al método. Aunque haremos una excepción respecto al eje Y si es que la cámara es terrestre.

El código:


| void Camera::Strafe(float fValue)
| {
| // Sólo me muevo sobre el eje Y cuando la cámara es área
| if (m_cameraType == ECT_AIR)
| // Me muevo una cierta cantidad de unidades sobre el eje Y de m_v3Right
| m_v3Pos.y += m_v3Right.y * fValue;
|
| // Me muevo una cierta cantidad de unidades sobre el eje X de m_v3Right
| m_v3Pos.x += m_v3Right.x * fValue;
| // Me muevo una cierta cantidad de unidades sobre el eje Z de m_v3Right
| m_v3Pos.z += m_v3Right.z * fValue;
| }


El método Fly

Este método, en el cual nos movemos sobre el eje "arriba" (m_v3Up) tendrá sentido sólo cuando la cámara sea aérea.

El código:


| void Camera::Fly(float fValue)
| {
| // Sólo realizo algo en este método cuando la cámara es área
| if (m_cameraType == ECT_AIR)
| {
| // Me muevo una cierta cantidad de unidades sobre el eje X de m_v3Up
| m_v3Pos.x += m_v3Up.x * fValue;
| // Me muevo una cierta cantidad de unidades sobre el eje Y de m_v3Up
| m_v3Pos.y += m_v3Up.y * fValue;
| // Me muevo una cierta cantidad de unidades sobre el eje Z de m_v3Up
| m_v3Pos.z += m_v3Up.z * fValue;
| }
| }


El método SetPos

El método SetPos simplemente fija la posición de la cámara en un punto determinado por el parámetro de entrada al método. Esta acción no requiere la modificación de ninguna otra componente.

El código:


| void Camera::SetPos(Vector3 & v3Pos)
| {
| m_v3Pos = v3Pos;
| }


El método SetLookAt

Los tres vectores que posee la cámara (dirección, derecha y arriba) poseen una relación entre sí: son perpendiculares. Esta relación no debe ser rota por lo tanto la modificación arbitraria de un vector puede llevar a la modificación necesaria de los otros dos.

El método SetLookPos

Ciertamente puede resultar cómodo modificar la dirección hacia donde mira la cámara especificando un punto como objetivo. Pero nosotros almacenamos un vector normalizado hacia donde mirar, por lo tanto deberemos trabajar un poco con el punto recibido por parámetro. Veamos:

1. Creamos un vector dirección entre el punto posición de la cámara y el punto hacia donde debemos mirar.
2. Normalizamos el vector de modo de quedarnos sólo con sus componentes de dirección (fijando su magnitud en uno).
3. Invocamos el método SetLookAt para modificar los componentes que sean necesarios.

El código:


| void Camera::SetLookPos(Vector3 & v3LookPos)
| {
| Vector3 v3;
|
| v3.x = v3LookPos.x - m_v3Pos.x;
| v3.y = v3LookPos.y - m_v3Pos.y;
| v3.z = v3LookPos.z - m_v3Pos.z;
|
| D3DXVec3Normalize(&v3, &v3);
|
| // Una vez obtenido el vector lookAt, modifico las componentes
| SetLookAt(v3);
| }


Dibujando la cámara

Las componentes de la cámara transformarán la matriz de vista cuando se invoque el método Draw, en este método también podríamos aprovechar para dibujar guías de la cámara (como una línea que indique hacia donde mira la cámara) y/o un mesh que indique la posición de la misma, todo esto con fines de depuración.

Para crear una matriz de vista utilizaremos la función D3DXMatrixLookAtLH, dicha función solicita básicamente los componentes que ya poseemos en la clase pero existe una expeción:
Poseemos el vector dirección normalizado, es decir hacia donde miramos y la función de creación de la matriz de vista nos solicita el punto al cual miramos, por lo tanto dicho punto deberemos construirlo dinámicamente:

punto donde miramos = posición de la cámara + vector dirección

Luego creada la matriz de vista modificaremos la que está utilizando DirectX, esto es posible realizarlo por medio del método SetTransform del dispositivo de Direct3D, en nuestro caso hacemos uso de un método de la clase Renderer que finalmente hará una llamada al método citado.

El código:


| void Camera::Draw(float fTimeBetweenFrames)
| {
| Matrix mat;
| Vector3 v3Look = m_v3Pos + m_v3Look;
| D3DXMatrixLookAtLH(&mat, &m_v3Pos, &v3Look, &m_v3Up);
|
| g_renderer.SetMatrixMode(AGL_VIEW);
| g_renderer.SetTransform(mat);
| }


Las dos últimas líneas de la función Draw son específicas del motor que utilicé, allí deberás utilizar los métodos que tu motor/librería/programa posea para modificar la matriz de vista.

~fuzzyLogic

Pages: 1 2 3

Comentarios (3)