void init3DSettings() {
glInit();
glEnable(GL_TEXTURE_2D | GL_ANTIALIAS | GL_BLEND);
glClearColor(31, 31, 31, 0);
glClearPolyID(63);
glClearDepth(GL_MAX_DEPTH);
glViewport(0, 0, 255, 191);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glFrustum(-6.4, 6.4, -4.8, 4.8, 6.4, 25);
glMaterialf(GL_AMBIENT, RGB15(8, 8, 8));
glMaterialf(GL_DIFFUSE, RGB15(23, 23, 23));
glMaterialf(GL_SPECULAR, BIT(15) | RGB15(8, 8, 8));
glMaterialf(GL_EMISSION, RGB15(5, 5, 5));
glMaterialShinyness();
glLight(0, RGB15(31, 31, 31), floattov10(4.0), 0, floattov10(-0.8));
glLight(1, RGB15(31, 31, 31), floattov10(-4.0), 0, floattov10(-0.8));
glLight(2, RGB15(31, 31, 31), 0, floattov10(-4.0), floattov10(-0.8));
glLight(3, RGB15(31, 31, 31), 0, floattov10(4.0), floattov10(-0.8));
glPolyFmt(POLY_ALPHA(31) | POLY_CULL_BACK | POLY_FORMAT_LIGHT0
| POLY_FORMAT_LIGHT1 | POLY_FORMAT_LIGHT2 | POLY_FORMAT_LIGHT3);
}
void LightsourceManager::setLightsources(DisplayState* displayState,GLContextData& contextData) const
{
/* Retrieve the data item: */
DataItem* dataItem=contextData.retrieveDataItem<DataItem>(this);
/* Process all physical light sources first: */
GLsizei lightIndex=0;
bool haveNavigationalLightsources=false;
for(const LightsourceListItem* lsPtr=firstLightsource;lsPtr!=0&&lightIndex<dataItem->numLightsources;lsPtr=lsPtr->succ)
{
if(lsPtr->isEnabled())
{
/* Only set light source now if it is physical: */
if(lsPtr->physical)
{
glEnableLight(lightIndex);
glLight(lightIndex,lsPtr->getLight());
/* Increment the light index: */
++lightIndex;
}
else
haveNavigationalLightsources=true;
}
}
if(haveNavigationalLightsources)
{
/* Temporarily go to navigational coordinates: */
glPushMatrix();
glLoadIdentity();
glMultMatrix(displayState->modelviewNavigational);
/* Process all navigational light sources: */
for(const LightsourceListItem* lsPtr=firstLightsource;lsPtr!=0&&lightIndex<dataItem->numLightsources;lsPtr=lsPtr->succ)
{
if(lsPtr->isEnabled())
{
/* Only set light source now if it is navigational: */
if(!lsPtr->physical)
{
glEnableLight(lightIndex);
glLight(lightIndex,lsPtr->getLight());
/* Increment the light index: */
++lightIndex;
}
}
}
/* Return to physical coordinates: */
glPopMatrix();
}
/* Disable all unused light sources still enabled from the last pass: */
for(GLsizei i=lightIndex;i<dataItem->lastNumLightsources;++i)
glDisableLight(i);
dataItem->lastNumLightsources=lightIndex;
}
void LightsourceManager::setLightsources(GLContextData& contextData) const
{
/* Retrieve the data item: */
DataItem* dataItem=contextData.retrieveDataItem<DataItem>(this);
/* Process all light sources: */
int lightIndex=0;
for(const LightsourceListItem* lsPtr=firstLightsource;lsPtr!=0&&lightIndex<dataItem->lightTracker.getMaxNumLights();lsPtr=lsPtr->succ)
{
if(lsPtr->isEnabled())
{
glEnableLight(lightIndex);
glLight(lightIndex,lsPtr->getLight());
/* Increment the light index: */
++lightIndex;
}
}
/* Disable all unused light sources still enabled from the last pass: */
for(GLsizei i=lightIndex;i<dataItem->lastNumLightsources;++i)
glDisableLight(i);
dataItem->lastNumLightsources=lightIndex;
/* Update the light source tracker (could be optimized by not going through OpenGL): */
dataItem->lightTracker.update();
}
void loseRender(Board *b, int step){
glResetMatrixStack();
if ( step > 1000 )
return;
glMatrixMode(GL_PROJECTION);
gluPerspective(20, 256.0 / 192.0, 0.1, 40);
float d = (float)step / 6.0;
gluLookAt( 5.0 + d, 5.0 + d, 7.0 + d, //camera possition
1.0, 0.0, 1.5, //look at
0.0, 1.0, 0.0); //up
glRotateY(step*3);
glLight(0, RGB15(31,31,31), 0, floattov10(1.0)-1, 0);
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glMaterialf(GL_AMBIENT, RGB15(8,8,8));
glMaterialf(GL_DIFFUSE, RGB15(31,31,31));
glMaterialf(GL_SPECULAR, RGB15(31,31,31));
glMaterialf(GL_EMISSION, RGB15(8,8,8));
glMaterialShinyness();
glPolyFmt( POLY_ALPHA(31) | POLY_CULL_BACK | POLY_FORMAT_LIGHT0 );
glBindTexture(0, textureID);
b->draw();
glFlush(0);
swiWaitForVBlank();
}
void App_Test::display_Model()
{
// gluLookAtf32( this->camera.getPosition()->get_vec_ox(),this->camera.getPosition()->get_vec_oy(),this->camera.getPosition()->get_vec_oz(),
// this->camera.getLookAt()->get_vec_ox(),this->camera.getLookAt()->get_vec_oy(),this->camera.getLookAt()->get_vec_oz(),
// 0,4096,0
// );
// glLoadIdentity();
glEnable(GL_TEXTURE_2D);
glEnable(GL_ANTIALIAS);
glEnable(GL_OUTLINE);
glLight(0, RGB15(31,31,31) , 0, floattov10(-6.0), floattov10(-1.0));
glSetOutlineColor(0,RGB15(0,0,0));
glPolyFmt(POLY_ID(0) | POLY_ALPHA(31)|POLY_CULL_NONE | POLY_FORMAT_LIGHT0 | POLY_TOON_HIGHLIGHT);
// glPolyFmt(POLY_ALPHA(31)|POLY_CULL_NONE | POLY_FORMAT_LIGHT0);
glColor3b(31,31,31);
glBindTexture(GL_TEXTURE_2D, this->textureID[0]);
glTranslatef(0,-6,0);
glRotatef(90,-1,0,0);
glRotatef(-90,0,0,1);
glCallList( (u32 *) this->model_selected);
glEnd();
}
void initMenu(void)
{
lcdMainOnTop();
videoSetMode(MODE_5_3D);
videoSetModeSub(MODE_5_2D);
vramSetPrimaryBanks(VRAM_A_TEXTURE,VRAM_B_TEXTURE,VRAM_C_SUB_BG,VRAM_D_TEXTURE);
initD3D();
glInit();
glEnable(GL_TEXTURE_2D);
glEnable(GL_ANTIALIAS);
glEnable(GL_BLEND);
glEnable(GL_OUTLINE);
glClearPolyID(63);
glClearDepth(0x7FFF);
glViewport(0,0,255,191);
initVramBanks(2);
initTextures();
initMenuScene();
initMenuButtons();
//TEMP
glLight(0, RGB15(31,31,31), cosLerp(4096), 0, sinLerp(4096));
glMaterialf(GL_AMBIENT, RGB15(8,8,8));
glMaterialf(GL_DIFFUSE, RGB15(24,24,24));
glMaterialf(GL_SPECULAR, RGB15(0,0,0));
glMaterialf(GL_EMISSION, RGB15(0,0,0));
glSetToonTableRange(0, 15, RGB15(8,8,8)); //TEMP?
glSetToonTableRange(16, 31, RGB15(24,24,24)); //TEMP?
applyCameraState(&menuCamera,&cameraStates[4]);
tempState=cameraStates[4];
testTransition=startCameraTransition(&cameraStates[1],&cameraStates[4],64);
setupMenuPage(startMenuPage, startMenuPageLength);
logoMain=createTexture("logo.pcx", "menu");
logoRotate=createTexture("rotate_logo.pcx", "menu");
logoAlpha=31;
glSetOutlineColor(0,RGB15(0,0,0)); //TEMP?
glSetOutlineColor(1,RGB15(0,0,0)); //TEMP?
glSetOutlineColor(7,RGB15(0,0,0)); //TEMP?
NOGBA("END mem free : %dko (%do)",getMemFree()/1024,getMemFree());
fadeIn();
}
void Torch::updateLightSource( GLenum light )
{
glLight( light, GL_POSITION, QVector4D( pointToWorld(mFlarePosition), 1 ) );
glLight( light, GL_CONSTANT_ATTENUATION, 0.0f );
glLight( light, GL_LINEAR_ATTENUATION, 0.05f );
glLight( light, GL_QUADRATIC_ATTENUATION, 0.0f );
if( parent() )
{
glLight( light, GL_AMBIENT, QVector4D( 0, 0, 0, 1 ) );
glLight( light, GL_DIFFUSE, QVector4D( color() ) );
glLight( light, GL_SPECULAR, QVector4D( color() ) );
glEnable( light );
}
else
{
glLight( light, GL_AMBIENT, QVector4D( 0, 0, 0, 1 ) );
glLight( light, GL_DIFFUSE, QVector4D( 0, 0, 0, 1 ) );
glLight( light, GL_SPECULAR, QVector4D( 0, 0, 0, 1 ) );
glDisable( light );
}
}
static void setup()
{
consoleDemoInit();
//put 3D on top
lcdMainOnTop();
//set mode 0, enable BG0 and set it to 3D
videoSetMode(MODE_0_3D);
// initialize gl
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);
// Set our viewport to be the same size as the screen
glViewport(0,0,255,191);
glColor3b(255,255,0);
glLight(0, RGB15(0,31,0) , 0, floattov10(-1.0), 0);
//need to set up some material properties since DS does not have them set by default
glMaterialf(GL_AMBIENT, RGB15(5,5,5));
glMaterialf(GL_DIFFUSE, RGB15(15,15,15));
glMaterialf(GL_SPECULAR, RGB15(8,8,8));
glMaterialf(GL_EMISSION, RGB15(5,5,5));
//ds uses a table for shinyness..this generates a half-assed one
glMaterialShinyness();
//ds specific, several attributes can be set here
glPolyFmt( POLY_ALPHA(31) | POLY_CULL_NONE | POLY_FORMAT_LIGHT0 );
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60, (float)W / H, Znear, Zfar);
lookAtSelectedModel();
}
void LightsourceManager::setLightsources(GLContextData& contextData) const
{
/* Retrieve the data item: */
DataItem* dataItem=contextData.retrieveDataItem<DataItem>(this);
/* Process all light sources: */
GLsizei lightIndex=0;
for(const LightsourceListItem* lsPtr=firstLightsource;lsPtr!=0&&lightIndex<dataItem->numLightsources;lsPtr=lsPtr->succ)
{
if(lsPtr->isEnabled())
{
glEnableLight(lightIndex);
glLight(lightIndex,lsPtr->getLight());
/* Increment the light index: */
++lightIndex;
}
}
/* Disable all unused light sources still enabled from the last pass: */
for(GLsizei i=lightIndex;i<dataItem->lastNumLightsources;++i)
glDisableLight(i);
dataItem->lastNumLightsources=lightIndex;
}
void Light::draw()
{
if(lightNumber < 0 || lightNumber >= MAXNUMLIGHTS)
{
glDisable(glLight(lightNumber));
return;
}
glEnable(glLight(lightNumber));
float light_ambient[4] = { ambient.r, ambient.g, ambient.b, ambient.a };
float light_diffuse[4] = { diffuse.r, diffuse.g, diffuse.b, diffuse.a };
float light_specular[4] = { specular.r, specular.g, specular.b, specular.a };
float light_position[4] = { position.x, position.y, position.z, 1.0f };
glLightfv(glLight(lightNumber), GL_AMBIENT, light_ambient);
glLightfv(glLight(lightNumber), GL_DIFFUSE, light_diffuse);
glLightfv(glLight(lightNumber), GL_SPECULAR, light_specular);
glLightfv(glLight(lightNumber), GL_POSITION, light_position);
}
void gameLoop(){
iprintf("\x1b[2J");
int frame = 0;
Board b(7);
Player* p;
p = new Player(b.space(5,4));
//iprintf("Entering Main Loop.\n");
int rot = 0;
while( !b.full() )
{
iprintf("\x1b[22;18HFrame: %d\n\x1b[0;0H", ++frame);
glResetMatrixStack();
//any floating point gl call is being converted to fixed prior to being implemented
glMatrixMode(GL_PROJECTION);
gluPerspective(20, 256.0 / 192.0, 0.1, 40);
gluLookAt( 5.0, 5.0, 7.0, //camera possition
1.0, 0.0, 1.5, //look at
0.0, 1.0, 0.0); //up
glLight(0, RGB15(31,31,31), 0, floattov10(1.0)-1, 0);
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glMaterialf(GL_AMBIENT, RGB15(8,8,8));
glMaterialf(GL_DIFFUSE, RGB15(31,31,31));
glMaterialf(GL_SPECULAR, RGB15(31,31,31));
glMaterialf(GL_EMISSION, RGB15(8,8,8));
//ds uses a table for shinyness..this generates a half-ass one
glMaterialShinyness();
//not a real gl function and will likely change
glPolyFmt( POLY_ALPHA(31) | POLY_CULL_BACK | POLY_FORMAT_LIGHT0 );
//glPolyFmt(POLY_ALPHA(15) | POLY_CULL_BACK | POLY_FORMAT_LIGHT0 );
glRotateY(rot);
glBindTexture(0, textureID);
b.draw();
glFlush(0);
b.tick();
Player::tickPlayers();
scanKeys();
u16 keys = keysHeld();
p->setDir(NODIR);
if((keys & KEY_UP)) p->setDir(NORTH);
if((keys & KEY_DOWN)) p->setDir(SOUTH);
if((keys & KEY_LEFT)) p->setDir(WEST);
if((keys & KEY_RIGHT)) p->setDir(EAST);
if (( keys & KEY_R )) rot++;
if (( keys & KEY_L )) rot--;
swiWaitForVBlank();
}
lose(&b);
}
int main(void)
{
float x_angle = 0, y_angle = 0;
float x_speed = 0, y_speed = 0;
float distance = 1;
powerON(POWER_ALL);
irqInit();
irqEnable(IRQ_VBLANK);
videoSetMode(MODE_0_3D);
consoleDemoInit();
/* Set up a timer to count FPS */
TIMER3_DATA = TIMER_FREQ_1024(1);
TIMER3_CR = TIMER_DIV_1024 | TIMER_IRQ_REQ;
irqSet(IRQ_TIMER3, fps_timer_irq);
irqEnable(IRQ_TIMER3);
glViewPort(0, 0, SCREEN_WIDTH-1, SCREEN_HEIGHT-1);
glClearColor(0, 0, 0);
glClearDepth(GL_MAX_DEPTH);
iprintf("Hello World!\n\n");
glReset();
gluPerspective(35, SCREEN_WIDTH / (float) SCREEN_HEIGHT, 0.1, 40.0);
gluLookAt(0.0, 0.0, 1.0, /* Eye */
0.0, 0.0, 0.0, /* Look at */
0.0, 1.0, 0.0); /* Up */
glMaterialf(GL_AMBIENT, RGB15(8,8,8));
glMaterialf(GL_DIFFUSE, RGB15(16,16,16));
glMaterialf(GL_SPECULAR, BIT(15) | RGB15(8,8,8));
glMaterialf(GL_EMISSION, RGB15(5,5,5));
glMaterialShinyness();
glColor(RGB15(31, 31, 31));
glLight(0, RGB15(20, 15, 15),
floattov10(-0.9),
floattov10( 0.9),
floattov10( 0.2));
glLight(1, RGB15(15, 15, 20),
floattov10( 0.4),
floattov10( 0.9),
floattov10( 0.2));
glPolyFmt(POLY_ALPHA(31) | POLY_CULL_BACK |
POLY_FORMAT_LIGHT0 | POLY_FORMAT_LIGHT1);
while (1) {
scanKeys();
if (keysHeld() & KEY_START) Loader_Exit9();
if (keysHeld() & KEY_UP) x_speed += 0.05;
if (keysHeld() & KEY_DOWN) x_speed -= 0.05;
if (keysHeld() & KEY_LEFT) y_speed += 0.05;
if (keysHeld() & KEY_RIGHT) y_speed -= 0.05;
if (keysHeld() & KEY_R) distance += 0.05;
if (keysHeld() & KEY_L) distance -= 0.05;
glPushMatrix();
glTranslate3f32(floattof32( 0.0),
floattof32( 0.0),
floattof32(-distance));
glRotateX(x_angle += x_speed);
glRotateY(y_angle += y_speed);
glCallList(display_list_bin);
glPopMatrix(1);
glFlush();
frames++;
swiWaitForVBlank();
}
return 0;
}
int main() {
int rotateX = 0;
int rotateY = 0;
//set mode 0, enable BG0 and set it to 3D
videoSetMode(MODE_0_3D);
// initialize gl
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);
//this should work the same as the normal gl call
glViewport(0,0,255,191);
//toon-table entry 0 is for completely unlit pixels, going up to entry 31 for completely lit
//We block-fill it in two halves, we get cartoony 2-tone lighting
glSetToonTableRange( 0, 15, RGB15(8,8,8) );
glSetToonTableRange( 16, 31, RGB15(24,24,24) );
//any floating point gl call is being converted to fixed prior to being implemented
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(70, 256.0 / 192.0, 0.1, 40);
//NB: When toon-shading, the hw ignores lights 2 and 3
//Also note that the hw uses the RED component of the lit vertex to index the toon-table
glLight(0, RGB15(16,16,16) , 0, floattov10(-1.0), 0);
glLight(1, RGB15(16,16,16), floattov10(-1.0), 0, 0);
gluLookAt( 0.0, 0.0, -3.0, //camera possition
0.0, 0.0, 0.0, //look at
0.0, 1.0, 0.0); //up
while(1) {
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glRotateXi(rotateX);
glRotateYi(rotateY);
glMaterialf(GL_AMBIENT, RGB15(8,8,8));
glMaterialf(GL_DIFFUSE, RGB15(24,24,24));
glMaterialf(GL_SPECULAR, RGB15(0,0,0));
glMaterialf(GL_EMISSION, RGB15(0,0,0));
glPolyFmt(POLY_ALPHA(31) | POLY_CULL_BACK | POLY_FORMAT_LIGHT0 | POLY_FORMAT_LIGHT1 | POLY_TOON_HIGHLIGHT);
scanKeys();
u32 keys = keysHeld();
if( keys & KEY_UP ) rotateX += 1;
if( keys & KEY_DOWN ) rotateX -= 1;
if( keys & KEY_LEFT ) rotateY += 1;
if( keys & KEY_RIGHT ) rotateY -= 1;
int pen_delta[2];
get_pen_delta( &pen_delta[0], &pen_delta[1] );
rotateY -= pen_delta[0];
rotateX -= pen_delta[1];
glCallList((u32*)statue_bin);
glPopMatrix(1);
glFlush(0);
swiWaitForVBlank();
}
return 0;
}
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;
}
void logo()
{
glResetMatrixStack();
glMatrixMode(GL_PROJECTION);
gluPerspective(20, 256.0 / 192.0, 0.1, 40);
gluLookAt( 0.0, .55, 0.0 , //camera possition
0.0, 0.0, 0.0, //look at
0.0, 0.0, -1.0); //up
glLight(0, RGB15(31,31,31), 0, floattov10(1.0)-1, 0);
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glMaterialf(GL_AMBIENT, RGB15(8,8,8));
glMaterialf(GL_DIFFUSE, RGB15(31,31,31));
glMaterialf(GL_SPECULAR, RGB15(31,31,31));
glMaterialf(GL_EMISSION, RGB15(8,8,8));
glMaterialShinyness();
glPolyFmt( POLY_ALPHA(31) | POLY_CULL_BACK | POLY_FORMAT_LIGHT0 );
glGenTextures(1, &logotex);
glBindTexture(0, logotex);
glTexImage2D(0, 0, GL_RGB, TEXTURE_SIZE_256 , TEXTURE_SIZE_256, 0, TEXGEN_TEXCOORD , (u8*)billkuker_bmp_bin);
glBindTexture(0, logotex);
glBegin(GL_QUAD);
glNormal(NORMAL_PACK(0,inttov10(1),0));
glTexCoord1i(TEXTURE_PACK(0,0));
glVertex3v16(floattov16(-0.5), floattov16(-0.5), floattov16(0.5) );
glTexCoord1i(TEXTURE_PACK(inttot16(256), inttot16(0)));
glVertex3v16(floattov16(0.5), floattov16(-0.5), floattov16(0.5) );
glTexCoord1i(TEXTURE_PACK(inttot16(256),inttot16(256)));
glVertex3v16(floattov16(0.5), floattov16(-0.5), floattov16(-0.5) );
glTexCoord1i(TEXTURE_PACK(0, inttot16(256)));
glVertex3v16(floattov16(-0.5), floattov16(-0.5), floattov16(-0.5) );
glEnd();
glFlush(0);
playGenericSound(down_raw, down_raw_size);
playGenericSound(up_raw, up_raw_size);
swiWaitForVBlank();
iprintf("Press any button");
while( !keysHeld() )
scanKeys();
glResetTextures();
iprintf("\x1b[2J");
}
int main()
{
int textureID;
int i;
float rotateX = 0.0;
float rotateY = 0.0;
//set mode 0, enable BG0 and set it to 3D
videoSetMode(MODE_0_3D);
// initialize gl
glInit();
//enable textures
glEnable(GL_TEXTURE_2D);
//this should work the same as the normal gl call
glViewport(0,0,255,191);
// 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);
vramSetBankA(VRAM_A_TEXTURE);
glGenTextures(1, &textureID);
glBindTexture(0, textureID);
glTexImage2D(0, 0, GL_RGB, TEXTURE_SIZE_128 , TEXTURE_SIZE_128, 0, TEXGEN_TEXCOORD, (u8*)texture_bin);
//any floating point gl call is being converted to fixed prior to being implemented
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(70, 256.0 / 192.0, 0.1, 40);
gluLookAt( 0.0, 0.0, 1.0, //camera possition
0.0, 0.0, 0.0, //look at
0.0, 1.0, 0.0); //up
while(1) {
glLight(0, RGB15(31,31,31) , 0, floattov10(-1.0), 0);
glLight(1, RGB15(31,0,31), 0, floattov10(1) - 1, 0);
glLight(2, RGB15(0,31,0) , floattov10(-1.0), 0, 0);
glLight(3, RGB15(0,0,31) , floattov10(1.0) - 1, 0, 0);
glPushMatrix();
//move it away from the camera
glTranslate3f32(0, 0, floattof32(-1));
glRotateX(rotateX);
glRotateY(rotateY);
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glMaterialf(GL_AMBIENT, RGB15(8,8,8));
glMaterialf(GL_DIFFUSE, RGB15(16,16,16));
glMaterialf(GL_SPECULAR, BIT(15) | RGB15(8,8,8));
glMaterialf(GL_EMISSION, RGB15(5,5,5));
//ds uses a table for shinyness..this generates a half-ass one
glMaterialShinyness();
//not a real gl function and will likely change
glPolyFmt(POLY_ALPHA(31) | POLY_CULL_BACK | POLY_FORMAT_LIGHT0 | POLY_FORMAT_LIGHT1 |
POLY_FORMAT_LIGHT2 | POLY_FORMAT_LIGHT3 ) ;
scanKeys();
u16 keys = keysHeld();
if((keys & KEY_UP)) rotateX += 3;
if((keys & KEY_DOWN)) rotateX -= 3;
if((keys & KEY_LEFT)) rotateY += 3;
if((keys & KEY_RIGHT)) rotateY -= 3;
glBindTexture(0, textureID);
//draw the obj
glBegin(GL_QUAD);
for(i = 0; i < 6; i++)
drawQuad(i);
glEnd();
glPopMatrix(1);
glFlush(0);
swiWaitForVBlank();
}
return 0;
}//end main
int main()
{
// initialize gl
glInit();
u32 rotateX = 0;
u32 rotateY = 0;
//set mode 0, enable BG0 and set it to 3D
videoSetMode(MODE_0_3D);
// used to hold touched position
touchPosition touchXY;
lcdMainOnBottom(); // we are going to be touching the 3D display
// enable edge outlining, this will be used to show which object is selected
glEnable(GL_OUTLINE);
//set the first outline color to white
glSetOutlineColor(0,RGB15(31,31,31));
int viewport[]={0,0,255,191}; // used later for gluPickMatrix()
// setup the rear plane
glClearColor(0,0,0,0); // set BG to black and clear
glClearPolyID(0); // the BG and polygons will have the same ID unless a polygon is highlighted
glClearDepth(0x7FFF);
// setup the camera
gluLookAt( 0.0, 0.0, 1.0, //camera possition
0.0, 0.0, 0.0, //look at
0.0, 1.0, 0.0); //up
glLight(0, RGB15(31,31,31) , 0, floattov10(-1.0), 0); // setup the light
while(1) {
// handle key input
scanKeys();
u16 keys = keysHeld();
if(!(keys & KEY_UP)) rotateX += 3;
if(!(keys & KEY_DOWN)) rotateX -= 3;
if(!(keys & KEY_LEFT)) rotateY += 3;
if(!(keys & KEY_RIGHT)) rotateY -= 3;
// get touchscreen position
touchRead(&touchXY);
glViewport(0,0,255,191); // set the viewport to fullscreen
// setup the projection matrix for regular drawing
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60, 256.0 / 192.0, 0.1, 20);
glMatrixMode(GL_MODELVIEW); // use the modelview matrix while drawing
glPushMatrix(); // save the state of the current matrix(the modelview matrix)
{
glTranslatef32(0,0,floattof32(-6));
glRotateXi(rotateX); // add X rotation to the modelview matrix
glRotateYi(rotateY); // add Y rotation to the modelview matrix
glPushMatrix(); // save the state of the modelview matrix while making the first pass
{
// draw the scene for displaying
glTranslatef32(floattof32(2.9),floattof32(0),floattof32(0)); // translate the modelview matrix to the drawing location
if(clicked==CONE) {
glPolyFmt(POLY_ALPHA(31) | POLY_CULL_BACK | POLY_FORMAT_LIGHT0 | POLY_ID(1)); // set a poly ID for outlining
} else {
glPolyFmt(POLY_ALPHA(31) | POLY_CULL_BACK | POLY_FORMAT_LIGHT0 | POLY_ID(0)); // set a poly ID for no outlining (same as BG)
}
glCallList((u32*)cone_bin); // draw a green cone from a predefined packed command list
glTranslatef32(floattof32(-3),floattof32(1.8),floattof32(2)); // translate the modelview matrix to the drawing location
if(clicked==CYLINDER) {
glPolyFmt(POLY_ALPHA(31) | POLY_CULL_BACK | POLY_FORMAT_LIGHT0 | POLY_ID(1)); // set a poly ID for outlining
} else {
glPolyFmt(POLY_ALPHA(31) | POLY_CULL_BACK | POLY_FORMAT_LIGHT0 | POLY_ID(0)); // set a poly ID for no outlining (same as BG)
}
glCallList((u32*)cylinder_bin); // draw a blue cylinder from a predefined packed command list
glTranslatef32(floattof32(.5),floattof32(-2.6),floattof32(-4)); // translate the modelview matrix to the drawing location
if(clicked==SPHERE) {
glPolyFmt(POLY_ALPHA(31) | POLY_CULL_BACK | POLY_FORMAT_LIGHT0 | POLY_ID(1)); // set a poly ID for outlining
} else {
glPolyFmt(POLY_ALPHA(31) | POLY_CULL_BACK | POLY_FORMAT_LIGHT0 | POLY_ID(0)); // set a poly ID for no outlining (same as BG)
}
glCallList((u32*)sphere_bin); // draw a red sphere from a predefined packed command list
}
glPopMatrix(1); // restores the modelview matrix to where it was just rotated
// draw the scene again for picking
{
clicked = NOTHING; //reset what was clicked on
closeW = 0x7FFFFFFF; //reset the distance
//set the viewport to just off-screen, this hides all rendering that will be done during picking
glViewport(0,192,0,192);
// setup the projection matrix for picking
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPickMatrix((touchXY.px),(191-touchXY.py),4,4,viewport); // render only what is below the cursor
gluPerspective(60, 256.0 / 192.0, 0.1, 20); // this must be the same as the original perspective matrix
glMatrixMode(GL_MODELVIEW); // switch back to modifying the modelview matrix for drawing
glTranslatef32(floattof32(2.9),floattof32(0),floattof32(0)); // translate the modelview matrix to the drawing location
startCheck();
glCallList((u32*)cone_bin); // draw a cone from a predefined packed command list
endCheck(CONE);
glTranslatef32(floattof32(-3),floattof32(1.8),floattof32(2)); // translate the modelview matrix to the drawing location
startCheck();
glCallList((u32*)cylinder_bin); // draw a cylinder from a predefined packed command list
endCheck(CYLINDER);
glTranslatef32(floattof32(.5),floattof32(-2.6),floattof32(-4)); // translate the modelview matrix to the drawing location
startCheck();
glCallList((u32*)sphere_bin); // draw a sphere from a predefined packed command list
endCheck(SPHERE);
}
}
glPopMatrix(1); // restores the modelview matrix to its original state
glFlush(0); // wait for everything to be drawn before starting on the next frame
}
return 0;
}//end main
int main()
{
int textureID;
int i;
float rotateX = 0.0;
float rotateY = 0.0;
//set mode 0, enable BG0 and set it to 3D
videoSetMode(MODE_0_3D);
// initialize gl
glInit();
//enable textures
glEnable(GL_TEXTURE_2D);
//this should work the same as the normal gl call
glViewport(0,0,255,191);
// 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);
vramSetBankB(VRAM_B_LCD);
REG_DISPCAPCNT =
DCAP_MODE(DCAP_MODE_BLEND) //blend source A and source B
//| DCAP_SRC_ADDR //this is not used since we are setting the display to render from VRAM
| DCAP_SRC_B(DCAP_SRC_B_VRAM)
| DCAP_SRC_A(DCAP_SRC_A_3DONLY)
| DCAP_SIZE(DCAP_SIZE_256x192)
| DCAP_OFFSET(0) //where to write the captured data within our chosen VRAM bank
| DCAP_BANK(DCAP_BANK_VRAM_B)
| DCAP_B(12) //blend mostly from B to make a very dramatic effect
| DCAP_A(4) //and blend only a little bit from the new scene
;
//but, dramatic effects tend to leave some garbage on the screen since the precision of the math is low,
//and we're not putting a lot of dampening on the effect.
//a more realistic value might be 8 and 8, but perhaps in a more complex 3d scene the garbage isn't such a bad thing
//since the scene is changing constantly
DisplayEnableMotionBlur();
bool displayBlurred = true;
vramSetBankA(VRAM_A_TEXTURE);
glGenTextures(1, &textureID);
glBindTexture(0, textureID);
glTexImage2D(0, 0, GL_RGB, TEXTURE_SIZE_128 , TEXTURE_SIZE_128, 0, TEXGEN_TEXCOORD, (u8*)texture_bin);
//any floating point gl call is being converted to fixed prior to being implemented
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(70, 256.0 / 192.0, 0.1, 40);
gluLookAt( 0.0, 0.0, 1.0, //camera possition
0.0, 0.0, 0.0, //look at
0.0, 1.0, 0.0); //up
while(1) {
glLight(0, RGB15(31,31,31) , 0, floattov10(-1.0), 0);
glLight(1, RGB15(31,0,31), 0, floattov10(1) - 1, 0);
glLight(2, RGB15(0,31,0) , floattov10(-1.0), 0, 0);
glLight(3, RGB15(0,0,31) , floattov10(1.0) - 1, 0, 0);
glPushMatrix();
//move it away from the camera
glTranslatef32(0, 0, floattof32(-1));
glRotateX(rotateX);
glRotateY(rotateY);
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glMaterialf(GL_AMBIENT, RGB15(8,8,8));
glMaterialf(GL_DIFFUSE, RGB15(16,16,16));
glMaterialf(GL_SPECULAR, BIT(15) | RGB15(8,8,8));
glMaterialf(GL_EMISSION, RGB15(5,5,5));
//ds uses a table for shinyness..this generates a half-ass one
glMaterialShinyness();
//not a real gl function and will likely change
glPolyFmt(POLY_ALPHA(31) | POLY_CULL_BACK | POLY_FORMAT_LIGHT0 | POLY_FORMAT_LIGHT1 |
POLY_FORMAT_LIGHT2 | POLY_FORMAT_LIGHT3 ) ;
scanKeys();
u16 keys = keysHeld();
if((keys & KEY_UP)) rotateX += 3;
if((keys & KEY_DOWN)) rotateX -= 3;
if((keys & KEY_LEFT)) rotateY += 3;
if((keys & KEY_RIGHT)) rotateY -= 3;
if(keysDown() & KEY_A)
{
displayBlurred = !displayBlurred;
if(displayBlurred)
DisplayEnableMotionBlur();
else
DisplayEnableNormal();
}
glBindTexture(0, textureID);
//draw the obj
glBegin(GL_QUAD);
for(i = 0; i < 6; i++)
drawQuad(i);
glEnd();
glPopMatrix(1);
glFlush(0);
swiWaitForVBlank();
if(keys & KEY_START) break;
//the display capture enable bit must be set again each frame if you want to continue capturing.
REG_DISPCAPCNT |= DCAP_ENABLE;
}
return 0;
}//end main
