Пример #1
0
void Map2D::DrawTranslucent( const glImage *Tiles )
{
	
	TxOff = (TxOff + 1) & 31;
	glPushMatrix();
	glPolyFmt( POLY_ALPHA(15) | POLY_CULL_FRONT | POLY_ID( GlobalManager::Instance()->GetFreePolyID() ) );
				
	for( int y = 0; y < Height; y++ )
	{
		for( int x = 0; x < Width ; x++ )
		{
			
			int Tile = GetElement(x,y);
			switch( Tile )
			{
				
				case WATER:
					DrawFrontCube( (x * TILE_SIZE_3D) + floattof32(0.5), (y * TILE_SIZE_3D) + floattof32(0.5), 0, 0, -TxOff, &Tiles[0] );
					break;
				case TOP_WATER:
					DrawFrontTopCube( (x * TILE_SIZE_3D) + floattof32(0.5), (y * TILE_SIZE_3D) + floattof32(0.5), 0, 0, -TxOff, &Tiles[0] );
					break;
					
			}
			
		}	
	}
	
	glPolyFmt( POLY_ALPHA(31) | POLY_CULL_NONE | POLY_ID( GlobalManager::Instance()->GetFreePolyID() ) );
	
	glPopMatrix(1);
	
}
Пример #2
0
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();
}
Пример #3
0
//This function initializes the device to a "default" setting. 
//You may begin sending GL commands to the DS after this function executes
void blu_impl::GFX_Init3DDevice(){
videoSetMode(MODE_0_3D);

// 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);

// Set our viewport to be the same size as the screen
glViewport(0,0,255,191);

// this controls your camera 
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(70, 256.0 / 192.0, 0.1, 100);

//ds specific, several attributes can be set here       
glPolyFmt(POLY_ALPHA(31) | POLY_CULL_NONE);
// Set the current matrix to be the model matrix
glMatrixMode(GL_MODELVIEW);
}
Пример #4
0
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();
}
Пример #5
0
void Scene::renderString(const char* str, f32 x, f32 y, int r, int g, int b)
{
    int l = 0;
    while(str[l] != 0) l++;

    x -= (l*25) / 2;

    int i = 0;
    while(str[i] != 0)
    {
        glPolyFmt(POLY_ALPHA(27+rand()%3) | POLY_ID(BG_FX2_POLYID) | POLY_CULL_NONE);
        int rr = r+irand(80);
        if(rr < 0) rr = 0;
        if(rr > 255) rr = 255;
        int gg = g+irand(80);
        if(gg < 0) gg = 0;
        if(gg > 255) gg = 255;
        int bb = b+irand(80);
        if(bb < 0) bb = 0;
        if(bb > 255) bb = 255;

        glColor3b(rr, gg, bb);
        renderChar(str[i], x+frand(1), y+frand(2), 10);
        x += 25;
        i++;
    }
}
Пример #6
0
// Setup viewport to a 1 pixel window where the user clicked.
// Set the "pickMode" flag and call draw to find out what piece of the grid was drawn.
bool MapDraw::pickPoint(int x, int y, Camera &cam)
{
  // This flag makes it so "startCheck" and "endCheck" are called
  // before and after every polygon is drawn
  pickMode = true;


  int viewport[]={0,0,255,191}; // used later for gluPickMatrix()
  //change ortho vs perspective
  glViewport(0,192,0,192); // set the viewport to fullscreen
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  gluPickMatrix(x,(191-y),4,4,viewport); // render only what is below the cursor
  cam.Perspective();
  glMatrixMode(GL_MODELVIEW);

  // opaque polygons, no culling, this fixes my problems.
  glPolyFmt(POLY_ALPHA(31) | POLY_CULL_NONE);

  // Un-mark the last one.
  if (picked)
    picked->picked = false;

  // pick mode flags will do the magic & return picked patch.
  picked = draw();

  // Mark the new one (which may still be the last one btw)
  if (picked)
    picked->picked = true;

  // Turn off pick mode.
  pickMode = false;

  return endCheck();
}
Пример #7
0
	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);
	}
Пример #8
0
void CharActor::renderUnrotated()
{
    glPolyFmt(POLY_ALPHA(27+rand()%3) | POLY_ID(BG_FX2_POLYID) | POLY_CULL_NONE);
    
    glColor3b(255, 160+irand(80), 0);
    
    renderChar(c, x+frand(1), y+frand(2), size);
}
Пример #9
0
int main() {
		
	// Setup the Main screen for 3D 
	videoSetMode(MODE_0_3D);
		
	// 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);
	
	// Set our viewport to be the same size as the screen
	glViewport(0,0,255,191);
	
	// setup the view
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluPerspective(70, 256.0 / 192.0, 0.1, 100);
	
	
	//ds specific, several attributes can be set here	
	glPolyFmt(POLY_ALPHA(31) | POLY_CULL_NONE);
	
	while (1) 
	{
		// Set the current matrix to be the model matrix
		glMatrixMode(GL_MODELVIEW);
		
		glColor3f(1, 1, 1);									// Set the color..not in nehe source...ds gl default will be black
		
		//Push our original Matrix onto the stack (save state)
		glPushMatrix();	

		DrawGLScene();
		
		// Pop our Matrix from the stack (restore state)
		glPopMatrix(1);

		//a handy little built in function to wait for a screen refresh
		swiWaitForVBlank();

		// flush to screen	
		glFlush(0);

		scanKeys();

		int pressed = keysDown();

		if(pressed & KEY_START) break;	
	}
	
	return 0;
}
Пример #10
0
void drawTurretStuff(turret_struct* t)
{
	if(!t || !t->used || t->dead)return;
	
	drawLaser(t->laserOrigin,t->laserDestination);
	if(t->laserThroughPortal)drawLaser(t->laserOrigin2,t->laserDestination2);

	//TEMP TEST BILLBOARD
		vect3D u1=vect(t->OBB->transformationMatrix[0],t->OBB->transformationMatrix[3],t->OBB->transformationMatrix[6]);
		vect3D u2=vect(t->OBB->transformationMatrix[1],t->OBB->transformationMatrix[4],t->OBB->transformationMatrix[7]);
		vect3D u3=vect(t->OBB->transformationMatrix[2],t->OBB->transformationMatrix[5],t->OBB->transformationMatrix[8]);

		glPolyFmt(POLY_ALPHA(31) | POLY_CULL_BACK | POLY_ID(63));
		GFX_COLOR=RGB15(31,31,31);
		applyMTL(turretShotTexture);

		if(t->drawShot[0])
		{
			glPushMatrix();
				glTranslatef32(t->laserOrigin.x, t->laserOrigin.y, t->laserOrigin.z);
				glTranslatef32(u3.x/128, u3.y/128, u3.z/128);
				glTranslatef32(u1.x/32, u1.y/32, u1.z/32);
				glScalef32(inttof32(1)/16,inttof32(1)/16,inttof32(1)/16);
				glRotatef32i(t->shotAngle[0],u3.x,u3.y,u3.z);
				glBegin(GL_QUADS);
					GFX_TEX_COORD = TEXTURE_PACK(inttot16(0), inttot16(0));
					glVertex3v16(-u1.x/2-u2.x, -u1.y/2-u2.y, -u1.z/2-u2.z);
					GFX_TEX_COORD = TEXTURE_PACK(inttot16(32), inttot16(0));
					glVertex3v16(+u1.x/2-u2.x, +u1.y/2-u2.y, +u1.z/2-u2.z);
					GFX_TEX_COORD = TEXTURE_PACK(inttot16(32), inttot16(64));
					glVertex3v16(+u1.x/2+u2.x, +u1.y/2+u2.y, +u1.z/2+u2.z);
					GFX_TEX_COORD = TEXTURE_PACK(inttot16(0), inttot16(64));
					glVertex3v16(-u1.x/2+u2.x, -u1.y/2+u2.y, -u1.z/2+u2.z);
			glPopMatrix(1);
		}

		if(t->drawShot[1])
		{
			glPushMatrix();
				glTranslatef32(t->laserOrigin.x, t->laserOrigin.y, t->laserOrigin.z);
				glTranslatef32(u3.x/128, u3.y/128, u3.z/128);
				glTranslatef32(-u1.x/32, -u1.y/32, -u1.z/32);
				glScalef32(inttof32(1)/16,inttof32(1)/16,inttof32(1)/16);
				glRotatef32i(t->shotAngle[1],u3.x,u3.y,u3.z);
				glBegin(GL_QUADS);
					GFX_TEX_COORD = TEXTURE_PACK(inttot16(0), inttot16(0));
					glVertex3v16(-u1.x/2-u2.x, -u1.y/2-u2.y, -u1.z/2-u2.z);
					GFX_TEX_COORD = TEXTURE_PACK(inttot16(32), inttot16(0));
					glVertex3v16(+u1.x/2-u2.x, +u1.y/2-u2.y, +u1.z/2-u2.z);
					GFX_TEX_COORD = TEXTURE_PACK(inttot16(32), inttot16(64));
					glVertex3v16(+u1.x/2+u2.x, +u1.y/2+u2.y, +u1.z/2+u2.z);
					GFX_TEX_COORD = TEXTURE_PACK(inttot16(0), inttot16(64));
					glVertex3v16(-u1.x/2+u2.x, -u1.y/2+u2.y, -u1.z/2+u2.z);
			glPopMatrix(1);
		}
}
Пример #11
0
void drawLogo(void)
{
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();

	glOrthof32(inttof32(0), inttof32(255), inttof32(191), inttof32(0), -inttof32(1), inttof32(1));
	
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();

	glPushMatrix();
		glPolyFmt(POLY_ALPHA(31) | POLY_CULL_NONE);
		applyMTL(logoMain);
		glScalef32(inttof32(256),inttof32(128),inttof32(1));
		glBegin(GL_QUADS);
			GFX_TEX_COORD = TEXTURE_PACK(inttot16(0), inttot16(0));
			glVertex3v16(inttof32(0), inttof32(0), inttof32(0));
			GFX_TEX_COORD = TEXTURE_PACK(inttot16(256), inttot16(0));
			glVertex3v16(inttof32(1), inttof32(0), inttof32(0));
			GFX_TEX_COORD = TEXTURE_PACK(inttot16(256), inttot16(128));
			glVertex3v16(inttof32(1), inttof32(1), inttof32(0));
			GFX_TEX_COORD = TEXTURE_PACK(inttot16(0), inttot16(128));
			glVertex3v16(inttof32(0), inttof32(1), inttof32(0));
	glPopMatrix(1);

	glPushMatrix();
		glPolyFmt(POLY_ALPHA(31) | POLY_CULL_NONE);
		applyMTL(logoRotate);
		glTranslate3f32(inttof32(90+32),inttof32(28+32),-inttof32(1)/16);
		glRotateZi(logoAngle+=32);
		glTranslate3f32(-inttof32(32),-inttof32(32),0);
		glScalef32(inttof32(64),inttof32(64),inttof32(1));
		glBegin(GL_QUADS);
			GFX_TEX_COORD = TEXTURE_PACK(inttot16(0), inttot16(0));
			glVertex3v16(inttof32(0), inttof32(0), inttof32(0));
			GFX_TEX_COORD = TEXTURE_PACK(inttot16(64), inttot16(0));
			glVertex3v16(inttof32(1), inttof32(0), inttof32(0));
			GFX_TEX_COORD = TEXTURE_PACK(inttot16(64), inttot16(64));
			glVertex3v16(inttof32(1), inttof32(1), inttof32(0));
			GFX_TEX_COORD = TEXTURE_PACK(inttot16(0), inttot16(64));
			glVertex3v16(inttof32(0), inttof32(1), inttof32(0));
	glPopMatrix(1);
}
Пример #12
0
void drawDoor(door_struct* d)
{
	if(!d || !d->used)return;

	glPushMatrix();
		u32 params=POLY_ALPHA(31)|POLY_CULL_FRONT|POLY_ID(30+d->id)|POLY_TOON_HIGHLIGHT|POLY_FOG;
		setupObjectLighting(NULL, d->position, &params);

		glTranslate3f32(d->position.x,d->position.y,d->position.z);
		
		if(d->orientation)glRotateYi(8192);
		
		renderModelFrameInterp(d->modelInstance.currentFrame,d->modelInstance.nextFrame,d->modelInstance.interpCounter,d->modelInstance.model,params,false,d->modelInstance.palette,RGB15(31,31,31));
	glPopMatrix(1);
}
Пример #13
0
void SeaActor::renderPerspective()
{


    glPolyFmt(POLY_ALPHA(20) | POLY_ID(BG_FX1_POLYID) | POLY_CULL_NONE);
    glColor3b(10, 50, 255);

    setTexture(13);

    ydelta = 0;
    renderSea(-6, 6, -10, -5, 1, false);
    renderSea(-10, 10, -5, -2, 1, true);
    renderSea(-18, 18, -2, 5, 2, true);
    renderSea(-20, 22, 6, 12, 4, true);

}
Пример #14
0
void hello_loop(helloObjectInstance *me) {
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluPerspective(70, 256.0 / 192.0, 0.1, 10);
	glPolyFmt(POLY_ALPHA(31) | POLY_CULL_FRONT);
	
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	
	glTranslatef(0, 0, -5);
	
	glRotateX(ry++);
	glRotateY(rx++);
	
	DSGM_DrawCube(-1, -1, -1, 2, 2, 2);
}
Пример #15
0
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();
}
Пример #16
0
void init3D(void)
{
	videoSetMode(MODE_0_3D);
	glInit();
	glEnable( GL_TEXTURE_2D | GL_ANTIALIAS );
	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( GL_MAX_DEPTH );
	glViewport(0,0,255,191);		// set the viewport to screensize
	glColor( 0x7FFF ); 				// max color
	glPolyFmt( POLY_ALPHA(31) | POLY_CULL_NONE );  // geen dingen laten verdwijnen
	glMatrixMode( GL_PROJECTION );
	glLoadIdentity();				// reset view
	glOrthof32( 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, -1 << 12, 1 << 12 );
	gluLookAt(	0.0, 0.0, 1.0,		//camera possition
	            0.0, 0.0, 0.0,		//look at
	            0.0, 1.0, 0.0);		//up
}
Пример #17
0
void Starfield_Draw(Starfield *starfield)
{
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	glOrthof32(0, inttof32(4), 0, inttof32(3), 0, inttof32(40));

	glMatrixMode(GL_MODELVIEW);
	glPushMatrix();

	gluLookAtf32(0, 0, inttof32(1),
				 0, 0, 0,
				 0, inttof32(1), 0);

	glPolyFmt(POLY_ALPHA(0x1f) | POLY_CULL_NONE);

	for (int i = 0; i < num_stars; i++) {
		StarfieldStar *star = &starfield->stars[i];
		Starfield_DrawStar(star);
	}

	glPopMatrix(1);
}
Пример #18
0
static void Splash_Drawer(void)
{
    I_CheckGFX();

    GFX_ORTHO();

    if(screenalpha > 1)
    {
        GFX_POLY_FORMAT =
            POLY_ALPHA(screenalpha) |
            POLY_ID(63)             |
            POLY_CULL_NONE          |
            POLY_MODULATION;

        GFX_TEX_FORMAT  = 0;
        GFX_PAL_FORMAT  = 0;
        GFX_COLOR       = 0;
        GFX_SCREENRECT();
    }

    if(screenalpha < 0x1F)
    {
        switch(splashstage)
        {
        case 0:
            R_SlamBackground("IDLOGO", 70, 28, 0xFFFFF);
            break;
        case 1:
            R_SlamBackground("WMSCRED1", 0, 58, 0xFFFFF);
            break;
        case 2:
            R_SlamBackground("USLEGAL", 0, 50, 0xFFFFF);
            break;
        default:
            break;
        }
    }
}
Пример #19
0
int main() {
    defaultExceptionHandler();
	// Setup the Main screen for 3D
	videoSetMode(MODE_0_3D);
    
	// 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);
    
	// Set our viewport to be the same size as the screen
	glViewport(0,0,255,191);
	
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluPerspective(70, 256.0 / 192.0, 0.1, 100);
	
	//ds specific, several attributes can be set here
	glPolyFmt(POLY_ALPHA(31) | POLY_CULL_FRONT);
	
	// Set the current matrix to be the model matrix
	glMatrixMode(GL_MODELVIEW);
	float x,y,z;
    float yOrbit;
    glClearColor(255,0,255,255);
	while (1)
	{
		// draw the scene
        
        glPushMatrix();
        glTranslatef(x,y,z);
        //gluLookAt(x,y,z,x,y,z+10,0,1,0);
        glRotatef(yOrbit,0,1,0);

		DrawGLScene();
        
        glPopMatrix(1);
		
		// flush to screen
		glFlush(0);
		
        scanKeys();
        
        if(keysHeld() & (KEY_UP))
        {
            z+=.05;
        }else
        if(keysHeld() & (KEY_DOWN))
        {
            z-=.05;
        }
        
        if(keysHeld() & (KEY_X))
        {
            y-=.05;
        }else
            if(keysHeld() & (KEY_B))
            {
                y+=.05;
            }
        
        
        if(keysHeld() & (KEY_LEFT|KEY_Y))
        {
            x+=.05;
        }else
            if(keysHeld() & (KEY_RIGHT|KEY_A))
            {
                x-=.05;
            }
        if(keysHeld() & KEY_L)
        {
            yOrbit-=1;
        }
        if(keysHeld() & KEY_R)
        {
            yOrbit+=1;
        }
		// wait for the screen to refresh
		swiWaitForVBlank();
	}
	
	return 0;
}
Пример #20
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;
}
Пример #21
0
//void drawVBO(float * verts,int* idx,int polyCount,int xOffset,int yOffset, int zOffset,int width)
//{
//    for (int i=0; i<polyCount; i++)
//    {
//        glBegin(GL_TRIANGLE);
//        for (int k=0; k<3; k++) {
//            
//            int vi1 = idx[i*3 +k];
//            
//            // glNormal3f (-Pickmin_vertex[vi1][2], -Pickmin_vertex[vi1][3],-Pickmin_vertex[vi1][4]);
//            glVertex3f(PikminLeaf_vertex[vi1*width +xOffset],
//                       PikminLeaf_vertex[vi1*width +yOffset],
//                       PikminLeaf_vertex[vi1*width +zOffset]
//                       );
//        }
//        glEnd();
//        
//    }
//}
void drawPikmin(int LOD)
{
    if(LOD >0)
    {
        for (int i=0; i<Pikmin_LOD1_polygoncount; i++)
        {
            glBegin(GL_TRIANGLE);
            for (int k=0; k<3; k++) {
                
                int vi1 = Pikmin_LOD1_index[i][k];
                glColor3f(1,
                          fmax(Pikmin_LOD1_vertex[vi1][3]*1.5 ,.1),
                          0
                          );
                // glNormal3f (-Pickmin_vertex[vi1][2], -Pickmin_vertex[vi1][3],-Pickmin_vertex[vi1][4]);
                glVertex3f(Pikmin_LOD1_vertex[vi1][5],
                           Pikmin_LOD1_vertex[vi1][6],
                           Pikmin_LOD1_vertex[vi1][7]
                           );
            }
            glEnd();
            
        }
    }
    else
    {
    for (int i=0; i<Pikmin_polygoncount; i++)
    {
        glBegin(GL_TRIANGLE);
        for (int k=0; k<3; k++) {
            
            int vi1 = Pikmin_index[i][k];
            glColor3f(1,
                      fmax(Pikmin_vertex[vi1][3]*1.5 ,.1),
                      0
                      );
            // glNormal3f (-Pickmin_vertex[vi1][2], -Pickmin_vertex[vi1][3],-Pickmin_vertex[vi1][4]);
            glVertex3f(Pikmin_vertex[vi1][5],
                       Pikmin_vertex[vi1][6],
                       Pikmin_vertex[vi1][7]
                       );
        }
        glEnd();
        
    }
    }
    
    glPolyFmt(POLY_ALPHA(31) | POLY_CULL_NONE);
    glColor3f(.1,
              leafGreen,
              .1
              );
    for (int i=0; i<PikminLeaf_polygoncount; i++)
    {
        glBegin(GL_TRIANGLE);
        for (int k=0; k<3; k++) {
            
            int vi1 = PikminLeaf_index[i][k];
            
            // glNormal3f (-Pickmin_vertex[vi1][2], -Pickmin_vertex[vi1][3],-Pickmin_vertex[vi1][4]);
            glVertex3f(PikminLeaf_vertex[vi1][5],
                       PikminLeaf_vertex[vi1][6],
                       PikminLeaf_vertex[vi1][7]
                       );
        }
        glEnd();
        
    }
    
    glPolyFmt(POLY_ALPHA(31) | POLY_CULL_FRONT);
    glColor3f(1,1,1);
    for (int i=0; i<PikminEyes_polygoncount; i++)
    {
        glBegin(GL_TRIANGLE);
        for (int k=0; k<3; k++) {
            
            int vi1 = PikminEyes_index[i][k];
            
            // glNormal3f (-Pickmin_vertex[vi1][2], -Pickmin_vertex[vi1][3],-Pickmin_vertex[vi1][4]);
            glVertex3f(PikminEyes_vertex[vi1][5],
                       PikminEyes_vertex[vi1][6],
                       PikminEyes_vertex[vi1][7]
                       );
        }
        glEnd();
        
    }
    
//    //glTranslatef(0.0,,0.5f);
//    glColor3f(.01,.01,.01);
//    glScalef(.7,.7,.7);
//    for (int i=0; i<PikminEyes_polygoncount; i++)
//    {
//        glBegin(GL_TRIANGLE);
//        for (int k=0; k<3; k++) {
//            
//            int vi1 = PikminEyes_index[i][k];
//            
//            // glNormal3f (-Pickmin_vertex[vi1][2], -Pickmin_vertex[vi1][3],-Pickmin_vertex[vi1][4]);
//            glVertex3f(PikminEyes_vertex[vi1][5],
//                       PikminEyes_vertex[vi1][6],
//                       PikminEyes_vertex[vi1][7]
//                       );
//        }
//        glEnd();
//        
//    }
}
Пример #22
0
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;
}
Пример #23
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;
}
Пример #24
0
void Map2D::DrawDebug( const glImage *Tiles )
{
	
	
	glPushMatrix();
	
	glPolyFmt( POLY_ALPHA(31) | POLY_CULL_FRONT | POLY_ID( GlobalManager::Instance()->GetFreePolyID() ) );
	
	for( int y = 0; y < Height; y++ )
	{
		for( int x = 0; x < Width ; x++ )
		{
			
			int Tile = GetElement(x,y);
			switch( Tile )
			{
				case BRICK:
					// offset by 0.5 so that (0,0) is top left of tile like standard 2D
					//DrawCube( x * TILE_SIZE_3D + floattof32(0.5), y * TILE_SIZE_3D + floattof32(0.5), 0, &Tiles[4] );
					break;
				case TOP_BRICK:
					//DrawCube( x * TILE_SIZE_3D + floattof32(0.5), y * TILE_SIZE_3D + floattof32(0.5), 0, &Tiles[0] );
					break;
				case TOP_BRICK_MOSS_TOP:
					//DrawCube( x * TILE_SIZE_3D + floattof32(0.5), y * TILE_SIZE_3D + floattof32(0.5), 0, &Tiles[0] );
					//glSprite3D( x * TILE_SIZE_3D, y  * TILE_SIZE_3D,  10 + TILE_SIZE_3D/2, GL_FLIP_NONE, &Tiles[7] );
					break;
				case BRICK_MOSS_BOTTOM:
					//DrawCube( x * TILE_SIZE_3D + floattof32(0.5), y * TILE_SIZE_3D + floattof32(0.5), 0, &Tiles[4] );
					//glSprite3D( x * TILE_SIZE_3D, y  * TILE_SIZE_3D,  10 + TILE_SIZE_3D/2, GL_FLIP_NONE, &Tiles[6] );
					break;
				case SPIKE:
					//glSprite3D( x * TILE_SIZE_3D, y  * TILE_SIZE_3D, -TILE_SIZE_3D/2, GL_FLIP_NONE, &Tiles[2] );
					//glSprite3D( x * TILE_SIZE_3D, y  * TILE_SIZE_3D,               0, GL_FLIP_NONE, &Tiles[2] );
					//glSprite3D( x * TILE_SIZE_3D, y  * TILE_SIZE_3D,  TILE_SIZE_3D/2, GL_FLIP_NONE, &Tiles[2] );
					break;
				case INVISIBLE:
					glSprite3D( x * TILE_SIZE_3D, y  * TILE_SIZE_3D, 8+ TILE_SIZE_3D, GL_FLIP_NONE, &Tiles[2] );
					break;
				case LADDER:
					//glSprite3D( x * TILE_SIZE_3D, y  * TILE_SIZE_3D, -64, GL_FLIP_NONE, &Tiles[1] );
					break;
				case TOP_LADDER:
					//glSprite3D( x * TILE_SIZE_3D, y  * TILE_SIZE_3D, -64, GL_FLIP_NONE, &Tiles[1] );
					break;
				case TOP_LADDER_HANDLE:
					//glSprite3D( x * TILE_SIZE_3D, y  * TILE_SIZE_3D, -64, GL_FLIP_NONE, &Tiles[5] );
					break;
				case SIGN:
					//glSprite3D( x * TILE_SIZE_3D, y  * TILE_SIZE_3D,  TILE_SIZE_3D/2, GL_FLIP_NONE, &Tiles[3] );
					break;
				case MOSS_BOTTOM:
					//glSprite3D( x * TILE_SIZE_3D, y  * TILE_SIZE_3D,  10 + TILE_SIZE_3D/2, GL_FLIP_NONE, &Tiles[6] );
					break;
				case BLOCK_COLLIDE:
					glSprite3D( x * TILE_SIZE_3D, y  * TILE_SIZE_3D, -TILE_SIZE_3D/2, GL_FLIP_NONE, &Tiles[2] );
					break;
					
			}
			
		}	
	}
	
	glPopMatrix(1);
	
}
Пример #25
0
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 
Пример #26
0
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);
}
Пример #27
0
int main()
{	
    struct touchPosition pos;
	float rotateX = 0.0;
	float rotateY = 0.0;

	powerON(POWER_ALL);
    consoleDemoInit();

	//set mode 0, enable BG0 and set it to 3D
	videoSetMode(MODE_0_3D);

	//irqs are nice
	irqInit();
	irqEnable(IRQ_VBLANK);
    
	// 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);
    
	//any floating point gl call is being converted to fixed prior to being implemented
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluPerspective(35, 256.0 / 192.0, 0.1, 100);
	
	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)		
	{
        float px, py;
        
    	pos = touchReadXY();
        px = pos.px;
        py = pos.py;

        px = (px * 5) / 256;
        py = (py * 3) / 192;

        px -= 2.5;
        py -= 1.5;

		glPushMatrix();

		//move it away from the camera
		glTranslate3f32(0, 0, floattof32(-1));

		glRotateX(rotateX);
		glRotateY(rotateY);

		glMatrixMode(GL_MODELVIEW);

		//not a real gl function and will likely change
		glPolyFmt(POLY_ALPHA(31) | POLY_CULL_NONE);
        
		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;
        
		//draw the obj
		glBegin(GL_TRIANGLE);
			
			glColor3b(255,0,0);
			glVertex3v16(inttov16(-1),inttov16(-1),0);

			glColor3b(0,255,0);
			glVertex3v16(inttov16(1), inttov16(-1), 0);

			glColor3b(0,0,255);
			glVertex3v16(inttov16(0), inttov16(1), 0);
			
		glEnd();

        glLoadIdentity();
        glTranslatef(px,-py,-3.0);
        glBegin(GL_TRIANGLE);
            glVertex3f( 0.0, 1.0, 0.0);
            glVertex3f(-1.0,-1.0, 0.0);
            glVertex3f( 1.0,-1.0, 0.0);
        glEnd();

		glPopMatrix(1);

		glFlush(0);
		swiWaitForVBlank();
	}

	return 0;
}//end main 
Пример #28
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");
}
Пример #29
0
int main()
{

	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 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);

	//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)
	{
		glPushMatrix();

		//move it away from the camera
		glTranslatef32(0, 0, floattof32(-1));

		glRotateX(rotateX);
		glRotateY(rotateY);


		glMatrixMode(GL_MODELVIEW);



		//not a real gl function and will likely change
		glPolyFmt(POLY_ALPHA(31) | POLY_CULL_NONE);

		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;

		//draw the obj
		glBegin(GL_QUAD);

			glColor3b(255,0,0);
			glVertex3v16(inttov16(-1),inttov16(-1),0);

			glColor3b(0,255,0);
			glVertex3v16(inttov16(1), inttov16(-1), 0);

			glColor3b(0,0,255);
			glVertex3v16(inttov16(1), inttov16(1), 0);

			glColor3b(255,0,255);
			glVertex3v16(inttov16(-1), inttov16(1), 0);

		glEnd();

		glPopMatrix(1);

		glFlush(0);

		swiWaitForVBlank();

		if(keys & KEY_START) break;
	}

	return 0;
}//end main
Пример #30
0
int main() {	
	
	int textureID;

	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);
	
	// 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);
	
	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) {
		glMatrixMode(GL_MODELVIEW);
		glPushMatrix();

		//move it away from the camera
		glTranslate3f32(0, 0, floattof32(-1));
				
		glRotateX(rotateX);
		glRotateY(rotateY);
		
		

		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();

		//not a real gl function and will likely change
		glPolyFmt(POLY_ALPHA(31) | POLY_CULL_BACK);

		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);
			glNormal(NORMAL_PACK(0,inttov10(-1),0));

			GFX_TEX_COORD = (TEXTURE_PACK(0, inttot16(128)));
			glVertex3v16(floattov16(-0.5),	floattov16(-0.5), 0 );
	
			GFX_TEX_COORD = (TEXTURE_PACK(inttot16(128),inttot16(128)));
			glVertex3v16(floattov16(0.5),	floattov16(-0.5), 0 );
	
			GFX_TEX_COORD = (TEXTURE_PACK(inttot16(128), 0));
			glVertex3v16(floattov16(0.5),	floattov16(0.5), 0 );

			GFX_TEX_COORD = (TEXTURE_PACK(0,0));
			glVertex3v16(floattov16(-0.5),	floattov16(0.5), 0 );
		
		glEnd();
		
		glPopMatrix(1);
			
		glFlush(0);

		swiWaitForVBlank();
	}

	return 0;
}//end main