Graphics/3D/nehe/lesson09/source/nehe9.cpp

/****************************************
 *      NDS NeHe Lesson 09              *
 *      Author: dovoto
 *      DS does not appear to support 
        the features needed for this demo
 ****************************************/

// include your ndslib
#include <nds.h>
#include <malloc.h>
//needed to load pcx files
#include <nds/arm9/image.h>
#include <stdlib.h>

#include "Star_pcx.h"

int DrawGLScene();


bool    twinkle;        // Twinkling Stars
bool    tp;             // 'T' Key Pressed?

const   int num=50;     // Number Of Stars To Draw

typedef struct          // Create A Structure For Star
{
    int r, g, b;        // Stars Color
    float dist,     // Stars Distance From Center
            angle;      // Stars Current Angle
}stars;

stars star[num];        // Need To Keep Track Of 'num' Stars

float   zoom=-15.0f;    // Distance Away From Stars
float tilt=90.0f;       // Tilt The View
float   spin;           // Spin Stars

int loop;           // General Loop Variable
int texture[1];         // Storage For One textures


// Load PCX files And Convert To Textures
int LoadGLTextures() {
    sImage pcx;         // (NEW) and different from nehe.

    //load our texture
    loadPCX((u8*)Star_pcx, &pcx);
    image8to16trans(&pcx, 0);

    //DS supports no filtering of anykind so no need for more than one texture
    glGenTextures(1, &texture[0]);
    glBindTexture(0, texture[0]);
    glTexImage2D(0, 0, GL_RGBA, TEXTURE_SIZE_128 , TEXTURE_SIZE_128, 0, TEXGEN_TEXCOORD, pcx.image.data8);

    imageDestroy(&pcx);

    return TRUE;
}

int main() {
    
    // Setup the Main screen for 3D 
    videoSetMode(MODE_0_3D);
    vramSetBankA(VRAM_A_TEXTURE);                        //NEW  must set up some memory for textures
    
    // initialize the geometry engine
    glInit();
    
    // enable antialiasing
    glEnable(GL_ANTIALIAS);
    
    // setup the rear plane
    glClearColor(0,0,0,31); // BG must be opaque for AA to work
    glClearPolyID(63); // BG must have a unique polygon ID for AA to work
    glClearDepth(0x7FFF);
    
    // enable textures
    glEnable(GL_TEXTURE_2D);
    
    // enable alpha blending
    glEnable(GL_BLEND);

    // Set our viewport to be the same size as the screen
    glViewport(0,0,255,191);
    
    LoadGLTextures();
    
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(70, 256.0 / 192.0, 0.1, 100);
    glColor3f(1,1,1);
    
    //set up a directional ligth arguments are light number (0-3), light color, 
    //and an x,y,z vector that points in the direction of the light
    glLight(0, RGB15(31,31,31) , 0, 0,floattov10(-1.0));
    
    //need to set up some material properties since DS does not have them set by default
    glMaterialf(GL_AMBIENT, RGB15(16,16,16));
    glMaterialf(GL_DIFFUSE, RGB15(16,16,16));
    glMaterialf(GL_SPECULAR, BIT(15) | RGB15(8,8,8));
    glMaterialf(GL_EMISSION, RGB15(16,16,16));
    
    //ds uses a table for shinyness..this generates a half-ass one
    glMaterialShinyness();
    
    glPolyFmt(POLY_ALPHA(15) | POLY_CULL_BACK  | POLY_FORMAT_LIGHT0);

    glMatrixMode(GL_MODELVIEW);
    
    while (1) {
        DrawGLScene();
        
        // flush to screen  
        glFlush(0);
        
        // wait for the screen to refresh
        swiWaitForVBlank();
    }
    
    return 0;
}

int DrawGLScene()                                           // Here's Where We Do All The Drawing
{
    glBindTexture(GL_TEXTURE_2D, texture[0]);           // Select Our Texture

    for (loop=0; loop<num; loop++)                      // Loop Through All The Stars
    {
        glLoadIdentity();                               // Reset The View Before We Draw Each Star
        glTranslatef(0.0f,0.0f,zoom);                   // Zoom Into The Screen (Using The Value In 'zoom')
        glRotatef(tilt,1.0f,0.0f,0.0f);                 // Tilt The View (Using The Value In 'tilt')
        glRotatef(star[loop].angle,0.0f,1.0f,0.0f);     // Rotate To The Current Stars Angle
        glTranslatef(star[loop].dist,0.0f,0.0f);        // Move Forward On The X Plane
        glRotatef(-star[loop].angle,0.0f,1.0f,0.0f);    // Cancel The Current Stars Angle
        glRotatef(-tilt,1.0f,0.0f,0.0f);                // Cancel The Screen Tilt
        
        if (twinkle)
        {
            glColor3b(star[(num-loop)-1].r,star[(num-loop)-1].g,star[(num-loop)-1].b);  
            glBegin(GL_QUADS);
                glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f,-1.0f, 0.0f);
                glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f,-1.0f, 0.0f);
                glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f, 1.0f, 0.0f);
                glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, 0.0f);
            glEnd();
        }

        glRotatef(spin,0.0f,0.0f,1.0f);
        glColor3b(star[loop].r,star[loop].g,star[loop].b);                            //different
        glBegin(GL_QUADS);
            glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f,-1.0f, 0.0f);
            glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f,-1.0f, 0.0f);
            glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f, 1.0f, 0.0f);
            glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, 0.0f);
        glEnd();

        spin+=0.01f;
        star[loop].angle+=float(loop)/num;
        star[loop].dist-=0.01f;
        if (star[loop].dist<0.0f)
        {
            star[loop].dist+=5.0f;
            star[loop].r=rand()%256;
            star[loop].g=rand()%256;
            star[loop].b=rand()%256;
        }
    }
    return TRUE;                                                            // Keep Going

}