[C64] Routine 80x50 in ASM

[fulviuz]

Quanto tempo free ha kymya?
Mentre lavori dico

[KymyA]

Ma se vuoi lavorare in grafica sul C64, perche' invece di usare quella merda di 80x50 non accedi alla memoria video direttamente tramite il VIC e ti spari i 320x200 ?

Perchè NO.

Mi è venuta 'sta cosa così... tanto per...
lo trovo stimolante.
Ho QUASI risolto tutto. Non ho capito perché se supero le coordinate 11 si rincoglionisce... forse la tabella dove ho mappato le singole righe per velocizzare avrò sbagliato qualcosa.
Avevo pensato di prendere il numero di riga e moltiplicarlo per 40. Per velocizzare la moltiplicazione per 40, posso sommare due moltiplicazioni: una per 32 (che corrisponde a 5 ROL) ad una per 8 (che corrisponde a 3 ROL). Quindi far fare 3 ROL, memorizzare il valore risultante, altri 2 ROL e sommare con il valore memorizzato.

Quanto tempo free ha kymya?
Mentre lavori dico

Lavoro su minimo 3 pc alla volta (2 fisici dai quali mi collego ad almeno 3 VM contemporaneamente) e comunque ogni tanto mi trovo ad aspettare le macchine. O alla pausa pranzo...

[gnappinox1]

Oh e non ci dovrebbe essere bisogno di dire che scherzavo, perché vedo che l'hai presa come dovrebbe.
;-)

Certo, considera che stavo per addormentarmi, ho visto la notifica, letto il messaggio mi sono scompisciato dal ridere ed ho acceso il pc per rispondere più o meno a tono

[Geralt di Rivia]

https://twitter.com/UridiumAuthor/st...18130239528960

[KymyA]

Dunque... so che continuerete a sbattervene il cazzo però...

...adesso la routine di plot 80x50 FUNZIONA!!!!

Adesso sto scrivendo la routine per tracciare una linea tra due punti utilizzando l'algoritmo di Bresenham che mi pare molto veloce.

E' troppo divertente! Cmq la parte per plottare il singolo punto è lunga 380byte circa comprese tabelle e buffer.

[Fruttolo]

[LordOrion]

https://twitter.com/UridiumAuthor/st...18130239528960

Avevo trovato un suo vecchio gioco in una compialtion su cassetta (di quelle da edicola) ai tempi del C64

[KymyA]

Mi potete aiutare su una questione matematica (byte signed)???
Vabbè, praticamente ho ottenuto e memorizzato il valore assoluto del delta tra due coordinate ( praticamente ABS(x2-x1) ) come byte signed.
Adesso devo calcolare il valore negativo. Come si fa?

praticamente ho:
A = ABS(X2-X1)
B = ABS(Y2-Y1)

C = -ABS(Y2-Y1) = -B

Avendo A e B, come calcolo C?

(tenete presente che i byte sono signed, quindi da -127 a 128 come valore e
00000010 = +2
00000001 = +1
00000000 = 0
11111111 = -1
11111110 = -2)

[LordOrion]

Mi potete aiutare su una questione matematica (byte signed)???
Vabbè, praticamente ho ottenuto e memorizzato il valore assoluto del delta tra due coordinate ( praticamente ABS(x2-x1) ) come byte signed.
Adesso devo calcolare il valore negativo. Come si fa?

praticamente ho:
A = ABS(X2-X1)
B = ABS(Y2-Y1)

C = -ABS(Y2-Y1) = -B

Avendo A e B, come calcolo C?

(tenete presente che i byte sono signed, quindi da -127 a 128 come valore e
00000010 = +2
00000001 = +1
00000000 = 0
11111111 = -1
11111110 = -2)

https://it.wikipedia.org/wiki/Complemento_a_due

C = ( 0 - B )

[KymyA]

cazzo che soluzione semplice ed elegante!
grazie bellooohhh!

Ti mando il prg compilato appena finito.

[KymyA]

Ciao Lord...

tu che sei bravo e mi capisci, se volessi "assemblerizzare" questa formula :

x= x + q
y= y + s
d= d + 2 * (a + b)

potrei scrivere, considerando che sono byte signed :

LDA line_x
CLC
ADC line_Q
STA line_X

LDA line_Y
CLC
ADC line_S
STA line_Y

LDA line_A
CLC
ADC line_B
CLC
ROL
ADC line_D
STA line_D

???

Perché ho "tradotto" tutto l'algoritmo ma mi spara punti a capocchia. Non ho mai "lavorato" con byte signed!

[LordOrion]

Kymy, vado a "rimembranze" in quanto e' una vita che non smanetto l'assembly del 6510, ma se non sbaglio l'ALU della cpu gestisce da sola l'artimetica signed. Dai una occhiata al manuale del set di instruzioni.

[LordOrion]

LDA line_x             // A <-X
CLC
ADC line_Q:           // A = A + Q
STA line_X:            // Q = A

LDA line_Y             // A = Y 
CLC
ADC line_S            // A = A + S
STA line_Y             // Y = A

LDA line_A            // A = a
CLC
ADC line_B           // A = A + B
CLC
ROL                     // A = A * 2
ADC line_D          // A = A + D 
STA line_D           // D = A

A occhio e croce direi che va bene

[Fruttolo]

Perché ho "tradotto" tutto l'algoritmo ma mi spara punti a capocchia. Non ho mai "lavorato" con byte signed!

Prendi questo parere con molta fotteseganza

https://www.c64-wiki.com/wiki/ROL

Doubling signed integers in this way requires programming efforts to keep the sign bit from mixing with the other bits, causing erratic sign-changes.

[LordOrion]

Prendi questo parere con molta fotteseganza

https://www.c64-wiki.com/wiki/ROL

Doubling signed integers in this way requires programming efforts to keep the sign bit from mixing with the other bits, causing erratic sign-changes.

Invece credo sia corretto: Usare lo shift per moltiplicare per due rischia di far uscire il bit di segno, es:

ROL 10001011 = 00010110!!

prova cosi:

LDA line_x             // A <-X
CLC
ADC line_Q:           // A = A + Q
STA line_X:            // Q = A

LDA line_Y             // A = Y 
CLC
ADC line_S            // A = A + S
STA line_Y             // Y = A

LDA line_A            // A = a
CLC
ADC line_B           // A = A + B
CLC
STA temp             // temp = A
ADC temp            // A = A + temp (= 2 * A )
CLC
ADC line_D          // A = A + D 
STA line_D           // D = A

[KymyA]

inutile.... l'assembly è ELEGANTE. Bella soluzione. invece di ROLlare, sommare a se stesso... provo...

[LordOrion]

inutile.... l'assembly è ELEGANTE. Bella soluzione. invece di ROLlare, sommare a se stesso... provo...

Bof, la soluzione "elegante" si comporterebbe in modo diverso a seconda del fatto che l'operando e' positivo o negativo. Sommare se stesso e' un trick ma non la cosa piu' efficente: 3 isturzioni contro 1 del ROL e un byte di memoria extra.

    LDA line_x             // A <-X
    CLC
    ADC line_Q:           // A = A + Q
    STA line_X:            // Q = A

    LDA line_Y             // A = Y 
    CLC
    ADC line_S            // A = A + S
    STA line_Y             // Y = A

    LDA line_A            // A = a
    CLC
    ADC line_B           // A = A + B

    BMI negative

    CLC
    ROL
    JMP end

negative:
    CLC
    STA temp             // temp = A
    ADC temp            // A = A + temp (= 2 * A )

end:
    CLC
    ADC line_D          // A = A + D 
    STA line_D           // D = A

[KymyA]

ottimizzo dopo.

continua a non funzionare. vediamo se riesco a debuggare in qualche modo.
Sto utilizzando Relaunch64 (Java) come IDE (DASM) e Vice.

Sotto di BREAK e Z ... è l'unica strada per giungere alla soluzione. Rottura di palle, ma stimolante.

[KymyA]

Fino al calcolo della d, tutto ok...
Dai... che sento che la soluzione è sotto mano dai!

[KymyA]

Mi sa che l'algoritmo è come al cazzo. controllato uno step alla volta e, almeno l'unico caso provato, quello che ho scritto segue l'algoritmo:

swap = 0;
DX = x2 - x1;
DY = y2 - y1;

//siccome scambio DY e DX ho sempre DX>=DY allora per sapere quale coordinata occorre cambiare uso una variabile
if (abs(DX) < abs(DY)) {
   swap(DX, DY);
   swap = 1;
}

//per non scrivere sempre i valori assoluti cambio DY e DX con altre variabili
a = abs(DY);
b = -abs(DX);

//assegna le coordinate iniziali
x = x1;
y = y1;

//il nostro valore d0
d = 2 * a + b;

//s e q sono gli incrementi/decrementi di x e y
q = 1;
s = 1;
if (x1 > x2) q = -1;
if (y1 > y2) s = -1;
disegna_punto(x, y);
disegna_punto(x2, y2);
for (k = 0; k < -b; k+=1) {
   if (d > 0) {
       x= x + q; y= y + s;
       d= d + 2 * (a + b);
   }
   else {
       x = x + q;
       if (swap==1) { y = y + s; x = x - q; }
       d = d + 2 * a;
   }
   disegna_punto(x, y);
}

preso da qui : https://it.wikipedia.org/wiki/Algori...a_di_Bresenham

(nb: provata in vb, funziona. quindi l'algoritmo è ok)