189 lines
11 KiB
Markdown
189 lines
11 KiB
Markdown
------------------------ --------------------------------- --------------------
|
||
[Previous](48-01.html) [Table of Contents](index.html) [Next](48-03.html)
|
||
------------------------ --------------------------------- --------------------
|
||
|
||
**LISTING 48.2 L48-2.ASM**
|
||
|
||
; 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
|
||
|
||
------------------------ --------------------------------- --------------------
|
||
[Previous](48-01.html) [Table of Contents](index.html) [Next](48-03.html)
|
||
------------------------ --------------------------------- --------------------
|
||
|
||
* * * * *
|
||
|
||
Graphics Programming Black Book © 2001 Michael Abrash
|