www

demo.c (6439B)

---

 #include <module.h>
 #include <types.h>
 #include <math.h>
 #include <interfaceUtilisateur/demo/demo.h>
 #include <interfaceUtilisateur/console/console.h>
 #include <pc/vesaGraphique/vesaGraphique.h>
 #include <interfaceUtilisateur/police/police.h>
 
 MODULE(Demo);
 
 DEPENDANCE_MODULE(Demo, Police);
 DEPENDANCE_MODULE(Demo, VesaGraphique);
 DEPENDANCE_MODULE(Demo, VgaTexte);
 DEPENDANCE_MODULE(Demo, Clavier);
 
 void demoAffiche(uint32 x1, uint32 y1) {
 	uint32 fg1 = 0x00880044;
 	uint32 fg2 = 0x00770055;
 	uint32 fg3 = 0x00550077;
 	uint32 fg4 = 0x00440088;
 	uint32 bg  = 0x00ffcccc;
 	uint32 ctr = 0x00886666;
 	
 	policeAfficherCaractereCouleurPosition('L', fg1, bg, x1, y1);
 	policeAfficherCaractereCouleurPosition('y', fg2, bg, x1 + 8, y1);
 	policeAfficherCaractereCouleurPosition('r', fg3, bg, x1 + 2*8, y1);
 	policeAfficherCaractereCouleurPosition('a', fg4, bg, x1 + 3*8, y1);
 	
 	rectangleContour (x1 - 1, y1 - 2, x1+(4*8) + 2, y1+15 + 1, ctr);
 }
 
 void faireDemo () {
 	int32 x1 = 1024/2-8*2;
 	int32 y1 = 768/2-15/2;
 	
 	int32 ac1 = 0x00ff0000;
 	int32 ac2 = 0x000000ff;
 	int32 dc1 = 50;
 	int32 dc2 = 50;
 	int32 c = ac1;
 	int32 x2 = 0;
 	int32 y2 = 768 / 2;
 	int32 x3 = x2;
 	int32 y3 = y2;
 	int32 dx = 3;
 	int32 dy = 7;
 	int32 ddx = 1;
 	int32 ddy = 1;
 	
 	while (FALSE) {
 		demoAffiche(x1, y1);
 		asm volatile ("hlt");
 		asm volatile ("hlt");
 		rectanglePlein (x1 - 1, y1 - 2, x1+(4*8) + 2, y1+15 + 1, 0);
 		
 		x1 = ((x1 + x1*x1*y1 + y1*3 + 7) % (1024 - 4*8 + 3)) + 1;
 		y1 = ((y1 + y1*y1*x1 + x1*3 + 42) % (768 - 15 + 3)) + 2;
 		
 		dc1 = dc1 + dy / 10;
 		dc2 = dc1 + dx / 5;
 		c = dc1 * ac1 + dc2 * ac2;
 		x3 = x2 + dx;
 		y3 = y2 + dy;
 		dx += abs(ddx - 3) - 1;
 		dy += abs(ddy - 5) - 2;
 		ddx = (ddx + 1) % 6;
 		ddy = (ddy + 1) % 10;
 		
 		if (x3 >= 1024) {
 			x3 = 1024 - (x3 % 1024);
 			dx = -dx;
 		}
 		if (y3 >= 768) {
 			y3 = 768 - (y3 % 768);
 			dy = -dy;
 		}
 
 		if (x3 < 0) {
 			x3 = abs(x3) % 1024;
 			dx = -dx;
 		}
 		if (y3 < 0) {
 			y3 = abs(y3) % 768;
 			dy = -dy;
 		}
 		
 		ligne(x2, y2, x3, y3, c);
 		
 		x2 = x3;
 		y2 = y3;
 	}
 	
 	{
 		int32 alx1 = 1024/2-8*2;
 		int32 aly1 = 768/2-15/2;
 		int32 lx1 = alx1;
 		int32 ly1 = aly1;
 		int32 lx2 = lx1;
 		int32 ly2 = ly1;
 		
 		uint32 i, compteur = 0, compteur2 = 0;
 		int32 angle=0;
 		int32 dangle=3;
 		int32 ddangle=0;
 		int32 x1 = 100;
 		int32 y1 = 768/2;
 		int32 x2 = x1;
 		int32 y2 = y1;
 		int32 ax = lx2; // 1024-100;
 		int32 ay = ly2; // 768/2;
 		int32 v = 15;
 		int32 dx, dy, adx1, ady1, adx2, ady2;
 		int32 cx1 = 9;
 		int32 cy1 = 9;
 		int32 colmod;
 		
 		
 		
 		int32 noiralx1 = 1024/2-8*2;
 		int32 noiraly1 = 768/2-15/2;
 		int32 noirlx1 = noiralx1;
 		int32 noirly1 = noiraly1;
 		int32 noirlx2 = noirlx1;
 		int32 noirly2 = noirly1;
 		
 		uint32 noiri, noircompteur = 0, noirprecompteur = 0, noircompteur2 = 0;
 		int32 noirangle=0;
 		int32 noirdangle=3;
 		int32 noirddangle=0;
 		int32 noirx1 = 100;
 		int32 noiry1 = 768/2;
 		int32 noirx2 = noirx1;
 		int32 noiry2 = noiry1;
 		int32 noirax = noirlx2; // 1024-100;
 		int32 noiray = noirly2; // 768/2;
 		int32 noirv = 15;
 		int32 noirdx, noirdy, noiradx1, noirady1, noiradx2, noirady2;
 		int32 noircx1 = 9;
 		int32 noircy1 = 9;
 		
 		while (TRUE) {
 			// demoAffiche(lx2, ly2);
 			compteur2++;
 			compteur = compteur2 / 4;
 			
 			// if (compteur2 % 4 == 0)
 			// 	asm volatile ("hlt");
 			// else
 				{ int t; for (t = 0; t < 1000000; t++) asm volatile ("nop"); }
 			
 			// lx2 += sign(alx1-lx2);
 			// ly2 += sign(aly1-ly2);
 			lx2 = alx1;
 			ly2 = aly1;
 			
 			rectanglePlein (lx1 - 1, ly1 - 2, lx1+(4*8) + 2, ly1+15 + 1, 0);
 			demoAffiche(lx2, ly2);
 			
 			lx1 = lx2;
 			ly1 = ly2;
 			
 			alx1 = (1024 - 96)/2 + 32 + (1024 - 64) * sinRapide(compteur2 * (2<<7)  ) / (2<<15);
 			aly1 = (768 - 80)/2  + 32 + (768 - 48)  * cosRapide(compteur2 * (2<<4)*3) / (2<<15);
 			
 			
 			for (i = 0; i < 2000; i += dx*dx + dy*dy) {
 				ax = alx1;
 				ay = aly1;
 				
 				adx1 = v * cosRapide(angle) / (2<<15);
 				ady1 = v * sinRapide(angle) / (2<<15);
 				
 				adx2 = (ax-x2) / 100;
 				ady2 = (ay-y2) / 100;
 				
 				dx = (cx1*adx1 + (10-cx1)*adx2) / 10;
 				dy = (cy1*ady1 + (10-cy1)*ady2) / 10;
 				
 				x2 += dx;
 				y2 += dy;
 
 				dangle += abs(ddangle - 4) - 2;
 				// dangle++;
 				angle += dangle*16;
 				
 				colmod = 0xcc / 2 + (0xcc * sinRapide(compteur * (2<<4)*15) / (2<<15));
 				if ((x1 > 0) && (x1 < 1024) &&
 				    (x2 > 0) && (x2 < 1024) &&
 				    (y1 > 0) && (y1 < 768) &&
 				    (y2 > 0) && (y2 < 768))
 				ligne(x1,y1,x2,y2,0x00ff0000 | (colmod << 8) | colmod);
 				
 				x1 = x2;
 				y1 = y2;
 			}
 			if (compteur2 % 4 == 0)
 				ddangle = (ddangle + 1) % 8;
 			
 			
 			
 			
 			
 			if (noirprecompteur <= 15) {
 				noirprecompteur++;
 			} else {
 			
 			noircompteur2++;
 			noircompteur = noircompteur2 / 4;
 			
 			// noirlx2 += sign(noiralx1-noirlx2);
 			// noirly2 += sign(noiraly1-noirly2);
 			noirlx2 = noiralx1;
 			noirly2 = noiraly1;
 			
 			//// rectanglePlein (noirlx1 - 1, noirly1 - 2, noirlx1+(4*8) + 2, noirly1+15 + 1, 0);
 			//// demoAffiche(noirlx2, noirly2);
 			
 			noirlx1 = noirlx2;
 			noirly1 = noirly2;
 			
 			noiralx1 = (1024 - 96)/2 + 32 + (1024 - 64) * sinRapide(noircompteur2 * (2<<7)  ) / (2<<15);
 			noiraly1 = (768 - 80)/2  + 32 + (768 - 48)  * cosRapide(noircompteur2 * (2<<4)*3) / (2<<15);
 			
 			
 			for (noiri = 0; noiri < 2000; noiri += noirdx*noirdx + noirdy*noirdy) {
 				noirax = noiralx1;
 				noiray = noiraly1;
 				
 				noiradx1 = noirv * cosRapide(noirangle) / (2<<15);
 				noirady1 = noirv * sinRapide(noirangle) / (2<<15);
 				
 				noiradx2 = (noirax-noirx2) / 100;
 				noirady2 = (noiray-noiry2) / 100;
 				
 				noirdx = (noircx1*noiradx1 + (10-noircx1)*noiradx2) / 10;
 				noirdy = (noircy1*noirady1 + (10-noircy1)*noirady2) / 10;
 				
 				noirx2 += noirdx;
 				noiry2 += noirdy;
 
 				noirdangle += abs(noirddangle - 4) - 2;
 				// dangle++;
 				noirangle += noirdangle*16;
 				
 				if ((noirx1 > 0) && (noirx1 < 1024) &&
 				    (noirx2 > 0) && (noirx2 < 1024) &&
 				    (noiry1 > 0) && (noiry1 < 768) &&
 				    (noiry2 > 0) && (noiry2 < 768))
 				ligne(noirx1,noiry1,noirx2,noiry2,0);
 				
 				noirx1 = noirx2;
 				noiry1 = noiry2;
 			}
 			if (noircompteur2 % 4 == 0)
 				noirddangle = (noirddangle + 1) % 8;
 			
 			} // if noirprecompteur <= 10
 		}
 	}
 }
 
 void demoNombres() {
 	int i;
 	for (i = 0; i <= 10; i++) {
 		afficherEntierEnDecimal(i);
 		afficherChaineZ(" ");
 	}
 	afficherChaineZ("\n");
 }
 
 
 void initDemo(void** etat) {
 	*etat = NULL;
 }
 
 void deinitDemo(void** etat) {
 	*etat = NULL;
 }