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:05:58

            HomerEro > J'adore !! :o
            • Partager sur Facebook
            • Partager sur Twitter
            La société ou je bosse recrute : (bac +5, Lyon, C++, prog bas niveau, maths...) contactez moi par MP pour en savoir plus !
              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:09:21

                HomerEro > J'adore !! :o
                • Partager sur Facebook
                • Partager sur Twitter
                La société ou je bosse recrute : (bac +5, Lyon, C++, prog bas niveau, maths...) contactez moi par MP pour en savoir plus !
                  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