Sfuma nei giochi più vecchi. Ho bisogno di aiuto per capire come è stato derivato l'algoritmo

Scusa, questa domanda è un po 'esoterica, ma non riesco proprio a togliermela dalla testa!

Sto guardando l'algoritmo di dissolvenza utilizzato nel gioco arcade DoDonPachi (così come molti altri giochi più vecchi):

Ho scritto uno script Python per selezionare alcuni pixel e seguirli per la durata della dissolvenza. Ecco un campione rappresentativo dei risultati. La prima riga di ciascun gruppo è il valore del colore iniziale, mentre ogni riga successiva è la differenza tra il valore del colore del fotogramma corrente e il valore del colore del fotogramma precedente.

Starting Value: (132, 66, 189)
Frame 1:    [9, 9, 8]
Frame 2:    [8, 8, 8]
Frame 3:    [8, 8, 8]
Frame 4:    [8, 8, 9]
Frame 5:    [9, 9, 8]
Frame 6:    [8, 8, 8]
Frame 7:    [8, 8, 8]
Frame 8:    [8, 8, 9]
Frame 9:    [9, 0, 8]
Frame 10:   [8, 0, 8]
Frame 11:   [8, 0, 8]
Frame 12:   [8, 0, 9]
Frame 13:   [9, 0, 8]
Frame 14:   [8, 0, 8]
Frame 15:   [8, 0, 8]
Frame 16:   [8, 0, 9]
Frame 17:   [0, 0, 8]
Frame 18:   [0, 0, 8]
Frame 19:   [0, 0, 8]
Frame 20:   [0, 0, 9]
Frame 21:   [0, 0, 8]
Frame 22:   [0, 0, 8]
Frame 23:   [0, 0, 8]
Frame 24:   [0, 0, 0]
Frame 25:   [0, 0, 0]
Frame 26:   [0, 0, 0]
Frame 27:   [0, 0, 0]
Frame 28:   [0, 0, 0]
Frame 29:   [0, 0, 0]

Starting Value: (132, 0, 0)
Frame 1:    [9, 0, 0]
Frame 2:    [8, 0, 0]
Frame 3:    [8, 0, 0]
Frame 4:    [8, 0, 0]
Frame 5:    [9, 0, 0]
Frame 6:    [8, 0, 0]
Frame 7:    [8, 0, 0]
Frame 8:    [8, 0, 0]
Frame 9:    [9, 0, 0]
Frame 10:   [8, 0, 0]
Frame 11:   [8, 0, 0]
Frame 12:   [8, 0, 0]
Frame 13:   [9, 0, 0]
Frame 14:   [8, 0, 0]
Frame 15:   [8, 0, 0]
Frame 16:   [8, 0, 0]
Frame 17:   [0, 0, 0]
Frame 18:   [0, 0, 0]
Frame 19:   [0, 0, 0]
Frame 20:   [0, 0, 0]
Frame 21:   [0, 0, 0]
Frame 22:   [0, 0, 0]
Frame 23:   [0, 0, 0]
Frame 24:   [0, 0, 0]
Frame 25:   [0, 0, 0]
Frame 26:   [0, 0, 0]
Frame 27:   [0, 0, 0]
Frame 28:   [0, 0, 0]
Frame 29:   [0, 0, 0]

Starting Value: (165, 156, 222)
Frame 1:    [9, 8, 8]
Frame 2:    [8, 8, 8]
Frame 3:    [8, 8, 8]
Frame 4:    [8, 9, 9]
Frame 5:    [9, 8, 8]
Frame 6:    [8, 8, 8]
Frame 7:    [8, 8, 8]
Frame 8:    [8, 9, 9]
Frame 9:    [9, 8, 8]
Frame 10:   [8, 8, 8]
Frame 11:   [8, 8, 8]
Frame 12:   [8, 9, 9]
Frame 13:   [9, 8, 8]
Frame 14:   [8, 8, 8]
Frame 15:   [8, 8, 8]
Frame 16:   [8, 9, 9]
Frame 17:   [9, 8, 8]
Frame 18:   [8, 8, 8]
Frame 19:   [8, 8, 8]
Frame 20:   [8, 0, 9]
Frame 21:   [0, 0, 8]
Frame 22:   [0, 0, 8]
Frame 23:   [0, 0, 8]
Frame 24:   [0, 0, 9]
Frame 25:   [0, 0, 8]
Frame 26:   [0, 0, 8]
Frame 27:   [0, 0, 8]
Frame 28:   [0, 0, 0]
Frame 29:   [0, 0, 0]

Starting Value: (156, 90, 206)
Frame 1:    [8, 8, 8]
Frame 2:    [8, 8, 9]
Frame 3:    [8, 8, 8]
Frame 4:    [9, 9, 8]
Frame 5:    [8, 8, 8]
Frame 6:    [8, 8, 9]
Frame 7:    [8, 8, 8]
Frame 8:    [9, 9, 8]
Frame 9:    [8, 8, 8]
Frame 10:   [8, 8, 9]
Frame 11:   [8, 8, 8]
Frame 12:   [9, 0, 8]
Frame 13:   [8, 0, 8]
Frame 14:   [8, 0, 9]
Frame 15:   [8, 0, 8]
Frame 16:   [9, 0, 8]
Frame 17:   [8, 0, 8]
Frame 18:   [8, 0, 9]
Frame 19:   [8, 0, 8]
Frame 20:   [0, 0, 8]
Frame 21:   [0, 0, 8]
Frame 22:   [0, 0, 9]
Frame 23:   [0, 0, 8]
Frame 24:   [0, 0, 8]
Frame 25:   [0, 0, 8]
Frame 26:   [0, 0, 0]
Frame 27:   [0, 0, 0]
Frame 28:   [0, 0, 0]
Frame 29:   [0, 0, 0]

Come puoi vedere, un 8 o un 9 viene sottratto da ciascun componente di colore in ogni fotogramma. Inoltre, un 9 appare sempre tre fotogrammi dopo un 8, anche se il valore sottratto iniziale è diverso per ciascun componente di colore. Si noti inoltre che ogni componente di colore raggiunge 0 (cioè nero) con una differenza di 8 o 9, non di un resto arbitrario. Ciò significa che il ciclo del valore sottratto di 8,8,8,9 non viene mai interrotto! (Questo algoritmo è stato probabilmente scritto per garantire che l'ultimo fotogramma della dissolvenza fosse uniforme come gli altri.)

Ora, questo mi confonde. Secondo i miei calcoli, se si inverte il processo, ovvero si prende il ciclo 8,8,8,9 e si somma per trovare tutte le possibili combinazioni in 29 frame, si ottengono solo 52 numeri univoci. Ma, come accade, ogni componente del colore è un membro di questo set! Ciò significa che o i colori sono stati scelti appositamente per questo algoritmo di dissolvenza (improbabile) o che l'algoritmo di dissolvenza è stato progettato attorno alla tavolozza dei colori del gioco. Ma come mai qualcuno avrebbe potuto capire che se prendi 8,8,8,9, sposti il ​​ciclo in modo appropriato e continui a sottrarre i numeri da ogni componente di colore nella tua tavolozza, alla fine raggiungerai 0 per ogni singolo colore? ! Dev'esserci qualche trucco matematico che mi manca. Che cos'è?

In realtà, c'è una semplice logica dietro il modello 8-8-8-9. Si presenta naturalmente se si utilizzano solo 32 livelli di intensità (5 bit per componente), ma si desidera renderlo su un display a 8 bit per componente.

Considera se hai un livello di intensità di 5 bit e vuoi estenderlo a 8 bit. La cosa più semplice da fare sarebbe semplicemente spostare a sinistra e lasciare zero i tre bit bassi. Il problema è che non si spinge fino al bianco puro. Il livello di intensità più alto che puoi raggiungere è 11111000, o 248. Quindi non stai utilizzando l'intera gamma di intensità del display a 8 bit.

In realtà, quello che vorresti fare è un calcolo simile intensity8 = round(intensity5 * 255.0 / 31.0), per ridimensionare l'intervallo [0, 31] su [0, 255]. Tuttavia, c'è un trucco per farlo senza alcuna matematica in virgola mobile o divisioni: impostare i tre bit bassi uguali ai tre bit alti. Cioè, per convertire l'intensità da 5 bit a 8 bit, lo faresti

intensity8 = (intensity5 << 3) | (intensity5 >> 2);

Quindi un'intensità di 11111 verrà mappata su 11111111 (31 mappe su 255) e anche i risultati intermedi faranno qualcosa di sano, ad esempio 10000 -> 10000100 (16 -> 132).

Questo set di numeri è esattamente quello che hai. Prendendo il componente rosso del tuo primo esempio, hai:

132    10000100
123    01111011
115    01110011
107    01101011
 99    01100011
 90    01011010
 82    01010010
 74    01001010

Nota come i tre bit bassi sono sempre uguali ai primi tre bit. La differenza di 9 si verifica quando entrambi i bit 0 e 3 si capovolgono contemporaneamente.

Non sono sicuro del motivo per cui livelli di intensità a 5 bit sarebbero stati utilizzati in questa situazione; forse quello era il limite dell'hardware della macchina arcade? È da notare che un valore RGB a 5 bit è 15 bit, che si adatta perfettamente a una parola a 16 bit. In ogni caso, ciò spiega lo strano modello 8-8-8-9.

Dovresti guardare in modalità 13h o dissolvenza della tavolozza di 256 colori. Allora, avevi così tanti colori e quello che hai fatto è stato fare casino con l'intera tavolozza, dal momento che non era possibile calcolare nuovi colori che non c'erano.