Previous | Table of Contents | Next

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 | Table of Contents | Next

Graphics Programming Black Book © 2001 Michael Abrash