; Mode X (320x240, 256 colors) rectangle 4x4 pattern fill routine.
; Upper left corner of pattern is always aligned to a multiple-of-4
; row and column. Works on all VGAs. Uses approach of copying the
; pattern to off-screen display memory, then loading the latches with
; the pattern for each scan line and filling each scan line four
; pixels at a time. Fills up to but not including the column at EndX
; and the row at EndY. No clipping is performed. All ASM code tested
; with TASM. C near-callable as:
;
;    void FillPatternX(int StartX, int StartY, int EndX, int EndY,
;	unsigned int PageBase, char* Pattern);

SC_INDEX	equ	03c4h	;Sequence Controller Index register port
MAP_MASK	equ	02h	;index in SC of Map Mask register
GC_INDEX	equ	03ceh	;Graphics Controller Index register port
BIT_MASK	equ	08h	;index in GC of Bit Mask register
PATTERN_BUFFER	equ	0fffch	;offset in screen memory of the buffer used
				; to store each pattern during drawing
SCREEN_SEG	equ	0a000h	;segment of display memory in Mode X
SCREEN_WIDTH	equ	80	;width of screen in addresses from one scan
				; line to the next
parms	struc
	dw	2 dup (?)	;pushed BP and return address
StartX	dw	?		;X coordinate of upper left corner of rect
StartY	dw	?		;Y coordinate of upper left corner of rect
EndX	dw	?		;X coordinate of lower right corner of rect
				; (the row at EndX is not filled)
EndY	dw	?		;Y coordinate of lower right corner of rect
				; (the column at EndY is not filled)
PageBase dw	?		;base offset in display memory of page in
				; which to fill rectangle
Pattern dw	?		;4x4 pattern with which to fill rectangle
parms	ends

NextScanOffset	 equ   -2	;local storage for distance from end of one
				; scan line to start of next
RectAddrWidth	 equ   -4	;local storage for address width of rectangle
Height		 equ   -6	;local storage for height of rectangle
STACK_FRAME_SIZE equ	6

	.model	small
	.data
; Plane masks for clipping left and right edges of rectangle.
LeftClipPlaneMask	db	00fh,00eh,00ch,008h
RightClipPlaneMask	db	00fh,001h,003h,007h
	.code
	public	_FillPatternX
_FillPatternX proc    near
	push	bp		;preserve caller's stack frame
	mov	bp,sp		;point to local stack frame
	sub	sp,STACK_FRAME_SIZE ;allocate space for local vars
	push	si		;preserve caller's register variables
	push	di

	cld
	mov	ax,SCREEN_SEG	;point ES to display memory
	mov	es,ax
				;copy pattern to display memory buffer
	mov	si,[bp+Pattern] ;point to pattern to fill with
	mov	di,PATTERN_BUFFER ;point ES:DI to pattern buffer
	mov	dx,SC_INDEX	;point Sequence Controller Index to
	mov	al,MAP_MASK	; Map Mask
	out	dx,al
	inc	dx		;point to SC Data register
	mov	cx,4		;4 pixel quadruplets in pattern
DownloadPatternLoop:
	mov	al,1		;
	out	dx,al		;select plane 0 for writes
	movsb			;copy over next plane 0 pattern pixel
	dec	di		;stay at same address for next plane
	mov	al,2		;
	out	dx,al		;select plane 1 for writes
	movsb			;copy over next plane 1 pattern pixel
	dec	di		;stay at same address for next plane
	mov	al,4		;
	out	dx,al		;select plane 2 for writes
	movsb			;copy over next plane 2 pattern pixel
	dec	di		;stay at same address for next plane
	mov	al,8		;
	out	dx,al		;select plane 3 for writes
	movsb			;copy over next plane 3 pattern pixel
				; and advance address
	loop	DownloadPatternLoop

	mov	dx,GC_INDEX	;set the bit mask to select all bits
	mov	ax,00000h+BIT_MASK ; from the latches and none from
	out	dx,ax		; the CPU, so that we can write the
				; latch contents directly to memory
	mov	ax,[bp+StartY]	;top rectangle scan line
	mov	si,ax
	and	si,011b		;top rect scan line modulo 4
	add	si,PATTERN_BUFFER ;point to pattern scan line that
				; maps to top line of rect to draw
	mov	dx,SCREEN_WIDTH
	mul	dx		;offset in page of top rectangle scan line
	mov	di,[bp+StartX]
	mov	bx,di
	shr	di,1		;X/4 = offset of first rectangle pixel in scan
	shr	di,1		; line
	add	di,ax		;offset of first rectangle pixel in page
	add	di,[bp+PageBase] ;offset of first rectangle pixel in
				; display memory
	and	bx,0003h	;look up left edge plane mask
	mov	ah,LeftClipPlaneMask[bx] ; to clip
	mov	bx,[bp+EndX]
	and	bx,0003h	;look up right edge plane
	mov	al,RightClipPlaneMask[bx] ; mask to clip
	mov	bx,ax		;put the masks in BX

	mov	cx,[bp+EndX]	;calculate # of addresses across rect
	mov	ax,[bp+StartX]
	cmp	cx,ax
	jle	FillDone	;skip if 0 or negative width
	dec	cx
	and	ax,not 011b
	sub	cx,ax
	shr	cx,1
	shr	cx,1		;# of addresses across rectangle to fill - 1
	jnz	MasksSet	;there's more than one pixel to draw
	and	bh,bl		;there's only one pixel, so combine the left
				; and right edge clip masks
MasksSet:
	mov	ax,[bp+EndY]
	sub	ax,[bp+StartY]	;AX = height of rectangle
	jle	FillDone	;skip if 0 or negative height
	mov	[bp+Height],ax
	mov	ax,SCREEN_WIDTH
	sub	ax,cx		;distance from end of one scan line to start
	dec	ax		; of next
	mov	[bp+NextScanOffset],ax
	mov	[bp+RectAddrWidth],cx ;remember width in addresses - 1
	mov	dx,SC_INDEX+1	;point to Sequence Controller Data reg
				; (SC Index still points to Map Mask)
FillRowsLoop:
	mov	cx,[bp+RectAddrWidth] ;width across - 1
	mov	al,es:[si]	;read display memory to latch this scan
				; line's pattern
	inc	si		;point to the next pattern scan line, wrapping
	jnz	short NoWrap	; back to the start of the pattern if
	sub	si,4		; we've run off the end
NoWrap:
	mov	al,bh		;put left-edge clip mask in AL
	out	dx,al		;set the left-edge plane (clip) mask
	stosb			;draw the left edge (pixels come from latches;
				; value written by CPU doesn't matter)
	dec	cx		;count off left edge address
	js	FillLoopBottom	;that's the only address
	jz	DoRightEdge	;there are only two addresses
	mov	al,00fh		;middle addresses are drawn 4 pixels at a pop
	out	dx,al		;set the middle pixel mask to no clip
	rep	stosb		;draw the middle addresses four pixels apiece
				; (from latches; value written doesn't matter)
DoRightEdge:
	mov	al,bl		;put right-edge clip mask in AL
	out	dx,al		;set the right-edge plane (clip) mask
	stosb			;draw the right edge (from latches; value
				; written doesn't matter)
FillLoopBottom:
	add	di,[bp+NextScanOffset] ;point to the start of the next scan
				; line of the rectangle
	dec	word ptr [bp+Height] ;count down scan lines
	jnz	FillRowsLoop
FillDone:
	mov	dx,GC_INDEX+1	;restore the bit mask to its default,
	mov	al,0ffh		; which selects all bits from the CPU
	out	dx,al		; and none from the latches (the GC
				; Index still points to Bit Mask)
	pop	di		;restore caller's register variables
	pop	si
	mov	sp,bp		;discard storage for local variables
	pop	bp		;restore caller's stack frame
	ret
_FillPatternX endp
	end