Forums des Zéros

25 août 2010 à 17:51:30

Citation : n!co69

ca me fait un truc tout moche (des ronds pas en dégradé)

Un screenshot?

hum, tu peux essayer d'enlever le / 10, et poste le code.

Zeste de Savoir, le site qui en a dans le citron !

25 août 2010 à 18:20:54

voila ce que ca donne
Image utilisateur

et si j'enlève le /10 ( il me permet d'agrandir l'épaisseur des cercles )
Image utilisateur

ou elles sont mes images ? o_O

----------------------------------

édit : j'ai réussi

j'ai transformé ma fonction de pré-création du sin ( j'avais pas compris son principe )

et mettre période en négatif sa fait partir aussi dans le tableau de sin en négatif :-°

voici ce que ca donne
le code

#include "declarations.h"

#include "main.h"
#include "commande.h"

#define PI2 6.28318531

int main ( int argc, char** argv )
{
    if (SDL_Init(SDL_INIT_VIDEO) == -1)
    {
        fprintf(stderr, "Erreur d'initialisation de la SDL : %s\n", SDL_GetError());
        exit(EXIT_FAILURE);
    }

    Input in;
    memset(&in,0,sizeof(in));

    int temps = 0 , i = 0 , j = 0 , periode = 0 , sintable[256] = {0} , bufer = 0;
    for ( i = 0 ; i < 256 ; i++ )
    sintable[i] = 126 * sin( i * ( PI2 / 255 ) ) + 125 ;

    SDL_Surface *ecran = NULL ;

    ecran = SDL_SetVideoMode(800, 600, 32, SDL_HWSURFACE | SDL_DOUBLEBUF );
    if (ecran == NULL)
    {
        fprintf(stderr, "erreur pas d'eran charge %s\n", SDL_GetError());
        exit(EXIT_FAILURE);
    }
    SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 0, 0, 0));

    SDL_Rect position ;
        position.x = 0 ;
        position.y = 0 ;
        position.h = 1 ;
        position.w = 1 ;

    temps = SDL_GetTicks();

    while ( !in.quit )
    {
        UpdateEvents(&in);

        if ( temps + 50 < SDL_GetTicks() )
        {
            temps += 50 ;
            periode++ ;

            SDL_Surface *s = SDL_GetVideoSurface();

            for( j = 0; j < 600; j++ )
            {
                Uint8 *offset = ( Uint8 * )s->pixels + j * s->pitch;
                for( i = 0; i < 800; i++ )
                {
                    Uint8 r, g, b;
                    bufer = ( sqrt( ( i - 400 ) * ( i - 400 ) + ( j - 300 ) * ( j - 300 ) ) + periode ) ;
                    r = sintable[ bufer % 256 ] ;
                    bufer = ( sqrt( ( i - 400 ) * ( i - 400 ) + ( j - 300 ) * ( j - 300 ) ) + 2 * periode ) ;
                    g = sintable[ bufer % 256 ] ;
                    bufer = ( sqrt( ( i - 400 ) * ( i - 400 ) + ( j - 300 ) * ( j - 300 ) ) + 3 * periode ) ;
                    b = sintable[ bufer % 256 ] ;

                    *( Uint32 * )( offset + ( i << 2 ) ) = ( r  << 16 ) + ( g << 8 ) + b;
                }
            }

        }

        SDL_Flip(ecran);
    }




    SDL_Quit();

    return( EXIT_SUCCESS);
}

et une image
Image utilisateur

jolis arc en ciel :lol:

pourquoi mes images ne s'envoient pas ??? o_O

"Tout devrait être rendu aussi simple que possible, mais pas plus." A.Einstein

25 août 2010 à 23:04:55

Parce que ton lien n'est pas bon. Ca me met que la page n'a pas été trouvée.

25 août 2010 à 23:21:50

c'est bizarre o_O

j'envoie les images sur le site ( par "envoi d'images" a gauche de la fenêtre d'écriture )
quand le site a reçu mes images le nom de celle-ci s'affiche a la place de sa miniature . pourquoi ?
bug ? problème lier a mon navigateur ? la mise a jours d'adobe que j'ai fait ce matin ? ( ca ne marche plus depuis ce matin )

-------------------------------------------------------------------

édit : voila ce que je suis arrivé a faire

il y a 12 .exe :-°

plasma version 1.exe est le plus vieux et plasma version 12.exe est le plus récent

plasma_2.rar

mais je ne comprend pas trop le système de la palette ( même avec tes explications )

"Tout devrait être rendu aussi simple que possible, mais pas plus." A.Einstein

26 août 2010 à 4:18:32

Citation : N!co69

voila ce que je suis arrivé a faire
édit

Pas mal du tout!

Pour le cycle de palette.
Il faut travailler avec des surfaces avec une profondeur de 8bpp.
Tu vas devoir créer un palette de 256 couleurs cyclique par le moyen que tu veux(HSV, sin, etc...).
Partant de là tu affiches une forme quelconque(à l'aide des fonctions que tu connais maintenant), et c'est fini.
A chaque frame tu fais évoluer ta palette, tu ne fais plus d'affichage.

Une fois que tu à fais quelques plasmas simples sympas, tu peux combiner avec les plasmas que tu as déjà fait.

Une petite remarque, tes plasmas sont très statiques.
Tu peux maintenant, plutôt qu'utiliser une table de sinus, précalculer pour chaque x et y.
Tu utilisent plusieurs buffers avec des dimensions 2 fois supérieures à celle de ton écran. Tu précalcules pour chaque pixel de ton buffer à l'aide de fonctions de ton choix.

Au moment de l'affichage, tu affiches tes buffers en leur appliquant un petit décalage sur chaque axe.
J'ai posté plusieurs plasmas qui utilisent ce principe, tu peux commencer par regarder.

Zeste de Savoir, le site qui en a dans le citron !

26 août 2010 à 12:35:06

j'ai regardé mais j'ai pas bien compris :-°

sinon voila un résultat avec une palette a une dimension

et son code

#include "declarations.h"

#include "main.h"
#include "commande.h"

#define PI2 6.28318531

int main ( int argc, char** argv )
{
    if (SDL_Init(SDL_INIT_VIDEO) == -1)
    {
        fprintf(stderr, "Erreur d'initialisation de la SDL : %s\n", SDL_GetError());
        exit(EXIT_FAILURE);
    }

    Input in;
    memset(&in,0,sizeof(in));

    int temps = 0 , i = 0 , j = 0 , periode = 0 , variable[2] = {0} , sintable [1536] ;

    for ( i = 0 ; i < 1536 ; i++ )
    {
        if ( i < 256 )
        sintable[i] = ( 255 << 16 ) + ( i << 8 ) ;

        if ( i >= 256 && i < 512 )
        sintable[i] = ( ( 511 - i ) << 16 ) + ( 255 << 8 ) ;

        if ( i >= 512 && i < 768 )
        sintable[i] = ( 255 << 8 ) + ( i - 512 ) ;

        if ( i >= 768 && i < 1024 )
        sintable[i] = ( ( 1023 - i ) << 8 ) + 255 ;

        if ( i >= 1024 && i < 1280 )
        sintable[i] = ( ( i - 1024 ) << 16 ) + 255 ;

        if ( i >= 1280 && i < 1536 )
        sintable[i] = ( 255 << 16 ) + ( 1535 - i ) ;
    }

    SDL_Surface *ecran = NULL ;

    ecran = SDL_SetVideoMode(800, 600, 32, SDL_HWSURFACE | SDL_DOUBLEBUF );
    if (ecran == NULL)
    {
        fprintf(stderr, "erreur pas d'eran charge %s\n", SDL_GetError());
        exit(EXIT_FAILURE);
    }
    SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 0, 0, 0));

    SDL_Rect position ;
        position.x = 0 ;
        position.y = 0 ;
        position.h = 1 ;
        position.w = 1 ;

    temps = SDL_GetTicks();

    while ( !in.quit )
    {
        UpdateEvents(&in);

        if ( temps + 40 < SDL_GetTicks() )
        {
            temps += 40 ;
            periode++ ;

            SDL_Surface *s = SDL_GetVideoSurface();

            for( j = 0; j < 600; j++ )
            {
                Uint8 *offset = ( Uint8 * )s->pixels + j * s->pitch;
                for( i = 0; i < 800; i++ )
                {
                    variable[0] = sqrt ( ( i - 400 ) * ( i - 400 ) + ( j - 300 ) * ( j - 300 ) ) + 5 * periode ;

                    *( Uint32 * )( offset + ( i << 2 ) ) = sintable[ variable[0] % 1536 ] ;
                }
            }
        }

        SDL_Flip(ecran);
    }




    SDL_Quit();

    return( EXIT_SUCCESS);
}

mais comme chez moi les images sa veut plus :colere2:

voici le .exe
plasma_2.rar

--------------------------------------------------------

édit : il est super ton topic !!!

on change un ou 2 truc a la fonction et hop ca change tout a l'écran

je vient de me faire des carré de couleurs :lol:

avec cette fonction

variable[0] = 1000 * sin( i / 100 ) + 1000 * sin( j / 100 ) + 2000 + 5 * periode ;

*( Uint32 * )( offset + ( i << 2 ) ) = sintable[ variable[0] % 1536 ];

vive les effets plasma !!!

"Tout devrait être rendu aussi simple que possible, mais pas plus." A.Einstein

26 août 2010 à 17:16:46

Ce n'est pas vraiment, un effet de palette, puisque qu'à chaque frame, tu actulises l'écran en écrivant des pixels. En fait, tu utilises la même technique qu'avant mais avec une fonction.
Le princicpe du plasma, c'est de combiner le résultat de plusieurs fonctions.

Hum, ce serait sympa, que tu colles tout dans un main.c.
Qu'on puisse tester en faisant simplement copier coller.

edit: merci pour le topic, il aura fallu attendre presque un an pour intéresser quelqu'un. :lol:

Zeste de Savoir, le site qui en a dans le citron !

26 août 2010 à 17:55:46

je pensait que c'était comme ca une palette :-°

( j'ai refait les nuances de couleurs que tu montre dans ton 1er post )

je vais essayé de tous mettre dans le main

--------------------------------------------

édit
voila le code ( entier

) avec les carrés

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

#define PI2 6.28318531

typedef struct
{
	char key[SDLK_LAST];
    int mousex,mousey;
	int mousexrel,mouseyrel;
	char mousebuttons[6];
    char quit;

} Input;

void UpdateEvents(Input* in);


int main ( int argc, char** argv )
{
    if (SDL_Init(SDL_INIT_VIDEO) == -1)
    {
        fprintf(stderr, "Erreur d'initialisation de la SDL : %s\n", SDL_GetError());
        exit(EXIT_FAILURE);
    }

    Input in;
    memset(&in,0,sizeof(in));

    int temps = 0 , i = 0 , j = 0 , periode = 0 , variable[2] = {0} , sintable [1536] = {0} ;

    for ( i = 0 ; i < 1536 ; i++ )
    {
        if ( i < 256 )
        sintable[i] = ( 255 << 16 ) + ( i << 8 ) ;

        if ( i >= 256 && i < 512 )
        sintable[i] = ( ( 511 - i ) << 16 ) + ( 255 << 8 ) ;

        if ( i >= 512 && i < 768 )
        sintable[i] = ( 255 << 8 ) + ( i - 512 ) ;

        if ( i >= 768 && i < 1024 )
        sintable[i] = ( ( 1023 - i ) << 8 ) + 255 ;

        if ( i >= 1024 && i < 1280 )
        sintable[i] = ( ( i - 1024 ) << 16 ) + 255 ;

        if ( i >= 1280 && i < 1536 )
        sintable[i] = ( 255 << 16 ) + ( 1535 - i ) ;
    }

    SDL_Surface *ecran = NULL ;

    ecran = SDL_SetVideoMode(800, 600, 32, SDL_HWSURFACE | SDL_DOUBLEBUF );
    if (ecran == NULL)
    {
        fprintf(stderr, "erreur pas d'eran charge %s\n", SDL_GetError());
        exit(EXIT_FAILURE);
    }
    SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 0, 0, 0));

    SDL_Rect position ;
        position.x = 0 ;
        position.y = 0 ;
        position.h = 1 ;
        position.w = 1 ;

    temps = SDL_GetTicks();

    while ( !in.quit )
    {
        UpdateEvents(&in);

        if ( temps + 40 < SDL_GetTicks() )
        {
            temps += 40 ;
            periode++ ;

            SDL_Surface *s = SDL_GetVideoSurface();

            for( j = 0; j < 600; j++ )
            {
                Uint8 *offset = ( Uint8 * )s->pixels + j * s->pitch;
                for( i = 0; i < 800; i++ )
                {
                    variable[0] = 1000 * sin( i / 100 ) + 1000 * sin( j / 100 ) + 2000 + 5 * periode ;

                    *( Uint32 * )( offset + ( i << 2 ) ) = sintable[ variable[0] % 1536 ];
                }
            }
        }

        SDL_Flip(ecran);
    }




    SDL_Quit();

    return( EXIT_SUCCESS);
}

void UpdateEvents(Input* in)
{
	SDL_Event event;
	while(SDL_PollEvent(&event))
	{
		switch (event.type)
		{
		case SDL_KEYDOWN:
			in->key[event.key.keysym.sym]=1;
			break;
		case SDL_KEYUP:
			in->key[event.key.keysym.sym]=0;
			break;
		case SDL_MOUSEMOTION:
			in->mousex=event.motion.x;
			in->mousey=event.motion.y;
			in->mousexrel=event.motion.xrel;
			in->mouseyrel=event.motion.yrel;
			break;
		case SDL_MOUSEBUTTONDOWN:
			in->mousebuttons[event.button.button-1]=1;
			break;
		case SDL_MOUSEBUTTONUP:
			in->mousebuttons[event.button.button-1]=0;
			break;
		case SDL_QUIT:
			in->quit = 1;
			break;
		default:
			break;
		}
	}
}

----------------------------------------------------------

édit 2

j'ai réussi a refaire tes ronds ( trop content

)

voici le code

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

#define PI2 6.28318531

typedef struct
{
	char key[SDLK_LAST];
    int mousex,mousey;
	int mousexrel,mouseyrel;
	char mousebuttons[6];
    char quit;

} Input;

void UpdateEvents(Input* in);


int main ( int argc, char** argv )
{
    if (SDL_Init(SDL_INIT_VIDEO) == -1)
    {
        fprintf(stderr, "Erreur d'initialisation de la SDL : %s\n", SDL_GetError());
        exit(EXIT_FAILURE);
    }

    Input in;
    memset(&in,0,sizeof(in));

    int temps = 0 , i = 0 , j = 0 , periode = 0 , variable[2] = {0} , sintable [1536] = {0} , fonction[800][600] = {{0}} ;

    for ( i = 0 ; i < 1536 ; i++ )
    {
        if ( i < 256 )
        sintable[i] = ( 255 << 16 ) + ( i << 8 ) ;

        if ( i >= 256 && i < 512 )
        sintable[i] = ( ( 511 - i ) << 16 ) + ( 255 << 8 ) ;

        if ( i >= 512 && i < 768 )
        sintable[i] = ( 255 << 8 ) + ( i - 512 ) ;

        if ( i >= 768 && i < 1024 )
        sintable[i] = ( ( 1023 - i ) << 8 ) + 255 ;

        if ( i >= 1024 && i < 1280 )
        sintable[i] = ( ( i - 1024 ) << 16 ) + 255 ;

        if ( i >= 1280 && i < 1536 )
        sintable[i] = ( 255 << 16 ) + ( 1535 - i ) ;
    }

    for ( i = 0 ; i < 800 ; i++ )
    {
        for ( j = 0 ; j < 600 ; j++ )
        {
            fonction[i][j] = ( 300 * sin( ( sqrt( ( i - 400 ) * ( i - 400 ) + ( j - 300 ) * ( j - 300 ) ) ) / 100 ) + 1000 ) + ( i + j / 2 ) / 2 ;
        }
    }

    SDL_Surface *ecran = NULL ;

    ecran = SDL_SetVideoMode(800, 600, 32, SDL_HWSURFACE | SDL_DOUBLEBUF );
    if (ecran == NULL)
    {
        fprintf(stderr, "erreur pas d'eran charge %s\n", SDL_GetError());
        exit(EXIT_FAILURE);
    }
    SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 0, 0, 0));

    SDL_Rect position ;
        position.x = 0 ;
        position.y = 0 ;
        position.h = 1 ;
        position.w = 1 ;

    temps = SDL_GetTicks();

    while ( !in.quit )
    {
        UpdateEvents(&in);

        if ( temps + 40 < SDL_GetTicks() )
        {
            temps += 40 ;
            periode++ ;

            SDL_Surface *s = SDL_GetVideoSurface();

            for( j = 0; j < 600; j++ )
            {
                Uint8 *offset = ( Uint8 * )s->pixels + j * s->pitch;
                for( i = 0; i < 800; i++ )
                {
                    variable[0] = fonction [i][j] + 5 * periode ;

                    *( Uint32 * )( offset + ( i << 2 ) ) = sintable[ variable[0] % 1536 ];
                }
            }
        }

        SDL_Flip(ecran);
    }

    SDL_Quit();

    return( EXIT_SUCCESS);
}

void UpdateEvents(Input* in)
{
	SDL_Event event;
	while(SDL_PollEvent(&event))
	{
		switch (event.type)
		{
		case SDL_KEYDOWN:
			in->key[event.key.keysym.sym]=1;
			break;
		case SDL_KEYUP:
			in->key[event.key.keysym.sym]=0;
			break;
		case SDL_MOUSEMOTION:
			in->mousex=event.motion.x;
			in->mousey=event.motion.y;
			in->mousexrel=event.motion.xrel;
			in->mouseyrel=event.motion.yrel;
			break;
		case SDL_MOUSEBUTTONDOWN:
			in->mousebuttons[event.button.button-1]=1;
			break;
		case SDL_MOUSEBUTTONUP:
			in->mousebuttons[event.button.button-1]=0;
			break;
		case SDL_QUIT:
			in->quit = 1;
			break;
		default:
			break;
		}
	}
}

c'est plutôt comme ca une palette ?

ou encore celle la avec 3 fonctions ?

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

#define PI2 6.28318531

typedef struct
{
	char key[SDLK_LAST];
    int mousex,mousey;
	int mousexrel,mouseyrel;
	char mousebuttons[6];
    char quit;

} Input;

void UpdateEvents(Input* in);


int main ( int argc, char** argv )
{
    if (SDL_Init(SDL_INIT_VIDEO) == -1)
    {
        fprintf(stderr, "Erreur d'initialisation de la SDL : %s\n", SDL_GetError());
        exit(EXIT_FAILURE);
    }

    Input in;
    memset(&in,0,sizeof(in));

    int temps = 0 , i = 0 , j = 0 , periode = 0 , variable[2] = {0} , sintable [1536] = {0} , fonction[800][600] = {{0}} ;

    for ( i = 0 ; i < 1536 ; i++ )
    {
        if ( i < 256 )
        sintable[i] = ( 255 << 16 ) + ( i << 8 ) ;

        if ( i >= 256 && i < 512 )
        sintable[i] = ( ( 511 - i ) << 16 ) + ( 255 << 8 ) ;

        if ( i >= 512 && i < 768 )
        sintable[i] = ( 255 << 8 ) + ( i - 512 ) ;

        if ( i >= 768 && i < 1024 )
        sintable[i] = ( ( 1023 - i ) << 8 ) + 255 ;

        if ( i >= 1024 && i < 1280 )
        sintable[i] = ( ( i - 1024 ) << 16 ) + 255 ;

        if ( i >= 1280 && i < 1536 )
        sintable[i] = ( 255 << 16 ) + ( 1535 - i ) ;
    }

    for ( i = 0 ; i < 800 ; i++ )
    {
        for ( j = 0 ; j < 600 ; j++ )
        {
            fonction[i][j] = ( 300 * sin( ( sqrt( ( i - 400 ) * ( i - 400 ) + ( j - 300 ) * ( j - 300 ) ) ) / 20 ) + 1000 ) + ( i + j / 2 ) / 2 ;
            fonction[i][j] += 400 * sin( ( sqrt( ( i ) * ( i ) + ( j ) * ( j ) ) ) / 70 ) ;
            fonction[i][j] += 200 * sin( ( sqrt( ( i - 800 ) * ( i - 800 ) + j * j ) ) / 30 ) ;

        }
    }

    SDL_Surface *ecran = NULL ;

    ecran = SDL_SetVideoMode(800, 600, 32, SDL_HWSURFACE | SDL_DOUBLEBUF );
    if (ecran == NULL)
    {
        fprintf(stderr, "erreur pas d'eran charge %s\n", SDL_GetError());
        exit(EXIT_FAILURE);
    }
    SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 0, 0, 0));

    SDL_Rect position ;
        position.x = 0 ;
        position.y = 0 ;
        position.h = 1 ;
        position.w = 1 ;

    temps = SDL_GetTicks();

    while ( !in.quit )
    {
        UpdateEvents(&in);

        if ( temps + 20 < SDL_GetTicks() )
        {
            temps += 20 ;
            periode++ ;

            SDL_Surface *s = SDL_GetVideoSurface();

            for( j = 0; j < 600; j++ )
            {
                Uint8 *offset = ( Uint8 * )s->pixels + j * s->pitch;
                for( i = 0; i < 800; i++ )
                {
                    variable[0] = fonction [i][j] + 5 * periode ;

                    *( Uint32 * )( offset + ( i << 2 ) ) = sintable[ variable[0] % 1536 ];
                }
            }
        }

        SDL_Flip(ecran);
    }

    SDL_Quit();

    return( EXIT_SUCCESS);
}

void UpdateEvents(Input* in)
{
	SDL_Event event;
	while(SDL_PollEvent(&event))
	{
		switch (event.type)
		{
		case SDL_KEYDOWN:
			in->key[event.key.keysym.sym]=1;
			break;
		case SDL_KEYUP:
			in->key[event.key.keysym.sym]=0;
			break;
		case SDL_MOUSEMOTION:
			in->mousex=event.motion.x;
			in->mousey=event.motion.y;
			in->mousexrel=event.motion.xrel;
			in->mouseyrel=event.motion.yrel;
			break;
		case SDL_MOUSEBUTTONDOWN:
			in->mousebuttons[event.button.button-1]=1;
			break;
		case SDL_MOUSEBUTTONUP:
			in->mousebuttons[event.button.button-1]=0;
			break;
		case SDL_QUIT:
			in->quit = 1;
			break;
		default:
			break;
		}
	}
}

--------------------------------------------------------

édit 3 : y a quelqu'un ? :lol:

je tente les fonctions aléatoires :-°

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

#define PI2 6.28318531

typedef struct
{
	char key[SDLK_LAST];
    int mousex,mousey;
	int mousexrel,mouseyrel;
	char mousebuttons[6];
    char quit;

} Input;

void UpdateEvents(Input* in);


int main ( int argc, char** argv )
{
    srand(time(NULL));

    if (SDL_Init(SDL_INIT_VIDEO) == -1)
    {
        fprintf(stderr, "Erreur d'initialisation de la SDL : %s\n", SDL_GetError());
        exit(EXIT_FAILURE);
    }

    Input in;
    memset(&in,0,sizeof(in));

    int temps = 0 , i = 0 , j = 0 , periode = 0 , variable[2] = {0} , sintable [1536] = {0} , fonction[800][600] = {{0}} , rouge = 0 , vert = 0 , bleu = 0 ;

    for ( i = 0 ; i < 1536 ; i++ )
    {
        rouge = 127 * sin ( i * PI2 / 1536 ) + 127 ;
        vert = 127 * sin ( i * PI2 / 1536 + PI2 / 6 ) + 127 ;
        bleu = 127 * sin ( i * PI2 / 1536 + PI2 / 3 ) + 127 ;

        sintable[i] = ( rouge << 16 ) + ( vert << 8 ) + bleu ;
    }

    for ( i = 0 ; i < 800 ; i++ )
    {
        for ( j = 0 ; j < 600 ; j++ )
        {

            if ( i > 0 && j > 0 )
            fonction[i][j] = ( fonction[i-1][j] + fonction[i][j-1] ) / 2 + rand() % 9 - 4 ;
            else if ( i == 0 && j == 0 )
            fonction[i][j] = rand() % 1000 + 1000;
            else if ( i == 0 )
            fonction[i][j] = fonction[i][j-1] + rand() % 9 - 4 ;
            else
            fonction[i][j] = fonction[i-1][j] + rand() % 9 - 4 ;
        }

    }

    for ( i = 0 ; i < 800 ; i++ )
    {
        for ( j = 0 ; j < 600 ; j++ )
        {
            fonction[i][j] += 1000 * sin ( sqrt( (i - 400 ) * ( i - 400 ) + ( j - 300 ) * ( j - 300 ) ) / 100 ) + 1000 - i ;
        }
    }

    SDL_Surface *ecran = NULL ;

    ecran = SDL_SetVideoMode(800, 600, 32, SDL_HWSURFACE | SDL_DOUBLEBUF );
    if (ecran == NULL)
    {
        fprintf(stderr, "erreur pas d'eran charge %s\n", SDL_GetError());
        exit(EXIT_FAILURE);
    }
    SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 0, 0, 0));

    SDL_Rect position ;
        position.x = 0 ;
        position.y = 0 ;
        position.h = 1 ;
        position.w = 1 ;

    temps = SDL_GetTicks();

    while ( !in.quit )
    {
        UpdateEvents(&in);

        if ( temps + 20 < SDL_GetTicks() )
        {
            temps += 20 ;
            periode++ ;

            SDL_Surface *s = SDL_GetVideoSurface();

            for( j = 0; j < 600; j++ )
            {
                Uint8 *offset = ( Uint8 * )s->pixels + j * s->pitch;
                for( i = 0; i < 800; i++ )
                {
                    variable[0] = fonction [i][j] + 5 * periode ;

                    *( Uint32 * )( offset + ( i << 2 ) ) = sintable[ variable[0] % 1536 ];
                }
            }
        }

        SDL_Flip(ecran);
    }

    SDL_Quit();

    return( EXIT_SUCCESS);
}

void UpdateEvents(Input* in)
{
	SDL_Event event;
	while(SDL_PollEvent(&event))
	{
		switch (event.type)
		{
		case SDL_KEYDOWN:
			in->key[event.key.keysym.sym]=1;
			break;
		case SDL_KEYUP:
			in->key[event.key.keysym.sym]=0;
			break;
		case SDL_MOUSEMOTION:
			in->mousex=event.motion.x;
			in->mousey=event.motion.y;
			in->mousexrel=event.motion.xrel;
			in->mouseyrel=event.motion.yrel;
			break;
		case SDL_MOUSEBUTTONDOWN:
			in->mousebuttons[event.button.button-1]=1;
			break;
		case SDL_MOUSEBUTTONUP:
			in->mousebuttons[event.button.button-1]=0;
			break;
		case SDL_QUIT:
			in->quit = 1;
			break;
		default:
			break;
		}
	}
}

je trouve que ca fait effet de papier froicé

"Tout devrait être rendu aussi simple que possible, mais pas plus." A.Einstein

27 août 2010 à 5:44:19

Tu utilises un index de couleurs, ça revient à utiliser une palette, sauf que...

Avec une vraie palette indexée, tu affiches 1 fois, et c'est fini. Ensuite tu te contentes de faire évoluer la palette.

Un exemple simple en HSV

#include <stdlib.h>
#include <stdio.h>

#include <SDL.h>
#include <math.h>

#define TICK_INTERVAL   20

/* Retourne le nombre de millisecondes à attendre avant le prochain frame */
Uint32 time_left(Uint32 nextTime)
{
    Uint32 now = SDL_GetTicks();
    return nextTime <= now ? 0 : nextTime - now;
}


/* Go wikipédia  */
SDL_Color HSVtoRGB(Uint8 hi, Uint8 si, Uint8 vi)
{
    SDL_Color ret;
    double r, g, b, h, s, v;
    h = hi / 256.0;
    s = si / 256.0;
    v = vi / 256.0;

    if(s == 0)
        r = g = b = v;
    else
    {
        double f, p, q, t;
        int i;
        h *= 6;
        i = floor(h);
        f = h - i;
        p = v * (1 - s);
        q = v * (1 - (s * f));
        t = v * (1 - (s * (1 - f)));
        switch(i)
        {
            case 0: r = v; g = t; b = p; break;
            case 1: r = q; g = v; b = p; break;
            case 2: r = p; g = v; b = t; break;
            case 3: r = p; g = q; b = v; break;
            case 4: r = t; g = p; b = v; break;
            case 5: r = v; g = p; b = q; break;
        }
    }

    ret.r = r * 255.0;
    ret.g = g * 255.0;
    ret.b = b * 255.0;
    return ret;
}


/* On affiche une fois pour toute */
void init(void)
{
    int x, y;
    SDL_Surface *s = SDL_GetVideoSurface();
    int yc = s->h / 2;
    int xc = s->w / 2;

    for ( y = 0 ; y < s->h; y++ )
    {
        Uint8 *offset = (Uint8 *)s->pixels + y * s->pitch;
        for ( x = 0 ; x < s->w; x++ )
        {
            offset[x] =   128 + 127.0 * sin(sqrt((x - xc) * (x - xc) + (y - yc) * (y - yc)) / 64.0);
        }
    }
}


/* On fait évoluer notre palette de 256 couleurs */
void setPalette(int p)
{
    SDL_Surface *s = SDL_GetVideoSurface();
    SDL_Color colors[256];
    int i;

    for (i = 0; i < 256; i++)
    {
        /* on fait varier le hue(teinte) */
        colors[i] = HSVtoRGB((i + p) % 256, 255, 255);
    }
    SDL_SetColors(s, colors, 0, 256);
}


int main ( int argc, char** argv )
{
    Uint32 nextTime;
    Uint8 periode;

    SDL_Surface *ecran = NULL ;

    if (SDL_Init(SDL_INIT_VIDEO) == -1)
    {
        fprintf(stderr, "Erreur d'initialisation de la SDL : %s\n", SDL_GetError());
        exit(EXIT_FAILURE);
    }

    ecran = SDL_SetVideoMode(800, 600, 8, SDL_SWSURFACE | SDL_HWPALETTE );
    if (ecran == NULL)
    {
        fprintf(stderr, "erreur pas d'eran charge %s\n", SDL_GetError());
        exit(EXIT_FAILURE);
    }

    init();

    nextTime = SDL_GetTicks() + TICK_INTERVAL;
    periode = 0;
    while ( !SDL_QuitRequested() )
    {
        SDL_PumpEvents();
        
        setPalette(periode);
        
        SDL_Delay(time_left(nextTime));
        nextTime += TICK_INTERVAL;

        /* Même pas obligatoire ici */
        SDL_Flip(ecran);
        periode++;
    }

    SDL_Quit();

    return EXIT_SUCCESS;
}

C'est volontairement simple, pour que tu vois l'essentiel.
A toi d'ajouter des fonctions mathématiques dans init().

Quelques remarques.
Dans tes codes, la gestion d'events, c'est overkill pour ce qu'on fait ici.

Tu moulines dans le vide, en attendant le bon moment pour afficher. Mieux vaut utiliser un SDL_Delay, pour éviter les 100% d'usage CPU.
Les flags SDL_HWSURFACE | SDL_DOUBLEBUF, sont inutiles. Au pire, si vraiment tu arrivais à avoir une surface en mémoire vidéo, tes codes ne fonctionneraient pas, il faudrait locker, accèder aux pixels puis délocker.

J'éspère que ce sera plus clair cette question de palette.

Zeste de Savoir, le site qui en a dans le citron !

27 août 2010 à 18:29:52

il y a un truc que je ne saisit pas ( qui me semble illogique ) comment peut t'on afficher une seule fois et avoir une animation :waw:

de plus c'est quoi :
- SDL_HWPALETTE
- SDL_PumpEvents()
:-°

merci pour ce merveilleux topic mais je pence que le niveau devient un peut trop élevé pour moi
il m'a permis de :
- mieux connaitre les "double" leurs utilisation et leurs utilités
- d'avoir une utilisation concrète de la bibliothèque mathématique
- de connaitre la gestion des pixels

une dernière chose

*( Uint32 * )( offset + ( i << 2 ) ) = sintable[ variable[0] % 1536 ];
// ceci permet de colorer un pixel ...

couleur = *( Uint32 * )( offset + ( i << 2 ) ) ;
// ... mais a t'on le droit d'écrire ceci pour récupérer la couleur d'un pixel ?

je pence que je vais m'arrêter là avec les effet plasma :-°

n!co69

"Tout devrait être rendu aussi simple que possible, mais pas plus." A.Einstein

27 août 2010 à 20:25:12

Citation : n!co69

il y a un truc que je ne saisit pas ( qui me semble illogique ) comment peut t'on afficher une seule fois et avoir une animation

et bien avec une palette indexée(8 bits quoi), chaque pixel de ton écran à une valeur entre 0 et 255.
Cette valeur représente l'index dans un tableau si tu veux. En faisant varier les couleurs correspondant à ces indexs tu obtiens une animation à moindre frais.

Citation : n!co69

une dernière chose

Oui, c'est correct(sauf erreur. :-°). Tu as un setPixel et getPixel 32 bits!

Consulte la doc SDL(ainsi que les exemples), tu devrais trouver pas mal de réponses.

Merci en tout cas, tu as fait des plasmas sympas!

Zeste de Savoir, le site qui en a dans le citron !

28 août 2010 à 16:29:06

Seulement, on n'a toujours pas le rendu que font certains programmes :-°

Peut-être utiliser des types de modifications précalculés (ou pas) et les mettre en place automatiquement (éventuellement aléatoirement). Par exemple, faire une sorte d'explosion à tel endroit.
Le tout est de faire pour que ces modifications fassent vraiment l'effet souhaité.
Je verrais par exemple un post-effet qui, en un point, fasse un cercle de plus en plus grand qui "repousse" les couleurs rencontrées. Après, il faut trouver un moyen simple de le créer. Il faudrait aussi prendre certains coefficients pas forcément évidents à calculer parce que les lignes ne vont pas forcément se trouver sur des pixels entiers.

Sinon, on peut essayer de remplir au début avec des fonctions et faire ensuite une série de modifications comme ça.

28 août 2010 à 22:44:22

Citation : Alinore

Seulement, on n'a toujours pas le rendu que font certains programmes

Effectivement!

Je suis pour l'instant resté sur une technique bien datée. :-°

Après quelques recherches, les pixels shaders, seraient LA méthode à employer pour faire des plasmas "modernes".

J'apprend de mon coté, mais ne te prives surtout pas pour proposer un truc.

Zeste de Savoir, le site qui en a dans le citron !

28 août 2010 à 23:41:30

J'en ai déjà proposé un et c'est ce qui mélange le mieux les couleurs (d'après ce que tu as dit :-°

).
Je vais voir si je ne peux pas essayer la technique à laquelle j'ai pensée mais elle me semble très gourmande.

28 août 2010 à 23:52:09

Citation : Alieniore

J'en ai déjà proposé un et c'est ce qui mélange le mieux les couleurs (d'après ce que tu as dit ).

tout à fait, c'est très réussi. Mais c'est difficilment exploitable.

Ce n'était pas une agression Alienore, je sais ce que tu as proposé, et je t'en remercie.

Seulement je cherche de mon coté, et avec tes idées, et cells d'AstroB, j'ai de quoi faire. :lol:

Zeste de Savoir, le site qui en a dans le citron !

29 août 2010 à 0:01:32

Je ne l'avais pas prise comme une agression. Inclure une fonction de chaleur pourrait peut-être être utile pour la luminosité. Je vais voir ce que je peux tirer des équations. Le problème après, c'est que le plasma peut être à de nombreuses températures. Il faudrait voir pour donner des points critiques.

Sinon, essayer d'utiliser des calculs vectoriels pour un déplacement (en utilisant les shaders par exemple). En effet, le plasma n'est pas solide (puisque ce sont 2 états de la matière différents

)

Yannshu

24 septembre 2010 à 11:16:21

Hello all

J'ai fait quelques essaies sur le sujet, voilà ce que ça donne :

Le code n'a pas grand intérêt, c'est la même chose que tout le monde à peu de choses près, je le posterais si des gens le demande.

Découvrez un petit jeu Android bien sympa : http://www.siteduzero.com/forum/sujet/appli-jeu-android-cube-racer

24 septembre 2010 à 13:53:13

Salut Yannshu!

Alors perso, je pense que tu devrais poster le code, n'oublie que ton prog n'est pas une image fixe, alors c'est difficile d'apprécier le résultat.

Sinon, palette 8 bits, il me semble, avec la sdl?

Très joli, j'aime bien ce coté "vieux plasmas".

Zeste de Savoir, le site qui en a dans le citron !

magma

24 septembre 2010 à 14:17:37

Un exemple également ici: http://www.libsdl.org/projects/plasma/

Yannshu

24 septembre 2010 à 14:55:19

Citation : GurneyH

Alors perso, je pense que tu devrais poster le code, n'oublie que ton prog n'est pas une image fixe, alors c'est difficile d'apprécier le résultat.

Le code est dispo ici : http://vlad.washere.free.fr/src/C/Plasma.zip

Citation : GurneyH

Sinon, palette 8 bits, il me semble, avec la sdl?

Tout à fait ^_^

Citation : GurneyH

Très joli, j'aime bien ce coté "vieux plasmas".

Merci

Découvrez un petit jeu Android bien sympa : http://www.siteduzero.com/forum/sujet/appli-jeu-android-cube-racer