Nie bardzo mam czas dokładnie to analizować, ale zszokował mnie sposób mnożenia liczby przez 256, poprzez 8-krotne asl+ror... Jeśli już, to asl+rol. A poza tym, nie łatwiej przepisać bajtów całych? :)
Podobnie z dzieleniem przez 512...
To tak na pierwszy rzut, jak znajdę chwilę to poczytam więcej.

[ Dodano: Sob Sty 22, 2005 8:45 pm ]
Ojej. I czemu chcesz używać 360 stopni? Używaj 256, to znacząco ułatwia życie :)

[ Dodano: Sob Sty 22, 2005 8:53 pm ]
Poza tym, w Rotate na oko w X i Y wstawiasz to samo, zupełnie bez sensu, nic nie kumam już. Czemu indeksujesz (sinus)? Spróbuj tak (skoro juz musisz tak podchodzic do tematu):

  lda katx
  asl @
  tax 
  lda katx+1
  rol @
  tay
  lda sinus,x
  sta _sinx
  lda sinus+1,y
  sta _siny+1

Ogólnie, nie podoba mi się ten kod, zacznij uczyć się może assemblera od czegoś prostszego, poważnie :)

hmm...
mnozenie przez 256 mozna latwiej i o wiele szybciej zrobic tak: powiedzmy ,ze chcesz pomnozyc liczbe 16bitowa przez 256 (wynik 24bit)

lda liczba
sta wynik+1
lda liczba+1
sta wynik+2
lda #$00
sta wynik

dzielenie liczby 16bitowej (ze znakiem) przez 512 mozna zrobic szybciej po przez pominiecie najmlodszego bajtu (czyli podzielenie przez 256) oraz podzielenie tego przez 2 (256*2=512):

    lda liczba+1 ; starszy bajt liczby do podzielenia
    bmi _ujemna
    lsr @
    sta wynik ; wynik 8bitowy
    jmp _dalej

_ujemna    eor #$ff
    clc
    adc #$01
    lsr @
    eor #$ff
    clc
    adc #$01
    sta wynik

_dalej    ...

jesli chodzi o szybkosc to dzielic przez 512 mozna tak :)

    ldx liczba+1
    lda div512tb,x

wystarczy miec teraz talibce 256 bajtowa, ktora tworzysz tak:

gendvtb    ldx #$00
    txa
    bpl _neg
    lsr @
    sta div512tb,x
    jmp _gendv
_neg    eor #$ff
    clc
    adc #$01
    lsr @
    eor #$ff
    clc
    adc #$01
    sta div512tb,x
_gendv    inx
    bne gendvtb+2

i masz dzielenie przez 512 liczby 16bitowej w 7-9cykli ;)

co do mnozenia liczby 8bitowej przez 8bitowa to jest bardzo dobry przyklad tutaj: http://www.6502.org/source/integers/fastmult.htm

korzysta on z zaleznosci, ze: a*b=f(a+b)-f(a-b), f(x)=x*x/4
chyba najlepszy i najszybszy sposob na mnozenie (pomijajac pamieciozerne tablice :>)

gorzej jesli chcesz pomnozyc WIEKSZE liczby ze znakiem, mialem ostatnio wlasnie taki problem...

ztablicowanie wynikow (8bit * 8bit) zajmie dokladnie cala pamiec atarynki, wiedz odpada...

mozna tak stworzyc tablice f(x) ,zeby dalo sie pomozyc liczby ze znakiem ale sa pewne ograniczenia:
jesli a+b>128 mamy przepelnienie
jesli a-b>128 mamy przepelnienie
wiedz np. nie pomnozymy liczby 124 razy 8 bo 124+8 daje nam -124 (w kodzie U2) wiedz mamy przepelnienie,

mozna zastosowac tutaj pewna wlasciwosc ,ze

a*b=(a_lo+256*a_hi)*b=(a_lo*b) + 256*(a_hi*b)

dzieki czemu mozna obliczyc mnozenie 16bit ze znakiem razy 8bit ze znakiem po przez 2 mnozenia 8bit*8bit ze znakiem, niestety takie cos zajmuje ~100cykli wiedz przy duzej ilosc mnozen to odpada...

ja ten problem rozwiazlem tak (mnozy 9bitowa liczbe ze znakiem razy 8bitowa liczbe ze znakiem):

; tmp,tmp+1 * Y
; bestcase: 10+mul+rts (unsigned by unsigned)
; worstcase: 37+mul+rts (unsigned by signed)
; worstcase: 35+mul+rts (signed by unsigned)
; worstcase: 26+mul+rts (signed by signed)
;
mul16    bmi neg0
    lda tmp+1
    bmi neg2
    lda tmp
    jsr mul
    rts
neg2    lda tmp
    eor #$ff
    clc
    adc #$01
    jsr mul
    tay
    lda res
    eor #$ff
    clc
    adc #$01
    sta res
    tya
    eor #$ff
    adc #$00
    rts

neg0    lda tmp+1
    bmi neg1
    lda negtab,y
    ldy tmp
    jsr mul
    tay
    lda res
    eor #$ff
    clc
    adc #$01
    sta res
    tya
    eor #$ff
    adc #$00
    rts

neg1    lda negtab,y
    sta tmp2
    ldy tmp
    lda negtab,y
    ldy tmp2
    jsr mul
    rts

majac szybkie mnozenie 8bit*8bit=16bit res (takie jak w przykladzie z 6502.org) da to nam wynik w przyzwoitym czasie (oczywiscie jsr mul nalzy zastapic cala procedura mnozenia ,zeby nie tracic 12cykli na jsr+rts)

ale jesli to ma byc prosta scena 3d najlepszym i najszybszym sposobem jest zrobienie sobie tablicy sin(a)*x, i bez zadnego mnozenia mozemy obracac punkty w bardzo szybkim tepie (niestety bardzo pamieciozerne ;>, poniwaz przy 128katach i "gridzie" -64..64 tablica sinosow zajmuje nam 16384bajty...)
oczywiscie da sie ta tablice skrocic kosztem kilku(nastu) cykli np. wiedzadz ,ze -64*-43 to to samo co -(64*-43), dzieki czemu mozemy ztablicowac tylko wartosci dodatnie i przed mnozeniem sprawdzac znaki (a potem je zmieniac).
majac taka fajna tablice obrot punktu to poprostu pare linijek, cos w stylu tego:

ldy X
lda (costab),y
sec
ldy Y
sbc (sintab),y
sta newX

ldy X
lda (sintab),y
clc
ldy Y
adc (costab),y
sta newY

oczywiscie przed obrotem nalzy ustawic wskazniki sintab i costab tak aby wskazywaly do wartosci wynikow odpowiedniego dla danego kata:

lda katalfa
clc
adc #>sintab
sta sintab+1
lda katalfa
clc
adc #>costab
sta costab+1
lda #$00
sta sintab
sta costab

i robimy to tylko RAZ przed obrotem punktow.

jesli chodzi ogolnie o programowaniu 6502 to najlepsza strona jaka znalazlem jest: http://www.ffd2.com/fridge/chacking/
na niej praktycznie nauczylem sie programowac w asemblerze, co prawda przyklady sa dla c64 ale procesor jest ten sam, wiedz nie ma zadnego problemu, polecam nr 9 gdzie jest bardzo spory artykul o programowaniu 3d na 6502 (mnozenie, dzielenie, perspektywa, obroty, macierze itp)

Racja. Nie przeczytałem z uwagą. Chciałem poprawić to co on zamierzał, nie zastanawiając się za bardzo nad całością. Ech, wstyd.

Chodzi o taki mily trick, zeby wykorzystac fakt, ze 6502 bardzo lubi liczbe 256  ;). Jezeli wiec podzielimy sobie kat pelny nie na 360 jednostek, a na 256, to obliczenia trygonometryczne (uzywajac tablic sin cos i pochodnych) baaardzo nam sie uproszcza.

pozdrawiam

Różnica między 360 a 256 kątami obrotu jest zasadniczo niezauważalna.
Dzięki temu np. kąt zawsze się mieści w 1 bajcie co ułatwia i usprawnia obliczenia.
Myślę, że na 8 bitach, w rozdzielczościach jakie mamy, 256 kątów zupełnie wystarcza.