les DI, Screen.Buffer
  mov BX, Y1
  add BX, BX
  add DI, WORD [BX+Screen.YTable]  { DI := Y1*320+X1 }
  add DI, X1

  mov AX, X2   { DeltaX := X2-X1+1 }
  mov BX, Y2   { DeltaY := Y2-Y1+1 }
  sub AX, X1
  sub BX, Y1
  inc AX
  inc BX

  { ShortLen := DeltaX DIV DeltaY
    Rem := DeltaX MOD DeltaY }

  xor DX, DX  { Clear upper word       }
  div BX      { AX = ShortLen DX = Rem }
  mov CX, AX   { CX = ShortLen }

  xor AX, AX   { Rem is already SHL 16 }
  div BX       { Incr := (LONGINT(Rem) SHL 16) DIV DeltaY }

  mov SI, AX   { SI := Incr }

  mov DX, CX             { DX = ShortLen                               }
  mov AH, BL             { AH = DeltaY                                 }
  mov AL, Color
  xor CX, CX             { Initialize CX to zero                       }
  mov BX, 32768          { BX = 0.5 SHL 16                             }
@InnerLoop:
  add BX, SI             { Update our fraction...                      }
  adc CX, DX             { If it overflows, then draw a long line!     }
  rep stosb              { Draw the run (Sets CX to zero)              }
  add DI, Screen.Width   { Next Y!                                     }

  dec AH
  jnz @InnerLoop         { Try again                                   
    

mov BX, 32768          { BX = 0.5 SHL 16                             }
@InnerLoop:
  add BX, SI             { Update our fraction...                      }
  adc CX, DX             { If it overflows, then draw a long line!     }
    

xor AX, AX   { Rem is already SHL 16 }
  div BX       { Incr := (LONGINT(Rem) SHL 16) DIV DeltaY }
    

It is adding one half (0.5) using fixed point (16 bit integer and 16 bit fraction) arithmetic.

Well could you explain how it works? Thanks

me239 wrote:

Well could you explain how it works? Thanks

http://en.wikipedia.org/wiki/Fixed-point_arithmetic

... one last thing though, why when AX is empty and DX has a value the DIV command returns a number in AX.

me239 wrote:

... one last thing though, why when AX is empty and DX has a value the DIV command returns a number in AX.

Weel as the Intel/AMD manual will tell you, DIV returns the quotient in AX and the remainder in DX.

mov dx, 2 ; DX = 2 
    xor ax, ax ; AX = 0
    mov bx, 10d ; BX = 0Ah
    div bx ; Now AX hold 3333h?!?
    int 20h
    

DX:AX == 0002:0000
BX == 000A

DX:AX / BX = 20000h / 0Ah = 3333h (in AX) + 2 remainder (in DX).
Same as: 131072 / 10 = 13107.2

I'm still trying to decipher what the .5 shl 16 is really for with respect to the code, but thanks anyway

Think about it in binary.

0001 in binary is one. If you divide this number by two (i.e. shift right by one) the answer is one half. We can represent this as 0000.1000 -- requiring a fractional register with the high bit set. Each position to the right of the decimal represents negative powers of two: 2^-1, 2^-2, 2^-3, ... Work through smaller examples in binary until you are fully convinced as this is a very useful technique.

I'm understanding the fixed point math using DX:AX, but I'm still confused as to why adding 32768(.1) make an accurate line.

me239 wrote:

I'm understanding the fixed point math using DX:AX, but I'm still confused as to why adding 32768(.1) make an accurate line.

32768 is 1/2, not 0.1.

Did you try it with a zero value yet? When you see the results then you will understand why.