Atelier Cod'Art

#include <stdio.h>
#include <stdlib.h>
#include <SDL/SDL.h>
#include <math.h>
#include <time.h>

void pause()
{
    int continuer = 1;
    SDL_Event event;

    while (continuer)
    {
        SDL_WaitEvent(&event);
        switch(event.type)
        {
            case SDL_QUIT:
                continuer = 0;
        }
    }
}

Uint32 obtenirPixel(SDL_Surface *surface, int x, int y)
{
    int nbOctetsParPixel = surface->format->BytesPerPixel;
    Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * nbOctetsParPixel;

    switch(nbOctetsParPixel)
    {
        case 1:
            return *p;
        case 2:
            return *(Uint16 *)p;
        case 3:
            if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
                return p[0] << 16 | p[1] << 8 | p[2];
            else
                return p[0] | p[1] << 8 | p[2] << 16;
        case 4:
            return *(Uint32 *)p;
        default:
            return 0;
    }
}

void definirPixel(SDL_Surface *surface, int x, int y, Uint32 pixel)
{
    int nbOctetsParPixel = surface->format->BytesPerPixel;
    Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * nbOctetsParPixel;

    switch(nbOctetsParPixel)
    {
        case 1:
            *p = pixel;
            break;

        case 2:
            *(Uint16 *)p = pixel;
            break;

        case 3:
            if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
            {
                p[0] = (pixel >> 16) & 0xff;
                p[1] = (pixel >> 8) & 0xff;
                p[2] = pixel & 0xff;
            }
            else
            {
                p[0] = pixel & 0xff;
                p[1] = (pixel >> 8) & 0xff;
                p[2] = (pixel >> 16) & 0xff;
            }
            break;

        case 4:
            *(Uint32 *)p = pixel;
            break;
    }
}

int main (int argc, char** argv) {

        SDL_Surface *screen;
        Uint32 pixel;
        Uint8 r,g,b,a;
        int j,i,n;
        float k,m,x1,x,y;
        int nmax = 255;

        srand(time(NULL));

        SDL_Init (SDL_INIT_VIDEO);

        screen = SDL_SetVideoMode(800, 600, 32, SDL_SWSURFACE);
        SDL_LockSurface(screen);

        for (j=0; j<600; j++) {
                m=(300.-j)/200.;
                for (i=0; i<800; i++) {
                        k=(-500.+i)/200.;
                        x=0;
                        y=0;
                        n=0;
                        do {
                                x1=x*x-y*y+k;
                                y=2*x*y+m;
                                x=x1;
                                n++;
                        } while (((x*x+y*y) <4) && (n<nmax));
                        pixel = obtenirPixel(screen,i,j);
                        SDL_GetRGBA(pixel, screen->format, &r,&g,&b,&a);
                        r=rand()*n%256;
                        g=(255-n)*rand()%256;
                        b=cos(n)*(rand()%256);     
                        pixel=SDL_MapRGBA(screen->format,r,g,b,a);
                        definirPixel(screen,i,j,pixel);
                }
        }



        SDL_UnlockSurface(screen);


        SDL_Flip(screen);

        pause();


        SDL_Quit();

        return EXIT_SUCCESS;
}
 

#include <stdlib.h>
#include <stdio.h>
#include <SDL/SDL.h>
#include <math.h>

//Qualité
#define NOMBREDEFOI 4 //itération de la fractale
//forme
#define NOMBRE_SOMMETS 3
#define CST_RAYON 400.0
//Répetition
#define NOMBRE_INTERNE 4.0 //float
#define DECREMENTATION_RAYON 120
//Couleurs
#define ROUGE_DEPART 0
#define VERT_DEPART 255
#define BLEU_DEPART 0
#define ROUGE_ARRIVE 255
#define VERT_ARRIVE 0
#define BLEU_ARRIVE 0
//Tracage
#define TAILLE_PIXEL 1
#define LARGEUR 1024
#define HAUTEUR 768
//Gestion mémoire
#define DIMTAB (pow(4,NOMBREDEFOI)+1)*2*NOMBRE_SOMMETS //Ne pas toucher

void pause();
void tracer_ligne(SDL_Surface *trait,SDL_Surface *ecran, float x1, float y1, float x2, float y2);
float absolu(float a);
void iteration(int *tableau);
void afficher(SDL_Surface *trait,SDL_Surface *ecran,int *tableau);

int main(int argc, char *argv[])
{
    SDL_Init(SDL_INIT_VIDEO);

    srand(time(NULL));

    SDL_Surface *ecran = NULL;
    SDL_Surface *trait = NULL;

    SDL_Rect position;

    int i,j,k;
    i=DIMTAB;
    int tableau[i];
    float rayon;

    ecran = SDL_SetVideoMode(LARGEUR, HAUTEUR, 32, SDL_HWSURFACE);
    trait = SDL_CreateRGBSurface(SDL_HWSURFACE, TAILLE_PIXEL, TAILLE_PIXEL, 32, 0, 0, 0, 0);

    SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 0, 0, 0));
    SDL_FillRect(trait, NULL, SDL_MapRGB(trait->format, 0, 0, 0));

    rayon=CST_RAYON;
    for (j=0;j<NOMBRE_INTERNE;j++)
    {
        SDL_FillRect(trait, NULL, SDL_MapRGB(trait->format, (((NOMBRE_INTERNE-j-1)/(NOMBRE_INTERNE-1))*ROUGE_DEPART+(j/(NOMBRE_INTERNE-1))*ROUGE_ARRIVE)/2,
                                                            (((NOMBRE_INTERNE-j-1)/(NOMBRE_INTERNE-1))*VERT_DEPART+(j/(NOMBRE_INTERNE-1))*VERT_ARRIVE)/2,
                                                            (((NOMBRE_INTERNE-j-1)/(NOMBRE_INTERNE-1))*BLEU_DEPART+(j/(NOMBRE_INTERNE-1))*BLEU_ARRIVE)/2));

        for (i=0;i<DIMTAB;i++)
        {
            tableau[i]=0;
        }
        k=0;
        for(i=0;i<NOMBRE_SOMMETS+1;i+=1)
        {
            tableau[k]=LARGEUR/2+rayon*cos((i*2*3.14159)/NOMBRE_SOMMETS);
            tableau[k+1]=HAUTEUR/2+rayon*sin((i*2*3.14159)/NOMBRE_SOMMETS);
            k+=2;
        }

        for (i=0;i<NOMBREDEFOI;i++)
        {
            iteration(tableau);
        }
        afficher(trait,ecran,tableau);
        SDL_Flip(ecran);
        rayon-=DECREMENTATION_RAYON;
    }


    SDL_Flip(ecran);

    pause();

    SDL_FreeSurface(trait);
    SDL_Quit();

    return 0;
}

void afficher(SDL_Surface *trait,SDL_Surface *ecran,int *tableau)
{
    int i=0;
    for(i=0;i+2<DIMTAB;i+=2)
    {
        if (tableau[i+2]!=0 && tableau[i+3]!=0)
        tracer_ligne(trait,ecran, tableau[i], tableau[i+1], tableau[i+2], tableau[i+3]);
    }
}

void iteration(int *tableau)
{
    SDL_Rect milieu;
    float x1,x2,y1,y2,a,i,HAUTEUR_TRIANGLE,milieu_x,milieu_y;
    int j,k,l,m;
    for (m=0;m+8<DIMTAB;m+=8)
    {
        if(tableau[m]==0 || tableau[m+1]==0 || tableau[m+2]==0 || tableau[m+3]==0) {break;}
        x1=tableau[m];y1=tableau[m+1];
        x2=tableau[m+2];y2=tableau[m+3];
        HAUTEUR_TRIANGLE=(sqrt(pow(y2-y1,2)+pow(x2-x1,2)))/(sqrt(12));
        a=(y2-y1)/(x2-x1);
        if (absolu(a)<=1)
        {
            if (x1 > x2) {i=x2;x2=x1;x1=i;i=y2;y2=y1;y1=i;}
            a=(y2-y1)/(x2-x1);
            milieu_x=x1+(x2-x1)/2;
            milieu_y=y1+a*(x2-x1)/2;
        }
        else
        {
            if