; Scan converts an edge from (X1,Y1) to (X2,Y2), not including the
; point at (X2,Y2). If SkipFirst == 1, the point at (X1,Y1) isn't
; drawn; if SkipFirst == 0, it is. For each scan line, the pixel
; closest to the scanned edge without being to the left of the scanned
; edge is chosen. Uses an all-integer approach for speed & precision.
;
; C near-callable as:
;    void ScanEdge(int X1, int Y1, int X2, int Y2, int SetXStart,
;	  int SkipFirst, struct HLine **EdgePointPtr);
;
; Edges must not go bottom to top; that is, Y1 must be <= Y2.
; Updates the pointer pointed to by EdgePointPtr to point to the next
;  free entry in the array of HLine structures.

HLine	struc
XStart	dw	?	;X coordinate of leftmost pixel in scan line
XEnd	dw	?	;X coordinate of rightmost pixel in scan line
HLine	ends

Parms	struc
		dw	2 dup(?) ;return address & pushed BP
X1		dw	?	;X start coord of edge
Y1		dw	?	;Y start coord of edge
X2		dw	?	;X end coord of edge
Y2		dw	?	;Y end coord of edge
SetXStart	dw	?	;1 to set the XStart field of each
				; HLine struc, 0 to set XEnd
SkipFirst	dw	?	;1 to skip scanning the first point
				; of the edge, 0 to scan first point
EdgePointPtr	dw	?	;pointer to a pointer to the array of
				; HLine structures in which to store
				; the scanned X coordinates
Parms	ends

;Offsets from BP in stack frame of local variables.
AdvanceAmt      equ     -2
Height          equ     -4
LOCAL_SIZE      equ     4	;total size of local variables

	.model small
	.code
	public _ScanEdge
	align	2
_ScanEdge	proc
	push	bp		;preserve caller's stack frame
	mov	bp,sp		;point to our stack frame
        sub     sp,LOCAL_SIZE   ;allocate space for local variables
	push	si		;preserve caller's register variables
	push	di
	mov	di,[bp+EdgePointPtr]
	mov	di,[di]		;point to the HLine array
	cmp	[bp+SetXStart],1 ;set the XStart field of each HLine
				; struc?
	jz	HLinePtrSet	;yes, DI points to the first XStart
	add	di,XEnd		;no, point to the XEnd field of the
				; first HLine struc
HLinePtrSet:
	mov	bx,[bp+Y2]
	sub	bx,[bp+Y1]	;edge height
	jle	ToScanEdgeExit	;guard against 0-length & horz edges
	mov	[bp+Height],bx	;Height = Y2 - Y1
	sub	cx,cx		;assume ErrorTerm starts at 0 (true if
                                ; we're moving right as we draw)
	mov	dx,1		;assume AdvanceAmt = 1 (move right)
	mov	ax,[bp+X2]
	sub	ax,[bp+X1]      ;DeltaX = X2 - X1
        jz      IsVertical     	;it's a vertical edge--special case it
	jns	SetAdvanceAmt	;DeltaX >= 0
	mov	cx,1		;DeltaX < 0 (move left as we draw)
	sub	cx,bx		;ErrorTerm = -Height + 1
	neg	dx		;AdvanceAmt = -1 (move left)
        neg     ax              ;Width = abs(DeltaX)
SetAdvanceAmt:
	mov	[bp+AdvanceAmt],dx
; Figure out whether the edge is diagonal, X-major (more horizontal),
; or Y-major (more vertical) and handle appropriately.
	cmp	ax,bx		;if Width==Height, it's a diagonal edge
	jz	IsDiagonal	;it's a diagonal edge--special case
	jb	YMajor		;it's a Y-major (more vertical) edge
				;it's an X-major (more horz) edge
        sub     dx,dx           ;prepare DX:AX (Width) for division
        div     bx		;Width/Height
				;DX = error term advance per scan line
	mov	si,ax		;SI = minimum # of pixels to advance X
				; on each scan line
        test    [bp+AdvanceAmt],8000h ;move left or right?
        jz      XMajorAdvanceAmtSet ;right, already set
        neg     si              ;left, negate the distance to advance
				; on each scan line
XMajorAdvanceAmtSet:            ;
	mov	ax,[bp+X1]	;starting X coordinate
        cmp     [bp+SkipFirst],1 ;skip the first point?
        jz	XMajorSkipEntry	;yes
XMajorLoop:
	mov	[di],ax		;store the current X value
	add	di,size HLine	;point to the next HLine struc
XMajorSkipEntry:
	add	ax,si		;set X for the next scan line
	add	cx,dx		;advance error term
	jle	XMajorNoAdvance ;not time for X coord to advance one
				; extra
	add	ax,[bp+AdvanceAmt] ;advance X coord one extra
        sub     cx,[bp+Height]  ;adjust error term back
XMajorNoAdvance:
        dec     bx		;count off this scan line
        jnz     XMajorLoop
	jmp	ScanEdgeDone
	align	2
ToScanEdgeExit:
	jmp	ScanEdgeExit
        align	2
IsVertical:
	mov	ax,[bp+X1]	;starting (and only) X coordinate
	sub	bx,[bp+SkipFirst] ;loop count = Height - SkipFirst
        jz      ScanEdgeExit 	;no scan lines left after skipping 1st
VerticalLoop:
	mov	[di],ax		;store the current X value
	add	di,size HLine	;point to the next HLine struc
	dec	bx		;count off this scan line
	jnz	VerticalLoop
	jmp	ScanEdgeDone
        align	2
IsDiagonal:
	mov	ax,[bp+X1]	;starting X coordinate
        cmp     [bp+SkipFirst],1 ;skip the first point?
	jz	DiagonalSkipEntry ;yes
DiagonalLoop:	
	mov	[di],ax		;store the current X value
	add	di,size HLine	;point to the next HLine struc
DiagonalSkipEntry:
	add	ax,dx		;advance the X coordinate
	dec	bx		;count off this scan line
	jnz	DiagonalLoop
	jmp	ScanEdgeDone
        align	2
YMajor:
	push	bp		;preserve stack frame pointer
	mov	si,[bp+X1]	;starting X coordinate
        cmp     [bp+SkipFirst],1 ;skip the first point?
	mov	bp,bx		;put Height in BP for error term calcs
        jz	YMajorSkipEntry	;yes, skip the first point
YMajorLoop:
	mov	[di],si		;store the current X value
	add	di,size HLine	;point to the next HLine struc
YMajorSkipEntry:
	add	cx,ax		;advance the error term
	jle	YMajorNoAdvance ;not time for X coord to advance
	add	si,dx		;advance the X coordinate
        sub     cx,bp		;adjust error term back
YMajorNoAdvance:
        dec     bx		;count off this scan line
        jnz     YMajorLoop
	pop	bp		;restore stack frame pointer
ScanEdgeDone:
	cmp	[bp+SetXStart],1 ;were we working with XStart field?
	jz	UpdateHLinePtr	;yes, DI points to the next XStart
	sub	di,XEnd		;no, point back to the XStart field
UpdateHLinePtr:
	mov	bx,[bp+EdgePointPtr] ;point to pointer to HLine array
	mov	[bx],di		;update caller's HLine array pointer
ScanEdgeExit:
	pop	di		;restore caller's register variables
	pop	si
        mov     sp,bp           ;deallocate local variables
	pop	bp		;restore caller's stack frame
	ret
_ScanEdge	endp
	end
