Vous ne trouvez pas de réponse à votre problème ? Alors posez la question dans le forum. Souvenez-vous qu'il n'y a jamais de question bête, mais rester dans l'ignorance parce que l'on n'ose pas poser une question, ça c'est une erreur !

FRACTALE DE KOCH


Information sur la source

Catégorie :OpenGL Classé sous : Fractale, Koch, SDL, OpenGL Niveau : Débutant Date de création : 28/12/2007 Date de mise à jour : 12/01/2008 19:12:34 Vu / téléchargé: 3 931 / 146

Note :
10 / 10 - par 1 personne
10,00 / 10

  • 1

  • 2

  • 3

  • 4

  • 5

  • 6

  • 7

  • 8

  • 9

  • 10

Commentaire sur cette source (38)
Ajouter un commentaire et/ou une note

Description

Cliquez pour voir la capture en taille normale
Générateur d'images fractales a partir du procédé de Koch!

Toutes les infos ici : http://colin.chargy.free.fr/Wiki/index.php?title=Fractale

Il ya dans le zip un exécutable Windows (renommer en .exx) et un exécutable Linux (sans extensions).
 

Source

  • #include <SDL/SDL.h>
  • #include <SDL/SDL_opengl.h>
  • #include <GL/gl.h>
  • #include <GL/glu.h>
  • #include <stdio.h>
  • #include <stdlib.h>
  • #include <stdexcept>
  • #include <string>
  • #include <vector>
  • #include <math.h>
  • #include <fstream>
  • using namespace std;
  • const double pi = 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067;
  • class Ligne
  • {
  • public:
  • double x1, y1, x2, y2;
  • };
  • vector<Ligne> Lignes;
  • int Split(vector<string>* vecteur, string chaine, char separateur)
  • {
  • vecteur->resize(1);
  • vecteur[0].empty();
  • int longeur = chaine.length();
  • for(int i = 0; i < longeur; ++i)
  • {
  • if(chaine.at(i) == separateur)
  • {
  • vecteur->resize(vecteur->size() + 1);
  • }
  • else
  • {
  • vecteur->at(vecteur->size() - 1).resize(vecteur->at(vecteur->size() - 1).size() + 1);
  • vecteur->at(vecteur->size() - 1).at(vecteur->at(vecteur->size() - 1).size() - 1) = chaine.at(i);
  • }
  • }
  • return vecteur->size();
  • }
  • void LireFichier()
  • {
  • ifstream fichier("geo.frac");
  • //Lecture du fichier
  • string Fichier, Ligne;
  • vector<string> Parties;
  • char ch;
  • while(fichier.get(ch))
  • Fichier += ch;
  • int nblignes = Split(&Parties, Fichier, '\n');
  • for(int i = 0; i < nblignes; i++)
  • {
  • Ligne = Parties[i];
  • if(Ligne[Ligne.size() - 1] == '\r') Ligne.erase(Ligne.size() - 1);
  • if((Ligne[0] != '/') && (Ligne[1] != '/'))
  • {
  • vector<string> SousParties, SousPartiesDebut, SousPartiesFin;
  • if((Split(&SousParties, Ligne, '>') == 2) && (Split(&SousPartiesDebut, SousParties[0], ',') == 2) && (Split(&SousPartiesFin, SousParties[1], ',') == 2))
  • {
  • Lignes.resize(Lignes.size() + 1);
  • Lignes[Lignes.size() - 1].x1 = atoi(SousPartiesDebut[0].c_str());
  • Lignes[Lignes.size() - 1].y1 = atoi(SousPartiesDebut[1].c_str());
  • Lignes[Lignes.size() - 1].x2 = atoi(SousPartiesFin[0].c_str());
  • Lignes[Lignes.size() - 1].y2 = atoi(SousPartiesFin[1].c_str());
  • }
  • }
  • }
  • }
  • void Calcul()
  • {
  • Uint32 temps = 0;
  • int size = Lignes.size();
  • glMatrixMode(GL_MODELVIEW);
  • glLoadIdentity();
  • for(int i = 0; i < size; i++)
  • {
  • if(temps + 50 < SDL_GetTicks())
  • {
  • temps = SDL_GetTicks();
  • glBegin(GL_QUADS);
  • glColor3ub(0, 0, 255);
  • glVertex2d(250, 100);
  • glVertex2d(-250, 100);
  • glVertex2d(-250, -100);
  • glVertex2d(250, -100);
  • glColor3ub(200, 55, 55);
  • glVertex2d(200, 50);
  • glVertex2d(-200, 50);
  • glVertex2d(-200, -50);
  • glVertex2d(200, -50);
  • glColor3ub(255, 0, 0);
  • glVertex2d((((400 * i) / size) - 200), 50);
  • glVertex2d(-200, 50);
  • glVertex2d(-200, -50);
  • glVertex2d((((400 * i) / size) - 200), -50);
  • glEnd();
  • glFlush();
  • SDL_GL_SwapBuffers();
  • }
  • if(Lignes.size() >= Lignes.max_size()) return;
  • Lignes.resize(Lignes.size() + 3);
  • Lignes.at(Lignes.size() - 3).x2 = Lignes.at(i).x2;
  • Lignes.at(Lignes.size() - 3).y2 = Lignes.at(i).y2;
  • Lignes.at(Lignes.size() - 3).x1 = Lignes.at(i).x1 + (2 * (Lignes.at(i).x2 - Lignes.at(i).x1) / 3);
  • Lignes.at(Lignes.size() - 3).y1 = Lignes.at(i).y1 + (2 * (Lignes.at(i).y2 - Lignes.at(i).y1) / 3);
  • Lignes.at(i).x2 = Lignes.at(i).x1 + ((Lignes.at(i).x2 - Lignes.at(i).x1) / 3);
  • Lignes.at(i).y2 = Lignes.at(i).y1 + ((Lignes.at(i).y2 - Lignes.at(i).y1) / 3);
  • //Le triangle
  • double angle = acos((Lignes.at(i).x2-Lignes.at(i).x1)/sqrt((Lignes.at(i).x2-Lignes.at(i).x1)*(Lignes.at(i).x2-Lignes.at(i).x1) + (Lignes.at(i).y2-Lignes.at(i).y1)*(Lignes.at(i).y2-Lignes.at(i).y1)));
  • if((Lignes.at(i).y2-Lignes.at(i).y1) < 0) angle = -angle;
  • Lignes.at(Lignes.size() - 2).x1 = Lignes.at(i).x2;
  • Lignes.at(Lignes.size() - 2).y1 = Lignes.at(i).y2;
  • Lignes.at(Lignes.size() - 1).x1 = ((Lignes.at(i).x2 + Lignes.at(Lignes.size() - 3).x1) / 2) + (cos(angle+pi/2)*sqrt((Lignes.at(i).x2-Lignes.at(i).x1)*(Lignes.at(i).x2-Lignes.at(i).x1)+(Lignes.at(i).y2-Lignes.at(i).y1)*(Lignes.at(i).y2-Lignes.at(i).y1)));
  • Lignes.at(Lignes.size() - 1).y1 = ((Lignes.at(i).y2 + Lignes.at(Lignes.size() - 3).y1) / 2) + (sin(angle+pi/2)*sqrt((Lignes.at(i).x2-Lignes.at(i).x1)*(Lignes.at(i).x2-Lignes.at(i).x1)+(Lignes.at(i).y2-Lignes.at(i).y1)*(Lignes.at(i).y2-Lignes.at(i).y1)));
  • Lignes.at(Lignes.size() - 2).x2 = Lignes.at(Lignes.size() - 1).x1;
  • Lignes.at(Lignes.size() - 2).y2 = Lignes.at(Lignes.size() - 1).y1;
  • Lignes.at(Lignes.size() - 1).x2 = Lignes.at(Lignes.size() - 3).x1;
  • Lignes.at(Lignes.size() - 1).y2 = Lignes.at(Lignes.size() - 3).y1;
  • }
  • }
  • int main(int argc, char *argv[])
  • {
  • LireFichier();
  • double Zoom = 1.0, OffsetX = 0.0, OffsetY = 0.0;
  • SDL_Init(SDL_INIT_VIDEO);
  • SDL_EnableKeyRepeat(50, 50);
  • SDL_WM_SetCaption("Fractale", NULL);
  • SDL_SetVideoMode(600, 600, 32, SDL_OPENGL | SDL_GL_DOUBLEBUFFER);
  • bool continuer = true, Redessine = true;
  • SDL_Event event;
  • glClearColor(1, 1, 1, 1);
  • glColor3ub(0, 0, 0);
  • glViewport(0, 0, (GLsizei) 600, (GLsizei) 600);
  • glMatrixMode(GL_PROJECTION);
  • glLoadIdentity();
  • gluOrtho2D((GLdouble)-300, (GLdouble)300, (GLdouble)-300, (GLdouble)300);
  • glMatrixMode(GL_MODELVIEW);
  • glLoadIdentity();
  • while (continuer)
  • {
  • while(!Redessine)
  • {
  • while(SDL_PollEvent(&event))
  • {
  • switch(event.type)
  • {
  • case SDL_QUIT:
  • continuer = false;
  • Redessine = true;
  • break;
  • case SDL_KEYDOWN:
  • if(event.key.keysym.sym == SDLK_ESCAPE)
  • {
  • continuer = false;
  • Redessine = true;
  • }
  • if(event.key.keysym.sym == SDLK_RETURN)
  • {
  • Calcul();
  • Redessine = true;
  • char titre[100];
  • sprintf(titre, "Fractale - Nombre de lignes : %d", Lignes.size());
  • SDL_WM_SetCaption(titre, NULL);
  • }
  • if(event.key.keysym.sym == SDLK_PAGEUP)
  • {
  • Zoom *= 1.1;
  • Redessine = true;
  • }
  • if(event.key.keysym.sym == SDLK_PAGEDOWN)
  • {
  • Zoom *= .9;
  • Redessine = true;
  • }
  • if(event.key.keysym.sym == SDLK_UP)
  • {
  • OffsetY -= 10/Zoom;
  • Redessine = true;
  • }
  • if(event.key.keysym.sym == SDLK_DOWN)
  • {
  • OffsetY += 10/Zoom;
  • Redessine = true;
  • }
  • if(event.key.keysym.sym == SDLK_LEFT)
  • {
  • OffsetX -= 10/Zoom;
  • Redessine = true;
  • }
  • if(event.key.keysym.sym == SDLK_RIGHT)
  • {
  • OffsetX += 10/Zoom;
  • Redessine = true;
  • }
  • break;
  • case SDL_ACTIVEEVENT:
  • Redessine = true;
  • break;
  • }
  • }
  • if(!Redessine && continuer) SDL_Delay(50);
  • }
  • if(continuer)
  • {
  • glClear(GL_COLOR_BUFFER_BIT);
  • glColor3ub(0, 0, 0);
  • glMatrixMode(GL_MODELVIEW);
  • glLoadIdentity();
  • glScaled(Zoom, Zoom, 1.0);
  • glTranslated(-OffsetX, -OffsetY, 0.0);
  • glBegin(GL_LINES);
  • for(int i = 0; i < Lignes.size(); i++)
  • {
  • if(i % 1000 == 0)
  • {
  • glFlush();
  • }
  • glVertex2d(Lignes[i].x1, Lignes[i].y1);
  • glVertex2d(Lignes[i].x2, Lignes[i].y2);
  • }
  • glEnd();
  • glFlush();
  • SDL_GL_SwapBuffers();
  • Redessine = false;
  • }
  • }
  • SDL_Quit();
  • return 0;
  • }
#include <SDL/SDL.h>

#include <SDL/SDL_opengl.h>

#include <GL/gl.h>

#include <GL/glu.h>



#include <stdio.h>

#include <stdlib.h>

#include <stdexcept>

#include <string>

#include <vector>

#include <math.h>

#include <fstream>



using namespace std;



const double pi = 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067;



class Ligne

{

	public:

		double x1, y1, x2, y2;

};



vector<Ligne> Lignes;



int Split(vector<string>* vecteur, string chaine, char separateur)

{



    vecteur->resize(1);

    vecteur[0].empty();



    int longeur = chaine.length();



    for(int i = 0; i < longeur; ++i)

    {



        if(chaine.at(i) == separateur)

        {

            vecteur->resize(vecteur->size() + 1);

        }

        else

        {

            vecteur->at(vecteur->size() - 1).resize(vecteur->at(vecteur->size() - 1).size() + 1);

            vecteur->at(vecteur->size() - 1).at(vecteur->at(vecteur->size() - 1).size() - 1) = chaine.at(i);

        }



    }



    return vecteur->size();



}



void LireFichier()

{

	ifstream fichier("geo.frac");

	//Lecture du fichier

	string Fichier, Ligne;

	vector<string> Parties;

	char ch;

	

	while(fichier.get(ch))

      Fichier += ch;

   

   int nblignes = Split(&Parties, Fichier, '\n');

   for(int i = 0; i < nblignes; i++)

   {

		Ligne = Parties[i];

		if(Ligne[Ligne.size() - 1] == '\r') Ligne.erase(Ligne.size() - 1);

		if((Ligne[0] != '/') && (Ligne[1] != '/'))

		{

			vector<string> SousParties, SousPartiesDebut, SousPartiesFin;

			if((Split(&SousParties, Ligne, '>') == 2) && (Split(&SousPartiesDebut, SousParties[0], ',') == 2) && (Split(&SousPartiesFin, SousParties[1], ',') == 2))

			{

				Lignes.resize(Lignes.size() + 1);

				Lignes[Lignes.size() - 1].x1 = atoi(SousPartiesDebut[0].c_str());

				Lignes[Lignes.size() - 1].y1 = atoi(SousPartiesDebut[1].c_str());

				Lignes[Lignes.size() - 1].x2 = atoi(SousPartiesFin[0].c_str());

				Lignes[Lignes.size() - 1].y2 = atoi(SousPartiesFin[1].c_str());

			}

		}

	}

	

}



void Calcul()

{

	Uint32 temps = 0;

	int size = Lignes.size(); 

	

	glMatrixMode(GL_MODELVIEW);

	glLoadIdentity();

	

	for(int i = 0; i < size; i++)

	{

		if(temps + 50 < SDL_GetTicks())

		{

			temps = SDL_GetTicks();

			glBegin(GL_QUADS);

				glColor3ub(0, 0, 255);

				glVertex2d(250, 100);

				glVertex2d(-250, 100); 

				glVertex2d(-250, -100); 

				glVertex2d(250, -100); 

				

				glColor3ub(200, 55, 55);

				glVertex2d(200, 50);

				glVertex2d(-200, 50); 

				glVertex2d(-200, -50); 

				glVertex2d(200, -50); 	

				

				glColor3ub(255, 0, 0);

				glVertex2d((((400 * i) / size) - 200), 50);

				glVertex2d(-200, 50); 

				glVertex2d(-200, -50); 

				glVertex2d((((400 * i) / size) - 200), -50); 	

			glEnd();

			

			glFlush();

      	SDL_GL_SwapBuffers();

		}

		

		if(Lignes.size() >= Lignes.max_size()) return;

		Lignes.resize(Lignes.size() + 3);

		

		Lignes.at(Lignes.size() - 3).x2 = Lignes.at(i).x2;

		Lignes.at(Lignes.size() - 3).y2 = Lignes.at(i).y2;

		

		Lignes.at(Lignes.size() - 3).x1 = Lignes.at(i).x1 + (2 * (Lignes.at(i).x2 - Lignes.at(i).x1) / 3);

		Lignes.at(Lignes.size() - 3).y1 = Lignes.at(i).y1 + (2 * (Lignes.at(i).y2 - Lignes.at(i).y1) / 3);

		

		Lignes.at(i).x2 = Lignes.at(i).x1 + ((Lignes.at(i).x2 - Lignes.at(i).x1) / 3);

		Lignes.at(i).y2 = Lignes.at(i).y1 + ((Lignes.at(i).y2 - Lignes.at(i).y1) / 3);

		

		//Le triangle

		double angle = acos((Lignes.at(i).x2-Lignes.at(i).x1)/sqrt((Lignes.at(i).x2-Lignes.at(i).x1)*(Lignes.at(i).x2-Lignes.at(i).x1) + (Lignes.at(i).y2-Lignes.at(i).y1)*(Lignes.at(i).y2-Lignes.at(i).y1)));

		if((Lignes.at(i).y2-Lignes.at(i).y1) < 0) angle = -angle;

		

		Lignes.at(Lignes.size() - 2).x1 = Lignes.at(i).x2;

		Lignes.at(Lignes.size() - 2).y1 = Lignes.at(i).y2;

		

		Lignes.at(Lignes.size() - 1).x1 = ((Lignes.at(i).x2 + Lignes.at(Lignes.size() - 3).x1) / 2) + (cos(angle+pi/2)*sqrt((Lignes.at(i).x2-Lignes.at(i).x1)*(Lignes.at(i).x2-Lignes.at(i).x1)+(Lignes.at(i).y2-Lignes.at(i).y1)*(Lignes.at(i).y2-Lignes.at(i).y1)));

		Lignes.at(Lignes.size() - 1).y1 = ((Lignes.at(i).y2 + Lignes.at(Lignes.size() - 3).y1) / 2) + (sin(angle+pi/2)*sqrt((Lignes.at(i).x2-Lignes.at(i).x1)*(Lignes.at(i).x2-Lignes.at(i).x1)+(Lignes.at(i).y2-Lignes.at(i).y1)*(Lignes.at(i).y2-Lignes.at(i).y1)));

		

		Lignes.at(Lignes.size() - 2).x2 = Lignes.at(Lignes.size() - 1).x1;

		Lignes.at(Lignes.size() - 2).y2 = Lignes.at(Lignes.size() - 1).y1;

		

		Lignes.at(Lignes.size() - 1).x2 = Lignes.at(Lignes.size() - 3).x1;

		Lignes.at(Lignes.size() - 1).y2 = Lignes.at(Lignes.size() - 3).y1;

		

		

	}

	

}



int main(int argc, char *argv[])

{

	LireFichier();

	

	double Zoom = 1.0, OffsetX = 0.0, OffsetY = 0.0;

	

   SDL_Init(SDL_INIT_VIDEO);

   SDL_EnableKeyRepeat(50, 50);

   SDL_WM_SetCaption("Fractale", NULL);

   SDL_SetVideoMode(600, 600, 32, SDL_OPENGL | SDL_GL_DOUBLEBUFFER);

   bool continuer = true, Redessine = true;

   SDL_Event event;

   

   glClearColor(1, 1, 1, 1);

   glColor3ub(0, 0, 0);

    

	glViewport(0, 0, (GLsizei) 600, (GLsizei) 600);

	glMatrixMode(GL_PROJECTION);

	glLoadIdentity();

	gluOrtho2D((GLdouble)-300, (GLdouble)300, (GLdouble)-300, (GLdouble)300);

	glMatrixMode(GL_MODELVIEW);

	glLoadIdentity(); 



   while (continuer)

   {

   	while(!Redessine)

   	{

			while(SDL_PollEvent(&event))

			{

		   	switch(event.type)

		   	{

		   		case SDL_QUIT:

		         	continuer = false;

						Redessine = true;

						break;

		         	

			      case SDL_KEYDOWN:

						if(event.key.keysym.sym == SDLK_ESCAPE)

						{

							continuer = false;

							Redessine = true;

						}

						

						if(event.key.keysym.sym == SDLK_RETURN) 

						{

							Calcul();

							Redessine = true;

							char titre[100];

							sprintf(titre, "Fractale - Nombre de lignes : %d", Lignes.size());

							SDL_WM_SetCaption(titre, NULL);

							

						}

						

						if(event.key.keysym.sym == SDLK_PAGEUP)

						{

							Zoom *= 1.1;

							Redessine = true;

						}

						

						if(event.key.keysym.sym == SDLK_PAGEDOWN)

						{

							Zoom *= .9;

							Redessine = true;

						}

						

						if(event.key.keysym.sym == SDLK_UP)

						{

							OffsetY -= 10/Zoom;

							Redessine = true;

						}

						

						if(event.key.keysym.sym == SDLK_DOWN)

						{

							OffsetY += 10/Zoom;

							Redessine = true;

						}					

						

						if(event.key.keysym.sym == SDLK_LEFT)

						{

							OffsetX -= 10/Zoom;

							Redessine = true;

						}	

						

						if(event.key.keysym.sym == SDLK_RIGHT)

						{

							OffsetX += 10/Zoom;

							Redessine = true;

						}	

						

						break;

				

					case SDL_ACTIVEEVENT:

						Redessine = true;

						break;

			   }

	      }

	      if(!Redessine && continuer) SDL_Delay(50);

		}

		

		if(continuer)

		{



		   glClear(GL_COLOR_BUFFER_BIT);

		   glColor3ub(0, 0, 0);

		   

		   glMatrixMode(GL_MODELVIEW);

			glLoadIdentity();

			

			glScaled(Zoom, Zoom, 1.0);

			glTranslated(-OffsetX, -OffsetY, 0.0);



		   glBegin(GL_LINES);

		   	for(int i = 0; i < Lignes.size(); i++)

		   	{

		   		if(i % 1000 == 0)

		   		{

		   			glFlush();

		   		}	

					glVertex2d(Lignes[i].x1, Lignes[i].y1);

					glVertex2d(Lignes[i].x2, Lignes[i].y2);

				}

		   glEnd();



		   glFlush();

		   SDL_GL_SwapBuffers();

		   

		   Redessine = false;

		   

      }

   }



   SDL_Quit();



   return 0;

}

Conclusion

Voilà si vous avez des remarques, commentaires n'hésitez pas!
 

Fichier Zip

Pour les "Membres Club", vous pouvez télécharger directement un fichier contenu dans le zip sans télécharger le zip en entier !
  • Fractale.exxTélécharger ce fichier [Réservé aux membres club]1 952 334 octets
  • FractalesTélécharger ce fichier [Réservé aux membres club]47 200 octets
  • geo.fracTélécharger ce fichier [Réservé aux membres club]343 octets
  • geo.frac.2Télécharger ce fichier [Réservé aux membres club]343 octets
  • main.cppTélécharger ce fichier [Réservé aux membres club]Voir ce fichier7 543 octets
  • main.oTélécharger ce fichier [Réservé aux membres club]24 763 octets
  • Makefile.winTélécharger ce fichier [Réservé aux membres club]1 067 octets
  • Projet1.devTélécharger ce fichier [Réservé aux membres club]1 038 octets
  • Projet1.icoTélécharger ce fichier [Réservé aux membres club]Voir ce fichier766 octets
  • Projet1_private.hTélécharger ce fichier [Réservé aux membres club]Voir ce fichier642 octets
  • Projet1_private.rcTélécharger ce fichier [Réservé aux membres club]Voir ce fichier864 octets
  • Projet1_private.resTélécharger ce fichier [Réservé aux membres club]1 876 octets
  • SDL.dllTélécharger ce fichier [Réservé aux membres club]258 048 octets

Télécharger le zip

Historique

30 décembre 2007 14:02:39 :
Modification selon les commentaires retournés sur la source ... Modification du maximum de points! Modification de la constante de pi!
12 janvier 2008 19:12:35 :
Rajout du zoom dans la fractale... Utiliser les touches Gauche, Droite, Haut, Bas, Page Précédente et Page Suivante.

Commentaires et avis

signaler à un administrateur
Commentaire de tit_toinou le 28/12/2007 17:02:13 10/10

Salut,
très belle fractales de Koch.
En fait le principe c'est qu'on remplace toutes les ligne droite
______ par __/\__ !


Juste une petite question : pourquoi utilise-tu OpenGL ? SDL ne suffit pas pour tracer des lignes ?


10/10 programme qui fait ce qu'on lui demande.

signaler à un administrateur
Commentaire de CChargy le 28/12/2007 17:07:29

OpenGl c'est juste parce que je suis en train de l'apprendre et puis c'est plus rapide que SDL (vu que c'est du matériel normalement et pas du logiciel).
Dans la barre de titre figure le nombre de lignes affichés à l'écran.
C'est limité à 65000 et des brouettes (2^32)(A cause de l'index du vector qui est un int soit de - 65000 0 + 65000). Donc cela signifie que mon programme doit pouvoir afficher un peu plus de 65000 lignes, presque rien pour OpenGL (penser aux grosses scènes des jeux vidéos modernes). C'est vrai que je n'ai pas tester avec du SDL pur mais je pense qu'il doit y passer un certain temps.

Voilà
Merci du commentaire!
A+
Bonne prog ;)

signaler à un administrateur
Commentaire de luhtor le 28/12/2007 17:40:06

"vu que c'est du matériel normalement et pas du logiciel"
=> Manque de bol, la carte graphique ne fait que du FLOAT, donc tous tes appels "glVertex2d" sont d'abord convertis en FLOAT par le CPU ! Donc tu auras des perfs horribles avec ton programme. Des que tu vas atteindre quelques dizaines de milliers de poly, ca va commencer à ramer.

De deux, les glVertex* c'est plus a utilisé. Tout facon, ca disparait dans la nouvelle version d'opengl. Ces fonctions sont catastrophiques pour les performances. Donc en conclusion, faire du pure hardware en opengl, c'est délicat...

Autrement remarque, un short = -+ 65000. Un int, c'est en milliards...

signaler à un administrateur
Commentaire de tit_toinou le 28/12/2007 17:49:50

Avec SDL ca ne devrait pas être beaucoup plus long pour les premières itérations, après mieux vaut utiliser OpenGL..
Si j'ai bien compris, tu ouvre une fenetre avec SDL et tu affiche tout (tracer les lignes quoi) avec OpenGL ?

65 536 correspond à 2^16, donc une variable codée sur 2octets (un short) ! un signed int va de -2147483648 à 2147483647.
L'index est toujours positif, non ? Changes int pour unsigned int ! tu pourras aller deux fois plus loin.

Je ne sais pas pourquoi je dis ca car de toute facon au dessus de 4096 je ne vois pas la difference !

Il existe des variantes de la courbe de Koch : flocon de Koch (même règles mais on commence avec un triangle)

Pour améliorer ton programme tu pourrais enregistrer une suite de bitmap dans un dossier pour faire une mini animations :)
Sinon tu pourrais aussi afficher le nombre d'itérations dans la barre de titre (qui est facilement devinable à partir du nombre de lignes mais bon .. c'est une petite amélioration quoi)

signaler à un administrateur
Commentaire de CChargy le 28/12/2007 18:43:20

Luhtor =>
Le "ramage" de mon programme n'est pas très grave, c'est pas du temps réel! (C'est bon a savoir pour les jeux que je programme).
Par contre ton histoire de glVertex* plus utilisé sa m'intéresse. J'ai acheter cet été le bible d'OpenGL 2.0, dans lequel glVertex* est encore utilisé.

Tit_toinou=>
Oui et oui (à tes deux première phrases).

Là, je vais demander aux experts en quoi sont typés les index des vector de la librairies standard...

Si tu change geo.frac tu peux créer le flocon, le programme a été prévu pour sa au départ.
Toutes les infos sont sur le lien
http://colin.chargy.free.fr/Wiki/index.php?title=Fractale

Je pense effectivement fortement à créer un raccourci clavier pour sauvegarder en bmp l'image affichée à l'écran!
Il est très simple aussi d'indiquer le nombre d'itérations dans la barre de titre.

Merci encore!
Bonne prog!

signaler à un administrateur
Commentaire de luhtor le 28/12/2007 19:49:01

CChargy : Je parle de la dernière version d'openGL : "Opengl 3"
Mais il y aurait encore un support des fonctions à la con (ex: glVertex) pendant quelques temps je crois.

signaler à un administrateur
Commentaire de CChargy le 28/12/2007 20:38:42

OK! Pardon...
Mais alors c'est remplacer par quoi ?
Je m'avoue surpris!

signaler à un administrateur
Commentaire de luhtor le 28/12/2007 21:13:19

Remplacé par rien. A jeter ces fonctions. Pour afficher, c'est:
glDrawElements
glDrawRangeElements

et rien d'autre.

signaler à un administrateur
Commentaire de CChargy le 28/12/2007 22:18:54

Ok je me renseignerait!
Merci pour l'info!
Bonne nuit

signaler à un administrateur
Commentaire de JCDjcd le 29/12/2007 18:35:13

const double pi = 4.0*atan(1.0);

bof de chez bof !

signaler à un administrateur
Commentaire de CChargy le 29/12/2007 18:52:44

ah bon!
Et pourquoi?
Je croyais que c'était ce qu'il y avait de plus précis...
En tout cas mathématiquement parlant c'est juste.

signaler à un administrateur
Commentaire de juju12 le 29/12/2007 19:12:15

Oui mais tant de précision est inutile...tu crois vraiment avoir besoin du 45ème chiffre après la virgule? D'autant plus que la fonction atan() va elle-même te retourner un résultat d'une précision limitée alors autant mettre tout de suite :
#define PI (3.1416)

signaler à un administrateur
Commentaire de CChargy le 29/12/2007 20:04:13

Non j'en ai pas forcément besoin  mais ça ne change rien, ni au niveau rapidité d'exécution, ni au niveau   difficulté de codage. Donc j'utilise la méthode la plus précise. Et sa permet de rappeller a qui lira le code que tan(pi/4) = 1...

signaler à un administrateur
Commentaire de JCDjcd le 30/12/2007 12:16:51

oui mais tu depends de la fonction tan... rien te dit qu'elle te donnera toutes les decimales de juste !
et il existe beaucoup d'autre formule que celle la pour pi... alors pourquoi priviligier celle la plutot qu'une autre !
n'oublions surtout pas que c'est un double, donc on connait le nombre de decimales a collees en dur...

bref ca ne se fait pas, c'est comme ca !!!!

signaler à un administrateur
Commentaire de CChargy le 30/12/2007 13:41:27

Oulla je te trouve bien sévère...
Moi je dis que ça se fait et c'est plus précis que #define PI (3.1416)...
Je ne effectivement aucune raison de privilégié cette formule là par rapport au autres, si tu m'en trouve une meilleure je prends...

"n'oublions surtout pas que c'est un double, donc on connait le nombre de decimales a collees en dur..."
euh sa ne dépend pas de l'implémentation ?!?

Enfin toujours est-il que l'on chipote pour pas grand chose je trouve...

Bref, il faut que je change le nombre de lignes maximum ....

signaler à un administrateur
Commentaire de CChargy le 30/12/2007 14:06:44

Enfin toujours est-il que j'ai modifier mon code en conséquence de vos remarques ...
Les 100 décimales de pi sont dédicacés à JCDjcd ... Même si je suis d'accord que même 10 aurait suffis ...

Bonne prog !

signaler à un administrateur
Commentaire de BruNews le 30/12/2007 14:30:38 administrateur CS

Le compilo ne les garde pas alors tu peux réduire la taille du code.

signaler à un administrateur
Commentaire de JCDjcd le 30/12/2007 23:40:17

merci pour la dedicace ... j'en suis tres flatte !
c'est pas mechant ce que je dis (quand je le suis c'est beaucoup plus vache, et ca se sent... j'ai un sale caractere parait-il... ^^)

bon maintenant un peu de math : mantisse du double est de 52 bits (c'est dans le C standard, c'est fixe ca ne changera jamais quelque soit l'implementation), donc comme log10(2)*52=16 (arrondi superieur), il suffit de mettre seulement 16 decimales !

signaler à un administrateur
Commentaire de tit_toinou le 31/12/2007 00:36:28

JCDjcd : j'ai appris de "source sûre" ;) que le standard IEEE (pas le langage C !) pour le format double est de 52 bits stockés + un 1 implicite (à gauche de la virgule) qui n'est pas stocké. Il y a donc en réalité 53 bits de précision...

signaler à un administrateur
Commentaire de BruNews le 31/12/2007 01:27:30 administrateur CS

Non, ce sont les 52 bits de mantisse qui donnent la précision et ce sur quoi on calcule.

signaler à un administrateur
Commentaire de CChargy le 31/12/2007 10:02:06

De rien pour la dédicace ...
Je suis moi même très flatté car dans ce code, pour la première fois que je pose un code sur code-source, on ne remet pas en cause la totalité du code ...
C'est déjà un point positif!

Je n'ai pas compris ton histoire de math. Je suis en Term S et on vient juste de faire les log donc sa m'intéresse d'avoir un peu d'explication. Ton log10(), c'est bien log et pas ln ? Ou c'est encore autre chose? Et au juste c'est quoi que tu cherche? Le nombre de décimales qui ne seront jamais prises en compte pour le calcul ?

Voilà si tu pouvais m'aider ...

Sinon vous pourrez sûrement m'aider sur cette question : Je me suis mis à la programmation réseau (socket, client, serveur et tutti quanti). Je cherche à savoir si tout les types de variables (en C++: int, char, bool, double et les classes) sont codés de la même manière et sur le même nombre d'octets sur tous les ordinateurs (pc ou mac), (16, 32 ou 64 bits) et sur tous les systèmes d'exploitation (Windows/Linux/BeOs ....) et pour tous les compilateurs.

Voilà merci d'avance

signaler à un administrateur
Commentaire de JCDjcd le 31/12/2007 18:17:32

>> Tit_Toinou : tu diras boujour a ta source sure ^^ meme un gros bisou baveux si tu en as envie ! le bit implicite a gauche de la virgule est toujours 0 (sauf dans le cas 1.000), donc pour le calcul c'est bien 52 qu'il faut prendre ! (cf. une de mes sources qui a ete supprimee ( :-( ) sur l'associativite de l'operation + des flottants)

>> CChargy : ben log c'est le logarithme a base 10, mais on a la formule log10(x)=ln(x)/ln(10), ln etant le logarithme naturel
le 16=52*log10(2) correspond aus nombres de decimales stockees en machine, les suivantes sont oubliees, c'est une troncature que l'on effectue (enfin pas nous, le processeur)

signaler à un administrateur
Commentaire de darunia le 01/01/2008 13:45:18

Au risque de passer pour un idiot ...... a quoi ça sert les fractales ???
C'est vrai qu'on voit pas mal de source à ce sujet mais finalement je me suis jamais posé la question.

signaler à un administrateur
Commentaire de tit_toinou le 01/01/2008 15:23:29

Salut,
JCDjcd : la "source sûre" est complètement sure d'avoir raison ! le bit implicite est presque toujours (souligné,gras,rouge,police taille 72) à 1 !
Je laisse la parole à la "source sûre" car je suis incompétent...

double pi = 3.14159265358979323846264338327950;
Hexadecimal pour pi : 0x400921fb54442d18
Idem avec espaces (police non proportionnelle utile ici)
                 4   0    0    9   2    1    f     b    5    4    4    4    2    d    1    8
Binaire     : 0100 0000 0000 1001 0010 0001 1111 1011 0101 0100 0100 0100 0010 1101 0001 1000
Format IEEE 754 pour flottant 64 bits
1<---11----><---------------------52--------------------------->
SEEEEEEEEEEEMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
Avec S = le signe du nombre, EE l'exposant en base 2 (biasé / décalé de 1023) et MMM un nombre de 52 bits qui est la mantisse
Le nombre représenté QUAND l'exposant EE n'est pas aux deux extremes (0 ou 2047) est au signe +/- près (suivant que S vaut 0 resp. 1) la valeur positive suivante :
  (1+M*2^-52)*2^(E-1023) <= le (1+...) represente le bit implicite qui est à 1 et non pas 0
Application numérique pour Pi : S = 0 <=> +1, E = 1024, M = 0x921fb54442d18 = 2570638124657944 en décimal
D'où Pi ~= (1+0.57079632679489655799898173427209)*2^(1024-1023), CQFD
Le cas 'normal' := (0 != EE && 2047 != EE) est bien avec le bit implicite à 1, c'est le zéro qui est un nombre 'denormal' a savoir dénormalisé pour lequel l'exposant est au minimum à savoir zero, soit une puissance de 2 qui vaut (0-1023) = -1023. Pour ces nombres 'denormal' avec EE = 0, la règle est que le 1 caché disparait et M contient toute l'info i.e. (0+M*2^-52)*2^-1022; ca fatigue le co-processeur flottant car il lui faut des cycles supplémentaires pour remettre tout ca au carré, et c'est pour ça que quand on veut que ça pédale vite, on active l'option de contrôle 'flush denormal to zero' (par exemple le code SSE qui doit aller  vite, les cartes graphiques ont des multiplieurs flottants 'simplifiés' qui ont ce comportement cablé en dur etc...). Quand l'exposant EE est au max 2047, on a affaire à un nombre 'spécial', il y en a des tas (les deux infinis ont M = 0), y compris des NaN := 'Not a Number', les 'quiet' qui ne declenchent pas d'exception ont le bit de poids fort de M a 1, les 'signalling' l'ont à 0 mais M n'est pas nul pour autant.

Voilà, fin du tuto sur les nombres flottants IEEE (c'est en gros pareil pour les 'float' 32 bits avec 8 bits d'exposant et 23 bits de mantisse, ce qui donne 24 bits de précision)...

signaler à un administrateur
Commentaire de JCDjcd le 01/01/2008 19:30:03

mais oui, une petite erreur d'etourderie, mais bref sauf pour me contredire et me faire admettre que j'ai tord (je m'y resouds, mais c'est trez clair dans ma petite tete), le principe est la et c'est bien 52 qu'il faut prendre en compte.
Je me corrige : Le bit implicite est a 1 sauf dans le cas 0.0000 et les inifinis, NAN...

TitToinou : tu es tres cultive...

signaler à un administrateur
Commentaire de tit_toinou le 01/01/2008 22:42:12

Au contraire, je ne le suis pas assez pour connaître tout cela ; comme je l'ai dit, j'ai laissé la parole à qqun d'autre (qui ne souhaitait pas créér un compte mais voulait juste poster une explication)

D'ailleurs, comme tu le fais si bien remarquer : tout ceci n'a d'intérêt que dans la mesure où tu as tort, et qu'il fallait le démontrer :P  !

Juste une petite chose : (d'après ce que j'ai compris..) si on ne comptait pas ce bit implicite lors de la conversion binaire-decimal d'un double, tout le calcul ne marcherait pas !
(dans le calcul Pi ~= (1+0.57079632679489655799898173427209)*2)

Enfin bon, la personne qui voulait absolument te transmettre ce message est très têtue..

signaler à un administrateur
Commentaire de BruNews le 01/01/2008 22:54:11 administrateur CS

0.57079632679489655799898173427209
parce que qlq'un arrivera à rentrer ça en FPU ???
Jette un oeil sur le listing asm du compilo pour voir ce qu'il en reste.

signaler à un administrateur
Commentaire de tit_toinou le 02/01/2008 21:43:48

Je relaisse la parole à la "source sûre".

"rentrer ça en FPU ???" : ben oui, et ca donne le résultat déjà mentionné à savoir 0x400921fb54442d18. En fait il manquait 20 chiffres décimaux : il faut hélas 52 chiffres décimaux pour représenter *exactement* en base 10 un nombre binaire à 52 bits, la version complète est en fait
+0.5707963267948965579989817342720925807952880859375000
Comme le compilateur est bien écrit (on peut l'espérer), il convertit sans erreur ce nombre exactement exprimable en format IEE-754. Certes, on peut obtenir la meme valeur avec nettement moins de chiffres, mais aussi avec nettement moins de certitudes...

Pour la petite histoire 52 versus 53 bits, le format natif 80 bits du coprocesseur X87 adopte l'autre convention, avec 64 bits de mantisse mais incluant le 1 explicitement mémorisé (pour les nombres 'normal'). Si on compare des choses comparables, les précisions disponibles sont

80 bits 'long double'      64 bits 'double'     32 bit 'float'
    64/63                     53/52               24/23

Il est d'usage de dire que le format 80 bits a 64 bits de précision, donc pour etre homogène, le format 64 bits a 53 bits de precision. On peut adopter l'autre convention et dire que le format 80 bits a 63 bits de precision tandis que le format 64 bits a 52 bits de précision.

signaler à un administrateur
Commentaire de tit_toinou le 02/01/2008 21:54:55

Salut,
là c'est moi qui parle,
pour en revenir au sujet : CChargy, tu pourrais mettre une touche pour qu'on puisse zoomer dans la fractale (une super amélioration !)

signaler à un administrateur
Commentaire de BruNews le 02/01/2008 22:19:35 administrateur CS

#include <windows.h>
#include <stdio.h>

double dA = 0.57079632679489655799898173427209;
double dB = 0.57079632679489655;

char szappname[] = "ACHANGER";

void Tester()
{
  char buf[24];
  sprintf(buf, "", dA);
  MessageBox(0, buf, szappname, 0);
  sprintf(buf, "", dB);
  MessageBox(0, buf, szappname, 0);
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE x, PSTR y, int z)
{
  Tester();
  return 0;
}

ASM COMPILO:
_dA DQ 03fe243f6a8885a30r
_dB DQ 03fe243f6a8885a30r
etc, etc.

Toutes ces décimales sont intraduisibles, c'est indiqué dans toutes les docs Intel autant que MS. Aucune raison de s'enliser ainsi, on n'a que rarement raison contre tous, faut s'y faire.

signaler à un administrateur
Commentaire de SourceSure le 03/01/2008 02:11:05

Mea culpa pour l'ambiguité, voilà qui va tout éclairer. Pi, Pi-1 et (Pi-1)/2 ont quand meme quelques petites differences, mais nous autres pauvres humains ne savons pas bien decaler d'un bit en base 16 de tete :

#include <stdio.h>

double Pi     = 3.14159265358979323846264338327950;
double PiM1   = 1.57079632679489655799898173427209;
double PiM1S2 = 0.57079632679489655799898173427209;

int main(int argc,char *argv[])
{
printf(" Pi      = %.16lf, 0x%16I64X\n",Pi    ,Pi    );
printf(" Pi-1    = %.16lf, 0x%16I64X\n",PiM1  ,PiM1  );
printf("(Pi-1)/2 = %.16lf, 0x%16I64X\n",PiM1S2,PiM1S2);
printf("     0x121FB54442D18 << 1    = 0x%16I64X\n",0x121FB54442D18i64 << 1);
return  0;
} // main()
/*
Pi      = 3.1415926535897931, 0x400921FB54442D18
Pi-1    = 1.5707963267948966, 0x3FF921FB54442D18
(Pi-1)/2 = 0.5707963267948966, 0x3FE243F6A8885A30
     0x121FB54442D18 << 1    = 0x   243F6A8885A30
*/

Comparaison n'est pas raison...

signaler à un administrateur
Commentaire de CChargy le 03/01/2008 14:33:42

tit_toinou, je vais y réfléchior alors ... Mais zommer ou? Au centre ? Sur certaines fractales on verrait rien ... Peut-être zommer avec le curseur ? Après pourquoi pas faire de la capture vidéo (de surperbes anims en perspective) ?
Enfin bref!

Tous vos discours m'on l'air bien compliqué je trouve ...
Enfin je laisse tomber, je laisse les as de programmation discuter tranquilou ...Bonneprog (sans trop de prise de tête a tous ...) :)

signaler à un administrateur
Commentaire de tit_toinou le 04/01/2008 12:28:14

Salut,
alors je voulais dire par zoomer :
une touche pour zoomer (double clique gauche, touche +..)
une touche pour dézoomer (clique droite, touche -..)
et avec la souris on se déplace dans la fractale ! (on bouge le curseur en cliquant gauche)

Tu regardes dans n'importes quel programme de fractal sur ce site et tu trouves ca !

Bon je vais te donner des fonctions utiles que j'ai trouvé dans la SDL :
SDL_SaveBMP(surface, file) : ca prend une surface et ca l'enregistre dans l'ordi en bitmap !! (c'est pile ce qu'il faut, non?)
ensuite pour savoir de combien à bougée la souris tu fait une bêbête soustraction ! Mais si la souris dépasse la fenêtre ? Pour forcer la souris à rester dans la fenêtre tu peux utiliser SDL_WM_GrabInput(SDL_GrabMode mode) (tu donne SDL_GRAB_ON je pense)
(
typedef enum {
SDL_GRAB_QUERY = -1,
SDL_GRAB_OFF = 0,
SDL_GRAB_ON = 1,
SDL_GRAB_FULLSCREEN /* Used internally */
} SDL_GrabMode;
)
avec ca l'utilisateur ne peut pas sortir !
Enfin essayes tout ca voir si ca marche ;)
De toute facon j'ai trouvé tout cela dans SDL.h, SDL_video.h etc.. donc si tu veux vraiment savoir tout ce que t'apporte la SDL faut aller voir dans les fichiers h !

signaler à un administrateur
Commentaire de tit_toinou le 04/01/2008 13:42:08

C'est bon je viens de tester les deux fonctions..
donc SDL_WM_GrabInput(SDL_GrabMode mode) marche mais ne sert à rien en fait : tu ne peux pas sortir le curseur de la fenêtre (même pas pour la déplacer)..
Pour SDL_SaveBMP : c'est une fonction super utile !

SDL_SaveBMP(le_nom_du_pointeur_sur_ta_surface,le_nom_du_fichier) tout simplement !
Apres pour faire une animation tu fais un sprintf() pour changer le_nom_du_fichier (genre "animation 01.bmp","animation 02.bmp" etc..)
et puis voilà ca marche y'a rien à redire, la SDL a pensée à tout !

signaler à un administrateur
Commentaire de CChargy le 04/01/2008 14:25:07

C'est gentils de me donner des cours de SDL mais sa devrait aller merci :)
Enfin j'espère que ça servira à quelqu'un, mais je ne connaissais pas SDL_WM_GrabInput
Je connais SDL_SaveBMP merci... Juste le bmp qui me chagrine, je vais voir du côté de OpenGL si on peux pas faire quelque chose ...
Voilà je sais pas quand j'aurais le temps de faire ces modifications ...
Bonne prog !

signaler à un administrateur
Commentaire de tit_toinou le 06/01/2008 20:40:11

Salut,
dsl ^^
sinon tu connais SDL_image ? (jpensait que oui mais apparemment.. non)

signaler à un administrateur
Commentaire de CChargy le 06/01/2008 21:22:53

Sisi je connais la SDL_Image (j'ai un TPE en première donc l'année dernière sur un logiciel de modification d'image (léger). Mais on peut charger une image et non l'enregistrer. Par contre j'avais utiliser FreeImage pour l'enregistrement... Il faut que je vérifie la portabillitée Linux de FreeImage ...
Voilà
Bonne prog!
(PS.: Je verrais ça dimanche prochain si j'ai le temps, on entre dans la période où je suis très pris ...)

signaler à un administrateur
Commentaire de tit_toinou le 08/01/2008 17:52:31

Salut,
ouais jme suis trompé..
Non mais à quoi cela sert BMP c'est bien..
Déjà fait des mises à jour avec animation, zoom et déplacement et après tu vois si il y a utilité à continuer les maj.

Ajouter un commentaire

Discussions en rapport avec ce code source dans le forum

prog d'exemple openGL + SDL [ par Arnaud16022 ] Hi!je cherche une source qui montre comment créer une fenetre, détecter les touches du clavier et les mouvements de la souris ... avec la SDL, ET d'af Configurer Borland C++ pour les librairies graphiques OPENGL et SDL [ par serialkilled ] Bonjour,J'aimerais savoir comment configurer Borland C++, quels fichiers du site de SDL et OPENGL faut il prendre et ou faut il les mettre. J'ai essay Affichage de texte avec OpenGL et SDL sans SDL_ttf [ par asmanur ] Voilà je cherche à faire un code le plus portable possible e j'aimerais afficher du texte dans une fenetre SDL & OpenGL seulement voila SD_ttf ne fonc SDL semble ne pas fonctionner ? [ par neodelphi ] Bonjour tout le monde ! Voila mon probl&#232;me : je suis en train d'essayer de faire de l'openGl avec la sdl sous un syst&#232;me linux. Apr&#232;s a Tutoriaux Complet SDL OpenGL C++ [ par Fireflect ] Bonjours, Je recherche des bons tutoriaux sur le m&#233;lange OpenGL SDL C++ sans glut ou quoi que ce soit d'autre avec des sources bien optimis&#233 Différence SDL - SDL avec OpenGL et OpenGl [ par Turok ] Donc voila, j'ai recemment commenc&#233; &#224; programmer en C++ avec SDL. La question que je me pose, en sachant que je ne veux faire que de la 2d, SDL ou OpenGL ? [ par nikoland ] Bonjour,J'aimerais votre avis concernant la programmation multimedia (jeux 2D/3D). Me conseillez-vous de coder avec la librairie SDL ou avec OpenGL ?S SDL est deformation de surface [ par wil51 ] Bonjour,Je suis actuellement sur le devellopemeny d'un jeu en 2D en SDL style GTA en vue de dessusTous est en 2D sauf les batiments qui sont 3D.Actuel texte openGL et SDL [ par vangeurmasker ] Bonjour Je cherche &#224; afficher du texte dans une fen&#234;tre OpenGL g&#233;r&#233;e par SDL. Mon application doit &#234;tre portable sur windows [SDL - OpenGL - POO] cherche collaborateurs pour jeu 2D [ par MrdJack ] salut, je projetes de faire un jeu 2D de type bomberman/dynablaster en SDL/OpenGL/POO, je cherche des programmeurs interress&#233; ayant juste des not


Nos sponsors

Sondage...

CalendriCode

Juillet 2009
LMMJVSD
  12345
6789101112
13141516171819
20212223242526
2728293031  

Consulter la suite du CalendriCode

Téléchargements

Comparez les prix Nouvelle version


LG KP501

Entre 9€ et 159€


Photothèque Nouveau !



Développement réalisé par Nicolas SOREL (Nix) avec l'aide de : Cyril DURAND et Emmanuel (EBArtSoft), Merci à Vincent pour ses précieux conseils
CodeS-SourceS.com© Toute reproduction même partielle est interdite sauf accord écrit du Webmaster
CodeS-SourceS.com© est une marque déposée tous droits réservés
Temps d'éxécution de la page : 0,593 sec

Google Coop CodeS-SourceS Google Coop CodeS-SourceS


Certaines images présentes sur le site (notament certains avatars) sont issues des collections IconShock, donc si vous souhaitez utiliser ces icons vous devez les acheter, ne les copiez pas et ne utilisez pas dans vos sites et applications sans les avoir commandé.