home *** CD-ROM | disk | FTP | other *** search
/ DP Tool Club 26 / CD_ASCQ_26_1295.iso / voxrom / textes / repwin08 / annexes / scythale / graph / scroll.pas < prev    next >
Pascal/Delphi Source File  |  1995-10-01  |  7KB  |  248 lines
  1. { SCROLL UNIT : Programmation SQUIRREL }
  2. {$A+,B-,D+,E+,F-,G+,I-,L+,N+,O-,P+,Q-,R-,S+,T+,V+,X+}
  3. Unit Scroll;
  4.  
  5. INTERFACE
  6.  
  7. PROCEDURE Scroll_Up (x, y, l, h : word; speed : byte);
  8. PROCEDURE Scroll_Down (x, y, l, h : word; speed : byte);
  9.  
  10. IMPLEMENTATION
  11.  
  12. { 640x350 & 640x480  ...  x16 }
  13.  
  14. PROCEDURE Scroll_Up (x, y, l, h : word; speed : byte);
  15. ASSEMBLER;
  16. ASM
  17.     push  ds               { sauver DS ! }
  18.  
  19.     mov   dx, $3CE         { Graphique controleur }
  20.     mov   ax, $0105        { $01 Write 1/Read 0. $05 reg. Mode  }
  21.     out   dx, ax
  22.  
  23.     cld                    { tant qu'à faire, autant aller dans le bon sens }
  24.  
  25.     mov   cx, h
  26.     mov   ax, cx
  27.     shl   ax, 4
  28.     shl   cx, 6
  29.     add   cx, ax           { cx = h * 80 }
  30.  
  31.     mov   bx, y
  32.     mov   ax, bx
  33.     shl   ax, 4
  34.     shl   bx, 6
  35.     add   bx, ax           { bx = y * 80 }
  36.     mov   ax, x
  37.     shr   ax, 3
  38.     add   bx, ax           { bx = y * 80 + x / 8 }
  39.  
  40.     xor   dh, dh
  41.     mov   dl, speed
  42.     mov   ax, dx
  43.     shl   ax, 4
  44.     shl   dx, 6
  45.     add   dx, ax           { dx = vitesse * 80 }
  46.  
  47.     mov   ax, cx           { ax = cx = nombre de déplacements }
  48.     add   ax, bx
  49.  
  50.     mov   cl, test8086                              { Type de processeur.. }
  51.  
  52.     mov   si, $A000
  53.     mov   ds, si
  54.     mov   es, si           { ds & es ^ $A000, Mémoire vidéo }
  55.  
  56.     cmp   cl, 1                                        { je me passe du G+ }
  57. {    je    @yop286          { Instructions 16 bits }
  58. {    ja    @yop386          { Instructions 32 bits }
  59.                             { sinon, simples instr. 8 bits }
  60.  
  61. {═[08]═════════════════════════════════════════════════════[ 8086 only ]═══ }
  62. @yop8086:                  { boucle... }
  63.  
  64.     mov   si, bx
  65.     mov   di, si
  66.     sub   di, dx           { di = si + vitesse de déplacement }
  67.  
  68.     mov   cx, l            { cx = largeur / 8 }
  69.     shr   cx, 3
  70.     rep   movsb            { On repete cx fois }
  71.  
  72.     add   bx, 80           { incrementer l'offset }
  73.     cmp   bx, ax
  74.     jb    @yop8086         { pas fini ? ---> yop ! }
  75.  
  76.     jmp   @fin
  77.  
  78.  
  79. {═[16]════════════════════════════════════════════════════[ 80286 only ]═══ }
  80. @yop286:                   { boucle... }
  81.  
  82.     mov   si, bx
  83.     mov   di, si
  84.     sub   di, dx           { di = si + vitesse de déplacement }
  85.  
  86.     mov   cx, l            { cx = largeur / 8 }
  87.     shr   cx, 4
  88.     rep   movsw            { On repete cx fois des word }
  89.     test  l, 8             { Paire ??? }
  90.     jz    @Paire16bit
  91.     movsb                  { c'est impair ! }
  92.  
  93. @Paire16bit:
  94.     add   bx, 80           { incrementer le deplacement }
  95.     cmp   bx, ax
  96.     jb    @yop286          { pas fini ? ---> yop ! }
  97.  
  98.     jmp   @fin
  99.  
  100. {═[32]═════════════════════════════════════════════[ 80386 et suivants ]═══ }
  101. @yop386:                   { boucle... }
  102.  
  103.     mov   si, bx
  104.     mov   di, si
  105.     sub   di, dx           { di = si + vitesse de déplacement }
  106.  
  107.     mov   cx, l            { cx = largeur / 8 }
  108.     shr   cx, 5
  109.   { rep   movsd            { On repete cx fois des long } db $F3,$66,$A5
  110.     mov   cx, l
  111.     shr   cx, 3
  112.     and   cx, 3
  113.     rep   movsb            { Complement à 4 }
  114.  
  115.     add   bx, 80           { incrementer le deplacement }
  116.     cmp   bx, ax
  117.     jb    @yop386          { pas fini ? ---> yop ! }
  118.  
  119.     jmp   @fin
  120.  
  121. @fin:
  122.     pop   ds               { on restaure DS }
  123.   END;
  124.  
  125. PROCEDURE Scroll_Down (x, y, l, h : word; speed : byte);
  126. ASSEMBLER;
  127. ASM
  128.     push  ds               { sauver DS ! }
  129.  
  130.     mov   dx, $3CE         { Graphique controleur }
  131.     mov   ax, $0105        { $01 Write 1/Read 0. $05 reg. Mode  }
  132.     out   dx, ax
  133.  
  134.     cld
  135.  
  136.     mov   cx, h
  137.     mov   ax, cx
  138.     shl   ax, 4
  139.     shl   cx, 6
  140.     add   cx, ax           { cx = h * 80 }
  141.  
  142.     mov   bx, y
  143.     mov   ax, bx
  144.     shl   ax, 4
  145.     shl   bx, 6
  146.     add   bx, ax           { bx = y * 80 }
  147.     mov   ax, x
  148.     shr   ax, 3
  149.     add   bx, ax           { bx = y * 80 + x / 8 }
  150.  
  151.     xor   dh, dh
  152.     mov   dl, speed
  153.     mov   ax, dx
  154.     shl   ax, 4
  155.     shl   dx, 6
  156.     add   dx, ax           { dx = vitesse * 80 }
  157.  
  158.     mov   ax, cx           { ax = cx = nombre de déplacements }
  159.  
  160.     mov   cl, test8086                              { Type de processeur.. }
  161.  
  162.     mov   si, $A000
  163.     mov   ds, si
  164.     mov   es, si           { ds & es ^ $A000, Mémoire vidéo }
  165.  
  166.     cmp   cl, 1                                        { je me passe du G+ }
  167. {    je    @yop286          { Instructions 16 bits }
  168. {    ja    @yop386          { Instructions 32 bits }
  169.                            { sinon, simples instr. 8 bits }
  170.  
  171. {═[08]═════════════════════════════════════════════════════[ 8086 only ]═══ }
  172. @yop8086:                  { boucle... }
  173.  
  174.     mov   si, bx
  175.     add   si, ax
  176.     mov   di, si
  177.     add   di, dx           { di = si + vitesse de déplacement }
  178.  
  179.     mov   cx, l            { cx = largeur / 8 }
  180.     shr   cx, 3
  181.     rep   movsb            { On repete cx fois }
  182.  
  183.     sub   ax, 80           { incrementer l'offset }
  184.     cmp   ax, 0
  185.     ja    @yop8086         { pas fini ? ---> yop ! }
  186.  
  187.     jmp   @fin
  188.  
  189.  
  190. {═[16]════════════════════════════════════════════════════[ 80286 only ]═══ }
  191. @yop286:                   { boucle... }
  192.  
  193.     mov   si, bx
  194.     add   si, ax           { si = bx + cx soit offset + deplacement }
  195.     mov   di, si
  196.     add   di, dx           { di = si + vitesse de déplacement }
  197.  
  198.     mov   cx, l            { cx = largeur / 8 }
  199.     shr   cx, 4
  200.     rep   movsw            { On repete cx fois des word }
  201.     test  l, 8             { Paire ??? }
  202.     jz    @Paire16bit
  203.     movsb                  { c'est impair ! }
  204.  
  205. @Paire16bit:
  206.     sub   ax, 80           { incrementer le deplacement }
  207.     cmp   ax, 0
  208.     jne   @yop286          { pas fini ? ---> yop ! }
  209.  
  210.     jmp   @fin
  211.  
  212. {═[32]═════════════════════════════════════════════[ 80386 et suivants ]═══ }
  213. @yop386:                   { boucle... }
  214.  
  215.     mov   si, bx
  216.     add   si, ax           { si = bx + cx soit offset + deplacement }
  217.     mov   di, si
  218.     add   di, dx           { di = si + vitesse de déplacement }
  219.  
  220.     mov   cx, l            { cx = largeur / 8 }
  221.     shr   cx, 5
  222.   { rep   movsd            { On repete cx fois des long } db $F3,$66,$A5
  223.     mov   cx, l
  224.     shr   cx, 3
  225.     and   cx, 3
  226.     rep   movsb            { Complement à 4 }
  227.  
  228.     sub   ax, 80           { incrementer le deplacement }
  229.     cmp   ax, 0
  230.     jne   @yop386          { pas fini ? ---> yop ! }
  231.  
  232.     jmp   @fin
  233.  
  234. @fin:
  235.     pop   ds               { on restaure DS }
  236.   END;
  237.  
  238. END.
  239.  
  240.  
  241. Les déplacements 16/32 bits ne marchent pas car la carte VGA s'embrouille
  242. les papattes dans ses registres latches. Je n'ai pas encore tout compris
  243. sur le sujet, mais il est claire qu'en lisant 2 ou 4 octets à la fois,
  244. l'ensemble des registres latches qui l'entoure ne peuvent contenir eux
  245. de 2 à 4 valeurs !! Donc nous voilà condamnés au mode 8 bits ! :-(
  246.  
  247.                                                                Squirrel.
  248.