Buenas, continúo con la saga de tutoriales de programación 3D para NDS, en esta ocasión vamos a ver los últimos
retoques para saber todo lo que la NDS nos permite por 3D, esta clase será la última y tratará sobre optimización y
control de todo lo que hacemos (las funciones que nos faltan) y terminaré con un pequeño juego en 3D con todo lo que
hemos aprendido...

Bueno, sin más preámbulos, empezamos!

1- Controlar lo dibujado por GPU

 Bien, hasta ahora hemos estado usando todo lo posible en 3D para NDS, intentando no pasarnos del límite de 6500 vértices
de la NDS, pero, por ejemplo, si estuviéramos haciendo un modelador 3D (como Blender, 3DSmax, Maya...), el usuario
no podría conocer los límites de la NDS y pasarse del límite, por ejemplo...

Para ello la NDS nos ofrece mediante la GPU unos datos sobre lo dibujado en cada frame, lo podemos saber con esta función:

void glGetInt(GLenum dato, int *valor);
 
          Devuelve el "dato" que le hemos dicho que nos diga en el puntero valor, son los siguientes:
              - GL_GET_VERTEX_RAM_COUNT --> Devuelve el numero de vertices dibujados (los que estan en la GPU)
              - GL_GET_POLYGON_RAM_COUNT --> Devuelve el numero de cuadrados y triangulos dibujados
              - GL_GET_TEXTURE_WIDTH --> Devuelve el ancho de la textura actualmente seleccionada (con glBindTexture())
              - GL_GET_TEXTURE_HEIGHT --> Devuelve el alto de la textura actualmente seleccionada

Además, podemos obtener datos de las matrices de la NDS (que por defecto son calculadas automáticamente), pero podemos
obtenerlas con la función glGetFixed():

void glGetFixed(GLenum matrix, int *datos_a_devolver);
        Obten los datos de las matrices calculadas por la NDS
            matrix --> La matrix a obtener, pueden ser:
                    - GL_GET_MATRIX_VECTOR, devuelve la matriz de dirección en un int[9]
                    - GL_GET_MATRIX_POSITION, devuelve la matriz de transformaciones, donde aplicamos glTranslatef o glRotateX por ejemplo...
                    - GL_GET_MATRIX_PROJECTION, devuelve la matriz de proyección (4x4), aquí es donde configuramos la perspectiva y la cámara

Bien, con esto tendremos bien controlada a la NDS, lo suyo sería crear una función en la cual obtenemos los datos de la GPU
cada frame, como esta:

// Estructura de la GPU de la NDS
     typedef struct{
        int VerticesDibujados;
        int CarasDibujadas;
        int *Vectorial, *Proyeccion, *Transformaciones;
     }NDS_GPU;
 
     // Obten los datos de la GPU de la NDS
     void ObtenGPU(NDS_GPU *datos){
        glGetInt(GL_GET_VERTEX_RAM_COUNT, &datos->VerticesDibujados);  // Obten los vertices dibujados
        glGetInt(GL_GET_POLYGON_RAM_COUNT, &datos->CarasDibujadas);    // Obten las caras dibujadas
        glGetFixed(GL_GET_MATRIX_VECTOR, datos->Vectorial);            // Obten la matriz de direccion
        glGetFixed(GL_GET_MATRIX_POSITION, datos->Transformaciones);   // Obten la matriz de transformaciones
        glGetFixed(GL_GET_MATRIX_PROJECTION, datos->Proyeccion);       // Obten la matrix de proyeccion
     }

Bueno, ya está, con esto controlaremos la NDS a partir de ahora...

2- Limitar la distancia de dibujado

Bueno, otra parte de la optimización es esta, limitar la distancia de dibujado, esto lo que hace es cuando llegemos a una
cierta zona del espacio, no se dibuje nada, puede parecer una tontería pero puede servir por ejemplo cuando te pasas de
rango en el espacio, o cuando no quieras ver algo a cierta distancia de la cámara, esta es la función que se encarga de
hacerlo...

void glCutoffDepth(short valor);
          Establece la distancia por la cual no se va a dibujar nada
          valor --> El valor establecido en el eje Z donde no se va a dibujar nada

3- Algo de efectos en texturas

Bueno, las funciones que he dado son para la optimización de la NDS, pero en el tutorial anterior entramos con los
cube maps y no dimos lo suficiente sobre ello, hay que saber que la NDS puede aplicar distintos modos de texturización,
hasta ahora hemos estado usando por coordenadas de textura (la más fácil), y por TEXGEN_NORMAL (cube maps, alias texturización esférica), pero OpenGL soporta más tipos, los pongo a continuación:

NOTA: Recordad que hay que poner los parámetros en glTexImage2D():

GL_TEXTURE_WRAP_S --> Si te pasas del rango de una textura (dimensiones XY), la textura se repite en X
    GL_TEXTURE_WRAP_T --> Lo mismo pero en Y
    GL_TEXTURE_FLIP_S --> Si te pasas de las dimensiones de una textura, la textura se voltea en X
    GL_TEXTURE_FLIP_T --> Lo mismo pero en Y
    GL_TEXTURE_COLOR0_TRANSPARENT --> La NDS interpreta el primer color de la paleta como el transparente
    TEXGEN_TEXCOORD --> La textura se generará por coordenadas de textura
    TEXGEN_NORMAL   --> La textura se generará por texturización esférica (cube maps)
    TEXGEN_POSITION --> La textura se generará según los vértices del objeto afectado

Con esto tendréis nuevas posibilidades para la texturización de objetos.

4- Sobre el entorno 3D, configuración

Ya hemos visto que podemos configurar el entorno 3D a placer con las funciones glEnable() o glDisable(), pero no vimos
todos los atributos de los que son capaces de hacer, son los siguientes (algunos ya los hemos visto):

GL_TEXTURE_2D      --> Activa el uso de texturas
    GL_TOON_HIGHLIGHT  --> Activa el Toon Shading
    GL_ALPHA_TEST      --> Activa las transparencias
    GL_BLEND           --> Activa el alpha-blending
    GL_ANTIALIAS       --> Activa el Antialias
    GL_FOG             --> Activa la niebla
    GL_CLEAR_BMP       --> En el modo BMP, esto permite tener acceso al buffer de renderizado, y, por supuesto, modificarlo a tu gusto...

Bueno, esto es todo lo que nos quedaba, ahora queda el ejemplo final, donde usaremos todo lo aprendido en el mes que hemos
tardado en aprender 3D para NDS, que no es moco de pavo... Además, si sabéis dominar el OpenGL de la NDS tenéis un pie dentro
en el de PC y el de PSP, los cuales son más complejos...

Ejercicio 12

Este es el ejemplo final, se trata simplemente de, un pong, si, el básico juego en 2D en el cual todo programador que se precie
debe haberlo hecho, pues con toda nuestra experiencia en el 3D podemos pasar este juego a algo más real.

Con + te mueves por la zona (con el stylus también vale)
Con A y X confirmas los mensajes

El objetivo es hacer 5 puntos antes que la IA, usaremos todo lo dado en 3D, y usaremos modelos, texturas y colisiones,
con una IA.

Descarga: http://www.mediafire.com/download.php?sh851txsvrhyolf

Bueno, este es el fin de la saga de tutoriales, espero que os haya gustado, y gracias por haberlas seguido con tan buena
onda. Recordad no quedaros en el mundo 3D de la NDS, id más allá, como por ejemplo el OpenGL de PC o de otra plataforma, donde podréis ampliar vuestros conocimientos, y a ver si algún día de estos vemos por aquí algún buen videojuego en 3D!

Bueno, ha sido un placer hacer estos tutoriales, agradezco a los usuarios que los han leído uno a uno, los que me han resuelto muchas de mis dudas, y a todos los usuarios de Scenebeta, y hasta la próxima ocasión.