Discussion :

[powerpsy]

hello, world !

bon, aujourd'hui, je m'intéresse aux tracés de droites.
j'ai déjà vu le topic sur le sujet connexe, mais là c'est plus un souci d'optimisation...


Le bon point, j'y parviens !
d'ailleurs, merci à Jeremia pour son site avec beaucoup d'explications. J'ai pris le dernier algo de la page (6)
le mauvais : j'ai l'impression de faire 100 lignes de code pour rien, et disons que j'aimerais bien avoir des idées d'optimisation...

exemple : je fais un petit prog qui trace une droite à l'écran de 10,10 à 100,50
voilà le code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
org 100h          ; programme .COM
 
segment .data
 
X   db 10
Y   db 10
k   db 0
err db 0
 
segment .text
 
  mov ax,13h
  int 10h      ;Mode 13 (320x200 - 256 couleurs)
 
  push 0A000h    
  pop  es         ;le debut de la mem video dans ES
 
  mov  ax,320
  imul bx,[Y],320
  mov  al,[X]
  add  bl,al      ; on place l'origine en X,Y
 
  add byte [err],2*(20-10)-(100-10)
  mov cl,100
  sub cl,[X]      ; on va tracer 100-X points
ligne:            ; ligne de 10,10 à 100,50
  mov al,1
  mov [es:bx],al  ; trace le point
  inc bx
  cmp byte [err],0 ; if err>0
  js signblock
  jo elseblock
  jmp thenblock
signblock:
  jo thenblock
elseblock:         ; err += deltaY-deltaX
  add bx,320
  add byte [err],(20-10)-(100-10)
  jmp next
thenblock:         ; err += deltaY
  add byte [err],(20-10)
next:
  loop ligne
 
 
  xor    ax,ax
  int    16h    ;Attend la pression d'une touche
 
  mov ax,4C00h
  int 21h       ; quit

quelqu'un voudrait essayer de voir ça ? merci !
Sam

[jeremya]

J'ai fait quelques améliorations à ton code:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
    mov  ax,320
    mul Y
    movzx bx,X
    add  ax,bx      ; on place l'origine en X,Y
    mov bx,ax
    mov dl,2*(20-10)-(100-10) ; dl=err
    mov cl,100
    sub cl,X      ; on va tracer 100-X points
    mov al,1
ligne:            ; ligne de 10,10 à 100,20
    mov es:[bx],al  ; trace le point
    inc bx
    and dl,dl ; if err>0
    js thenblock
elseblock:         ; err += deltaY-deltaX
    add bx,320
    add dl,(20-10)-(100-10)
    jmp next
thenblock:         ; err += deltaY
    add dl,(20-10)
next:
    dec cl
    jnz ligne

Quelques optimisations :

- utiliser un registre pour err (les registres sont plus rapides que la RAM)

- utiliser and dl,dl pour comparer dl à 0
en fait, and n'est pas plus rapide qua cmp (ces 2 instructions durent 1 micro-opération)
mais and est plus prend moins de place dans le binaire
en effet,
pour un cmp dl,0 il faut 1 octet pour stocker 0
pour un cmp dx,0 il faut 2 octet pour stocker 0
pour un cmp edx,0 il faut 4 octet pour stocker 0

- utiliser "dec cl" suivi de jnz label au lieu de "loop"
A part sur les vieux processeurs, loop est plus lent que dec et jnz