Na szybko:

clc
.rept 768
txa
adc src_table+#
bcc skip
  tya
  clc
skip:
sta dst_table+#
.endr

X = value to add
Y = 255
src_table - wiadomo
dst_table - wiadomo

Wychodzi min. 9984 cykli, max 12288, średnio 11136.  Nie pamiętam ile jest dokładnie linii niewidocznych, ale może być na styk w przypadku min.

B. możliwe, że można to jeszcze skrócić przy dod. założeniach.

Flaga C przy LDA nie jest zmieniana, więc PHP/PLP są zbędne. LDA zmienia tylko flagi N oraz Z.

Jeżeli dodajesz stałą wartość do tablicy wejściowej, to można napisać prostszy i szybszy wariant w oparciu o tablicę pośrednią:

.rept 768
ldx src_table+#
lda Add_3,x
sta dst_table+#
.endr

12*768 = 9216 cykli

Tablica Add_3 zawiera wartości indeksu powiększone o stałą z uwzględnieniem saturacji. Można ją wygenerować w następujący sposób.

ldy #0
loop:
tya
clc
adc #3
bcc skip
lda #255
skip
sta Add_3,y
iny
bne loop

Chyba jednak się nie zmieści w przerwaniu VBL, gdyż jest w nim ok. 50 linii jeśli dobrze pamiętam. Tutaj wychodzi nam ~80.

Drobna wskazówka. Jeżeli możesz sobie pozwolić na zmianę zawartości nie co każdą ramkę, ale więcej, to wtenczas problem wydajności znika bowiem podczas normalnego czasu procesora (poza VBL) możesz wygenerować sobie wartości do zapisania w palecie na VBL. Wtedy sam zapis uprości się do formy:

.rept 256
lda #$ff
sta R_palette_registers+#
lda #$ff
sta G_palette_registers+#
lda #$ff
sta B_palette_registers+#
.endr

Argumenty dla powyższych rozkazów lda #$xx w tym wariancie generowane są przez procedurę liczącą wartości pośrednie do fade'a i zapisywane w drodze automodyfikacji. Szybciej się nie da już tego zrealizować.

To będzie 4608 cykli czyli 40 linii, a to powinno już wejść w VBL przed pokazaniem pierwszej linii obrazu.

Jeżeli jest coś takiego jak buforowanie palety/mapy kolorów to nie ma problemu. Wystarczą 2 bufory, a fade co 1 klatkę będzie osiągalny.

Jest też jeszcze inny sposób, trick, który może skutkować drobnymi artefaktami wizualnymi, choć chyba nie jakimiś drastycznymi. Możesz spróbować na zmianę zapisywać po połowie palety w VBL zamiast całości. Które indeksy palety wybierać to już jest sprawa do określenia po eksperymentach. Można zrobić interleaving co bajt (#0 #2, #4... i #1, #3, #5, ...) lub 2 liniowe sekwencje po 128 rejestrów. Co prawda pełne zaktualizowanie palety następować będzie w okresach co 2 ramki, lecz samo odświeżenie części palety co jedną.

tebe: ja moge kodowac jako ze jestem ze sceny 16/32 bit bardziej niz z 8 bit
koderow troche sie znalo, ale wiekszosc pisala w c, a to jest problem
ja pisalem w czystym asmie
a koderow ze sceny pctowej to masz np troche wyzej w tym poscie

to chyba bylo na RH98 jak cos konop zmalowal

no to widzielismy sie na quascie, na gravicie bylem rok pozniej, bo w 98 juz zbraklo kasy na 3cie party w roku

ostatecznie stanelo na takim cusiu:

;--------------------------------------------------------
;Fade_In - fade the palette in one step
Fade_In
    lda    OVLPalette
    sta    Fade_In_pal1
    lda    DSTPalette
    sta    Fade_In_pal2
    sta    Fade_In_pal3
    sta    Fade_In_pal4
    lda    OVLPalette+1
    sta    Fade_In_pal1+1
    lda    DSTPalette+1
    sta    Fade_In_pal2+1
    sta    Fade_In_pal3+1
    sta    Fade_In_pal4+1
    
    ldy    #3
Fade_In_l1
    ldx    #0
Fade_In_l2
    lda    0x55AA,x    ; orginal palette
Fade_In_pal1    equ *-2
    inc    0xAA55,x    ; destination, self modyfying code
Fade_In_pal2    equ *-2
    sec
    cmp    0xAA55,x
Fade_In_pal3    equ *-2
    bcs    Fade_In_Skip
    sta    0xAA55,x
Fade_In_pal4    equ *-2
Fade_In_Skip
    dex
    bne    Fade_In_l2
    inc    Fade_In_pal1+1
    inc    Fade_In_pal2+1
    inc    Fade_In_pal3+1
    inc    Fade_In_pal4+1
    dey
    bne    Fade_In_l1
    rts
;--------------------------------------------------------
;Fade_Out - fade the palette out one step
Fade_Out
    lda    DSTPalette
    sta    Fade_Out_pal1
    sta    Fade_Out_pal2
    sta    Fade_Out_pal3
    lda    DSTPalette+1
    sta    Fade_Out_pal1+1
    sta    Fade_Out_pal2+1
    sta    Fade_Out_pal3+1
    lda    #255
    ldy    #3
Fade_Out_l1
    ldx    #0
Fade_Out_l2
    dec    0xAA55,x    ; destination, self modyfying code
Fade_Out_pal1    equ *-2
    cmp    0xAA55,x
Fade_Out_pal2    equ *-2
    bne    Fade_Out_Skip
    lda    #0
    sta    0xAA55,x
Fade_Out_pal3    equ *-2
    lda    #255
Fade_Out_Skip
    dex
    bne    Fade_Out_l2
    inc    Fade_Out_pal1+1
    inc    Fade_Out_pal2+1
    inc    Fade_Out_pal3+1
    dey
    bne    Fade_Out_l1
    rts

fade_out - jakies 2 ramki
fade_in - 3

podziekowal

po reorganizacji danych dla palety, troche sie uproscilo...

;--------------------------------------------------------
; VBXE_SetPalette - sets overlay (1) palette
VBXE_SetPalette
    lda    OVLPalette
    sta    VBXE_SetPalette_pal1
    sta    VBXE_SetPalette_pal2
    sta    VBXE_SetPalette_pal3
    ldx    OVLPalette+1
    stx    VBXE_SetPalette_pal1+1
    inx
    stx    VBXE_SetPalette_pal2+1
    inx
    stx    VBXE_SetPalette_pal3+1
    ldx    #0
VBXE_SetPalette_l1
    stx    VBXE_MB0
    lda    0xAA55,y
VBXE_SetPalette_pal1    equ *-2
    sta    VBXE_MB1
    lda    0xAA55,y
VBXE_SetPalette_pal2    equ *-2
    sta    VBXE_MB2
    lda    0xAA55,y
VBXE_SetPalette_pal3    equ *-2
    sta    VBXE_MB3
    lda    #0xc1
    sta    VBXE_MSEL
    dex
    bne    VBXE_SetPalette_l1
    rts

organoleptycznie nie ma to jednak wiekszego znaczenia
nawet jak chodzi w 3 ramkach na zmiane to wciaz nie ma tragedii
aczkolwiek nieco to dolujace ze tak prosta operacja sprawia tyle problemow

pod wieczor bedzie pewnie jakis "slideshow" (duze slowo...)

pare platfofrm znam, ale ze sprzetowa implementacja sie nie spotkalem...

Każdy kolor z palety powinien być stały w obrębie całej wyświetlanej klatki obrazu. Nie możemy założyć, że w sekwencji kolejnych liń będą znajdowały się wyłącznie kolory z wąskiego zakresu palety, dla których takie podejście miałoby jakiś sens. Każdy kolor z palety może znajdować się w dowolnym miejscu obrazu.