Robilem podejscie do efektu plasmy i o ile udalo mi sie uzyskac statyczny (bez animacji od funkcji czasu) efekt "plasmopodobny" to zorientowalem sie ze sama moja procedura rysowania punktow na ekranie jest bardzo niewydajna.
Jakie byly moje zalozenia:
- uzylem trybu z 16 odcieniami jednego koloru
- sinus etc mam ztablicowane
- mam wskaznik 16bitowy na aktualnie przetwarzany bajt pamieci ekranu
- zwiekszam kolejno wskaznik i dla odpowieniego X,Y obliczam sobie odcien i aktualizuje pamiec
Tak jak napisalem statyczny obraz mam cool, ale proba animowania tego konczy sie starsznym mruganiem ekranu w roznych jego czesciach. Wyrzucilem wiec dla testow samo obliczanie odcienia (zmieniam 2 kolory naprzemiennie) by przetestowac predkosc samego rysowania. No i dla 80pixeli w 80 liniach obraz strasznie mruga (no ale nie caly obraz na raz, tylko w srodku w rozsynchronizowany sposob). Moje pierwsze podejrzenie padlo na to ze w srodku rysowania sceny (pelne 80linii jednym z dwu naprzemiennie zmienianych kolorow) konczy sie ramka i musze to jakos synchronizowac.
Dla testow dodalem tez w ostatniej linii przewanie DLI z petla nieskonczona by sprawdzic ile jestem w stanie wyrenderwac w jednej ramce - no i okazuje sie to jest na oko nie wiecej niz kilkanascie linii obrazu w tej rozdzielczosci.
No i zastanawiam sie co moge zrobicby usyskac plynnosc.
- czy macie pomysl jak samo rysowanie takiej ilosci pixeli zrobic duzo wydajniej?
- jak zadbac o plynnosc gdy procedura rysowania nie miesci sie w jedej ramce? tzn niech zmiany "animacyjne" beda wolniejsze ale obraz nie mrugal etc
Wrzucam moj przykladowy kod testowy:
      org $8000   
      lda #0
      sta 559
    
      ldx <antic     
      ldy >antic     
      stx 560        
      sty 561   
      
      ;gtia
      lda #%01000000
      sta 623
 
      lda <dli
      sta $200
      lda >dli
      sta $201
      
      ; dli config
      lda #$c0      
      ; ODKOMENTUJ BY SPRAWDZIC ILE WYRYSUJEMY W JEDNEJ RAMCE      
      ;sta $d40e 
  
      ;antic
      lda #%00100010
      sta 559      
; poczatek pamieci ekranu      
GFX_MEM=$9000
; adres gdzie trzymam 16bit pointer na aktualnie rysowany punkt ekranu
GFX_PTR=$32
; pozycje X,Y uzywane docelowo do obliczenia koloru etc
POS_X=$8000 ; pozycja x
POS_Y=$8001 ; pozycja y
COLOR=$8002 ; odcien 2 pixeli (4bit+4bit)
      
init 
      ; powiedzmy ze najpierw rysujemy na bialo
      lda #%11111111
      sta COLOR
rysObrazuLoop
      ; ustawiamy pointer na poczatek pamieci obrazu
      ldx <GFX_MEM     
      ldy >GFX_MEM     
      stx GFX_PTR        
      sty GFX_PTR+1
      ; zerujemy zapamietane pozycje x/y
      ldy #0
      ldx #0
      stx POS_X
      stx POS_Y
  
      ;czekamy na ramke
      lda 20   
      cmp 20
      beq *-2 
  
rysPixeliLoop  
     lda COLOR
     ; y=0 - po prostu 16bit pointer, ktory jest przesuwany, i tylko dlatego ten tryb aderesowania
     ; trace na tym pewnie 1 czy 2 cykli, ale to chyba nie powinno byc kluczowe
     sta (GFX_PTR),y
         
     ; przesuwamy pointer na aktualnie wypelniany bajt pamieci obrazu
     lda GFX_PTR
     clc
     adc #1
     sta GFX_PTR     
     bcc noCC
     ; jesli mniej znaczacy bajt sie "przekrecil" to zmiekszamy bardziej znaczacy
     lda GFX_PTR+1
     clc
     adc #1
     sta GFX_PTR+1
noCC
     ; aktualizyjemy zapisana pozycje X (2 razy bo aktualizujemy 2 pixele na raz)
     ldx POS_X
     inx
     inx
     stx POS_X
     
     ; 80 pkt w linii
     cpx #80
     bcc rysPixeliLoop
     
     ; to byl koniec linii wiec zerujemy pozycje X
     ldx #0
     stx POS_X
     
     ;ilosc linii
     ldx POS_Y
     inx
     stx POS_Y     
     cpx #80
     bcc rysPixeliLoop     
     
     ; ostatnia linia czyli zmieniamy kolor obu pixeli w bajcie
     ; odcien zmieniamy naprzemiennie by bylo widac, jak wolno generuje sie obraz
     lda COLOR
     cmp #%00110011
     beq cl1
     lda #%00110011
     jmp stCl
cl1     lda #%11111111
stCl sta COLOR
     ; rysujemy od nowa z nowym kolorem
     jmp rysObrazuLoop     
    
; DLI IMPL - inf loop aby zobaczyc ile jestem w stanie narysowac w jednej ramce
dli    
        jmp dli
    
antic dta b($70,$70,$70)
      dta b($00),b($4f),a($9000),b($f,$f,$f,$f,$f,$f,$f,$f,$f)
      dta b($f,$f,$f,$f,$f,$f,$f,$f,$f,$f)
      dta b($f,$f,$f,$f,$f,$f,$f,$f,$f,$f)
      dta b($f,$f,$f,$f,$f,$f,$f,$f,$f,$f)
      dta b($f,$f,$f,$f,$f,$f,$f,$f,$f,$f)
      
      dta b($f,$f,$f,$f,$f,$f,$f,$f,$f,$f)
      dta b($f,$f,$f,$f,$f,$f,$f,$f,$f,$f)    
      dta b($f,$f,$f,$f,$f,$f,$f,$f,$f,$f) 
      dta b($f,$f,$f,$f,$f,$f,$f,$f,$f,$f+$80)     
      
      dta b($41),a(antic)  
Macie jakies hint'y ??? W sumie to interesuja mnie 2 problemy niezaleznie czyli kwestia szybkiego rysowania i synchornizacji i niemrugania podczas rysowania czegos co zajmuje kilka ramek. Oraz druga sprawa dotyczaca samej plazmy czy taki sposob ma szanse powodzenia czy zabieram sie za to od .... strony;)