Décoloration progressive en dessinant un rectangle transparent à plusieurs reprises

Question

Il s'agit d'une question à propos de Processing.org.

Je supprime les objets précédemment dessinés en dessinant un rectangle blanc semi-transparent sur la vue pour chaque image.

Cependant, il semble qu'ils ne deviennent jamais complètement blancs. L'évanouissement a un point fixe à une nuance de gris sensiblement non-blanche. La même chose arrive en essayant de passer au noir.

Est-ce une fonctionnalité standard de la façon dont alpha-blending fonctionne dans le traitement? Y at-il un relativement facile autour, pour obtenir un fond complètement blanc (assez d'étapes)?

J'ai imaginé que la couleur résultante serait une combinaison linéaire des couleurs qui sont mélangées, ce qui signifie que la limite devrait être blanche. Peut-être que le point fixe non blanc est un artefact d'arrondi?

Exemple de code illustrant la question:

void setup() { 
    size(300,300); 
    background(0); 
    noStroke(); 
    frameRate(15); 
} 

void draw() { 
    fill(255,10); 
    rect(0,0,width,height); 
    fill(255); 
    rect(0,0,50,50); // for comparison to white 
} 

modifier: ajouté tag java dans l'espoir d'une plus grande attention

Answer 1

Je ne sais pas ce qui se passe, il semble que vous devriez avoir raison et que si le nombre de rectangles dessinés * la valeur alpha de ces rectangles est supérieur à 255, il devrait être complètement blanc. Quoi qu'il en soit, pourquoi ne pas redessiner chaque image (comme je le fais en déplaçant la ligne d'arrière-plan (0) dans la boucle de dessin), puis augmenter simplement votre valeur alpha. Je pense que ce chemin vous donnera plus de contrôle dans vos animations dans le futur.

int a; 

void setup() { 
    size(300,300); 
    noStroke(); 
    frameRate(15); 
    a = 0; 
} 

void draw() { 
    background(0); 
    a += 1; 
    if(a<=255){ 
    fill(255,a); 
    } 
    rect(0,0,width,height); 
    fill(255); 
    rect(0,0,50,50); // for comparison to white 
} 

Answer 2

Je fait beaucoup de creuser et maintenant je suis assez confiant pour dire que la décoloration complète avec le canal alpha n'est pas possible. Il y a cependant une chose appelée luminosité, alors utilisons-la.

void setup() { 
    size(300,300); 
    background(0); 
    noStroke(); 
    frameRate(15); 

    // White rectangle for fading comparison. 
    fill(255); 
    rect(0, 0, 50, 50); 
} 

void draw() { 
    fade(10); 
} 

void fade(final int fadeSpeed) { 
    loadPixels(); 
    for (int row = 0; row < height; row++) { 
    for (int col = 0; col < width; col++) { 
     final int pixelIndex = row * width + col; 
     int pixel = pixels[pixelIndex]; 
     int red = ((pixel >>> 16) & 0xFF) + fadeSpeed; 
     int green = ((pixel >>> 8) & 0xFF) + fadeSpeed; 
     int blue = (pixel   & 0xFF) + fadeSpeed; 
     if (red > 255) { red = 255; } 
     if (green > 255) { green = 255; } 
     if (blue > 255) { blue = 255; } 

     // Shift bits back into propper position and 
     red <<= 16; 
     green <<= 8; 
     pixel &= 0xFF000000; // Keep alpha bits. 
     pixel |= red |= green |= blue; 

     pixels[pixelIndex] = color(pixel); 
    } 
    } 
    updatePixels(); 
} 

En incrémenter les trois canaux de couleur (rouge, vert, bleu) en même temps, nous ne changeons pas la couleur, mais la luminosité.

Answer 3

J'ai découvert que, si l'erreur d'arrondi (si c'est ce qu'il est) applique à peu près tout ce que vous pouvez essayer, en utilisant blendMode(SUBTRACT), suivi d'un remplissage avec une très petite couleur de gris (comme fill(2)) réalise un fondu progressif sur beaucoup de cycles draw() sans l'image "fantôme" que toutes les autres approches semblent avoir, tout en gardant le taux de trame élevé (ce qui est souvent critique dans les situations de dessin en temps réel).

// The only reasonable way to actually "fade" out the pixels. 
blendMode(SUBTRACT); 
fill(2); 
rect(0, 0, width, height); 
blendMode(NORMAL);