Procedure Line(x1,y1,x2,y2:Integer;Col:Byte);
var i, dx, dy, npix, d, di1, di2, x, xi1, xi2, y, yi1, yi2 : Integer;
begin

  dx := abs(x2 - x1);
  dy := abs(y2 - y1);

  if dx >= dy then
    begin
      npix := dx + 1;
      d := (2 * dy) - dx;
      di1 := 2 * dy;
      di2 := 2 * (dy - dx);
      xi1 := 1;
      xi2 := 1;
      yi1 := 0;
      yi2 := 1;
    end
  else
    begin
      npix := dy + 1;
      d := (2 * dx) - dy;
      di1 := 2 * dx;
      di2 := 2 * (dx - dy);
      xi1 := 0;
      xi2 := 1;
      yi1 := 1;
      yi2 := 1;
    end;

  if x1 > x2 then
    begin
      xi1 := - xi1;
      xi2 := - xi2;
    end;
  if y1 > y2 then
    begin
      yi1 := - yi1;
      yi2 := - yi2;
    end;

  x := x1;
  y := y1;

  for i := 1 to npix do
    begin
      PutPixel(x, y, col);
      if d < 0 then
        begin
          d := d + di1;
          x := x + xi1;
          y := y + yi1;
        end
      else
        begin
          d := d + di2;
          x := x + xi2;
          y := y + yi2;
        end;
    end;
end;

Procedure HLine(x1,x2,y:word;col:byte;output:word); assembler;
asm
   mov   es,output { adresa kam se má čára kreslit -> es }
   mov   ax,y      { y souřadnice horizontální čáry -> ax }
   xchg  al,ah     { prohodí horní a dolní bajt registru ax }
   mov   di,ax     { ax -> di }
   shr   di,2      { posun o dva bity doprava v registru di }
   add   di,ax     { připočte ax k di (Y*320) }
   add   di,x1     { připočte souřadnice x, začne se vykreslovat na [es:di] }
   mov   al,col    { barva čáry do registru al }
   mov   ah,al     { skopíruje dolní bajt do horního bajtu registru ax }
   mov   cx,x2     { konečná souřadnice čáry x2 do registru cx }
   sub   cx,x1     { cx bude obsahovat délku čáry: cx = x2 - x1 }
   shr   cx,1      { posun o bit doprava v registru cx }
   jnc   @1        { zjistí zda-li je cx sudé, pak-li, že je, skočí na @1 }
   stosb           { je-li cx liché nakreslí lichý bod a pokračuje }
@1:rep   stosw     { vyplní pamět od [es:di] do [es:di+cx] registrem ax }
end;

Procedure Line(x1,y1,x2,y2:integer;col:byte;output:word); assembler;
var i, dx, dy, npix, d, di1, di2, x, xi1, xi2,
    y, yi1, yi2,scri1, scri2 : integer;
    scr : word;
asm
       mov ax,x1      { do ax souřadnici x1 }
       mov bx,x2      { do bx souřadnici x2 }
       sub ax,bx      { odečte x2 - x1 a výsledek uloží do ax }
       jae @x         { je-li výsledek kladný skočí na @x }
       neg ax         { není-li kladný, zneguje ax }
   @x: mov cx,ax      { cx <- abs(x2-x1), x-ová délka čáry (deltaX) }
       mov ax,y1      { do ax souřadnici y1 }
       mov bx,y2      { do bx souřadnici y2 }
       sub ax,bx      { odečte y2 - y1 a výsledek uloží do ax }
       jae @y         { je-li výsledek kladný skočí na @y }
       neg ax         { není-li kladný, zneguje ax }
   @y: mov dx,ax      { dx <- abs(y2-y1), y-ová délka čáry (deltaY) }
       mov xi1,1      { xi1 <- 1 }
       mov xi2,1      { xi2 <- 1 }
       mov yi1,0      { yi1 <- 0 }
       mov yi2,1      { yi2 <- 1 }
       cmp cx,dx      { porovná cx a dx (deltaX a deltaY) }
       jae @@1        { je-li cx >= dx pak sokočí na @@1 }
       xchg cx,dx     { jinak prohodí cx a dx }
       mov ax,yi1     { a do ax uloří inkrement yi1 }
       xchg xi1,ax    { do xi1 hodí ax a do ax hodí xi1 }
       mov yi1,ax     { yi1 <- ax, prohodil yi1 s xi1 }
  @@1: mov ax,cx      { ax <- cx (v cx je vyžší z deltaY a deltaX) }
       inc ax         { ax = ax + 1 }
       mov npix,ax    { npix <- ax }
       mov ax,cx      { ax <- cx }
       mov bx,dx      { bx <- dx (v dx je nižší z deltaY a deltaX) }
       shl bx,1       { provede posuv o jeden bit doleva v registru bx }
       mov di1,bx     { di1 <- (bx * 2) }
       sub bx,ax      { bx = bx - ax }
       mov d,bx       { d <- bx (delta) }
       mov bx,dx      { bx <- dx }
       sub bx,ax      { bx = bx - ax }
       shl bx,1       { provede posuv o jeden bit doleva v registru bx }
       mov di2,bx     { di2 <- (bx * 2) }
       mov ax,x1      { ax <- souřadnice x1 }
       mov bx,x2      { bx <- souřadnice x2 }
       cmp bx,ax      { porovná bx a ax (x1 a x2) }
       jae @@2        { je-li bx >= ax skočí na @@2 }
       neg xi1        { jinak zneguje xi1 }
       neg xi2        { zneguje xi2 }
   @@2:mov ax,y1      { ax <- souřadnice y1 }
       mov bx,y2      { bx <- souřadnice y2 }
       cmp bx,ax      { porovná bx a ax (y1 a y2) }
       jae @@3        { je-li bx >= ax skočí na @@3 }
       neg yi1        { jinak zneguje yi1 }
       neg yi2        { zneguje yi2 }
   @@3:mov ax,y1      { ax <- souřadnice y1 }
       mov bx,y1      { bx <- souřadnice y1 }
       shl ax,8       { provede posun o 8 bitů doleva v registru ax }
       shl bx,6       { provede posun o 6 bitů doleva v registru bx }
       add ax,bx      { ax = ax + bx, (ax=y1*320) }
       add ax,x1      { ax = ax + x1, (ax=y1*320+x1) }
       mov scr,ax     { scr <- ax }
       mov ax,yi1     { ax <- yi1 }
       mov bx,yi1     { bx <- yi1 }
       shl ax,8       { provede posun o 8 bitů doleva v registru ax }
       shl bx,6       { provede posun o 6 bitů doleva v registru bx }
       add ax,bx      { ax = ax + bx, (ax=yi1*320) }
       add ax,xi1     { ax = ax + x1, (ax=yi1*320+xi1) }
       mov scri1,ax   { scri1 <- ax }
       mov ax,yi2     { ax <- yi2 }
       mov bx,yi2     { bx <- yi2 }
       shl ax,8       { provede posun o 8 bitů doleva v registru ax }
       shl bx,6       { provede posun o 6 bitů doleva v registru bx }
       add ax,bx      { ax = ax + bx, (ax=yi2*320) }
       add ax,xi2     { ax = ax + x1, (ax=yi2*320+xi2) }
       mov scri2,ax   { scri2 <- ax }
       push output    { uloží na vrchol zásobníku cílový segment }
       pop es         { naplní register es cílový segment }
       mov di,scr     { di <- scr }
       mov dx,d       { dx <- d (delta) }
       mov al,col     { al <- barva čáry col }
       mov cx,npix    { cx <- npix (počet pixelů) }
       mov bx,di1     { bx <- di1 }
   @b1:mov es:[di],al { naplní bajt na adrese [es:di] bajtem al }
       cmp dx,0       { porovná dx s 0 }
       jnl @b2        { je-li dx >= 0 skočí na @b2 }
       add dx,bx      { dx = dx + bx }
       add di,scri1   { di = di + scri1 }
       jmp @b3        { skočí na @b3 }
   @b2:add dx,di2     { dx = dx + di2 }
       add di,scri2   { di = di + scri2 }
   @b3:loop @b1       { opakuje @b1 dokud cx<>0 }
end;


            výheň