Nintendo DS Dynamic Lighting

/*
-------------------------------------------------

    Krystals DS

    Funciones de dibujado 3D

    Requiere DevkitARM
    Requiere NightFox's Lib

    Codigo por Cesar Rincon "NightFox"
    http://www.nightfoxandco.com
    Inicio 08 de Septiembre del 2012

    (c) 2012 - 2013 NightFox & Co.

-------------------------------------------------
*/



/*
-------------------------------------------------
    Includes
-------------------------------------------------
*/

// Includes C
#include <stdio.h>
// Includes propietarios NDS
#include <nds.h>
// Includes librerias propias
#include <nf_lib.h>
// Includes del juego
#include "includes.h"



/*
Metodos de la clase "CEngine3d"
*/

// Contructor clase CEngine3d
CEngine3d::CEngine3d(void) {
    // Debug
    Engine3d->angle[0] = 0;
    Engine3d->angle[1] = 0;
    Engine3d->angle[2] = 0;
}



// Destructor clase CEngine3d
CEngine3d::~CEngine3d(void) {
}



// Metodos globlales de la clase CEngine3d
CEngine3d* Engine3d;



// Inicializa el Engine 3D
void CEngine3d::Init3D(void) {

    // Habilita el 3D en la pantalla principal
    videoSetMode(MODE_0_3D);


    // *** Inicializa OpenGL ***

    // Inicializa el OpenGL de Libnds
    glInit();

    // Define el tamaño de la ventana 3D (toda la pantalla)
    glViewport(0, 0, 255, 191);

    // Configura la matriz de proyeccion
    glMatrixMode(GL_PROJECTION);    // Selecciona la matriz
    glLoadIdentity();

    // Configura la visual
    gluPerspective(70, (256.0 / 192.0), 0.1, 40);       // Perspectiva

    // Posiciona la camara por defecto
    gluLookAtf32(   0, 0, 0,                // Posicion de la camara
                    0, 0, 0,                // Punto hacia el que miras
                    0, (128 << 4), 0        // Normal
                    );

    // Configura la matriz de visualizacion de modelos
    glMatrixMode(GL_MODELVIEW);     // Selecciona la matriz
    glLoadIdentity();               // Y reseteala

    // Configura el fondo
    glClearColor(0, 0, 0, 0);       // Fondo transparente
    glClearDepth(0x7FFF);           // Define la distancia de vision

    // Configura la iluminacion global mediante el color del poligono
    glColor(RGB15(31, 31, 31));

    // Habilita la capa de dibujado
    REG_DISPCNT |= (DISPLAY_BG0_ACTIVE);

    // *** Fin de la inicializacion OpenGL ***



    // Inicializa los fondos 2D en el main engine
    NF_InitTiledBgSys(0);

    // Y habilita la capa de dibujado para el 3D en el main engine, poniendola al fondo
    Engine3d->Layer3d(3);
    NF_ShowBg(0, 0);

}



// Especifica en que capa se dibujara la escena 3d
void CEngine3d::Layer3d(u8 layer) {

    // Resetea los BITS de control de prioridad en todos los fondos
    REG_BG0CNT &= 0xfffc;       // Pon a 0 los bits 0 y 1 del registro
    REG_BG1CNT &= 0xfffc;
    REG_BG2CNT &= 0xfffc;
    REG_BG3CNT &= 0xfffc;

    // Reordena todas las capas segun la solicitud
    switch (layer) {
        case 0:     // 3D en la capa 0
            REG_BG0CNT += BG_PRIORITY_0;
            REG_BG1CNT += BG_PRIORITY_1;
            REG_BG2CNT += BG_PRIORITY_2;
            REG_BG3CNT += BG_PRIORITY_3;
            break;
        case 1:     // 3D en la capa 1
            REG_BG0CNT += BG_PRIORITY_1;
            REG_BG1CNT += BG_PRIORITY_0;
            REG_BG2CNT += BG_PRIORITY_2;
            REG_BG3CNT += BG_PRIORITY_3;
            break;
        case 2:     // 3D en la capa 2
            REG_BG0CNT += BG_PRIORITY_2;
            REG_BG1CNT += BG_PRIORITY_0;
            REG_BG2CNT += BG_PRIORITY_1;
            REG_BG3CNT += BG_PRIORITY_3;
            break;
        case 3:     // 3D en la capa 3
            REG_BG0CNT += BG_PRIORITY_3;
            REG_BG1CNT += BG_PRIORITY_0;
            REG_BG2CNT += BG_PRIORITY_1;
            REG_BG3CNT += BG_PRIORITY_2;
            break;
        default:    // 3D en la capa 0
            REG_BG0CNT += BG_PRIORITY_0;
            REG_BG1CNT += BG_PRIORITY_1;
            REG_BG2CNT += BG_PRIORITY_2;
            REG_BG3CNT += BG_PRIORITY_3;
            break;
    }

}



// Prepara el mundo 3D
void CEngine3d::Setup3dWorld(void) {


    // Activas las opciones OpenGL de esta escena
    // (Alpha blending, antialias, outline)
    glEnable(GL_BLEND | GL_ANTIALIAS | GL_OUTLINE);

    // Habilita el OUTLINE
     glClearPolyID(0);                          // Los poligonos con el ID 0, no tienen outline, usar el ID 1 para habilitarlo
     glSetOutlineColor(0, RGB15(8, 8, 8));  //

    // Crea las luces
    glLight(0, RGB15(31, 0, 0), floattov10(0.5), floattov10(-0.66), floattov10(-1.0));
    glLight(1, RGB15(0, 24, 0), floattov10(-0.5), floattov10(-0.66), floattov10(-1.0));
    glLight(2, RGB15(0, 0, 16), floattov10(0.66), floattov10(-0.5), floattov10(1.0));
    glLight(3, RGB15(8, 8, 0), floattov10(-0.66), floattov10(0.5), floattov10(1.0));



}



// Renderiza la escena y mandala a la pantalla
void CEngine3d::Render(void) {

    // Primero de todo, guarda la matriz de transformacion
    glPushMatrix();

    // posiciona la camara
    gluLookAtf32(   (128 << 4), (96 << 4), (128 << 4),      // Posicion
                    (128 << 4), (96 << 4), 0,               // Look At
                    0 , (128 << 4), 0);                     // Normal

    // Define el material a usar en el render
    glMaterialf(GL_AMBIENT, RGB15(8, 8, 8));
    glMaterialf(GL_DIFFUSE, RGB15(16, 16, 16));
    glMaterialf(GL_SPECULAR, RGB15(24, 24, 24));
    glMaterialf(GL_EMISSION, RGB15(0, 0, 0));

    // Define el formato de los poligonos a dibujar en esta fase
    glPolyFmt(POLY_ALPHA(31) | POLY_CULL_BACK | POLY_FORMAT_LIGHT0 | POLY_FORMAT_LIGHT1 | POLY_FORMAT_LIGHT2 | POLY_FORMAT_LIGHT3 | POLY_ID(1));


    /*
        Ejecuta aqui todos los renders necesarios
    */

    Engine3d->DrawGem(128, 96, 64, 64, 24, 8, Engine3d->angle[1], Engine3d->angle[2], 0);

    for (u8 i = 0; i < 3; i ++) {
        Engine3d->angle[i] += i;
        if (Engine3d->angle[i] > 511) Engine3d->angle[i] -= 512;
    }

    // Recupera la matriz de transformacion original
    glPopMatrix(1);

    // Manda la escena preparada para su renderizado al Engine 3D
    glFlush(0);

    // Espera al sincronismo vertical
    swiWaitForVBlank();

}



// Dibuja un cuadrado solido
void CEngine3d::DrawSolidQuad(  s32 x1, s32 y1, s32 z1,         // Coordenadas Vertice 1 (arriba / izquierda)
                                s32 x2, s32 y2, s32 z2,         // Coordenadas Vertice 2 (abajo / izquierda)
                                s32 x3, s32 y3, s32 z3,         // Coordenadas Vertice 3 (abajo / derecha)
                                s32 x4, s32 y4, s32 z4,         // Coordenadas Vertice 4 (arriba / derecha)
                                float nx, float ny, float nz    // Normales de la cara
                                ) {
    // Dibuja el cuadrado
    glBegin(GL_QUAD);
        // Normal de la cara
        glNormal(NORMAL_PACK(floattov10(nx), floattov10(ny), floattov10(nz)));
        // Vertice 1 - (superior izquierdo)
        glVertex3v16(x1, y1, z1);
        // Vertice 2 - (inferior izquierdo)
        glVertex3v16(x2, y2, z2);
        // Vertice 3 - (inferior derecho)
        glVertex3v16(x3, y3, z3);
        // Vertice 4 - (superior derecho)
        glVertex3v16(x4, y4, z4);


}



// Dibuja una Gema del color especificado
void CEngine3d::DrawGem(s32 px, s32 py, s32 pz, s32 width, s32 height, s32 deep, s32 rx, s32 ry, s32 rz) {

    // Variables
    u8 n = 0;

    // Crea el array de vectores para los vertices
    Vector3* vertex[16];
    for (n = 0; n < 16; n ++) {
        vertex[n] = new Vector3();
    }

    // Calcula el valor de cada vertice de la parte frontal del cuerto de la gema
    vertex[0]->Set((px - (width >> 1)), (py + (height >> 1)), (pz + (deep >> 1)));
    vertex[1]->Set((px - (width >> 1)), (py - (height >> 1)), (pz + (deep >> 1)));
    vertex[2]->Set((px + (width >> 1)), (py - (height >> 1)), (pz + (deep >> 1)));
    vertex[3]->Set((px + (width >> 1)), (py + (height >> 1)), (pz + (deep >> 1)));

    // Calcula el valor de cada vertice de la parte anterior del cuerto de la gema
    vertex[4]->Set((px - (width >> 1)), (py + (height >> 1)), (pz - (deep >> 1)));
    vertex[5]->Set((px - (width >> 1)), (py - (height >> 1)), (pz - (deep >> 1)));
    vertex[6]->Set((px + (width >> 1)), (py - (height >> 1)), (pz - (deep >> 1)));
    vertex[7]->Set((px + (width >> 1)), (py + (height >> 1)), (pz - (deep >> 1)));

    // Aplica si es necesario la transformacion de la matriz
    // Muevete al centro
    glTranslatef32((px << 4), (py << 4), (pz << 4));
    // Aplica la rotacion
    glRotateXi((rx << 6));
    glRotateYi((ry << 6));
    glRotateZi((rz << 6));
    // Vuelve a la posicion original
    glTranslatef32(-(px << 4), -(py << 4), -(pz << 4));

    // Dibuja el objeto
    // Cara frontal
    Engine3d->DrawSolidQuad(    vertex[0]->x, vertex[0]->y, vertex[0]->z,
                                vertex[1]->x, vertex[1]->y, vertex[1]->z,
                                vertex[2]->x, vertex[2]->y, vertex[2]->z,
                                vertex[3]->x, vertex[3]->y, vertex[3]->z,
                                0, 0, 1.0);

    // Cara derecha
    Engine3d->DrawSolidQuad(    vertex[3]->x, vertex[3]->y, vertex[3]->z,
                                vertex[2]->x, vertex[2]->y, vertex[2]->z,
                                vertex[6]->x, vertex[6]->y, vertex[6]->z,
                                vertex[7]->x, vertex[7]->y, vertex[7]->z,
                                1.0, 0, 0);

    // Cara posterior
    Engine3d->DrawSolidQuad(    vertex[7]->x, vertex[7]->y, vertex[7]->z,
                                vertex[6]->x, vertex[6]->y, vertex[6]->z,
                                vertex[5]->x, vertex[5]->y, vertex[5]->z,
                                vertex[4]->x, vertex[4]->y, vertex[4]->z,
                                0, 0, -1.0);

    // Cara izquierda
    Engine3d->DrawSolidQuad(    vertex[4]->x, vertex[4]->y, vertex[4]->z,
                                vertex[5]->x, vertex[5]->y, vertex[5]->z,
                                vertex[1]->x, vertex[1]->y, vertex[1]->z,
                                vertex[0]->x, vertex[0]->y, vertex[0]->z,
                                -1.0, 0, 0);

    // Cara Superior
    Engine3d->DrawSolidQuad(    vertex[4]->x, vertex[4]->y, vertex[4]->z,
                                vertex[0]->x, vertex[0]->y, vertex[0]->z,
                                vertex[3]->x, vertex[3]->y, vertex[3]->z,
                                vertex[7]->x, vertex[7]->y, vertex[7]->z,
                                0, 1.0, 0);

    // Cara Inferior
    Engine3d->DrawSolidQuad(    vertex[1]->x, vertex[1]->y, vertex[1]->z,
                                vertex[5]->x, vertex[5]->y, vertex[5]->z,
                                vertex[6]->x, vertex[6]->y, vertex[6]->z,
                                vertex[2]->x, vertex[2]->y, vertex[2]->z,
                                0, -1.0, 0);

    // Elimina los objetos creados
    for (n = 0; n < 16; n ++) {
        delete vertex[n];
        vertex[n] = NULL;
    }

}



// Conversion de color a RGB32
u32 CEngine3d::RGB32(u8 r, u8 g, u8 b) {

    return ((r << 16) | (g << 8) | (b));

}




/*
Metodos de la clase "Vector3"
*/

// Contructor
Vector3::Vector3(void) {

    // Inicializa los componentes del Vector3 a 0
    x = 0;
    y = 0;
    z = 0;

}

// Destructor
Vector3::~Vector3(void) {
}


// Asigna las coordenadas al Vector3 (Ya convertidas en coordenadas de pantalla)
void Vector3::Set(s32 px, s32 py, s32 pz) {

    x = (px << 4);
    y = (py << 4);
    z = (pz << 4);

}