home *** CD-ROM | disk | FTP | other *** search
/ No Fragments Archive 10: Diskmags / nf_archive_10.iso / MAGS / FALKMAG / FKM_07_2.ZIP / CLIPPING.S / CP_2DP_S.S < prev   
Text File  |  1997-04-25  |  20KB  |  777 lines
  1. * fenêtrage de polygone réentrant
  2. * par Golio Junior pour Falk'mag 7
  3.  
  4. * Définition de l'image
  5. Video_mode        equ %000100100    * 40 col, 200 lig, 65536 cou, TV Pal
  6. Taille_ecran    equ 320*200*2
  7. ecran_largeur    equ 320
  8. ecran_hauteur    equ 200
  9. Pas_Fond        equ 0
  10.  
  11.             * zone de clipping
  12. min_x    equ 100
  13. max_x    equ 220
  14. min_y    equ 40
  15. max_y    equ 160
  16.  
  17.             * définition du polygone
  18. nbre_cote    equ 4
  19. couleur    equ $f0f0        * couleur
  20.  
  21.             * struture definissant une arete
  22.     rsreset
  23. dep_x    rs.w 1
  24. dep_y    rs.w 1
  25. arr_x    rs.w 1
  26. arr_y    rs.w 1
  27. aretes    equ __rs
  28.  
  29.             * struture definissant une intersection d'arete
  30.     rsreset
  31. coor_x    rs.w 1
  32. pente    rs.l 1
  33. accu    rs.w 1
  34. hauteur    rs.w 1
  35. aretes_inter    equ __rs
  36.  
  37.  
  38.     include "principa.s"
  39.  
  40. prg_init
  41.                 * effacement de l'écran
  42.     move.w #ecran_largeur*ecran_hauteur/8-1,d0
  43.     move.l #-1,d1
  44.     movea.l adr_ecran,a0
  45. prg_init_b1
  46.     move.l d1,(a0)+
  47.     move.l d1,(a0)+
  48.     move.l d1,(a0)+
  49.     move.l d1,(a0)+
  50.     dbra d0,prg_init_b1
  51.                 * coloriage de la zone de clipping pour bien voir 
  52.     movea.l adr_ecran,a0
  53.     adda.l #(ecran_largeur*min_y+min_x)*2,a0
  54.     move.l #0,d2
  55.     move.w #max_y-min_y-1,d0
  56. prg_init_b2
  57.     move.w #(max_x-min_x)/8-1,d1
  58. prg_init_b3
  59.     move.l d2,(a0)+
  60.     move.l d2,(a0)+
  61.     move.l d2,(a0)+
  62.     move.l d2,(a0)+
  63.     dbra d1,prg_init_b3
  64.     adda.l #(ecran_largeur-(max_x-min_x))*2,a0
  65.     dbra d0,prg_init_b2
  66.  
  67.     rts
  68.  
  69. prg
  70.     lea polygone,a0
  71.     lea resultat1,a1
  72.     move.w #nbre_cote-1,d0
  73.     bsr clip_gauche
  74.     lea resultat1,a0
  75.     lea resultat2,a1
  76.     move.w d1,d0
  77.     bsr clip_droit
  78.     lea resultat2,a0
  79.     lea resultat1,a1
  80.     move.w d1,d0
  81.     bsr clip_haut
  82.     lea resultat1,a0
  83.     lea resultat2,a1
  84.     move.w d1,d0
  85.     bsr clip_bas
  86.     lea resultat2,a0
  87.     move.w d1,d7
  88.     bsr trace_polygone
  89.     rts
  90.             * routines de clipping : 
  91.             * entrée : d0 : Nbre de coté du polygone
  92.             *          a0 : liste des points du polygone
  93.             * sortie : a1 : liste des points du polygone clippé
  94.             *          d1 : Nbre de coté du polygone clippé
  95.             * clipping sur le bord gauche de la fenêtre
  96. clip_gauche
  97.     move.l a1,a2
  98.             * initialisation du nombre de coté du polygone clippé
  99.     move.w #-1,d1
  100.             * traitement du cas particulier du 1er point
  101.     move.w (a0,dep_x),d4
  102.     move.w (a0,dep_y),d5
  103.     cmp.w #min_x,d4
  104.     blt clip_gauche_1pt    * test de visibilité
  105.             * il est visible, il faut donc l'ajouter
  106.     move.w d4,(a1)+
  107.     move.w d5,(a1)+
  108.             * sinon, l'ajout se fera ultérieurement
  109. clip_gauche_1pt
  110. clip_gauche_b1
  111.     move.w (a0,dep_x),d4
  112.     move.w (a0,dep_y),d5
  113.     move.w (a0,arr_x),d6
  114.     move.w (a0,arr_y),d7
  115.                 * comparaison avec le bord gauche de la fenêtre
  116.                 * test pour savoir si les extrémités sont à l'intérieur
  117.     cmp.w #min_x,d4
  118.     bgt clip_gauche_bis
  119.                 * le bord gauche est coupé par le 1er point
  120.     cmp.w #min_x,d6
  121.     blt clip_gauche_pas_visible
  122.                 * mais par un seul point
  123.                 * on va de la partie invisible vers la partie visible
  124.                 * donc ajout de 2 points (2 arêtes)
  125.                 * calcul du point d'intersection
  126.                 * calcul de la pente
  127.     move.w d4,d2
  128.     sub.w d6,d2        * résultat positif car d6>d4 !
  129.     move.w d7,d3
  130.     sub.w d5,d3
  131.     beq clip_gauche_horizontal    * segment horizontal
  132.     swap d3
  133.     clr.w d3
  134.     ext.l d2
  135.     divs.l d2,d3
  136.                 * calcul de dx
  137.     sub.w #min_x,d4
  138.     ext.l d4
  139.                 * calcul du dy à ajouter
  140.     muls.l d4,d3
  141.     swap d3
  142.     add.w d3,d5
  143.  
  144. clip_gauche_horizontal        * segment horizontal,
  145.                 * donc intersection facile à calculer
  146.     move.w #min_x,d4
  147.                 * ajout des points dans la liste
  148.     move.w d4,(a1)+
  149.     move.w d5,(a1)+
  150.     move.w d6,(a1)+
  151.     move.w d7,(a1)+
  152.     addq.w #2,d1        * 2 arêtes suplémentaires
  153.     bra clip_gauche_s2
  154. clip_gauche_bis
  155.     cmp.w #min_x,d6
  156.     bgt clip_gauche_s1
  157.                 * le bord gauche est coupé par le second point,
  158.                 * mais pas par le premier
  159.                 * donc on va de la partie visible
  160.                 * vers la partie invisible
  161.                 * donc on ajoute 1 arête (le dernier point est significatif)
  162.                 * calcul du point d'intersection
  163.                 * calcul de la pente
  164.     move.w d4,d2
  165.     sub.w d6,d2        * résultat positif car d4>d6 !
  166.     move.w d5,d3
  167.     sub.w d7,d3
  168.     beq clip_gauche_bis_horizontal    * segment horizontal
  169.     swap d3
  170.     clr.w d3
  171.     ext.l d2
  172.     divs.l d2,d3
  173.                 * calcul de dx
  174.     sub.w #min_x,d6
  175.     neg.w d6
  176.     ext.l d6
  177.                 * calcul du dy à ajouter
  178.     muls.l d6,d3
  179.     swap d3
  180.     add.w d3,d7
  181.  
  182. clip_gauche_bis_horizontal        * segment horizontal,
  183.                 * donc intersection facile à calculer
  184.     move.w #min_x,d6
  185.                 * sauvegarde du dernier point calculé
  186.     move.w d6,(a1)+
  187.     move.w d7,(a1)+
  188.     addq.w #1,d1        * une arête de plus
  189.     bra clip_gauche_s2
  190. clip_gauche_s1
  191.                 * arête entièrement visible
  192.                 * on ajoute le dernier point
  193.     addq.w #1,d1
  194.                 * sauvegarde des coordonnées clippées
  195.     move.w d6,(a1)+
  196.     move.w d7,(a1)+
  197. clip_gauche_s2
  198.                 * passage aux coordonnées suivantes
  199. clip_gauche_pas_visible
  200.     adda.l #4,a0
  201.     dbra d0,clip_gauche_b1
  202.                 * traitement du dernier point
  203.                 * recopie du 1er !
  204.     move.l (a2),(a1)
  205.     rts
  206.  
  207.             * clipping sur le bord droit de la fenêtre
  208. clip_droit
  209.     move.l a1,a2
  210.             * initialisation du nombre de coté du polygone clippé
  211.     move.w #-1,d1
  212.             * traitement du cas particulier du 1er point
  213.     move.w (a0,dep_x),d4
  214.     move.w (a0,dep_y),d5
  215.     cmp.w #max_x,d4
  216.     bgt clip_droit_1pt    * test de visibilité
  217.             * il est visible, il faut donc l'ajouter
  218.     move.w d4,(a1)+
  219.     move.w d5,(a1)+
  220.             * sinon, l'ajout se fera ultérieurement
  221. clip_droit_1pt
  222. clip_droit_b1
  223.     move.w (a0,dep_x),d4
  224.     move.w (a0,dep_y),d5
  225.     move.w (a0,arr_x),d6
  226.     move.w (a0,arr_y),d7
  227.                 * comparaison avec le bord droit de la fenêtre
  228.                 * test pour savoir si les extrémités sont à l'intérieur
  229.     cmp.w #max_x,d4
  230.     blt clip_droit_bis
  231.                 * le bord droit est coupé par le 1er point
  232.     cmp.w #max_x,d6
  233.     bgt clip_droit_pas_visible
  234.                 * mais par un seul point
  235.                 * on va de la partie invisible vers la partie visible
  236.                 * donc ajout de 2 points (2 arêtes)
  237.                 * calcul du point d'intersection
  238.                 * calcul de la pente
  239.     move.w d6,d2
  240.     sub.w d4,d2        * résultat positif car d4>d6 !
  241.     move.w d7,d3
  242.     sub.w d5,d3
  243.     beq clip_droit_horizontal    * segment horizontal
  244.     swap d3
  245.     clr.w d3
  246.     ext.l d2
  247.     divs.l d2,d3
  248.                 * calcul de dx
  249.     sub.w #max_x,d4
  250.     neg.w d4
  251.     ext.l d4
  252.                 * calcul du dy à ajouter
  253.     muls.l d4,d3
  254.     swap d3
  255.     add.w d3,d5
  256.  
  257. clip_droit_horizontal            * segment horizontal,
  258.                 * donc intersection facile à calculer
  259.     move.w #max_x,d4
  260.                 * ajout des points dans la liste
  261.     move.w d4,(a1)+
  262.     move.w d5,(a1)+
  263.     move.w d6,(a1)+
  264.     move.w d7,(a1)+
  265.     addq.w #2,d1        * 2 arêtes suplémentaires
  266.     bra clip_droit_s2
  267. clip_droit_bis
  268.     cmp.w #max_x,d6
  269.     blt clip_droit_s1
  270.                 * le bord droit est coupé par le second point,
  271.                 * mais pas par le premier
  272.                 * donc on va de la partie visible
  273.                 * vers la partie invisible
  274.                 * donc on ajoute 1 arête (le dernier point est significatif)
  275.                 * calcul du point d'intersection
  276.                 * calcul de la pente
  277.     move.w d6,d2
  278.     sub.w d4,d2        * résultat positif car d6>d4 !
  279.     move.w d5,d3
  280.     sub.w d7,d3
  281.     beq clip_droit_bis_horizontal    * segment horizontal
  282.     swap d3
  283.     clr.w d3
  284.     ext.l d2
  285.     divs.l d2,d3
  286.                 * calcul de dx
  287.     sub.w #max_x,d6
  288.     ext.l d6
  289.                 * calcul du dy à ajouter
  290.     muls.l d6,d3
  291.     swap d3
  292.     add.w d3,d7
  293.  
  294. clip_droit_bis_horizontal        * segment horizontal,
  295.                 * donc intersection facile à calculer
  296.     move.w #max_x,d6
  297.                 * sauvegarde du dernier point calculé
  298.     move.w d6,(a1)+
  299.     move.w d7,(a1)+
  300.     addq.w #1,d1        * une arête de plus
  301.     bra clip_droit_s2
  302. clip_droit_s1
  303.                 * arête entièrement visible
  304.                 * on ajoute le dernier point
  305.     addq.w #1,d1
  306.                 * sauvegarde des coordonnées clippées
  307.     move.w d6,(a1)+
  308.     move.w d7,(a1)+
  309. clip_droit_s2
  310.                 * passage aux coordonnées suivantes
  311. clip_droit_pas_visible
  312.     adda.l #4,a0
  313.     dbra d0,clip_droit_b1
  314.                 * traitement du dernier point
  315.                 * recopie du 1er !
  316.     move.l (a2),(a1)
  317.     rts
  318.             * clipping sur le bord haut de la fenêtre
  319. clip_haut    
  320.     move.l a1,a2
  321.             * initialisation du nombre de coté du polygone clippé
  322.     move.w #-1,d1
  323.             * traitement du cas particulier du 1er point
  324.     move.w (a0,dep_x),d4
  325.     move.w (a0,dep_y),d5
  326.     cmp.w #min_y,d5
  327.     blt clip_haut_1pt    * test de visibilité
  328.             * il est visible, il faut donc l'ajouter
  329.     move.w d4,(a1)+
  330.     move.w d5,(a1)+
  331.             * sinon, l'ajout se fera ultérieurement
  332. clip_haut_1pt
  333. clip_haut_b1
  334.     move.w (a0,dep_x),d4
  335.     move.w (a0,dep_y),d5
  336.     move.w (a0,arr_x),d6
  337.     move.w (a0,arr_y),d7
  338.                 * comparaison avec le bord haut de la fenêtre
  339.                 * test pour savoir si les extrémités sont à l'intérieur
  340.     cmp.w #min_y,d5
  341.     bgt clip_haut_bis
  342.                 * le bord haut est coupé par le 1er point
  343.     cmp.w #min_y,d7
  344.     blt clip_haut_pas_visible
  345.                 * mais par un seul point
  346.                 * on va de la partie invisible vers la partie visible
  347.                 * donc ajout de 2 points (2 arêtes)
  348.                 * calcul du point d'intersection
  349.                 * calcul de la pente
  350.     move.w d5,d2
  351.     sub.w d7,d2        * résultat positif car d7>d5 !
  352.     move.w d6,d3
  353.     sub.w d4,d3
  354.     beq clip_haut_vertical    * segment vertical
  355.     swap d3
  356.     clr.w d3
  357.     ext.l d2
  358.     divs.l d2,d3
  359.                 * calcul de dy
  360.     sub.w #min_y,d5
  361.     ext.l d5
  362.                 * calcul du dx à ajouter
  363.     muls.l d5,d3
  364.     swap d3
  365.     add.w d3,d4
  366.  
  367. clip_haut_vertical            * segment vertical,
  368.                 * donc intersection facile à calculer
  369.     move.w #min_y,d5
  370.                 * ajout des points dans la liste
  371.     move.w d4,(a1)+
  372.     move.w d5,(a1)+
  373.     move.w d6,(a1)+
  374.     move.w d7,(a1)+
  375.     addq.w #2,d1        * 2 arêtes suplémentaires
  376.     bra clip_haut_s2
  377. clip_haut_bis
  378.     cmp.w #min_y,d7
  379.     bgt clip_haut_s1
  380.                 * le bord haut est coupé par le second point,
  381.                 * mais pas par le premier
  382.                 * donc on va de la partie visible
  383.                 * vers la partie invisible
  384.                 * donc on ajoute 1 arête (le dernier point est significatif)
  385.                 * calcul du point d'intersection
  386.                 * calcul de la pente
  387.     move.w d5,d2
  388.     sub.w d7,d2        * résultat positif car d5>d7 !
  389.     move.w d4,d3
  390.     sub.w d6,d3
  391.     beq clip_haut_bis_vertical    * segment vertical
  392.     swap d3
  393.     clr.w d3
  394.     ext.l d2
  395.     divs.l d2,d3
  396.                 * calcul de dy
  397.     sub.w #min_y,d7
  398.     neg.w d7
  399.     ext.l d7
  400.                 * calcul du dx à ajouter
  401.     muls.l d7,d3
  402.     swap d3
  403.     add.w d3,d6
  404.  
  405. clip_haut_bis_vertical        * segment vertical,
  406.                 * donc intersection facile à calculer
  407.     move.w #min_y,d7
  408.                 * sauvegarde du dernier point calculé
  409.     move.w d6,(a1)+
  410.     move.w d7,(a1)+
  411.     addq.w #1,d1        * une arête de plus
  412.     bra clip_haut_s2
  413. clip_haut_s1
  414.                 * arête entièrement visible
  415.                 * on ajoute le dernier point
  416.     addq.w #1,d1
  417.                 * sauvegarde des coordonnées clippées
  418.     move.w d6,(a1)+
  419.     move.w d7,(a1)+
  420. clip_haut_s2
  421.                 * passage aux coordonnées suivantes
  422. clip_haut_pas_visible
  423.     adda.l #4,a0
  424.     dbra d0,clip_haut_b1
  425.                 * traitement du dernier point
  426.                 * recopie du 1er !
  427.     move.l (a2),(a1)
  428.     rts
  429.  
  430.             * clipping sur le bord bas de la fenêtre
  431. clip_bas
  432.     move.l a1,a2
  433.             * initialisation du nombre de coté du polygone clippé
  434.     move.w #-1,d1
  435.             * traitement du cas particulier du 1er point
  436.     move.w (a0,dep_x),d4
  437.     move.w (a0,dep_y),d5
  438.     cmp.w #max_y,d5
  439.     bgt clip_bas_1pt    * test de visibilité
  440.             * il est visible, il faut donc l'ajouter
  441.     move.w d4,(a1)+
  442.     move.w d5,(a1)+
  443.             * sinon, l'ajout se fera ultérieurement
  444. clip_bas_1pt
  445. clip_bas_b1
  446.     move.w (a0,dep_x),d4
  447.     move.w (a0,dep_y),d5
  448.     move.w (a0,arr_x),d6
  449.     move.w (a0,arr_y),d7
  450.                 * comparaison avec le bord bas de la fenêtre
  451.                 * test pour savoir si les extrémités sont à l'intérieur
  452.     cmp.w #max_y,d5
  453.     blt clip_bas_bis
  454.                 * le bord bas est coupé par le 1er point
  455.     cmp.w #max_y,d7
  456.     bgt clip_bas_pas_visible
  457.                 * mais par un seul point
  458.                 * on va de la partie invisible vers la partie visible
  459.                 * donc ajout de 2 points (2 arêtes)
  460.                 * calcul du point d'intersection
  461.                 * calcul de la pente
  462.     move.w d7,d2
  463.     sub.w d5,d2        * résultat positif car d5>d7 !
  464.     move.w d6,d3
  465.     sub.w d4,d3
  466.     beq clip_bas_vertical        * segment vertical
  467.     swap d3
  468.     clr.w d3
  469.     ext.l d2
  470.     divs.l d2,d3
  471.                 * calcul de dy
  472.     sub.w #max_y,d5
  473.     neg.w d5
  474.     ext.l d5
  475.                 * calcul du dx à ajouter
  476.     muls.l d5,d3
  477.     swap d3
  478.     add.w d3,d4
  479.  
  480. clip_bas_vertical            * segment vertical,
  481.                 * donc intersection facile à calculer
  482.     move.w #max_y,d5
  483.                 * ajout des points dans la liste
  484.     move.w d4,(a1)+
  485.     move.w d5,(a1)+
  486.     move.w d6,(a1)+
  487.     move.w d7,(a1)+
  488.     addq.w #2,d1        * 2 arêtes suplémentaires
  489.     bra clip_bas_s2
  490. clip_bas_bis
  491.     cmp.w #max_y,d7
  492.     blt clip_bas_s1
  493.                 * le bord bas est coupé par le second point,
  494.                 * mais pas par le premier
  495.                 * donc on va de la partie visible
  496.                 * vers la partie invisible
  497.                 * donc on ajoute 1 arête (le dernier point est significatif)
  498.                 * calcul du point d'intersection
  499.                 * calcul de la pente
  500.     move.w d7,d2
  501.     sub.w d5,d2        * résultat positif car d7>d5 !
  502.     move.w d4,d3
  503.     sub.w d6,d3
  504.     beq clip_bas_bis_vertical    * segment vertical
  505.     swap d3
  506.     clr.w d3
  507.     ext.l d2
  508.     divs.l d2,d3
  509.                 * calcul de dy
  510.     sub.w #max_y,d7
  511.     ext.l d7
  512.                 * calcul du dx à ajouter
  513.     muls.l d7,d3
  514.     swap d3
  515.     add.w d3,d6
  516.  
  517. clip_bas_bis_vertical            * segment vertical,
  518.                 * donc intersection facile à calculer
  519.     move.w #max_y,d7
  520.                 * sauvegarde du dernier point calculé
  521.     move.w d6,(a1)+
  522.     move.w d7,(a1)+
  523.     addq.w #1,d1        * une arête de plus
  524.     bra clip_bas_s2
  525. clip_bas_s1
  526.                 * arête entièrement visible
  527.                 * on ajoute le dernier point
  528.     addq.w #1,d1
  529.                 * sauvegarde des coordonnées clippées
  530.     move.w d6,(a1)+
  531.     move.w d7,(a1)+
  532. clip_bas_s2
  533.                 * passage aux coordonnées suivantes
  534. clip_bas_pas_visible
  535.     adda.l #4,a0
  536.     dbra d0,clip_bas_b1
  537.                 * traitement du dernier point
  538.                 * recopie du 1er !
  539.     move.l (a2),(a1)
  540.     rts
  541.  
  542.  
  543. trace_polygone
  544.             * entrée :
  545.             * a0 : liste des points constituant le polygone
  546.             * d7 : Nbre de coté -1
  547.  
  548.             * sauter les aretes horizontales
  549.             * orienter les aretes
  550.             * ordonner les aretes
  551.     lea aretes_triees,a2    * pointeur sur la fin de la liste des aretes triees
  552.     move.w #-1,(a2,dep_y)    * initialisation des aretes triees
  553.     move.w #-1,liste_aretes+coor_x    * initialisation de la liste des aretes coupée
  554. constitution
  555.             * on recupere les coordonnees de l'arete
  556.     move.l (a0)+,d0    * coordonnées sur mot long : X : 16 de poid fort
  557.     move.l (a0),d1    *                            Y : 16 de poid faible
  558.     cmp.w d1,d0
  559.     beq arete_horizontal
  560.     bmi arete_positive
  561.     exg.l d0,d1    * ici l'arete est mal orientee
  562.             * elle monte!
  563. arete_positive
  564.             * recherche de la bonne place
  565.             * tri par insertion dans l'ordre croissant
  566.     lea aretes_triees,a1
  567. arete_suivante
  568.     cmp.w (a1,dep_y),d0
  569.     bmi bonne_place    * bonne place? si oui, alors bonne_place
  570.     addq.l #aretes,a1    * place suivante
  571.     cmpa.l a1,a2    * sort-on de la liste des aretes?
  572.     bgt arete_suivante    * non alors on continue
  573.     move.l d0,(a2)+    * on arrive à la fin de la liste
  574.     move.l d1,(a2)+    * donc on insere l'arete à la fin
  575.     bra arete_horizontal
  576. bonne_place
  577.             * c'est le bon endroit
  578.             * il faut se faire un peut de place
  579.     movea.l a2,a3    * pour se faire un peut de place
  580.     subq.l #aretes,a1    * on va copier l'arete courante dans la place suivante
  581. decalage    move.l (a3),(a3,aretes)    * donc on commence par la fin
  582.     move.l (a3,arr_x),(a3,aretes+arr_x)
  583.     subq.l #aretes,a3
  584.     cmpa.l a3,a1
  585.     blt decalage    * fin du decalage? non alors decalage!
  586.     addq.l #aretes,a2    * nouvelle fin de table
  587.     addq.l #aretes,a1
  588.     move.l d0,(a1)+    * on place l'arete dans la place que l'on
  589.     move.l d1,(a1)+    * vient de faire
  590. arete_horizontal
  591.     dbra d7,constitution    * on continue à constituer la liste des
  592.             * arêtes
  593.  
  594.             * a la fin, nous avons :
  595.             * a2 contient l'adresse de la fin de table
  596.  
  597.             * ici on commence à tracer le polygone
  598.             * 1ere ligne = 1 arete
  599.     lea aretes_triees,a0    * liste des aretes
  600.     move.w (a0,dep_y),d0    * y courant : on commence par le y de la 1ere arete
  601.     move.w d0,d1
  602.     mulu.w #ecran_largeur*2,d1
  603.     movea.l adr_ecran,a1    * a1 pointe sur la ligne ecran courante
  604.     adda.l d1,a1    * adresse de la 1ere ligne
  605.     lea liste_aretes,a3    * fin de la liste d'aretes deja traitee
  606.     clr.w d7        * d7 indique qu'il y a encore des aretes dans
  607.             * la liste des aretes triees
  608. ajout_arete
  609.             * ajout a la liste les aretes qui sont
  610.             * concernees par cette ligne
  611.     cmp.w (a0,dep_y),d0
  612.     bne plus_d_arete
  613.             * calcul des différents informations
  614.     move.w (a0,arr_y),d1
  615.     sub.w (a0,dep_y),d1    * hauteur
  616.     addq.w #1,d1
  617.     andi.l #$0000FFFF,d1    * la hauteur est toujours positive
  618.     move.w (a0),d2
  619.     move.w d2,d4
  620.     sub.w (a0,arr_x),d2    * largeur
  621.     beq arete_verticale
  622.     neg.w d2
  623.     addq.w #1,d2
  624.     move.w d2,d3
  625.     swap d3
  626.     clr.w d3
  627.     divs.l d1,d3    * pente en virgule fixe : 
  628.             * 16 bits partie entiere
  629.             * 16 bits partie decimale
  630.     bra range_arete
  631. arete_verticale
  632.     clr.l d3        * comme arete verticale, alors la pente est nulle!
  633.             * c'est plus rapide que de faire plein de calcul!
  634. range_arete
  635.     subq.w #2,d1
  636.             * rangement et trie de la nouvelle arete
  637.             * toujours un tri par insertion croissant sur les x
  638.     lea liste_aretes,a4
  639. liste_suivantes
  640.     cmp.w (a4,coor_x),d4
  641.     beq liste_aretes_idem    *arete qui on le meme x? oui alors saut!
  642.     bmi liste_bonne_place
  643.     adda.l #aretes_inter,a4
  644.     cmpa.l a4,a3
  645.     bgt liste_suivantes
  646.     move.w d4,(a3)+
  647.     move.l d3,(a3)+
  648.     clr.w (a3)+
  649.     move.w d1,(a3)+
  650.     bra liste_arete_suivante
  651. liste_aretes_idem
  652.             * ici puisque les x sont egaux, on compare les pentes
  653.             * dans l'ordre croissant
  654.     cmp.l (a4,pente),d3
  655.     ble liste_bonne_place
  656.             * ici il faut inserer avant
  657.     adda.l #aretes_inter,a4
  658. liste_bonne_place        * insertion (cf avant)
  659.     movea.l a3,a5
  660.     suba.l #aretes_inter,a4
  661. liste_decalage
  662.     move.l (a5),(a5,aretes_inter)
  663.     move.l (a5,4),(a5,aretes_inter+4)
  664.     move.w (a5,hauteur),(a5,aretes_inter+hauteur)
  665.     suba.l #aretes_inter,a5
  666.     cmpa.l a5,a4
  667.     blt liste_decalage
  668.     adda.l #aretes_inter,a3
  669.     adda.l #aretes_inter,a4
  670.     move.w d4,(a4)+
  671.     move.l d3,(a4)+
  672.     clr.w (a4)+
  673.     move.w d1,(a4)+
  674. liste_arete_suivante
  675.     adda.l #aretes,a0
  676.     cmpa.l a0,a2
  677.     bne ajout_arete
  678.             * fin de la liste des aretes
  679.     st.b d7        * plus la peine de chercher dans
  680.     clr.w (a0,dep_y)    * l'ensemble d'aretes
  681.  
  682. plus_d_arete        * tracage proprement dit
  683.     lea liste_aretes,a4
  684. tracage
  685.     cmpa.l a4,a3
  686.     beq fin_tracage
  687.             * on prend 2 intersections -> tracage de ligne
  688.     move.w (a4,coor_x),d1
  689.     move.w d1,d2
  690.     add.w d1,d1
  691.     movea.l a1,a5
  692.     adda.w d1,a5    * a5 : adresse du 1er point
  693.     sub.w (a4,aretes_inter+coor_x),d2
  694.     beq tracage_un_point
  695.     neg.w d2
  696.     subq.w #1,d2    * d2 : nombre de points-1 a afficher
  697. tracage_b
  698.     move.w #couleur,(a5)+    * affichage : vive le True Color!
  699.     dbra d2,tracage_b
  700.  
  701.     adda.l #aretes_inter*2,a4
  702.     bra tracage
  703. tracage_un_point
  704.     move.w #couleur,(a5)+
  705.     adda.l #aretes_inter*2,a4
  706.     bra tracage
  707.             * enlever les aretes inutiles
  708. fin_tracage
  709.     lea liste_aretes,a4
  710. elimine_arete
  711.     tst.w (a4,hauteur)
  712.     bne y_suivant
  713.             * il faut éliminer l'arete en l'ecrasant
  714.     movea.l a4,a5
  715. ecrase_arete
  716.     cmpa.l a5,a3
  717.     beq ecrase_arete_suite
  718.     move.w (a5,aretes_inter),(a5)
  719.     move.l (a5,aretes_inter+pente),(a5,pente)
  720.     move.l (a5,aretes_inter+accu),(a5,accu)
  721.     adda.l #aretes_inter,a5
  722.     bra ecrase_arete
  723. ecrase_arete_suite
  724.     suba.l #aretes_inter,a3
  725.     bra elimine_arete_fin    * il n'y a pas besoin d'ajouter aretes_inter
  726.             * à a4, car la prochaine arete est déja
  727.             * pointée par a4
  728.  
  729.             * passage à l'y suivant (calcul des nouveaux x)
  730. y_suivant
  731.             * hypothese : les contours sont non autointersectant
  732.             * sinon : rajouter un tri sur les X
  733.             * lorsque toutes les aretes sont recalculees!
  734.     subq.w #1,(a4,hauteur)
  735.     clr.l d1
  736.     move.w (a4,accu),d1
  737.     add.l (a4,pente),d1
  738.     move.w d1,(a4,accu)
  739.     swap d1
  740.     add.w d1,(a4,coor_x)
  741.     adda.l #aretes_inter,a4
  742. elimine_arete_fin
  743.     cmpa.l a4,a3
  744.     bne elimine_arete
  745.             * passage à la ligne suivante
  746.     addq.w #1,d0    * y suivant
  747.     adda.l #ecran_largeur*2,a1    * adresse suivante
  748.  
  749.     tst.w d7        * ici plus d'arete dans la liste d'intersection
  750.             * si il y en a encore dans l'ensemble d'arete,
  751.             * alors on passe à y suivant, sinon fin
  752.     bne fin_polygone
  753.     bra ajout_arete
  754. fin_polygone
  755.     cmpa.l #liste_aretes,a3    * liste d'arete_vide?
  756.     bne ajout_arete
  757.     rts
  758.     include "principh.s"
  759.  
  760.     section DATA
  761. polygone    dc.w 160,0
  762.     dc.w 60,100
  763.     dc.w 160,200
  764.     dc.w 260,100
  765.     dc.w 160,0
  766.     ds.w nbre_cote*2
  767.  
  768.     section BSS
  769. resultat1    ds.w nbre_cote*2*2
  770. resultat2    ds.w nbre_cote*2*2
  771.  
  772.     even
  773. aretes_triees    ds.b (12+1)*aretes
  774.     even
  775.         ds.b aretes_inter
  776. liste_aretes    ds.b (12+1)*aretes_inter
  777.