Chers amis bonsoir ! Préparez vous au pire, car nous allons passer du coté obscur du codage : nous allons pratiquer le plus classique des langages de vieux : le C. Un langage fourbe et pervers. Rassurez vous, les amateurs de FORTRAN auront un jour aussi leur chance de clignoter.
Je vous préviens d'entrée, si vous n'avez pas quelques notions de programmation en C, ce n'est paut-être pas la peine de continuer, mais bon, comme vous avez déja appris à faire du Bash, vous pouvez essayer de rester parmi nous :)
Pour manipuler les images en C, j'utilise un vieux kluge dont les premiers pas remontent à la fin des années 80. Il vous faudra donc l'installer à la hache, désolé ;)
Donc nous allons dire que la libimage de tTh est correctement installée, et que nous pouvons rentrer dans le vif du sujet. Le principe de cette animation est simple : sur une image de fond générée, nous allons poser une seconde image (que vous pourrez vous-même dessiner à la main avec le logiciel de votre choix), et c'est les pixels de cette image que nous allons faire danser !
Tout d'abord un peu de plomberie, quelques fonctions utilitaires (mais pas que) pour décomposer le problème en briques simples. Mais le problème n'est pas si simple que ça, en fait...
#include <stdio.h>
#include <stdlib.h>
#include <tthimage.h>
#define LARGEUR 640
#define HAUTEUR 480
#define NBR_FRAMES 50
/* ------------- pixeldance ------------------------------------- */
void preparation(void)
{
Image_load_fnt8x8("libimage.fonte", NULL, 0);
}
/* ------------- pixeldance ------------------------------------- */
int faire_le_fond(Image_Desc *img, int frame)
{
Image_mircol_3(img, "Pixels Dance", 0);
Image_col4bits_and(img, img);
return 0;
}
/* ------------- pixeldance ------------------------------------- */
int poke_a_pixel(Image_Desc *img, int x, int y, int r, int g, int b)
{
int i, j;
if (x<1 || y<1 || x>img->width-2 || y>img->height-2)
return -1;
for (i=-1; i<2; i++) {
for (j=-1; j<2; j++) {
Image_plotRGB(img, x+i, y+j, r, g, b);
}
}
return 0;
}
Hop, explications :
C'est pas trop compliqué : on charge une image, on la nettoie (ou on la brotche, c'est comme on veut) un peu, puis on la parcourt séquentiellement pour construire un tableau de descripteurs de pixel.
/* --------/* ------------- pixeldance ------------------------------------- */
typedef struct {
int r, g, b;
double x, y;
} Un_Pixel;
Un_Pixel *Les_Pixels;
----- pixeldance ------------------------------------- */
int charge_les_pixels(char *fname)
{
Image_Desc *picz;
int x, y, r, g, b;
int nbre_pixels, idx;
if (NULL==(picz=Image_TGA_alloc_load(fname))) {
perror(fname);
exit(1);
}
Image_col4bits_and(picz, picz);
nbre_pixels = picz->width * picz->height;
printf("nous avons %d pixels\n", nbre_pixels);
Les_Pixels = calloc(nbre_pixels, sizeof(Un_Pixel));
idx = 0;
for (y=0; y<picz->height; y++) {
for (x=0; x<picz->width; x++) {
Image_getRGB(picz, x, y, &r, &g, &b);
Les_Pixels[idx].r = r;
Les_Pixels[idx].g = g;
Les_Pixels[idx].b = b;
Les_Pixels[idx].x = (double)x;
Les_Pixels[idx].y = (double)y;
/* hop, next pixel */
idx++;
}
}
return idx;
}
/* ------------- pixeldance ------------------------------------- */
Bon, honnètement, j'ai un peu la flemme d'écrire les explications, d'autant plus que le code actuel est assez goret, et qu'il y a des trucs à passer à la poudre verte. Donc, pour patienter, voici le genre de truc auquel j'arrive en ce moment :