Partage
  • Partager sur Facebook
  • Partager sur Twitter

[Concours]Le code le plus sale

Laissez sortir le programmeur sale qui est en vous

    20 décembre 2010 à 14:56:03

    Quel est l'intérêt de continuer à poster des codes alors qu'il faut voter maintenant ?
    • Partager sur Facebook
    • Partager sur Twitter
      Staff 20 décembre 2010 à 14:58:23

      Citation : Loadware

      Quel est l'intérêt de continuer à poster des codes alors qu'il faut voter maintenant ?



      Le vote est cloturé ;) bientôt on va savoir qui l'a remporté.
      • Partager sur Facebook
      • Partager sur Twitter
      Anonyme
        20 décembre 2010 à 15:03:10

        He bon je ne savais pas ^^
        • Partager sur Facebook
        • Partager sur Twitter
          20 décembre 2010 à 15:59:38

          a moi de poster mon code : la recette (plus ou moins)
          #include<stdio.h>
          #include<stdlib.h>
          #include<time.h>
          #define Pour int
          #define faire main
          #define un (
          #define repas )
          #define bon int argc , char **argv
          #define il int
          #define te min
          #define faudra =
          #define beaucoup 1
          #define de max
          #define chose =
          #define a 100
          #define manger ;
          #define notamment int
          #define ce nombreMystere
          #define que =
          #define je 0
          #define vais ,
          #define Te nombreEntre
          #define dire =0;
          #define jaurais srand
          #define besoin (
          #define dune time
          #define courgette (
          #define du NULL
          #define poivre ))
          #define bravo   nombreMystere = (rand() % (max - min + 1)) + min;
          #define Je do
          #define ne {
          #define vous printf("nombre?\n");
          #define dirais scanf("%d",&nombreEntre);
          #define pas if(nombreMystere>nombreEntre)
          #define comment printf("+!\n\n");
          #define Faire else
          #define le if
          #define Plat (
          #define Et nombreMystere < nombreEntre
          #define Le )
          #define dessert printf("-!\n\n");
          #define coupe else
          #define les printf("Bravo");
          #define Courgette }
          #define met while
          #define y (
          #define Du nombreEntre != nombreMystere
          #define Poivre )
          #define et ;
          #define apres return
          #define Bon 0
          #define appetit ;
          
          
          
          
          //define
          
          Pour faire un bon repas {
          
          il te faudra beaucoup,de chose a manger
          notamment ce que je vais Te dire
          jaurais besoin dune courgette du poivre;
          bravo
          
          Je ne vous dirais pas comment Faire le Plat Et Le dessert  coupe les Courgette met y Du Poivre et
          apres Bon appetit
          
          }
          


          :D j'avais faim quand j'ai écris ce code
          A c'est clôturé :'(
          Bon je le me pour le fun alors
          • Partager sur Facebook
          • Partager sur Twitter
            20 décembre 2010 à 16:11:34

            Lol, moi aussi je continue avec la serie de codes-qui-servent-à-rien-et-qui-sont-illisibles :

            La première image de mon avatar:
            #include<stdio.h>
            #include<stdlib.h>
            
            int main(void)
            {
            	int i,y,x;
            	char avatar[7][7] = {0};
            	for(y=0;y<7;y++)
            		for(x=0;x<7;x++)
            		{
            			if(x==((3-y>=0)?3-y:0))
            				avatar[y][x] = '#';
            			if(x==((3+y<=6)?3+y:6))
            				avatar[y][x] = '#';
            		}
            	for(y=5;y<7;y++)
            		for(x=0;x<7;x++)
            			avatar[y][x] = (!(y%6)&&!(x&1))?0:'#';
            	for(x=0;x<7;x++)
            		avatar[3][x] = (avatar[6][x]=='#')?' ':'#';
            	
            	for(y=0;y<7;y++,puts(""))
            		for(x=0;x<7;x++)
            			printf("%c",((avatar[y][x])?:' '));
            	
            	getchar();
            	return 0;
            }
            
            • Partager sur Facebook
            • Partager sur Twitter
            🍊 - Étudiant - Codeur en C | Zeste de Savoir apprenez avec une communauté | Articles  - ♡ Copying is an act of love.
              20 décembre 2010 à 17:46:23

              Citation : informaticienzero

              #include <stdio.h>
              #include <stdlib.h>
              #include <math.h> //Inclus la bibliotheque mathématique
              
              int main(int argc, char *argv[])
              
              {
                  printf("Ce programme est destine a vous aider pour des operations mathematiques\n");
                  printf("Createur: ****** *********\n\n");
              
                  int choixOperation;
                  //Choix de l'operation à executer
                  printf("=== Choix de l'operation ===\n\n");
                  printf("1. Addition\n");
                  printf("2. Soustraction\n");
                  printf("3. Multiplication\n");
                  printf("4. Division\n");
                  printf("5. Modulo (permet de trouver le reste d'une division)\n");
                  printf("6. Puissances\n");
                  printf("7. Racine Carree\n");
                  printf("8. Exponientielle\n");
                  printf("9. Cosinus\n");
                  printf("10. Sinus\n");
                  printf("11. Tangente\n");
                  printf("12. Puissances de 10\n");
                  printf("13. Conversion Euros --> Francs\n");
                  printf("14. Conversion Francs --> Euros\n");
                  printf("15. Aire d'un Carre\n");
                  printf("16. Aire d'un Rectangle\n");
                  printf("17. Aire d'un Triangle quelconque\n");
                  printf("18. Aire d'un Triangle rectangle\n");
                  printf("19. Aire d'un Triangle equilateral\n");
                  printf("20. Surface d'un Cube\n");
                  printf("21. Surface d'un Pave\n");
                  printf("22. Surface d'une Sphere\n");
                  printf("23. Surface d'un Cylindre\n");
                  printf("24. Volume d'un Cube\n");
                  printf("25. Volume d'un Pave\n");
                  printf("26. Volume d'une Sphere\n");
                  printf("27. Volume d'un Cylindre\n");
                  printf("\nVotre choix ? "); //Demande l'opération à executer
                  scanf("%d", &choixOperation);//Le nombre tapé correspont à une opération
              
                  printf("\n");
              
                  switch (choixOperation)
                  {//Affichage de l'operation executée
                      case 1:
                          printf("Vous avez choisi l'Addition !");
                      break;
                      case 2:
                          printf("Vous avez choisi la Soustraction !");
                      break;
                      case 3:
                          printf("Vous avez choisi la Multiplication !");
                      break;
                      case 4:
                          printf("Vous avez choisi la Division !");
                      break;
                      case 5:
                          printf("Vous avez choisi le Modulo !");
                      break;
                      case 6:
                          printf("Vous avez choisi les Puissances !");
                      break;
                      case 7:
                          printf("Vous avez choisi la Racine Carree !");
                      break;
                      case 8:
                          printf("Vous avez choisi l'Exponientielle !");
                      break;
                      case 9:
                          printf("Vous avez choisi le Cosinus !");
                      break;
                      case 10:
                          printf("Vous avez choisi le Sinus !");
                      break;
                      case 11:
                          printf("Vous avez choisi la Tangente !");
                      break;
                      case 12:
                          printf("Vous avez choisi les Puissances de 10 !");
                      break;
                      case 13:
                          printf("Vous avez choisi la conversion Euros --> Franc !");
                      break;
                      case 14:
                          printf("Vous avez choisi la conversion Franc --> Euros !");
                      break;
                      case 15:
                          printf("Vous avez choisi l'aire d'un Carre  !");
                      break;
                      case 16:
                          printf("Vous avez choisi l'aire d'un Rectangle!");
                      break;
                      case 17:
                          printf("Vous avez choisi l'aire d'un Triangle quelconque!");
                      break;
                       case 18:
                          printf("Vous avez choisi l'aire d'un Triangle rectangle!");
                      break;
                       case 19:
                          printf("Vous avez choisi l'aire d'un Triangle equilateral!");
                      break;
                      case 20:
                          printf("Vous avez choisi la suface d'un Cube!");
                      break;
                      case 21:
                          printf("Vous avez choisi la suface d'un Pave!");
                      break;
                      case 22:
                          printf("Vous avez choisi la suface d'une Sphere!");
                      break;
                      case 23:
                          printf("Vous avez choisi la suface d'un Cylindre!");
                      break;
                      case 24:
                          printf("Vous avez choisi le volume d'un Cube!");
                      break;
                      case 25:
                          printf("Vous avez choisi le volume d'un Pave!");
                      break;
                      case 26:
                          printf("Vous avez choisi le volume d'une Sphere!");
                      break;
                      case 27:
                          printf("Vous avez choisi le volume d'un Cylindre!");
                      break;
                      default://Permet d'afficher un message d'erreur si un mauvais nombre est tapé
                          printf("Vous n'avez pas rentre un nombre correct !");
                      break;
                }
              
                printf("\n\n");
              
                if(choixOperation == 1)
                 {
              
                  double compteur = 0, resultat = 0, nombre1 = 0, nombre2 = 0;
              
              
                     do
                     {
                      printf("Entrer le nombre1\n");
                      scanf("%lf", &nombre1);
                      printf("Entrer le nombre2\n");
                      scanf("%lf", &nombre2);
              
                      resultat = nombre1 + nombre2;
              
                      printf("%lf + %lf =  %lf\n\n", nombre1, nombre2, resultat);
                      compteur++;
              
                     } while (1);//Boucle vraie donc infinie
                 }
              
                  else if(choixOperation == 2)
                 {
              
                  double compteur = 0, resultat = 0, nombre1 = 0, nombre2 = 0;
              
              
                     do
                     {
                      printf("Entrer le nombre1\n");
                      scanf("%lf", &nombre1);
                      printf("Entrer le nombre2\n");
                      scanf("%lf", &nombre2);
              
                      resultat = nombre1 - nombre2;
              
                      printf("%d - %d =  %d\n\n", nombre1, nombre2, resultat);
                      compteur++;
              
                     } while (1);
                 }
              
              
                  else if(choixOperation == 3)
              
                  {
                      double compteur = 0, resultat = 0, nombre1 = 0, nombre2 = 0;
              
              
                     do
                     {
                      printf("Entrer le nombre1\n");
                      scanf("%lf", &nombre1);
                      printf("Entrer le nombre2\n");
                      scanf("%lf", &nombre2);
              
                      resultat = nombre1 * nombre2;
              
                      printf("%lf * %lf =  %lf\n\n", nombre1, nombre2, resultat);
                      compteur++;
              
                     } while (1);
                  }
              
                  else if(choixOperation == 4)
              
                      {double compteur = 0, resultat = 0, nombre1 = 0.0, nombre2 = 0.0;
              
              
                     do
                     {
                      printf("Entrer le nombre1\n");
                      scanf("%lf", &nombre1);
                      printf("Entrer le nombre2\n");
                      scanf("%lf", &nombre2);
              
                      resultat = nombre1 / nombre2;
              
                      printf("%lf / %lf = %lf\n\n", nombre1, nombre2, resultat);
                      compteur++;
              
                     } while (1);
              
                      }
              
                else if(choixOperation == 5)
                 {
              
                  int compteur = 0, resultat = 0, nombre1 = 0.0, nombre2 = 0.0;
              
              
                     do
                     {
                      printf("Entrer le nombre1\n");
                      scanf("%d", &nombre1);
                      printf("Entrer le nombre2\n");
                      scanf("%d", &nombre2);
              
                      resultat = nombre1 % nombre2;//% est le signe du modulo
              
                      printf("%d %% %d =  %d\n\n", nombre1, nombre2, resultat);
                      compteur++;
              
                     } while (1);//Boucle vraie donc infinie
                 }
              
               if(choixOperation == 6)
                 {
              
                  double compteur = 0, resultat = 0, nombre1 = 0, nombre2 = 0;
              
              
                     do
                     {
                      printf("Entrer le nombre1\n");
                      scanf("%lf", &nombre1);
                      printf("Entrer le nombre2\n");
                      scanf("%lf", &nombre2);
              
                      resultat = pow(nombre1, nombre2); //pow permet de trouver le carré d'un nombre
              
                      printf("%lf a la puissance %lf =  %lf\n\n", nombre1, nombre2, resultat);
                      compteur++;
              
                     } while (1);//Boucle vraie donc infinie
                 }
              
              
              if(choixOperation == 7)
                 {
              
                  double compteur = 0, resultat = 0.0, nombre1 = 0.0;
              
                     do
                     {
                      printf("Entrer le nombre1\n");
                      scanf("%lf", &nombre1);
              
                      resultat = sqrt(nombre1); //sqrt permet de trouver la racine carré d'un nombre
              
                      printf("La racine carree de %lf est =  %lf\n\n", nombre1, resultat);
                      compteur++;
              
                     } while (1);//Boucle vraie donc infinie
                 }
              
              if(choixOperation == 8)
                 {
              
                  double compteur = 0, resultat = 0, nombre1 = 0;
              
              
                     do
                     {
                      printf("Entrer le nombre1\n");
                      scanf("%lf", &nombre1);
              
                      resultat =  exp(nombre1); //exp permet de trouver l'exponentielle d'un nombre
              
                      printf("L'exponientielle de %lf =  %lf\n\n", nombre1, resultat);
                      compteur++;
              
                     } while (1);//Boucle vraie donc infinie
                 }
              
              
              if(choixOperation == 9)
                 {
              
                  float compteur = 0, resultatdegre = 0, nombre1degre = 0;
              
              
                     do
                     {
                      printf("Entrer le nombre1\n");
                      scanf("%f", &nombre1degre);
              
                      resultatdegre =  cos(nombre1degre); //cos permet de trouver le cosinus d'un nombre
              
                      printf("Le cosinus de %f =  %f\n\n", nombre1degre, resultatdegre);
                      compteur++;
              
                     } while (1);
                 }
              
              if(choixOperation == 10)
                 {
              
                  float compteur = 0, resultatdegre = 0, nombre1degre = 0;
              
              
                     do
                     {
                      printf("Entrer le nombre1\n");
                      scanf("%f", &nombre1degre);
              
                      resultatdegre =  sin(nombre1degre); //sin permet de trouver le sinus d'un nombre
              
                      printf("Le sinus de %f =  %f\n\n", nombre1degre, resultatdegre);
                      compteur++;
              
                     } while (1);
                 }
              
              if(choixOperation == 11)
                 {
              
                  float compteur = 0, resultatdegre = 0, nombre1degre = 0;
              
              
                     do
                     {
                      printf("Entrer le nombre1\n");
                      scanf("%f", &nombre1degre);
              
                      resultatdegre =  tan(nombre1degre); //tan permet de trouver la tangente d'un nombre
              
                      printf("La tangente de %f =  %f\n\n", nombre1degre, resultatdegre);
                      compteur++;
              
                     } while (1);
                 }
              
              
              if(choixOperation == 12)
                 {
              
                  double compteur = 0, resultat = 0, nombre1 = 0, nombre2 = 0;
              
              
                     do
                     {
                      printf("Entrer le nombre1\n");
                      scanf("%lf", &nombre1);
                      printf("Entrer le nombre2\n");
                      scanf("%lf", &nombre2);
              
                      resultat =  nombre1 * pow(10, nombre2);
              
                      printf("%lf multiplie par 10 puissance %lf =  %lf\n\n", nombre1, nombre2, resultat);
                      compteur++;
              
                     } while (1);
                 }
              
                  if(choixOperation == 13)
                 {
              
                  double compteur = 0, resultat = 0, nombre1euro = 0;
              
              
                     do
                     {
                      printf("Entrer le nombre1\n");
                      scanf("%lf", &nombre1euro);
              
                      resultat = 6.55957 * (nombre1euro);
              
              
                      printf("%lf euros = %lf francs, \n\n", nombre1euro, resultat);
                      compteur++;
              
                     } while (1);//Boucle vraie donc infinie
                 }
              
                  if(choixOperation == 14)
                 {
              
                  double compteur = 0, resultat = 0, nombre1franc = 0;
              
              
                     do
                     {
                      printf("Entrer le nombre1\n");
                      scanf("%lf", &nombre1franc);
              
                      resultat = (nombre1franc) / 6.55957;
              
              
                      printf("%lf francs = %lf euros, \n\n", nombre1franc, resultat);
                      compteur++;
              
                     } while (1);//Boucle vraie donc infinie
                 }
              
              if(choixOperation == 15)
                 {
              
                  double compteur = 0, resultat = 0, cote = 0;
              
              
                     do
                     {
                      printf("Entrer la valeur d'un cote (en cm)\n");
                      scanf("%lf", &cote);
              
                      resultat =  cote * cote;
              
                      printf("L'aire d'un carre de %lf cm de cote =  %lf cm carre\n\n", cote, resultat);
                      compteur++;
              
                     } while (1);
                 }
              
                 if(choixOperation == 16)
                 {
              
                  double compteur = 0, resultat = 0, longeur = 0, largeur = 0;
              
              
                     do
                     {
                      printf("Entrer la longeur (en cm) du rectangle\n");
                      scanf("%lf", &longeur);
                      printf("Entrer la largeur (en cm) du rectangle\n");
                      scanf("%lf", &largeur);
              
                      resultat =  longeur * largeur;
              
                      printf("L'aire d'un rectangle de %lf cm de longeur et de %lf cm de largeur =  %lf cm carre\n\n", longeur, largeur,  resultat);
                      compteur++;
              
                     } while (1);
                 }
              
                 if(choixOperation == 17)
                 {
              
                  double compteur = 0, resultat = 0, base = 0, hauteur = 0;
              
              
                     do
                     {
                      printf("Entrer la base (en cm) du triangle\n");
                      scanf("%lf", &base);
                      printf("Entrer la hauteur (en cm) du triangle\n");
                      scanf("%lf", &hauteur);
              
                      resultat =  (base * hauteur) / 2;
              
                      printf("L'aire d'un triangle quelconque de %lf cm de base et de %lf cm de hauteur =  %lf cm carre\n\n", base, hauteur,  resultat);
                      compteur++;
              
                     } while (1);
                 }
              
                 if(choixOperation == 18)
                 {
              
                  double compteur = 0, resultat = 0, cote_a = 0, cote_b = 0;
              
              
                     do
                     {
                      printf("Entrer le cote a (en cm) du triangle\n");
                      scanf("%lf", &cote_a);
                      printf("Entrer le cote b (en cm) du triangle\n");
                      scanf("%lf", &cote_b);
              
                      resultat =  (cote_a * cote_b) / 2;
              
                      printf("L'aire d'un triangle rectangle de %lf cm de cote a et de %lf cm de cote b =  %lf cm carre\n\n", cote_a, cote_b,  resultat);
                      compteur++;
              
                     } while (1);
                 }
              
                 if(choixOperation == 19)
                 {
              
                  double compteur = 0, resultat = 0, cote_a = 0, cote_b = 0;
              
              
                     do
                     {
                      printf("Entrer le cote a (en cm) du triangle\n");
                      scanf("%lf", &cote_a);
              
                      resultat = (1.732051 / 4) * (cote_a * cote_a);
                      printf("L'aire d'un triangle equilateral de %lf cm de cote a =  %lf cm carre\n\n", cote_a, resultat);
                      compteur++;
              
                     } while (1);
                 }
              
                 if(choixOperation == 20)
                 {
              
                  double compteur = 0, resultat = 0, cote = 0;
              
              
                     do
                     {
                      printf("Entrer la valeur d'un cote (en cm)\n");
                      scanf("%lf", &cote);
              
                      resultat = 6 * (cote * cote);
              
                      printf("La surface d'un cube de %lf cm de cote =  %lf cm carre\n\n", cote, resultat);
                      compteur++;
              
                     } while (1);
                 }
              
                 if(choixOperation == 21)
                 {
              
                  double compteur = 0, resultat = 0, longeur = 0, largeur = 0, hauteur = 0;
              
              
                     do
                     {
                      printf("Entrer la longeur (en cm) du pave\n");
                      scanf("%lf", &longeur);
                      printf("Entrer la largeur (en cm) du pave\n");
                      scanf("%lf", &largeur);
                      printf("Enter le hauteur (en cm) du pave\n");
              
                      resultat =  2 * (longeur * largeur + longeur * hauteur + largeur * hauteur);
              
                      printf("La surface d'un pave de %lf cm de longeur, de %lf cm de largeur  et de %lf de hauteur=  %lf cm carre\n\n", longeur, largeur, hauteur,   resultat);
                      compteur++;
              
                     } while (1);
                 }
              
                 if(choixOperation == 22)
                 {
              
                  double compteur = 0, resultat = 0, rayon = 0;
              
              
                     do
                     {
                      printf("Entrer le rayon (en cm) de la sphere\n");
                      scanf("%lf", &rayon);
              
                      resultat =  4 * 3.141592654 * (rayon * rayon);
              
                      printf("La surface d'une sphere de %lf cm de rayon =  %lf cm carre\n\n", rayon, resultat);
                      compteur++;
              
                     } while (1);
                 }
              
                 if(choixOperation == 23)
                 {
              
                  double compteur = 0, resultat = 0, rayon = 0, hauteur = 0;
              
              
                     do
                     {
                      printf("Entrer le rayon (en cm) du cylindre\n");
                      scanf("%lf", &rayon);
                      printf("Entrer la hauteur (en cm) du cylindre\n");
                      scanf("%lf", &hauteur);
              
                      resultat =  2 * 3.141592654 * rayon * hauteur;
              
                      printf("La surface d'un cylindre de %f cm de rayon et de %f com de hauteur =  %f cm carre\n\n", rayon, hauteur, resultat);
              
                     } while (1);
                 }
              
                 if(choixOperation == 24)
                 {
              
                  double compteur = 0, resultat = 0, cote = 0;
              
              
                     do
                     {
                      printf("Entrer la valeur d'un cote (en cm)\n");
                      scanf("%lf", &cote);
              
                      resultat = (cote * cote * cote);
              
                      printf("Le volume d'un cube de %lf cm de cote =  %lf cm cube\n\n", cote, resultat);
                      compteur++;
              
                     } while (1);
                 }
              
                  if(choixOperation == 25)
                 {
              
                  double compteur = 0, resultat = 0, longeur = 0, largeur = 0, hauteur = 0;
              
              
                     do
                     {
                      printf("Entrer la longeur (en cm) du pave\n");
                      scanf("%lf", &longeur);
                      printf("Entrer la largeur (en cm) du pave\n");
                      scanf("%lf", &largeur);
                      printf("Enter le hauteur (en cm) du pave\n");
              
                      resultat =  longeur * largeur * hauteur;
              
                      printf("Le volume d'un pave de %lf cm de longeur, de %lf cm de largeur  et de %lf de hauteur=  %lf cm cube\n\n", longeur, largeur, hauteur,   resultat);
                      compteur++;
              
                     } while (1);
                 }
              
                 if(choixOperation == 26)
                 {
              
                  double compteur = 0, resultat = 0, rayon = 0;
              
              
                     do
                     {
                      printf("Entrer le rayon (en cm) de la sphere\n");
                      scanf("%lf", &rayon);
              
                      resultat =  (4 / 3) * 3.141592654 * (rayon * rayon * rayon);
              
                      printf("Le volume d'une sphere de %lf cm de rayon =  %lf cm cube\n\n", rayon, resultat);
                      compteur++;
              
                     } while (1);
                 }
              
                 if(choixOperation == 27)
                 {
              
                  double compteur = 0, resultat = 0, rayon = 0, hauteur = 0;
              
              
                     do
                     {
                      printf("Entrer le rayon (en cm) du cylindre\n");
                      scanf("%lf", &rayon);
                      printf("Entrer la hauteur (en cm) du cylindre\n");
                      scanf("%lf", &hauteur);
              
                      resultat = 3.141592654 * (rayon * rayon) * hauteur;
              
                      printf("Le volume d'un cylindre de %lf cm de rayon et de %lf com de hauteur =  %lf cm cube\n\n", rayon, hauteur, resultat);
                      compteur++;
              
                     } while (1);
                 }
              
              
              
              
                  return;
              
              }
              


              Le code doit être fonctionelle ^^, tu demandes l'angle en degré mais tu ne le modifies pas en Radian ;-) ;-)
              • Partager sur Facebook
              • Partager sur Twitter
              http://cpp-rendering.io : Vous trouverez tout ce dont vous avez besoin sur Vulkan / OpenGL et le rendu 3D !
                20 décembre 2010 à 17:55:41

                Citation : Fvirtman

                HomerEro > J'adore !! :o


                Citation : Fvirtman

                HomerEro > J'adore !! :o


                Double post. Bug ou innatention? :D

                Sinon, HomerEro...
                J'adore ! :p
                • Partager sur Facebook
                • Partager sur Twitter
                  20 décembre 2010 à 23:07:40

                  C'est quand les résultats ? :)
                  • Partager sur Facebook
                  • Partager sur Twitter
                    Staff 21 décembre 2010 à 12:50:15

                    Résultats



                    Voici le classement :

                    Obfusc


                    • 1) (6)Lithrein : 4 votes
                    • 2) (1)Tosh : 2 votes
                    • 3) (4)magma (10)Taurre (11)@che : 1 vote


                    Illisible


                    • 1) (1)Tosh (13)DunCaN213 : 2 votes
                    • 2) (2)schadocalex : 1 vote


                    Sale


                    • 1) (2)schadocalex (14)yoch : 3 votes
                    • 2) (12)Apéro : 1 vote


                    Totaux des votes (toutes catégories):
                    • (1)Tosh : 4 votes.
                    • (2)schadocalex : 4 votes.
                    • (4)magma : 1 vote.
                    • (6)Lithrein : 4 votes.
                    • (10)Taurre : 1 vote.
                    • (11)@che : 1 vote.
                    • (12)Apéro : 1 vote.
                    • (13)DunCaN213 : 2 votes.
                    • (14)yoch : 3 votes.

                    Ce n'est pas un classement!

                    Les autres candidats ont eu 0 vote.


                    Espérant ne pas avoir raté des votes :p si vous avez des réclamations -> MP.

                    Merci à tous les participants; et à la prochaine édition ;) .

                    Vous pouvez bien évidemment continuer à poster vos chefs-d'œuvre.
                    • Partager sur Facebook
                    • Partager sur Twitter
                      21 décembre 2010 à 17:47:36

                      Ouais ! zéro vote pour dolfinsbizou ! :p (même pas moi ! :D )
                      • Partager sur Facebook
                      • Partager sur Twitter
                        21 décembre 2010 à 20:58:54

                        Citation : uknow

                        Vous pouvez bien évidemment continuer à poster vos chefs-d'œuvre.



                        Héé! J'y comptais bien.
                        Code spéciale, comment monter un ordinateur: Edit, j'ai oublié de dire que c'est un éditeur de texte en console :-°

                        #include<stdlib.h>
                        #include<stdio.h>
                        
                        
                        void lire(char[]); // Obfusation
                        void ecrire(char[]); // code mal pensé
                        
                        
                        #define ordinateur char
                        #define la (
                        #define _O_ else
                        #define les (
                        #define position "%d"
                        #define processeur_sur "Quel fichier voulez-vous %s ?",(action-1)?"Ecrire":"Lire"
                        #define ram "Que souhaiter vous faire ?"
                        #define attachez_MB_au_boitier 0;
                        #define construit name[
                        #define fini return 0;
                        #define la_carte_mere );
                        #define O0 }
                        #define sur "\n1.Lire\n2.Ecrire"
                        #define _pour100seul ];
                        #define Position "%s"
                        #define du_ventilo_sur name
                        #define faites if(
                        #define inserez printf
                        #define oo printf
                        #define tout action==1
                        #define vous int
                        #define tous action
                        #define les_branchements )
                        #define des_fils lire(
                        #define verifier scanf
                        #define le (
                        #define ne_pas_oublier else if(
                        #define du_tout_sur ,&action
                        #define les_truck_et ==2
                        #define construire main
                        #define un_ordinateur (void)
                        #define genre_speaker_lumiere_sur ecrire(name
                        #define DD "Entrez un nombre valide."
                        #define et_lecteurs_sur "\nQuitter ?1.Non\n0.Oui"
                        #define o0 {
                        #define enfin else{
                        #define est ();}
                        
                        
                        vous construire un_ordinateur
                        {
                        	ordinateur construit 100 _pour100seul
                        	
                        	vous  action = attachez_MB_au_boitier
                        	inserez  la ram sur la_carte_mere
                        	verifier la position du_tout_sur la_carte_mere
                        	inserez le processeur_sur la_carte_mere
                        	verifier la Position , du_ventilo_sur la_carte_mere
                        	
                        	faites tout les_branchements des_fils du_ventilo_sur la_carte_mere 
                        		
                        	ne_pas_oublier tous les_truck_et les_branchements genre_speaker_lumiere_sur la_carte_mere
                        	
                        	enfin
                        	inserez les DD et_lecteurs_sur la_carte_mere
                        	verifier la position du_tout_sur la_carte_mere
                        	faites tout les_branchements
                        	
                        	construire est fini
                        }
                        void lire(char O[])
                        {
                        	FILE* o=0;
                        	o = fopen(O,"r");
                        	int _o = 0;
                        	oo("Lecture du fichier %s\n",O);
                        	if(0==(!o-1))
                        	oo("Erreur fichier impossible à ouvrir\n");
                        	_O_ o0 while((_o=getc(o)) != -1)oo("%c",_o);
                        	O0 fclose (o);
                        }
                        void ecrire(char name[])
                        {
                        	int c = 0;
                        	FILE* fichier;
                        	fichier = fopen(name,"r");
                        	if(fichier != NULL)
                        	{	oo("Le fichier existe.\nVoulez-vous :\n1.Ecrire à la suite\n2.Remplacer");
                        	fclose(fichier);
                        	scanf("%d", &c);}
                        	switch(!(c-1))
                        	{
                        		case 2:
                        			fichier = fopen(name,"w");
                        		case 1:
                        			fichier = fopen(name,"a");
                        		break;
                        		default:
                        			fichier = fopen(name,"w");			
                        	}
                        	if(fichier == NULL)
                        	{
                        		puts("Erreur fichier impossible à ouvrir\n");
                        		return;
                        	}
                        	else
                        	{
                        		while((c=getchar()) != -1)
                        			if(c-'.')
                        				putc(c,fichier);
                        			else
                        			{
                        				fclose(fichier);
                        				return;
                        			}
                        		return;
                        	}
                        }
                        


                        Ce concours était très intéressant. J'espère que l'on en refera un du même genre.
                        • Partager sur Facebook
                        • Partager sur Twitter
                        🍊 - Étudiant - Codeur en C | Zeste de Savoir apprenez avec une communauté | Articles  - ♡ Copying is an act of love.
                          21 décembre 2010 à 22:14:07

                          Citation : @che


                          Ce concours était très intéressant. J'espère que l'on en refera un du même genre.



                          Je l'espére. :)
                          • Partager sur Facebook
                          • Partager sur Twitter
                            22 décembre 2010 à 14:32:21

                            Attendes attendes ne parter pas tous de suite je veux juste vous montrait un code (qui n'a pas était créer pas moi)

                            #include "CTerrain.h"
                            #include <irrlicht.h>
                            
                            using namespace irr;
                            
                            CTerrain::CTerrain(c8* HeightmapFile,TerrainQuality Quality,f32 ScaleTexture,scene::ISceneNode* parent,scene::ISceneManager* smgr,s32 id): scene::ISceneNode(parent, smgr, id)
                            {
                                //Test if the number of quality is correct
                                if(Quality != 1 && Quality != 2 && Quality != 4 && Quality != 8)
                                {
                                    //if not force to medium quality
                                    Quality = Medium;
                                }
                            
                                //Set the Debug to false
                                Debug=false;
                            
                                //Get the Heightmap
                                video::IImage *Heightmap = SceneManager->getVideoDriver()->createImageFromFile(HeightmapFile);
                            
                                //Get dimension of heightmap
                                u16 Size = Heightmap->getDimension().Width;
                            
                                //Set the size of Tiles for Terrain
                                s32 SizeOfTiles = 0;
                            
                                //Switch Size for calculate the Size of Tile
                                switch(Size)
                                {
                                    case 64:
                                        SizeOfTiles=(Size/4)+1;
                                        NbsTiles = 4*4;
                                        break;
                                    case 128 :
                                        SizeOfTiles=(Size/8)+1;
                                        NbsTiles = 8*8;
                                        break;
                                    case 256 :
                                        SizeOfTiles=(Size/16)+1;
                                        NbsTiles = 16*16;
                                        break;
                                    case 512 :
                                        SizeOfTiles=(Size/16)+1;
                                        NbsTiles = 16*16;
                                        break;
                                    case 768 :
                                        SizeOfTiles=(Size/24)+1;
                                        NbsTiles = 24*24;
                                        break;
                                    case 1024:
                                        SizeOfTiles=(Size/32)+1;
                                        NbsTiles = 32*32;
                                        break;
                                    case 2048:
                                        SizeOfTiles=(Size/32)+1;
                                        NbsTiles = 32*32;
                                        break;
                                    default:
                                        SizeOfTiles=(Size/16)+1;
                                        NbsTiles = 16*16;
                                        break;
                                }
                            
                                //Create the Mesh for the Terrain Mesh
                                TerrainMesh = new scene::SMesh();
                            
                                //Calculate the quality factor
                                u32 SOTiles = irr::core::ceil32((f32)SizeOfTiles/(f32)Quality);
                            
                                //Init the array of MeshBuffer
                                CTTileBuffer=new scene::SMeshBufferLightMap* [NbsTiles];
                            
                                //Start the loop to create Buffers
                                u32 TileX=0,TileZ=0;
                                for (u32 i =0;i < NbsTiles;++i)
                                {
                                    CTTileBuffer[i]=new scene::SMeshBufferLightMap();
                                    CTTileBuffer[i]->Vertices.set_used(SizeOfTiles*SizeOfTiles);
                                    CTTileBuffer[i]->Indices.set_used(SizeOfTiles*SizeOfTiles*6);
                            
                                    const f32 tdSize = 1.0f/(f32)(Size-1);
                                    u32 Index=0;
                                    u16 NbsIndices=0,NbsVertices=0;
                            
                                    for(u32 x=TileX;x<(TileX+SizeOfTiles);x+=Quality)
                                    {
                                        for (u32 z=TileZ;z<(TileZ+SizeOfTiles);z+=Quality)
                                        {
                                            if (NbsVertices < (SOTiles*SOTiles)-SOTiles-1)
                                            {
                                                Index = NbsVertices;
                                                u32 TestValue = ( (((x-TileX)/Quality)+1) * ((z-TileZ)/Quality) + ((x-TileX)/Quality) );
                                                if (Index != TestValue || (x-TileX==0 && z < TileZ+SizeOfTiles-Quality))
                                                {
                                                    CTTileBuffer[i]->Indices[NbsIndices++]=Index;
                                                    CTTileBuffer[i]->Indices[NbsIndices++]=Index+1;
                                                    CTTileBuffer[i]->Indices[NbsIndices++]=Index+SOTiles+1;
                                                    CTTileBuffer[i]->Indices[NbsIndices++]=Index;
                                                    CTTileBuffer[i]->Indices[NbsIndices++]=Index+SOTiles+1;
                                                    CTTileBuffer[i]->Indices[NbsIndices++]=Index+SOTiles;
                                                }
                                            }
                            
                                            video::S3DVertex2TCoords Vertex;
                                            Vertex.Normal = core::vector3df(0,1,0);
                                            Vertex.Pos.X = (f32)x;
                                            video::SColor pixelColor(Heightmap->getPixel(x,z));
                                            Vertex.Pos.Y = (f32) pixelColor.getLuminance()/10.0f;
                                            Vertex.Pos.Z = (f32)z;
                                            Vertex.TCoords = core::vector2d<f32>( (f32)(x*tdSize), (f32)(z*tdSize));
                                            Vertex.TCoords2 = core::vector2d<f32>( (f32)(x*tdSize), (f32)(z*tdSize))*ScaleTexture;
                            
                                            CTTileBuffer[i]->Vertices[NbsVertices]=Vertex;
                            
                                            NbsVertices++;
                                        }
                                    }
                            
                                    CTTileBuffer[i]->Material.Lighting = true;
                                    //CTTileBuffer[i]->Material.Wireframe = true;
                                    CTTileBuffer[i]->Material.BackfaceCulling = true;
                                    CTTileBuffer[i]->Material.GouraudShading=true;
                                    CTTileBuffer[i]->Material.FogEnable=false;
                            
                                    CTTileBuffer[i]->Material.DiffuseColor=video::SColor(255,255,255,255);
                                    CTTileBuffer[i]->Material.AmbientColor=video::SColor(255,255,255,255);
                                    CTTileBuffer[i]->Material.EmissiveColor=video::SColor(255,255,255,255);
                            
                                    CTTileBuffer[i]->Vertices.set_used(NbsVertices);
                                    CTTileBuffer[i]->Indices.set_used(NbsIndices);
                            
                                    for(s32 j = 0; j < ((Quality+1)/2); j++)
                                    {
                                        for(u32 index = 2; index < (SOTiles * SOTiles - 2); index++)
                                    enum TerrainQuality {High=1,Medium=2,Low=4,ExtraLow=8};
                                        {
                                            //A[i] = (1/8)*(A[i-2] + 2*A[i-1] + 2*A[i] + 2*A[i+1] + A[i+2]);
                                            CTTileBuffer[i]->Vertices[index].Pos.Y += (1/8)*
                                            (CTTileBuffer[i]->Vertices[index-2].Pos.Y +
                                            2*CTTileBuffer[i]->Vertices[index-1].Pos.Y +
                                            2*CTTileBuffer[i]->Vertices[index].Pos.Y +
                                            2*CTTileBuffer[i]->Vertices[index+1].Pos.Y +
                                            CTTileBuffer[i]->Vertices[index+2].Pos.Y);
                                        }
                                    }
                            
                                    for(s32 k = 0; k < ((Quality+1)/2); k++)
                                    {
                                        for(u32 index = SOTiles; index < (SOTiles * (SOTiles - 1)); index++)
                                        {
                                            CTTileBuffer[i]->Vertices[index].Pos.Y = (CTTileBuffer[i]->Vertices[index - SOTiles].Pos.Y + CTTileBuffer[i]->Vertices[index + SOTiles].Pos.Y ) / 2.0f;
                                        }
                                    }
                            
                                    //Calculate the normals
                                    calculateNormals(CTTileBuffer[i],SOTiles);
                            
                                    //Recalculate the bounding box
                                    CTTileBuffer[i]->recalculateBoundingBox();
                            
                                    //Add the buffer to the Terrain Mesh
                                    TerrainMesh->addMeshBuffer(CTTileBuffer[i]);
                            
                                    TileX+=SizeOfTiles-1;
                                    if(TileX >= Size)
                                    {
                                        TileX=0;
                            
                                        TileZ+=SizeOfTiles-1;
                                        if(TileZ >= Size)
                                        {
                                            TileZ=0;
                                        }
                                    }
                                }
                                AutomaticCullingState = scene::EAC_OFF;
                                Heightmap->drop();
                            }
                            
                            CTerrain::~CTerrain()
                            {
                                for(u32 i=0;i<NbsTiles;++i)
                                {
                                    if (CTerrain::CTTileBuffer[i] != NULL)
                                    {
                                        CTerrain::CTTileBuffer[i]->drop();
                                    }
                                }
                            
                                delete [] CTerrain::CTTileBuffer;
                            
                                if(CTerrain::TerrainMesh != NULL)
                                {
                                    CTerrain::TerrainMesh->drop();
                                }
                            }
                            
                            void CTerrain::OnRegisterSceneNode()
                            {
                                if (IsVisible)
                                    SceneManager->registerNodeForRendering(this);
                            
                                ISceneNode::OnRegisterSceneNode();
                            }
                            
                            void CTerrain::render()
                            {
                                scene::ICameraSceneNode* cam = SceneManager->getActiveCamera();
                                const scene::SViewFrustum* frustum = cam->getViewFrustum();
                                video::IVideoDriver* Driver = SceneManager->getVideoDriver();
                                core::vector3df Pos = cam->getPosition();
                                cam->updateAbsolutePosition();
                            
                                Pos.Y=0.0f;
                            
                                for (u32 i=0;i<NbsTiles;i++)
                                {
                                    if (CTTileBuffer[i] != NULL)
                                    {
                                        Driver->setTransform(video::ETS_WORLD,AbsoluteTransformation);
                            
                                        //DEBUG HERE
                                        if(Debug==true)
                                        {
                                            video::SMaterial Mat;
                                            Mat.AmbientColor = video::SColor(255,255,255,255);
                                            Mat.DiffuseColor = video::SColor(255,255,255,255);
                                            Mat.EmissiveColor = video::SColor(255,0,255,0);
                                            Driver->setMaterial(Mat);
                                            Driver->draw3DBox(CTTileBuffer[i]->getBoundingBox(),video::SColor(255,255,255,255));
                                        }
                            
                                        if( frustum->getBoundingBox().intersectsWithBox(CTTileBuffer[i]->getBoundingBox())==true)
                                        {
                                            f64 ActualDistance = CTTileBuffer[i]->BoundingBox.getCenter().getDistanceFrom(Pos);
                                            if(ActualDistance < RenderDistance)
                                            {
                                                Driver->setMaterial(video::SMaterial(CTTileBuffer[i]->Material));
                                                Driver->drawIndexedTriangleList(&CTTileBuffer[i]->Vertices[0],CTTileBuffer[i]->getVertexCount(),&CTTileBuffer[i]->Indices[0], CTTileBuffer[i]->getIndexCount()/3 );
                                                //Driver->drawMeshBuffer(CTTileBuffer[i]);
                                            }
                                        }
                                    }
                                }
                            }
                            
                            void CTerrain::setPosition(const core::vector3df &Pos)
                            {
                                for (u32 i=0;i<NbsTiles;i++)
                                {
                                    if (CTTileBuffer[i] != NULL)
                                    {
                                        for (u32 j=0;j<CTTileBuffer[i]->getVertexCount();++j)
                                        {
                                            CTTileBuffer[i]->Vertices[j].Pos+=Pos;
                                        }
                                        CTTileBuffer[i]->recalculateBoundingBox();
                                    }
                                }
                            }
                            
                            void CTerrain::setScale(const core::vector3df &Scale)
                            {
                                for (u32 i=0;i<NbsTiles;i++)
                                {
                                    if (CTTileBuffer[i] != NULL)
                                    {
                                        for (u32 j=0;j<CTTileBuffer[i]->getVertexCount();++j)
                                        {
                                            CTTileBuffer[i]->Vertices[j].Pos*=Scale;
                                        }
                                        CTTileBuffer[i]->recalculateBoundingBox();
                                    }
                                }
                            }
                            
                            const core::aabbox3d<f32>& CTerrain::getBoundingBox() const
                            {
                                return Box;
                            }
                            
                            u32 CTerrain::getMaterialCount()
                            {
                                return 1;
                            }
                            
                            video::SMaterial& CTerrain::getMaterial(u32 i)
                            {
                                return Material;
                            }
                            
                            void CTerrain::ActivateSplattingTextures(scene::ISceneManager* smgr,f32 Height,f32 Fog,video::SColorf FogColor)
                            {
                                video::IVideoDriver* driver = smgr->getVideoDriver();
                                s32 newMaterialType1 = 0;
                                video::IGPUProgrammingServices* gpu = smgr->getVideoDriver()->getGPUProgrammingServices();
                            
                                if (driver->getDriverType() != video::EDT_OPENGL)
                                {
                                    //Merci à DeusXL pour son shader 
                                    c8 ShaderFileName[] =
                                        "float4x4 mWorldViewProj;\n" \
                                        "float4x4 mWorld;\n" \
                                        "float3 cameraPos;\n" \
                                        "float TerrainHeight;\n" \
                                        "float FogDistance;\n" \
                            
                                        "struct VS_OUTPUT\n" \
                                        "{\n" \
                                        "float4 Position : POSITION;\n" \
                                        "float4 Diffuse : COLOR0;\n" \
                                        "float2 TexCoord1 : TEXCOORD1;\n" \
                                        "};\n" \
                            
                                        "VS_OUTPUT vertexMain( in float4 vPosition : POSITION,in float3 vNormal : NORMAL,float2 texCoord1 : TEXCOORD1)\n" \
                                        "{\n" \
                                        "VS_OUTPUT Output;\n" \
                                        "Output.Position = mul(vPosition, mWorldViewProj);\n" \
                                        "float4 position = mul(vPosition, mWorld);\n" \
                                        "float dist = sqrt ( pow(position.x - cameraPos.x, 2.0f) +\n" \
                                        "pow(position.y - cameraPos.y, 2.0f) +\n" \
                                        "pow(position.z - cameraPos.z, 2.0f));\n" \
                                        "Output.Diffuse = float4(vPosition.y / TerrainHeight, dist / FogDistance, 0.0f, 0.0f);\n" \
                                        "Output.TexCoord1 = texCoord1;\n" \
                                        "return Output;\n" \
                                        "}\n" \
                            
                                        "struct PS_OUTPUT\n" \
                                        "{\n" \
                                        "float4 RGBColor : COLOR0;\n" \
                                        "};\n" \
                            
                                        "sampler2D tex[4];\n" \
                                        "float4 fog;\n" \
                                        "PS_OUTPUT pixelMain( float2 TexCoord1 : TEXCOORD1,float4 Position : POSITION,float4 Diffuse : COLOR0 )\n" \
                                        "{\n" \
                                        "PS_OUTPUT Output;\n" \
                                        "float heightpercent = Diffuse.x;\n" \
                                        "float dist = Diffuse.y;\n" \
                            
                                        "float4 grasscolor = tex2D(tex[0], TexCoord1 * 5.0f) * pow((1.0f - heightpercent), 4.0f);\n" \
                                        "float4 rockcolor = tex2D(tex[1], TexCoord1 * 5.0f) * pow((1.0f - abs(0.5f - heightpercent)), 4.0f);\n" \
                                        "float4 snowcolor = tex2D(tex[2], TexCoord1 * 5.0f) * pow(heightpercent,4.0f);\n" \
                                        "float4 detailcolor = tex2D(tex[3], TexCoord1 * 5.0f) * pow((1.0f - abs(0.7f - heightpercent)), 4.0f);\n" \
                                        "Output.RGBColor = (grasscolor + rockcolor + snowcolor  + detailcolor);\n" \
                            
                                        "if (dist >= 0.5f)\n" \
                                        "{\n" \
                                        "Output.RGBColor *= (1.0f - (dist-0.5f));\n" \
                                        "Output.RGBColor += (fog  * (dist-0.5f));\n" \
                                        "}\n" \
                            
                                        "return Output;\n" \
                                        "}\n";
                            
                                    if (gpu)
                                    {
                                        MyShaderCallBack* mc = new MyShaderCallBack();
                                        mc->setSplatScene(smgr,Height,Fog,FogColor);
                                        newMaterialType1 = gpu->addHighLevelShaderMaterial(
                                            ShaderFileName, "vertexMain", video::EVST_VS_2_0,
                                            ShaderFileName, "pixelMain", video::EPST_PS_2_0,
                                            mc, video::EMT_SOLID,0);
                                        mc->drop();
                                    }
                                }
                                else
                                {
                                    c8 ShaderFragment[] =
                                        "//\n" \
                                        "// Structure definitions\n" \
                                        "//\n" \
                                        "struct VS_OUTPUT {\n" \
                                        "vec4 Position;\n" \
                                        "vec4 Diffuse;\n" \
                                        "vec2 TexCoord1;\n" \
                                        "};\n" \
                            
                                        "struct PS_OUTPUT {\n" \
                                        "vec4 RGBColor;\n" \
                                        "};\n" \
                            
                            
                                        "//\n" \
                                        "// Global variable definitions\n" \
                                        "//\n" \
                            
                                        "uniform vec4 fog;\n" \
                                        "uniform sampler2D texgrass,texrock,texsnow,texdetail;\n" \
                            
                                        "//\n" \
                                        "// Function declarations\n" \
                                        "//\n" \
                                        "PS_OUTPUT pixelMain( in vec2 TexCoord1, in vec4 Position, in vec4 Diffuse );\n" \
                                        "//\n" \
                                        "// Function definitions\n" \
                                        "//\n" \
                                        "PS_OUTPUT pixelMain( in vec2 TexCoord1, in vec4 Position, in vec4 Diffuse ) {\n" \
                                        "float heightpercent;\n" \
                                        "float dist;\n" \
                                        "vec4 grasscolor;\n" \
                                        "vec4 rockcolor;\n" \
                                        "vec4 snowcolor;\n" \
                                        "vec4 detailcolor;\n" \
                                        "PS_OUTPUT Output;\n" \
                            
                                        "heightpercent = Diffuse.x ;\n" \
                                        "dist = Diffuse.y ;\n" \
                                        "grasscolor = (texture2D( texgrass, (TexCoord1 * 5.00000)) * pow( (1.00000 - heightpercent), 4.00000));\n" \
                                        "rockcolor = (texture2D( texrock, (TexCoord1 * 5.00000)) * pow( (1.00000 - abs( (0.500000 - heightpercent) )), 4.00000));\n" \
                                        "snowcolor = (texture2D( texsnow, (TexCoord1 * 5.00000)) * pow( heightpercent, 4.00000));\n" \
                                        "detailcolor = (texture2D( texdetail, (TexCoord1 * 5.00000)) * pow( (1.00000 - abs( (0.700000 - heightpercent) )), 4.00000));\n" \
                                        "Output.RGBColor = (((grasscolor + rockcolor) + snowcolor) + detailcolor);\n" \
                                        "if ( (dist >= 0.500000) ){\n" \
                                        "Output.RGBColor *= (1.00000 - (dist - 0.500000));\n" \
                                        "Output.RGBColor += (fog * (dist - 0.500000));\n" \
                                        "}\n" \
                                        "return Output;\n" \
                                        "}\n" \
                            
                                        "//\n" \
                                        "// Translator's entry point\n" \
                                        "//\n" \
                                        "void main() {\n" \
                                        "PS_OUTPUT xlat_retVal;\n" \
                                        "xlat_retVal = pixelMain( vec2(gl_TexCoord[1]), vec4(gl_FragCoord), vec4(gl_Color));\n" \
                                        "gl_FragData[0] = vec4( xlat_retVal.RGBColor);\n" \
                                        "}\n";
                            
                                    c8 ShaderVertex[]=
                                        "//\n" \
                                        "// Structure definitions\n" \
                                        "//\n" \
                            
                                        "struct VS_OUTPUT {\n" \
                                        "vec4 Position;\n" \
                                        "vec4 Diffuse;\n" \
                                        "vec2 TexCoord1;\n" \
                                        "};\n" \
                            
                                        "struct PS_OUTPUT {\n" \
                                        "vec4 RGBColor;\n" \
                                        "};\n" \
                            
                                        "//\n" \
                                        "// Global variable definitions\n" \
                                        "//\n" \
                            
                                        "uniform float FogDistance;\n" \
                                        "uniform float TerrainHeight;\n" \
                                        "uniform vec3 cameraPos;\n" \
                                        "uniform mat4 mWorld;\n" \
                                        "uniform mat4 mWorldViewProj;\n" \
                            
                                        "//\n" \
                                        "// Function declarations\n" \
                                        "//\n" \
                            
                                        "VS_OUTPUT vertexMain( in vec4 vPosition, in vec3 vNormal, in vec2 texCoord1 );\n" \
                            
                                        "//\n" \
                                        "// Function definitions\n" \
                                        "//\n" \
                            
                                        "VS_OUTPUT vertexMain( in vec4 vPosition, in vec3 vNormal, in vec2 texCoord1 ) {\n" \
                                        "VS_OUTPUT Output;\n" \
                                        "vec4 position;\n" \
                                        "float dist;\n" \
                            
                                        "Output.Position = ( vPosition * mWorldViewProj );\n" \
                                        "position = ( vPosition * mWorld );\n" \
                                        "dist = sqrt( ((pow( (position.x  - cameraPos.x ), 2.00000) + pow( (position.y  - cameraPos.y ), 2.00000)) + pow( (position.z  - cameraPos.z ), 2.00000)) );\n" \
                                        "Output.Diffuse = vec4( (vPosition.y  / TerrainHeight), (dist / FogDistance), 0.000000, 0.000000);\n" \
                                        "Output.TexCoord1 = texCoord1;\n" \
                                        "return Output;\n" \
                                        "}\n" \
                            
                            
                                        "//\n" \
                                        "// Translator's entry point\n" \
                                        "//\n" \
                                        "void main() {\n" \
                                        "VS_OUTPUT xlat_retVal;\n" \
                            
                                        "xlat_retVal = vertexMain( vec4(gl_Vertex), vec3(gl_Normal), vec2(gl_MultiTexCoord1));\n" \
                            
                                        "gl_Position = vec4( xlat_retVal.Position);\n" \
                                        "gl_FrontColor = vec4( xlat_retVal.Diffuse);\n" \
                                        "gl_TexCoord[1] = vec4( xlat_retVal.TexCoord1, 0.0, 0.0);\n" \
                                        "}\n";
                            
                                    if (gpu)
                                    {
                                        MyShaderCallBack* mc = new MyShaderCallBack();
                                        mc->setSplatScene(smgr,Height,Fog,FogColor);
                                        newMaterialType1 = gpu->addHighLevelShaderMaterial(
                                            ShaderVertex, "main", video::EVST_VS_1_1,
                                            ShaderFragment, "main", video::EPST_PS_1_1,
                                            mc, video::EMT_SOLID,0);
                                        mc->drop();
                                    }
                                }
                                setMaterialType((video::E_MATERIAL_TYPE)newMaterialType1);
                            }
                            
                            void CTerrain::setColorTexture(c8* FileName)
                            {
                                for (u32 i=0;i<NbsTiles;++i)
                                {
                                    if (CTTileBuffer[i] != NULL)
                                    {
                                        CTTileBuffer[i]->Material.MaterialType = video::EMT_SOLID;
                                        CTTileBuffer[i]->Material.Textures[0] = SceneManager->getVideoDriver()->getTexture(FileName);
                                    }
                                }
                            }
                            
                            void CTerrain::setDetailTexture(c8* FileName)
                            {
                                for (u32 i=0;i<NbsTiles;++i)
                                {
                                    if (CTTileBuffer[i] != NULL)
                                    {
                                        CTTileBuffer[i]->Material.MaterialType = video::EMT_DETAIL_MAP;
                                        CTTileBuffer[i]->Material.Textures[1] = SceneManager->getVideoDriver()->getTexture(FileName);
                                    }
                                }
                            }
                            
                            void CTerrain::SetTextureSplat(u32 NumTex,c8* FileName)
                            {
                                    for (u32 i=0;i<NbsTiles;++i)
                                {
                                    if (CTTileBuffer[i] != NULL)
                                    {
                                        CTTileBuffer[i]->Material.Textures[NumTex] = SceneManager->getVideoDriver()->getTexture(FileName);
                                    }
                                }
                            }
                            
                            void CTerrain::setDebugMode(bool Enable)
                            {
                                Debug=Enable;
                            }
                            
                            void CTerrain::setRenderDistance(f32 Distance)
                            {
                                RenderDistance = Distance;
                            }
                            
                            void CTerrain::setMaterialType(video::E_MATERIAL_TYPE Mat)
                            {
                                for (u32 i=0;i < NbsTiles;++i)
                                {
                                    if (CTTileBuffer[i] != NULL)
                                    {
                                        CTTileBuffer[i]->Material.MaterialType = Mat;
                                    }
                                }
                            }
                            
                            scene::IMesh* CTerrain::getMesh()
                            {
                                return (scene::IMesh*)TerrainMesh;
                            }
                            
                            f32 CTerrain::getHeight(f32 x,f32 z)
                            {
                                scene::SMeshBufferLightMap* TempBuffer=NULL;
                            
                                f32 ValueReturn = 0.0f;
                            
                                for (u32 i=0;i < NbsTiles;++i)
                                {
                                    if (CTTileBuffer[i] != NULL)
                                    {
                                        core::vector3df Vec(x,CTTileBuffer[i]->getBoundingBox().getCenter().Y,z);
                                        if(CTTileBuffer[i]->getBoundingBox().isPointInside(Vec))
                                        {
                                            TempBuffer=CTTileBuffer[i];
                                            break;
                                        }
                                    }
                                }
                            
                                if(TempBuffer != NULL)
                                {
                                    //Si le TempBuffer renvoi différent de null, on se situ dans un tile
                                    scene::SMesh* Mesh=new scene::SMesh();
                                    Mesh->addMeshBuffer(TempBuffer);
                                    scene::ITriangleSelector* selector= SceneManager->createTriangleSelector((scene::IMesh*)Mesh,this);
                                    this->setTriangleSelector(selector);
                            
                                    core::line3d<f32> line;
                                    line.start = core::vector3d<f32>(x,-200000,z);
                                    line.end = core::vector3d<f32>(x,200000,z);
                            
                                    core::vector3df intersection;
                                    core::triangle3df tri;
                            
                                    if (SceneManager->getSceneCollisionManager()->getCollisionPoint(line, selector, intersection,tri))
                                    {
                                        ValueReturn = intersection.Y;
                                    }
                                    selector->drop();
                                    Mesh->drop();
                                }
                                else
                                {
                                    ValueReturn=-999999.999f;
                                }
                            
                                return ValueReturn;
                            }
                            
                            //Take from the irrlicht source code
                            void CTerrain::calculateNormals ( scene::SMeshBufferLightMap* pMeshBuffer,s32 Size)
                            {
                                s32 count;
                                //s32 Size = 4;
                                core::vector3df a, b, c, t;
                            
                                for (s32 x=0; x<Size; ++x)
                                    for (s32 z=0; z<Size; ++z)
                                    {
                                        count = 0;
                                        core::vector3df normal;
                            
                                        // top left
                                        if (x>0 && z>0)
                                        {
                                            a = pMeshBuffer->Vertices[(x-1)*Size+z-1].Pos;
                                            b = pMeshBuffer->Vertices[(x-1)*Size+z].Pos;
                                            c = pMeshBuffer->Vertices[x*Size+z].Pos;
                                            b -= a;
                                            c -= a;
                                            t = b.crossProduct ( c );
                                            t.normalize ( );
                                            normal += t;
                            
                                            a = pMeshBuffer->Vertices[(x-1)*Size+z-1].Pos;
                                            b = pMeshBuffer->Vertices[x*Size+z-1].Pos;
                                            c = pMeshBuffer->Vertices[x*Size+z].Pos;
                                            b -= a;
                                            c -= a;
                                            t = b.crossProduct ( c );
                                            t.normalize ( );
                                            normal += t;
                            
                                            count += 2;
                                        }
                            
                                        // top right
                                        if (x>0 && z<Size-1)
                                        {
                                            a = pMeshBuffer->Vertices[(x-1)*Size+z].Pos;
                                            b = pMeshBuffer->Vertices[(x-1)*Size+z+1].Pos;
                                            c = pMeshBuffer->Vertices[x*Size+z+1].Pos;
                                            b -= a;
                                            c -= a;
                                            t = b.crossProduct ( c );
                                            t.normalize ( );
                                            normal += t;
                            
                                            a = pMeshBuffer->Vertices[(x-1)*Size+z].Pos;
                                            b = pMeshBuffer->Vertices[x*Size+z+1].Pos;
                                            c = pMeshBuffer->Vertices[x*Size+z].Pos;
                                            b -= a;
                                            c -= a;
                                            t = b.crossProduct ( c );
                                            t.normalize ( );
                                            normal += t;
                            
                                            count += 2;
                                        }
                            
                                        // bottom right
                                        if (x<Size-1 && z<Size-1)
                                        {
                                            a = pMeshBuffer->Vertices[x*Size+z+1].Pos;
                                            b = pMeshBuffer->Vertices[x*Size+z+1].Pos;
                                            c = pMeshBuffer->Vertices[(x+1)*Size+z+1].Pos;
                                            b -= a;
                                            c -= a;
                                            t = b.crossProduct ( c );
                                            t.normalize ( );
                                            normal += t;
                            
                                            a = pMeshBuffer->Vertices[x*Size+z+1].Pos;
                                            b = pMeshBuffer->Vertices[(x+1)*Size+z+1].Pos;
                                            c = pMeshBuffer->Vertices[(x+1)*Size+z].Pos;
                                            b -= a;
                                            c -= a;
                                            t = b.crossProduct ( c );
                                            t.normalize ( );
                                            normal += t;
                            
                                            count += 2;
                                        }
                            
                                        // bottom left
                                        if (x<Size-1 && z>0)
                                        {
                                            a = pMeshBuffer->Vertices[x*Size+z-1].Pos;
                                            b = pMeshBuffer->Vertices[x*Size+z].Pos;
                                            c = pMeshBuffer->Vertices[(x+1)*Size+z].Pos;
                                            b -= a;
                                            c -= a;
                                            t = b.crossProduct ( c );
                                            t.normalize ( );
                                            normal += t;
                            
                                            a = pMeshBuffer->Vertices[x*Size+z-1].Pos;
                                            b = pMeshBuffer->Vertices[(x+1)*Size+z].Pos;
                                            c = pMeshBuffer->Vertices[(x+1)*Size+z-1].Pos;
                                            b -= a;
                                            c -= a;
                                            t = b.crossProduct ( c );
                                            t.normalize ( );
                                            normal += t;
                            
                                            count += 2;
                                        }
                            
                                        if ( count != 0 )
                                        {
                                            normal.normalize ( );
                                        }
                                        else
                                        {
                                            normal.set( 0.0f, 1.0f, 0.0f );
                                        }
                            
                                        pMeshBuffer->Vertices[x * Size + z].Normal = normal;
                                    }
                            }
                            


                            Personne ?
                            • Partager sur Facebook
                            • Partager sur Twitter
                              22 décembre 2010 à 15:57:44

                              @H.E.: C'est du C++.
                              • Partager sur Facebook
                              • Partager sur Twitter
                              🍊 - Étudiant - Codeur en C | Zeste de Savoir apprenez avec une communauté | Articles  - ♡ Copying is an act of love.
                                22 décembre 2010 à 16:00:55

                                Je les trouver sur un forum d'irrlicht sur la génération de terrain aléatoire, il faudrait que je retrouve le lien.

                                Oui c'est du C++.

                                • Partager sur Facebook
                                • Partager sur Twitter

                                [Concours]Le code le plus sale

                                × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                                × Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
                                • Editeur
                                • Markdown