6 niveaux de gris en C ? - Page 2

Ah merci, je croyais qu'un 'x' ou un '*' apparaîtrait si j'utilisais *.

Sasume (./31) :
Ah merci, je croyais qu'un 'x' ou un '*' apparaîtrait si j'utilisais *.

Pour avoir le « x », il faut utiliser « × » et pour « * », c'est « \* ».
J'ai choisi le point (ċ) pour la multiplication, comme sur TI.

Sasume (./29) :
Selon la façon dont on "applique" le sprite, on peut obtenir une transparence sur une couleur (par contre, pour un masque, il faut au moins un bit (qui ne serve qu'à ça) par pixel).

Par exemple, avec 4 niveaux de gris : on a 4 couleurs, exprimées sur 2 bits : 00, 01, 10 et 11.
Je veux que la couleur 01 (gris clair) soit transparente (car sur TI le gris clair est quasiment blanc...).
Nommons les bits définissant la couleur d'un pixel du sprite s0 et s1, ceux correspondant à la couleur d'un pixel de l'arrière-plan b0 et b1 et ceux correspondant au résultat du dessin du sprite r0 et r1).
Le tableau de Karnaugh suivant nous indique quelle couleur doit résulter du dessin d'un pixel du sprite sur un pixel de l'arrière-plan (sur la première ligne, on a les configurations possibles pour s1 et s0 représentant le sprite, et sur la première colonne, la même chose avec b1 b0, et à l'intérieur le résultat de l'affichage du sprite r1 et r0) :

    | 00 | 01 | 11 | 10
----+----+----+----+----
 00 | 00 | 00 | 11 | 10
----+----+----+----+----
 01 | 00 | 01 | 11 | 10
----+----+----+----+----
 11 | 00 | 11 | 11 | 10
----+----+----+----+----
 10 | 00 | 10 | 11 | 10

On note bien que la deuxième colonne correspond à la couleur transparente, c'est pour cela que dans cette colonne rn = bn. Dans les autres cas, c'est la couleur du sprite qui est recopiée, donc rn = sn.
Cela nous conduit à deux équations :

En pseudo-asm (spécialement pour toi ), ça donnerait :

  move s1,r0 ; r0 = s1
  or   b0,r0 ; r0 = b0 + s1
  and  s0,r0 ; r0 = s0 . (b0 + s1)

  move b1,r1 ; r1 = b1
  and  s0,r1 ; r1 = b1 . s0
  or   s1,r1 ; r1 = s1 + b1 . s0

Tout ça m'a l'air affreusement compliqué : pourquoi ne pas dire tout simplement que le sprite a un masque qui, au lieu d'être stocké explicitement dans un plan séparé, est calculé en live ?
Dans ce cas là pour chaque pixel masque[pixel] = (valeur[pixel] == 4) = (plan2[pixel] && !plan1[pixel] && !plan0[pixel]), donc il suffit de poser masque = plan2&~plan1&~plan0 ^^

Oui, ce que tu dis est tout à fait pertinent. Et bien plus adapté à une explication pédagogique.
Cependant, avec ta solution (en reprenant une analogie sur 2 plans) tu as déjà 2 opérations pour calculer le masque, puis 2 opérations pour l'appliquer, puis 2 opérations pour afficher le sprite (total = 6).
Avec ce que j'indique on s'en sort avec 4 opérations. C'était juste pour ce gain que j'ai compliqué le bazar

euh si tu comptes les move comme des opérations tu fais aussi 6 opérations ^^ mais c'est vrai qu'avec une couleur transparente != blanc ou noir il y a un not dans ma solution, donc ça fait 7 opérations...

enfin on peut se débarrasser facilement du not : si par exemple on veut que 01 soit transparente, on inverse le bit de poids fort dans tout le sprite, et du coup :

move b0,bm
and b1,bm

or bm,s0
eor b0,s0
or bm,s1
and b1,s1

mais évidemment en 32 bits un move est plus rapide qu'un and, donc ta solution est effectivement plus rapide (par contre je pense pas que ça reste efficace en 7-8 niveaux de gris, non ?)