Afficher un dégradé de couleurs.

Dégradé de couleurs animé.

Voir version :

Pas de dépendances

Télécharger :

#include <sdl/sdl.h>

#ifdef WIN32
#pragma comment(lib,"sdl.lib")
#pragma comment(lib,"sdlmain.lib")
#endif

void UpdateEvents(Sint32* mousex,Sint32* mousey,char boutons[8],char key[SDLK_LAST])
{
    SDL_Event event;
    while(SDL_PollEvent(&event))
    {
        switch (event.type)
        {
        case SDL_KEYDOWN:
            key[event.key.keysym.sym]=1;
            break;
        case SDL_KEYUP:
            key[event.key.keysym.sym]=0;
            break;
        case SDL_MOUSEMOTION:
            *mousex=event.motion.x;
            *mousey=event.motion.y;
            break;
        case SDL_MOUSEBUTTONDOWN:
            boutons[event.button.button]=1;
            break;
        case SDL_MOUSEBUTTONUP:
            boutons[event.button.button]=0;
            break;
        }
    }
}

void SDL_PutPixel32(SDL_Surface *surface, int x, int y, Uint32 pixel)
{
    Uint8 *p = (Uint8*)surface->pixels + y * surface->pitch + x * 4;
    *(Uint32*)p = pixel;
}

Uint32 SDL_GetPixel32(SDL_Surface *surface, int x, int y)
{
    Uint8 *p = (Uint8*)surface->pixels + y * surface->pitch + x * 4;
    return *(Uint32*)p;
}

int main(int argc,char** argv)
{
    Sint32 mousex = 0;
    Sint32 mousey = 0;
    char boutons[8] = {0};
    char key[SDLK_LAST] = {0};
    SDL_Surface* screen;
    int i,j;
    unsigned char currentblue = 0;
    SDL_Init(SDL_INIT_VIDEO);
    screen=SDL_SetVideoMode(256,256,32,SDL_SWSURFACE|SDL_DOUBLEBUF);  
    SDL_ShowCursor(1);
    while(!key[SDLK_ESCAPE])
    {
        UpdateEvents(&mousex,&mousey,boutons,key);
        if (SDL_MUSTLOCK(screen))
            SDL_LockSurface(screen);
        for(i=0;i<256;i++)
            for(j=0;j<256;j++)
            {
                SDL_PutPixel32(screen,i,j,SDL_MapRGBA(screen->format,i,j,currentblue,0));
            }
        currentblue++;
        if (SDL_MUSTLOCK(screen))
            SDL_UnlockSurface(screen);        
        SDL_Flip(screen);
    }
    return 0;
}




Commentaires


  Un peu de couleurs ?

  A partir de maintenant, nous travaillons en 32 bits.
  La palette est constituée de :

  - 1 octet pour rouge
  - 1 octet pour vert
  - 1 octet pour bleu
  - 1 octet pour le canal alpha

  Bien que nous n'utiliserons pas ici le canal alpha, je prefere manipuler du 32 bits, car 32 bits, c'est mieux que 24 bits
  (c'est l'agument qui tue). Plus sérieusement, meme si ça consomme plus de place pour une image, l'alignement mémoire sous 4 octets
  est plus simple et plus optimal que sous 3 octets (24 bits), et que les cartes graphiques sont optimisées pour le 32 bits maintenant.

  Pour chaque composante, on remplit donc un octet : une valeur entre 0 et 255.
  A partir de la, vous faites toutes les couleurs.

  Chaque couleur fait donc 4 octets, donc un long.

  Dans ce long, nous avons un octet pour le Rouge, un octet pour le Vert, un octet pour le Bleu, un octet pour l'Alpha

  Selon le format interne de SDL, les données peuvent être rangées en RGBA (comprenez le premier octet rouge, le deuxieme vert, etc...) en BGRA, 
  voir d'autres configurations.

  La fonction SDL SDL_MapRGBA range correctement les composantes R, G, B, A que nous lui passons, selon le format interne de la surface dans laquelle on travaille.

  Le programme est simple : j'ai défini un écran de 256 * 256
  Pour chaque pixel i,j, je mets rouge  = i, vert = j, ce qui nous fait un beau dégradé.

  vous devez avoir du noir en haut a gauche, du vert en bas gauche, du rouge en haut a droite et du jaune en bas a droite.

  Pour faire intervenir le bleu, a chaque frame, je monte la valeur de tous les pixels d'un cran de bleu, ce qui fait "l'animation"

  Vous allez me dire "mais comment ça se fait que ça fasse une boucle alors que tu fais +1 a chaque fois : tu ne reviens jamais a ton point de départ !"
  Et bien si, car en unsigned char, 255 + 1 = 0.  et c'est reparti !!
  


Laissez un commentaire / post a comment