static int NDS_RenderClear(SDL_Renderer *renderer)
{
NDS_RenderData *data = (NDS_RenderData *) renderer->driverdata;
/* wait for capture unit to be ready */
while(REG_DISPCAPCNT & DCAP_ENABLE);
/* 3D engine can only work on one screen at a time. */
data->is_sub = !data->is_sub;
if (data->is_sub) {
lcdMainOnBottom();
vramSetBankC(VRAM_C_LCD);
vramSetBankD(VRAM_D_SUB_SPRITE);
REG_DISPCAPCNT = DCAP_BANK(2) | DCAP_ENABLE | DCAP_SIZE(3);
} else {
lcdMainOnTop();
vramSetBankD(VRAM_D_LCD);
vramSetBankC(VRAM_C_SUB_BG);
REG_DISPCAPCNT = DCAP_BANK(3) | DCAP_ENABLE | DCAP_SIZE(3);
}
glBegin2D();
glClearColor(renderer->r >> 3,
renderer->g >> 3,
renderer->b >> 3,
renderer->a >> 3);
return 0;
}
//-------------------------------------------------------
int main() {
//-------------------------------------------------------
videoSetMode(MODE_0_3D);
videoSetModeSub(MODE_5_2D);
glInit();
// sub sprites hold the bottom image when 3D directed to top
initSubSprites();
// sub background holds the top image when 3D directed to bottom
bgInitSub(3, BgType_Bmp16, BgSize_B16_256x256, 0, 0);
//-------------------------------------------------------
// Setup gl
//-------------------------------------------------------
glEnable(GL_ANTIALIAS);
glClearColor(0,0,0,31);
glClearPolyID(63);
glClearDepth(0x7FFF);
glViewport(0,0,255,191);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(70, 256.0 / 192.0, 0.1, 100);
glPolyFmt(POLY_ALPHA(31) | POLY_CULL_NONE);
//-------------------------------------------------------
// main loop
//-------------------------------------------------------
bool top = true;
while (true)
{
// wait for capture unit to be ready
while(REG_DISPCAPCNT & DCAP_ENABLE);
scanKeys();
int keys = keysDown();
if (keys & KEY_START) break;
//-------------------------------------------------------
// Switch render targets
//-------------------------------------------------------
top = !top;
if(top)
{
lcdMainOnBottom();
vramSetBankC(VRAM_C_LCD);
vramSetBankD(VRAM_D_SUB_SPRITE);
REG_DISPCAPCNT = DCAP_BANK(2) | DCAP_ENABLE | DCAP_SIZE(3);
}
else
{
lcdMainOnTop();
vramSetBankD(VRAM_D_LCD);
vramSetBankC(VRAM_C_SUB_BG);
REG_DISPCAPCNT = DCAP_BANK(3) | DCAP_ENABLE | DCAP_SIZE(3);
}
//-------------------------------------------------------
// Render the scene
//-------------------------------------------------------
glMatrixMode(GL_MODELVIEW);
renderScene(top);
glFlush(0);
}
return 0;
}
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
void Main()
{
extern void Init();
Init();
init();
// Init sprites to display like a big bitmap background
//VRAM_D_CR = VRAM_D_SUB_SPRITE | VRAM_ENABLE;
int y, x;
u16 * ptr = OAM_SUB;
for ( y = 0 ; y < 3 ; y++ ) {
for ( x = 0 ; x < 4 ; x++ ) {
// attribute 0
*ptr++ = ATTR0_BMP | (y*64);
// attribute 1
*ptr++ = ATTR1_SIZE_64 | (x*64);
// attribute 2
*ptr++ = ATTR2_ALPHA(15) | (x*8+y*256);
// pad (matrix)
ptr++;
}
}
int t = 0;
while ( t < 2576 ) {
#if FADES
if ( fade_current < fade_target )
fade_current++;
else if ( fade_current > fade_target )
fade_current--;
int v = 0;
if ( fade_current < (16 << 2) )
v = DARK | (16 - (fade_current >> 2));
else if ( fade_current > (16 << 2) )
v = BRIGHT | ((fade_current >> 2) - 16);
REG_MASTER_BRIGHT = v;
REG_MASTER_BRIGHT_SUB = v;
#endif
identity();
// Dual screen 3D
if ( t&1 ) {
REG_POWERCNT &= ~POWER_SWAP_LCDS; // main on bottom
VRAM_C_CR = VRAM_ENABLE;
VRAM_D_CR = VRAM_D_SUB_SPRITE | VRAM_ENABLE;
REG_DISPCAPCNT = DCAP_BANK(2) | DCAP_ENABLE | DCAP_SIZE(3);
} else {
REG_POWERCNT |= POWER_SWAP_LCDS; // main on top
VRAM_C_CR = VRAM_C_SUB_BG | VRAM_ENABLE;
VRAM_D_CR = VRAM_ENABLE;
REG_DISPCAPCNT = DCAP_BANK(3) | DCAP_ENABLE | DCAP_SIZE(3);
translate(0, -5*4096, 0);
}
// Reset polygon attributes
GFX_POLY_FORMAT = LIGHT0|POLYFRONT|SOLID;
// Lightweight 3D player -olol
int i;
for ( i = 0 ; i < sizeof(demo)/sizeof(Drawable) ; i++ ) {
if ( t >= demo[i].start && t < demo[i].end ) {
push();
translate(0, demo[i].ty*1024, demo[i].tz*1024);
scale(demo[i].s*1024, demo[i].s*1024, demo[i].s*1024);
demo[i].draw(t-demo[i].start);
pop();
}
}
t++;
swap();
}