GRIPS 2: Government Rast…rocessing Software & Data/GRIPS_2.cdr/dos/pcshow/src/msc5_1/vga.asm

Assembly Source File | 1990-01-06 | 28.6 KB | 1,594 lines

;
;    VGA support routines for raster oriented graphics
;
;    Quincey Koziol        January 1989
;
;    National Center for Supercomputing Applications,    University of Illinois
;    153    Water Resources Building
;    605 E. Springfield Ave.
;    Champaign, Ill    61820
;    [phone]
;
    TITLE      VGA GRAPHICS SUPPORT
.model LARGE
.code
X    EQU        6
;    INCLUDE DOS.MAC
;    SETX
;    PSEG
    PUBLIC    _PUTMAPV,_GETMAP,_VGALINE1,_VGACHUNK,_VGAPT,_VGAMODE,_VGAOFF,_VGAON
    PUBLIC    _OUTLINEV,_BALL,_VGABLOCK,_INVERSEV,_INVERT13,_LINE13
    PUBLIC    _SHOWPALV,_NOPALV
    PUBLIC    _CIRCLE13,_INCIRC13

;    name:     PIXELADDR13
;
;    FUNCTION: CALCULATE THE BUFFER ADDRESS OF PIXEL IN 320X200 256 COLOR MODE
;
;    CALLER:    AX = Y COOR. (0-199)
;            BX = X COOR. (0-319)
;
;
;    RETURNS:    BX = BYTE OFFSET IN BUFFER
;                ES = VIDEO BUFFER SEGMENT
;
ORIGINOFFSET    EQU    0
VIDEOBUFFSEG    EQU    0A000H
PIXELADDR13    PROC    NEAR
    XCHG    AH,AL
    ADD        BX,AX
    SHR        AX,1
    SHR        AX,1
    ADD        BX,AX
    ADD        BX,ORIGINOFFSET
    MOV        AX,VIDEOBUFFSEG
    MOV        ES,AX
    RET
PIXELADDR13    ENDP

;
;    take three arrays of color tables and interleave them into the
;    VGA registers in the fashion Red, Green, Blue.
;

_PUTMAPV    PROC    FAR
    PUSH    BP
    MOV        BP,SP
    PUSH    DS
    PUSH    ES
    PUSH    SI
    PUSH    DI
;
    LDS    SI,DWORD PTR [BP+X]        ; WHERE TO GET RED
    MOV DI,[BP+X+4]        ; WHERE TO GET GREEN
    MOV BP,[BP+X+8]        ; WHERE TO GET BLUE
    MOV    DX,03C8H        ; I/O PORT FOR PEL TABLE
    MOV AL,0            ; VALUE FOR BEGINNING OF TABLE
    OUT DX,AL            ; START OUTPUTTING VALUES
    INC DX                ; INCREMENT DX TO OUTPUT TABLE
    MOV CX,256            ; LENGTH OF THE TABLE IN BYTE TRIPLES

DORGB:
    MOV AL,DS:[SI]        ; GET A RED BYTE
    SHR AL,1
    SHR AL,1            ; GET RID OF TWO HIGHEST BITS
    OUT DX,AL
    INC SI
;
    MOV AL,DS:[DI]        ; GET A GREEN BYTE
    SHR    AL,1
    SHR AL,1            ; GET RID OF TWO HIGHEST BITS
    OUT DX,AL
    INC DI
;
    MOV    AL,DS:[BP]        ; GET A BLUE BYTE
    SHR AL,1
    SHR AL,1            ; GET RID OF TWO HIGHEST BITS
    OUT DX,AL
    INC BP
;
    LOOP DORGB            ; CONTINUE PRINTING UNTIL ALL 768 BYTES ARE WRITTEN
;
    POP        DI
    POP        SI
    POP    ES
    POP    DS
    POP    BP
    RET

_PUTMAPV    ENDP

_GETMAP    PROC    FAR
    RET
_GETMAP    ENDP

;
;  Transfer line to vga screen
;
;   usage : vgaline1(x,y,buf,xoff,linelen)
;
_VGALINE1    PROC    FAR
    PUSH    BP
    MOV        BP,SP
    PUSH    DS
    PUSH    ES
    PUSH    SI
    PUSH    DI

    LDS    SI,DWORD PTR [BP+X+4]    ; WHERE DATA WILL COME FROM
    ADD    SI,[BP+X+8]        ; ADD THE OFFSET TO THE OFFSET OF THE ARRAY
;

    MOV    AX,[BP+X+2]    ; GET THE Y VALUE
    MOV    BX,[BP+X]    ; GET THE X VALUE
    CALL    PIXELADDR13    ; CALCULATE THE ADDRESS OF THE PIXEL
    MOV    DI,BX        ; PREPARE FOR MOVS

    MOV    CX,[BP+X+10]    ; HOW MANY BYTES?
    SHR    CX,1                        ; CHECK WHETHER THIS CAN BE WORD MOV'ED OR NOT
    JC    DOBYTES                        ; NO, CANNOT USE WORD MOVE
    REP    MOVSW                        ; MOVE WORDS
    JMP    SHORT    DONEBYTES            ; JUMP AROUND THE BYTE COPY

DOBYTES:
    MOV    CX,[BP+X+10]                ; GET THE COUNT OF BYTES TO MOVE
    REP    MOVSB                        ; MOV THE MEMORY

DONEBYTES:
    POP        DI
    POP        SI
    POP    ES
    POP    DS
    POP    BP
    RET
_VGALINE1    ENDP


;
;  Transfer chunk to vga screen
;
;   usage : vgachunk(x,y,buf,xoff,yoff,width,height,linelen)
;                int x,y;  the position to place the block on the screen
;                char *buf; the chunk to display
;                int xoff,yoff; the x and y offset into the chunk
;                int width,height; the width and height of the chunk part to display
;                int linelen;  the length of a horizontal raster line in the chunk
;
_VGACHUNK    PROC    FAR
    PUSH    BP
    MOV        BP,SP
    PUSH    DS
    PUSH    ES
    PUSH    SI
    PUSH    DI

    LDS    SI,DWORD PTR [BP+X+4]    ; WHERE DATA WILL COME FROM
    MOV    AX,[BP+X+10]    ; GET THE OFFSET IN THE Y DIRECTION
    JZ    ADD_X_OFF        ; IF THE Y OFFSET IS ZERO THEN JUST ADD IN THE X OFFSET
    MOV    DX,[BP+X+16]    ; GET THE LINE LENGTH
    MUL    DX                ; CALCULATE THE AMOUNT OF OFFSET IN THE Y DIRECTION
    ADD    SI,AX            ; ADD IN THE Y OFFSET
ADD_X_OFF:
    ADD    SI,[BP+X+8]        ; ADD THE OFFSET TO THE OFFSET OF THE ARRAY
;

    MOV    AX,[BP+X+2]        ; GET THE Y VALUE
    MOV    BX,[BP+X]        ; GET THE X VALUE
    CALL    PIXELADDR13    ; CALCULATE THE ADDRESS OF THE PIXEL
    MOV    DI,BX            ; PREPARE FOR MOVS

    MOV    CX,[BP+X+12]    ; HOW MANY BYTES?
    SHR    CX,1            ; CHECK WHETHER THIS CAN BE WORD MOV'ED OR NOT
    JC    CHUNKLOOPB        ; NO, CANNOT USE WORD MOVE
    MOV    [BP+X+12],CX    ; STORE THE NUMBER OF WORDS TO COPY

CHUNKLOOPW:
    PUSH    SI            ; PUSH THE SOURCE INDEX
    PUSH    DI            ; PUSH THE DESTINATION INDEX
    MOV    CX,[BP+X+12]    ; GET THE COUNT OF BYTES TO MOVE
    REP    MOVSW            ; MOVE WORDS

    POP    DI
    ADD DI,320            ; ADD IN THE WIDTH OF THE SCREEN
    POP    SI
    ADD    SI,[BP+X+16]    ; ADD IN THE OFFSET FOR THE NEXT LINE THE CHUNK TO COPY
    DEC WORD PTR [BP+X+14]        ; DECREMENT THE NUMBER OF LINES TO COPY
    JNZ    CHUNKLOOPW        ; CONTINUE TO BLAST OUT LINES UNTIL WE HAVE DONE THEM ALL
    JMP    SHORT    ENDCHUNK

CHUNKLOOPB:
    PUSH    SI            ; PUSH THE SOURCE INDEX
    PUSH    DI            ; PUSH THE DESTINATION INDEX
    MOV    CX,[BP+X+12]    ; GET THE COUNT OF BYTES TO MOVE
    REP    MOVSB            ; MOV THE MEMORY

    POP    DI
    ADD DI,320            ; ADD IN THE WIDTH OF THE SCREEN
    POP    SI
    ADD    SI,[BP+X+16]    ; ADD IN THE OFFSET FOR THE NEXT LINE THE CHUNK TO COPY
    DEC WORD PTR [BP+X+14]        ; DECREMENT THE NUMBER OF LINES TO COPY
    JNZ    CHUNKLOOPB        ; CONTINUE TO BLAST OUT LINES UNTIL WE HAVE DONE THEM ALL

ENDCHUNK:
    POP        DI
    POP        SI
    POP    ES
    POP    DS
    POP    BP
    RET
_VGACHUNK    ENDP

;  draw a point on vga screen
;
;   usage : vgapt(x,y,color)
;
_VGAPT    PROC    FAR
    PUSH    BP
    MOV        BP,SP
    PUSH    DS
    PUSH    ES
    PUSH    DI

;
;   READY TO PUT THE POINT
;
POKBANK:
    MOV    AX,[BP+X+2]    ; GET THE Y VALUE
    MOV    BX,[BP+X]    ; GET THE X VALUE
    CALL PIXELADDR13    ; CALCULATE THE PIXEL ADDRESS
    MOV    DI,BX        ; PREPARE FOR MOVS
    MOV    AL,[BP+X+4]    ; GET COLOR TO PUT THERE

    STOSB            ; PUT IT

    POP        DI
    POP    ES
    POP    DS
    POP    BP
    RET
_VGAPT    ENDP

_VGAMODE        PROC    FAR
    PUSH    BP
    MOV        BP,SP
    PUSH    DS
    PUSH    ES

    MOV        AX,[BP+X]        ;GET SCREEN MODE TO SWITCH TO
    XOR        AH,AH            ;ENTER VIDEO_IO ROUTINE (SET MODE=0)
    INT        10H                ;VIDEO INTERUPT

    POP    ES
    POP    DS
    POP    BP
    RET
_VGAMODE    ENDP


_VGAOFF        PROC    FAR
    PUSH    BP
    MOV        BP,SP
    PUSH    DS
    PUSH    ES

    MOV        DX,03C4H        ;ADDRESS OF THE SEQ CONTROLLER
    MOV        AL,01H            ;INDEX OF THE CLOCKING MODE REGISTER
    OUT        DX,AL            ;SET UP TO READ THE CLOCKING MODE REGISTER
    MOV        DX,03C5H        ;ADDRESS TO READ FROM
    IN        AL,DX            ;GET THE CLOCKING MODE REGISTER
    OR        AL,20H            ;MASK OFF THE SCREEN ENABLE BIT
    MOV        BL,AL            ;KEEP THAT AROUND
    MOV        DX,03C4H        ;ADDRESS OF THE SEQ CONTROLLER
    MOV        AL,01H            ;INDEX OF THE CLOCKING REGISTER
    OUT        DX,AL            ;SET UP TO WRITE BACK THE CLOCKING MODE REGISTER
    INC        DX                ;SET TO ADDRESS TO WRITE TO
    MOV        AL,BL            ;GET BACK THE PROPER VALUE
    OUT        DX,AL            ;TURNS OFF THE VGA SCREEN

    POP    ES
    POP    DS
    POP    BP
    RET
_VGAOFF    ENDP

_VGAON        PROC    FAR
    PUSH    BP
    MOV        BP,SP
    PUSH    DS
    PUSH    ES

    MOV        DX,03C4H        ;ADDRESS OF THE SEQ CONTROLLER
    MOV        AL,01H            ;INDEX OF THE CLOCKING MODE REGISTER
    OUT        DX,AL            ;SET UP TO READ THE CLOCKING MODE REGISTER
    INC        DX                ;ADDRESS TO READ FROM
    IN        AL,DX            ;GET THE CLOCKING MODE REGISTER
    AND        AL,0DFH            ;TURN ON THE SCREEN ENABLE BIT
    MOV        BL,AL            ;KEEP THAT AROUND
    MOV        DX,03C4H        ;ADDRESS OF THE SEQ CONTROLLER
    MOV        AL,01H            ;INDEX OF THE CLOCKING REGISTER
    OUT        DX,AL            ;SET UP TO WRITE BACK THE CLOCKING MODE REGISTER
    INC        DX                ;SET TO ADDRESS TO WRITE TO
    MOV        AL,BL            ;GET BACK THE PROPER VALUE
    OUT        DX,AL            ;TURNS ON THE VGA SCREEN

    POP    ES
    POP    DS
    POP    BP
    RET
_VGAON    ENDP

;
;    showpalv(&palstore,pal_xoff,pal_yoff);
;
_SHOWPALV        PROC    FAR
    PUSH    BP
    MOV        BP,SP
    PUSH    DS
    PUSH    ES
    PUSH    SI
    PUSH    DI


    MOV     AX,[BP+X]        ;GET OFFSET OF ARRAY
    MOV        DI,AX
    MOV        AX,[BP+X+2]        ;GET SEGMENT OF STORAGE ARRAY
    MOV        ES,AX

    MOV        AX,[BP+X+6]        ;GET LINE TO START PALETTE ON
    MOV        DX,320            ;GET THE LINE LENGTH
    MUL        DX                ;GET THE OFFSET INTO THE SCREEN
    ADD        AX,[BP+X+4]        ;ADD IN THE X OFFSET
    JNC        NO_ROLLOVER        ;ADDITION DIDN'T CARRY
    INC        DX                ;INCREMENT THE DX REGISTER ON A CARRY
NO_ROLLOVER:
    MOV        SI,AX            ;KEEP TRACK OF THE OFFSET
    MOV        BX,SI            ;IN TWO PLACES
    MOV        AX,320            ;GET THE LINE LENGTH
    MOV        DX,8            ;GET THE NUMBER OF LINES
    MUL        DX                ;GET THE NUMBER OF BYTES TO COPY
    MOV        CX,AX            ;MOVE INTO COUNTER
    MOV        AX,0A000H
    MOV        DS,AX            ;GET THE SEGMENT FOR THE SOURCE
ZIP:
    REP        MOVSB            ;COPY THAT SECTION OF SCREEN

    MOV        CH,0            ;THE NUMBER OF LINES COPIED SO FAR
    MOV        CL,00            ;THE NUMBER OF PIXELS
TOP1:
    MOV        SI,BX            ;GET THE CORRECT OFFSET TO BE COPIED TO
    MOV        AX,0A000H
    MOV        ES,AX            ;GET THE SEGMENT TO BE COPIED TO
TOP2:
    MOV        ES:[SI],CL        ;COPY ACROSS THE SCREEN INCREMENTING VALUES
    INC        SI                ;MOVE TO NEXT PIXEL
    INC        CL                ;INCREMENT COUNTER
    JNE        TOP2            ;IF COUNTER NOT EQUAL TO ZERO THEN COPY AGAIN

    ADD        BX,320            ;MOVE DOWN TO NEXT LINE
    INC        CH                ;INCREMENT THE LINE COUNTER
    CMP        CH,8            ;CHECK IF ALL THE LINES ARE DONE
    JNE        TOP1            ;IF LINE COUNT <8 THEN COPY ANOTHER LINE

    POP    DI
    POP    SI
    POP    ES
    POP    DS
    POP    BP
    RET
_SHOWPALV    ENDP

;
;    nopalv(&palstore,pal_xoff,pal_yoff);
;
_NOPALV        PROC    FAR
    PUSH    BP
    MOV        BP,SP
    PUSH    DS
    PUSH    ES
    PUSH    SI
    PUSH    DI

    MOV     AX,[BP+X]        ;GET OFFSET OF ARRAY
    MOV        SI,AX
    MOV        AX,[BP+X+2]        ;GET SEGMENT OF STORAGE ARRAY
    MOV        DS,AX

    MOV        AX,[BP+X+6]        ;GET LINE TO COPY SCREEN BACK ONTO
    MOV        DX,320            ;GET THE LINE LENGTH
    MUL        DX                ;GET THE OFFSET INTO THE SCREEN
    ADD        AX,[BP+X+4]        ;ADD IN THE X OFFSET
    JNC        NO_ROLL2        ;ADDITION DIDN'T CARRY
    INC        DX                ;INCREMENT THE DX REGISTER ON A CARRY
NO_ROLL2:
    MOV        DI,AX            ;KEEP TRACK OF THE OFFSET
    MOV        AX,320            ;GET THE LINE LENGTH
    MOV        DX,8            ;GET THE NUMBER OF LINES
    MUL        DX                ;GET THE NUMBER OF BYTES TO COPY
    MOV        CX,AX            ;MOVE INTO COUNTER
    MOV        AX,0A000H
    MOV        ES,AX            ;GET THE SEGMENT FOR THE SOURCE
ZOOM:
    REP        MOVSB            ;COPY THAT SECTION OF SCREEN

    POP    DI
    POP    SI
    POP    ES
    POP    DS
    POP    BP
    RET
_NOPALV    ENDP

;
;  Invert A BOX ON THE SCREEN
;
;   usage : outlinev(x1,y1,x2,y2)
;
_OUTLINEV    PROC    FAR
    PUSH    BP
    MOV    BP,SP
    PUSH    DS
    PUSH    ES
    PUSH    SI
    PUSH    DI

    MOV    AX,[BP+X+2]    ; GET FIRST Y VALUE
    CMP    AX,[BP+X+6]    ; COMPARE WITH THE SECOND Y - VALUE
    JLE    CHECKX        ; OK ORDER GOTO CHECKING THE X VALUES
    MOV    CX,AX        ; SWAP THE TWO VALUES
    MOV    AX,[BP+X+6]    ;
    MOV    [BP+X+2],AX    ;
    MOV    AX,CX        ;
    MOV    [BP+X+6],AX    ;
CHECKX:
    MOV    AX,[BP+X]    ; GET FIRST X VALUE
    CMP    AX,[BP+X+4]    ; COMPARE WITH THE SECOND X - VALUE
    JLE    MAKELEN        ; OK ORDER GOTO COMPUTING THE LENGTHS
    MOV    CX,AX        ; SWAP THE TWO VALUES
    MOV    AX,[BP+X+4]    ;
    MOV    [BP+X],AX    ;
    MOV    AX,CX        ;
    MOV    [BP+X+4],AX    ;
MAKELEN:            ; COMPUTE THE X AND Y WIDTHS FOR THE BOX TO BE INVERTED
    MOV    AX,[BP+X+4]    ; GET THE LARGER OF THE TWO X VALUES
    SUB    AX,[BP+X]    ; SUBTRACT THE SMALLER VALUE TO FIND THE LENGTH
    ADD    AX,1        ;
    MOV    [BP+X+4],AX    ; STORE IT IN THE OLD LOCATION FOR THE 2ND X VALUE
    MOV    AX,[BP+X+6]    ; GET THE LARGER OF THE TWO Y VALUES
    SUB    AX,[BP+X+2]    ; SUBTRACT THE SMALLER VALUE TO FIND THE LENGTH
    SUB    AX,1        ; SUBTRACT TWO FOR THE TOP AND BOTTOM EDGES
    CMP    AX,0        ; CHECK IF IT IS LESS THAN ZERO
    JG     POSITIVE    ; JUMP AROUND ZEROING THE ACC.
    MOV    AX,0
POSITIVE:
    MOV    [BP+X+6],AX    ; STORE IT IN THE OLD LOCATION FOR THE 2ND Y VALUE
    MOV    AX,320        ; COMPUTE THE VALUE TO ADD TO THE DI FOR COMPLETE WRAPAROUND
    SUB    AX,[BP+X+4]    ;
    MOV    SI,AX        ; KEEP TRACK OF IT

;    MOV    AX,0A000H    ; DATA BUFFER
;    MOV    ES,AX
;
    MOV    AX,[BP+X+2]    ; GET THE Y VALUE
    MOV    BX,[BP+X]    ; GET THE X VALUE
    CALL    PIXELADDR13    ; CALCULATE THE PIXEL ADDRESS
    MOV    DI,BX        ; PREPARE FOR MOVS

    MOV    CX,[BP+X+4]    ; HOW MANY BYTES?
BLASTA:
    MOV    AL,ES:[DI]    ; GET THE VALUE TO INVERT
    NOT    AL        ; INVERT THE VALUE THERE
    MOV    ES:[DI],AL    ; REPLACE THE VALUE
    INC    DI        ; INCREMENT TO NEXT POSITION
    LOOP     BLASTA        ; LOOP UNTIL ALL HAVE BEEN DONE

    ADD    DI,SI        ; MOVE OVER TO THE BEGINNING OF THE NEXT LINE
    MOV    CX,[BP+X+6]    ; COUNT VALUE FOR THE NEXT SERIES
    CMP    CX,0        ; CHECK FOR NO LINES IN BETWEEN
    JLE    BLAST2A        ; JUMP AROUND PUTTING THE LINES IN BETWEEN
BLAST2:
    MOV    AL,ES:[DI]    ; GET THE VALUE TO INVERT
    NOT    AL            ; INVERT IT
    MOV    ES:[DI],AL    ; REPLACE THE INVERTED VALUE
    ADD    DI,[BP+X+4]    ; GO TO THE LAST VALUE TO INVERT ON THAT LINE
    SUB    DI,1        ;
    MOV    AL,ES:[DI]    ; GET THE VALUE TO INVERT
    NOT    AL        ; INVERT IT
    MOV    ES:[DI],AL    ; REPLACE THE INVERTED VALUE
    ADD    DI,SI        ; GET THE VALUE FOR THE BEGINNING OF THE NEXT LINE
    INC    DI        ;
    LOOP    BLAST2        ; DO THE NEXT LINE

BLAST2A:
    MOV    CX,[BP+X+4]    ; PREPARE FOR LAST LINE
BLAST3:
    MOV    AL,ES:[DI]    ; GET THE VALUE TO INVERT
    NOT    AL            ; INVERT THE VALUE THERE
    MOV    ES:[DI],AL    ; REPLACE THE VALUE
    INC    DI            ; INCREMENT TO NEXT POSITION
    LOOP    BLAST3        ; LOOP UNTIL ALL HAVE BEEN DONE

    POP        DI
    POP        SI
    POP    ES
    POP    DS
    POP    BP
    RET
_OUTLINEV    ENDP
;
;  Draw a 4x4 ball on the vga screen
;
;   usage : ball(x,y)
;
_BALL        PROC    FAR
    PUSH    BP
    MOV        BP,SP
    PUSH    DS
    PUSH    ES
    PUSH    DI

    MOV    AX,[BP+X+2] ; GET THE Y VALUE
    MOV    BX,[BP+X]    ; GET THE X VALUE
    CALL    PIXELADDR13    ; CALCULATE THE PIXEL ADDRESS
    MOV    DI,BX        ; PREPARE FOR MOVS

    MOV    AL,ES:[DI]    ; GET THE VALUE TO INVERT
    NOT    AL            ; INVERT IT
    MOV    ES:[DI],AL    ; REPLACE THE VALUE
    INC    DI            ; MOVE OVER ONE BYTE
    MOV    AL,ES:[DI]    ; GET THE VALUE TO INVERT
    NOT    AL            ; INVERT IT
    MOV    ES:[DI],AL    ; REPLACE THE VALUE

    ADD    DI,318        ; MOVE TO THE NEXT LINE
    MOV    CX,4        ; HOW MANY BYTES?
BLASTB:
    MOV    AL,ES:[DI]    ; GET THE VALUE TO INVERT
    NOT    AL            ; INVERT THE VALUE THERE
    MOV    ES:[DI],AL    ; REPLACE THE VALUE
    INC    DI            ; INCREMENT TO NEXT POSITION
    LOOP BLASTB        ; LOOP UNTIL ALL HAVE BEEN DONE

    MOV    CX,4        ; COUNT VALUE FOR THE NEXT SERIES
    ADD    DI,316        ; MOVE OVER TO THE BEGINNING OF THE NEXT LINE
BLASTC:
    MOV    AL,ES:[DI]    ; GET THE VALUE TO INVERT
    NOT    AL            ; INVERT IT
    MOV    ES:[DI],AL    ; REPLACE THE INVERTED VALUE
    INC DI            ;
    LOOP    BLASTC    ; DO THE NEXT LINE

    ADD    DI,317        ; MOVE ONE BYTE OVER INTO THE NEXT LINE
    MOV    AL,ES:[DI]    ; GET THE VALUE TO INVERT
    NOT    AL            ; INVERT IT
    MOV    ES:[DI],AL    ; REPLACE THE VALUE
    INC    DI            ; MOVE OVER ONE BYTE
    MOV    AL,ES:[DI]    ; GET THE VALUE TO INVERT
    NOT    AL            ; INVERT IT
    MOV    ES:[DI],AL    ; REPLACE THE VALUE

    POP        DI
    POP    ES
    POP    DS
    POP    BP
    RET
_BALL    ENDP

;
;  Draw a block on the vga screen
;
;   usage : vgablock(&block,x,y,xmax,ymax)
;
X_SIZE    DW    ?        ; X WIDTH OF THE BLOCK
X_WRAP    DW    ?        ; THE NUMBER OF BYTES TO WRAP AROUND THE SCREEN
Y_SIZE    DW    ?        ; THE Y HEIGHT OF THE BLOCK
_VGABLOCK    PROC    FAR
    PUSH    BP
    MOV        BP,SP
    PUSH    DS
    PUSH    ES
    PUSH    SI
    PUSH    DI

;    MOV    AX,0A000H    ; DATA BUFFER
;    MOV    ES,AX

    MOV    AX,[BP+X+8]    ; GET THE X SIZE
    MOV    X_SIZE,AX    ; STORE THE X SIZE

    MOV    AX,320        ; GET THE SCREEN SIZE
    SUB    AX,X_SIZE    ; CALCULATE THE X_WRAP VALUE
    MOV    X_WRAP,AX    ; STORE THE X_WRAP VALUE

    MOV    AX,[BP+X+10]; GET THE Y SIZE
    MOV    Y_SIZE,AX    ; STORE THE Y SIZE
    MOV    AX,[BP+X+6]    ; GET THE Y VALUE
    MOV    BX,[BP+X+4]    ; GET THE X VALUE
    CALL    PIXELADDR13 ; CALCULATE THE PIXEL OFFSET
    MOV    DI,BX        ; PREPARE FOR MOVS

    MOV    AX,[BP+X]    ; GET THE OFFSET OF THE BLOCK
    MOV    SI,AX        ; STORE THE OFFSET OF THE ARRAY
    MOV    AX,[BP+X+2]    ; GET THE SEGMENT OF THE ARRAY
    MOV    DS,AX        ; STORE THE SEGMENT
BLASTBLOCK:
    MOV    CX,X_SIZE    ; GET THE NUMBER OF BYTES TO MOVE
    REP    MOVSB        ; PUT A HORIZONTAL LINE OF THE BLOCK ON THE SCREEN

    ADD    DI,X_WRAP    ; MOVE THE DESTINATION POINTER TO THE BEGINNING OF THE NEXT BLOCK
    DEC    Y_SIZE        ; DECREMENT THE VERTICAL COUNTER
    JG    BLASTBLOCK    ; IF THE COUNTER IS NOT ZERO THEN DO ANOTHER LINE

    POP        DI
    POP        SI
    POP    ES
    POP    DS
    POP    BP
    RET
_VGABLOCK    ENDP

;
;   Inverse a block on the vga screen
;
;   usage : vgablock(x0,y0,width,height)
;
_INVERSEV    PROC    FAR
    PUSH    BP
    MOV        BP,SP
    PUSH    DS
    PUSH    ES
    PUSH    DI

    MOV    BX,[BP+X+4]    ; GET THE X SIZE
    MOV    X_SIZE,BX    ; STORE THE X SIZE

    MOV    AX,320        ; GET THE SCREEN SIZE
    SUB    AX,BX        ; CALCULATE THE X_WRAP VALUE
    MOV    X_WRAP,AX    ; STORE THE X_WRAP VALUE

    MOV    AX,[BP+X+6]    ; GET THE Y SIZE
    MOV    Y_SIZE,AX    ; STORE THE Y SIZE
;
    MOV    AX,[BP+X+2]; GET THE Y VALUE
    MOV    BX,[BP+X]    ; GET THE X VALUE
    CALL    PIXELADDR13        ; CALCULATE THE PIXEL ADDRESS (RETURNS WITH ES:VIDEO BUFF SEG, BX:OFFSET)
    MOV    DI,BX        ; PREPARE FOR MOVS

INVERSEBLOCK:
    MOV    CX,X_SIZE    ; GET THE NUMBER OF BYTES TO MOVE
INVERSELINE:
    MOV    AL,BYTE PTR ES:[DI]    ; GET THE BYTE TO INVERSE
    NOT    AL            ; INVERSE IT
    MOV    BYTE PTR ES:[DI],AL    ; PUT THE BYTE BACK
    INC    DI
    LOOP INVERSELINE

    ADD    DI,X_WRAP    ; MOVE THE DESTINATION POINTER TO THE BEGINNING OF THE NEXT BLOCK
    DEC    Y_SIZE        ; DECREMENT THE VERTICAL COUNTER
    JG    INVERSEBLOCK    ; IF THE COUNTER IS NOT ZERO THEN DO ANOTHER LINE

    POP        DI
    POP    ES
    POP    DS
    POP    BP
    RET
_INVERSEV    ENDP

;    CALLER         MICROSOFT C
;
;                    VOID(_LINE13(X1,Y1,X2,Y2,N);
;
;                        INT X1,Y1,X2,Y2;    /* PIXEL COOR. */
;
;                        INT N;            /* PIXEL VALUE */
;

ARGX1        EQU    WORD PTR [BP+6]    ; STACK FRAME ADDRESSING
ARGY1        EQU    WORD PTR [BP+8]
ARGX2        EQU    WORD PTR [BP+10]
ARGY2        EQU WORD PTR [BP+12]
ARGN        EQU    BYTE PTR [BP+14]
VARINCR1    EQU    WORD PTR [BP-6]
VARINCR2    EQU WORD PTR [BP-8]
VARROUTINE    EQU WORD PTR [BP-10]

BYTESPERLINE    EQU    320

_LINE13    PROC    FAR
    PUSH    BP
    MOV        BP,SP
    SUB        SP,16H
    PUSH    DS
    PUSH    ES
    PUSH    SI
    PUSH    DI

; CHECK FOR VERTICAL LINE
    MOV        SI,BYTESPERLINE

    MOV        CX,ARGX2
    SUB        CX,ARGX1
    JZ        VERT_LINE13

; FORCE X1<X2
    JNS        L01

    NEG     CX

    MOV        BX,ARGX2
    XCHG    BX,ARGX1
    MOV        ARGX2,BX

    MOV        BX,ARGY2
    XCHG    BX,ARGY1
    MOV        ARGY2,BX

; CALCULATE DY=ABS(Y2-Y1)
L01:
    MOV        BX,ARGY2
    SUB        BX,ARGY1
    JZ        HORIZ_LINE13

    JNS        L03

    NEG        BX
    NEG        SI
;SELECT APPROPRIATE ROUTINE FOR SLOPE OF LINE
L03:
    PUSH    SI
    MOV        VARROUTINE,OFFSET LOSLOPE_LINE13
    CMP        BX,CX
    JLE        L04
    MOV        VARROUTINE,OFFSET HISLOPE_LINE13
    XCHG    BX,CX

;CALCULATE INITIAL DECISION VARIABLE AND INCREMENTS
L04:
    SHL        BX,1
    MOV        VARINCR1,BX
    SUB        BX,CX
    MOV        SI,BX

    SUB        BX,CX
    MOV        VARINCR2,BX

;CALCULATE FIRST PIXEL ADDRESS
    PUSH    CX
    MOV        AX,ARGY1
    MOV        BX,ARGX1
    CALL    PIXELADDR13

    MOV        DI,BX

    POP        CX
    INC        CX

    POP        BX
    JMP        VARROUTINE

;ROUTINE FOR VERTICAL LINES
VERT_LINE13:
    MOV        AX,ARGY1
    MOV        BX,ARGY2
    MOV        CX,BX
    SUB        CX,AX
    JGE        L31

    NEG        CX
    MOV        AX,BX
L31:
    INC        CX
    MOV        BX,ARGX1
    PUSH    CX
    CALL    PIXELADDR13
    POP        CX
    MOV        DI,BX
    DEC        SI

    MOV        AL,ARGN
L32:
    STOSB
    ADD        DI,SI
    LOOP    L32
    JMP        LEXIT

;ROUTINE FOR HORIZONTAL LINES (SLOPE=0)
HORIZ_LINE13:
    PUSH    CX
    MOV        AX,ARGY1
    MOV        BX,ARGX1
    CALL    PIXELADDR13
    MOV        DI,BX

    POP        CX
    INC        CX

    MOV        AL,ARGN

    REP        STOSB
    JMP        LEXIT

;ROUTINE FOR DY<=DX (SLOPE<=1)
LOSLOPE_LINE13:
    MOV        AL,ARGN
L11:
    STOSB
    OR        SI,SI
    JNS        L12
    ADD        SI,VARINCR1
    LOOP    L11
    JMP        SHORT    LEXIT
L12:
    ADD        SI,VARINCR2
    ADD        DI,BX
    LOOP    L11
    JMP        SHORT LEXIT

;ROUTINE FOR DY>DX (SLOPE>1)
HISLOPE_LINE13:
    MOV        AL,ARGN
L21:
    STOSB
    ADD        DI,BX
L22:
    OR        SI,SI
    JNS        L23
    ADD        SI,VARINCR1
    DEC        DI
    LOOP    L21
    JMP        SHORT    LEXIT
L23:
    ADD        SI,VARINCR2
    LOOP    L21

LEXIT:
    POP        DI
    POP        SI
    POP        ES
    POP        DS
    MOV        SP,BP
    POP        BP
    RET
_LINE13        ENDP

_INVERT13    PROC    FAR
    PUSH    BP
    MOV        BP,SP
    SUB        SP,16H
    PUSH    DS
    PUSH    ES
    PUSH    SI
    PUSH    DI

; CHECK FOR VERTICAL LINE
    MOV        SI,BYTESPERLINE

    MOV        CX,ARGX2
    SUB        CX,ARGX1
    JZ        IVERT_LINE13

; FORCE X1<X2
    JNS        IL01

    NEG     CX

    MOV        BX,ARGX2
    XCHG    BX,ARGX1
    MOV        ARGX2,BX

    MOV        BX,ARGY2
    XCHG    BX,ARGY1
    MOV        ARGY2,BX

; CALCULATE DY=ABS(Y2-Y1)
IL01:
    MOV        BX,ARGY2
    SUB        BX,ARGY1
    JZ        IHORIZ_LINE13

    JNS        IL03

    NEG        BX
    NEG        SI
;SELECT APPROPRIATE ROUTINE FOR SLOPE OF LINE
IL03:
    PUSH    SI
    MOV        VARROUTINE,OFFSET ILOSLOPE_LINE13
    CMP        BX,CX
    JLE        IL04
    MOV        VARROUTINE,OFFSET IHISLOPE_LINE13
    XCHG    BX,CX

;CALCULATE INITIAL DECISION VARIABLE AND INCREMENTS
IL04:
    SHL        BX,1
    MOV        VARINCR1,BX
    SUB        BX,CX
    MOV        SI,BX

    SUB        BX,CX
    MOV        VARINCR2,BX

;CALCULATE FIRST PIXEL ADDRESS
    PUSH    CX
    MOV        AX,ARGY1
    MOV        BX,ARGX1
    CALL    PIXELADDR13

    MOV        DI,BX

    POP        CX
    INC        CX

    POP        BX
    JMP        VARROUTINE

;ROUTINE FOR VERTICAL LINES
IVERT_LINE13:
    MOV        AX,ARGY1
    MOV        BX,ARGY2
    MOV        CX,BX
    SUB        CX,AX
    JGE        IL31

    NEG        CX
    MOV        AX,BX
IL31:
    INC        CX
    MOV        BX,ARGX1
    PUSH    CX
    CALL    PIXELADDR13
    POP        CX
    MOV        DI,BX
    DEC        SI

    MOV        AL,0FFH
IL32:
    XOR        ES:[DI],AL
    INC        DI
;    STOSB
    ADD        DI,SI
    LOOP    IL32
    JMP        ILEXIT

;ROUTINE FOR HORIZONTAL LINES (SLOPE=0)
IHORIZ_LINE13:
    PUSH    CX
    MOV        AX,ARGY1
    MOV        BX,ARGX1
    CALL    PIXELADDR13
    MOV        DI,BX

    POP        CX
    INC        CX
    MOV        AL,0ffh

IL51:
    XOR        ES:[DI],AL
    INC        DI
    LOOP    IL51
;REP    STOSB
    JMP        ILEXIT

;ROUTINE FOR DY<=DX (SLOPE<=1)
ILOSLOPE_LINE13:
    MOV        AL,0ffh
IL11:
    XOR        ES:[DI],AL
    INC        DI
;    STOSB
    OR        SI,SI
    JNS        IL12
    ADD        SI,VARINCR1
    LOOP    IL11
    JMP        SHORT    ILEXIT
IL12:
    ADD        SI,VARINCR2
    ADD        DI,BX
    LOOP    IL11
    JMP        SHORT ILEXIT

;ROUTINE FOR DY>DX (SLOPE>1)
IHISLOPE_LINE13:
    MOV        AL,0ffh
IL21:
    XOR        ES:[DI],AL
    INC        DI
;    STOSB
    ADD        DI,BX
IL22:
    OR        SI,SI
    JNS        IL23
    ADD        SI,VARINCR1
    DEC        DI
    LOOP    IL21
    JMP        SHORT    ILEXIT
IL23:
    ADD        SI,VARINCR2
    LOOP    IL21

ILEXIT:
    POP        DI
    POP        SI
    POP        ES
    POP        DS
    MOV        SP,BP
    POP        BP
    RET
_INVERT13        ENDP

;NAME:    _CIRCLE13
;    _CIRCLE13(XC,YC,A,B,N)
;
ARGXC    EQU WORD PTR [BP+6]
ARGYC    EQU WORD PTR [BP+8]
ARGA    EQU WORD PTR [BP+10]
ARGB    EQU WORD PTR [BP+12]
ARGN    EQU    BYTE PTR [BP+14]

ULADDR    EQU WORD PTR [BP-6]
URADDR    EQU WORD PTR [BP-8]
LLADDR    EQU WORD PTR [BP-10]
LRADDR    EQU WORD PTR [BP-12]
LMASK    EQU BYTE PTR [BP-14]
RMASK    EQU BYTE PTR [BP-16]

VARD        EQU WORD PTR [BP-20]
VARDX        EQU WORD PTR [BP-24]
VARDY        EQU WORD PTR [BP-28]
ASQUARED    EQU WORD PTR [BP-32]
BSQUARED    EQU WORD PTR [BP-36]
TWOASQUARED    EQU WORD PTR [BP-40]
TWOBSQUARED    EQU WORD PTR [BP-44]

BYTESPERLINE EQU    320

_CIRCLE13    PROC    FAR
    PUSH    BP
    MOV    BP,SP
    SUB    SP,50
    PUSH    DS
    PUSH    ES
    PUSH    SI
    PUSH    DI

;INITIAL CONSTANTS
    MOV AX,ARGA
    MUL    AX
    MOV ASQUARED,AX
    MOV    ASQUARED+2,DX
    SHL    AX,1
    RCL    DX,1
    MOV    TWOASQUARED,AX
    MOV    TWOASQUARED+2,DX
    MOV    AX,ARGB
    MUL    AX
    MOV BSQUARED,AX
    MOV BSQUARED+2,DX
    SHL    AX,1
    RCL DX,1
    MOV TWOBSQUARED,AX
    MOV TWOBSQUARED+2,DX

;PLOT PIXELS FROM (0,B) UNTIL DY/DX =-1
;INITIAL BUFFER ADDRESS AND BIT MASK
    MOV    AX,BYTESPERLINE
    MUL    ARGB
    MOV    SI,AX
    MOV    DI,AX
    MOV    AX,ARGYC
    MOV    BX,ARGXC
    CALL    PIXELADDR13

    ADD    SI,BX
    MOV    ULADDR,SI
    MOV URADDR,SI
    SUB    BX,DI
    MOV    LLADDR,BX
    MOV    LRADDR,BX

;INITIAL DECISION VARIABLES
    XOR    AX,AX
    MOV    VARDX,AX
    MOV    VARDX+2,AX

    MOV    AX,TWOASQUARED
    MOV DX,TWOASQUARED+2
    MOV CX,ARGB
    CALL LONGMULTIPLY
    MOV VARDY,AX
    MOV VARDY+2,DX

    MOV AX,ASQUARED
    MOV    DX,ASQUARED+2
    SAR DX,1
    RCR    AX,1
    SAR    DX,1
    RCR AX,1

    ADD AX,BSQUARED
    ADC    DX,BSQUARED+2
    MOV    VARD,AX
    MOV VARD+2,DX

    MOV    AX,ASQUARED
    MOV    DX,ASQUARED+2
    MOV CX,ARGB
    CALL LONGMULTIPLY
    SUB    VARD,AX
    SBB    VARD+2,DX

    ;LOOP UNTIL DY/DX>=-1
    MOV    BX,ARGB
    XOR    CX,CX

C10:
    MOV    AX,VARDX
    MOV    DX,VARDX+2
    SUB    AX,VARDY
    SBB    DX,VARDY+2
    JNS    C20

    CALL    SET4PIXELS
    MOV CX,1
    CMP    VARD+2,0
    JS    C11
    MOV    CH,1
    DEC    BX

    MOV AX,VARDY
    MOV    DX,VARDY+2
    SUB AX,TWOASQUARED
    SBB    DX,TWOASQUARED+2
    MOV VARDY,AX
    MOV    VARDY+2,DX

    SUB    VARD,AX
    SBB    VARD+2,DX

C11:
    MOV AX,VARDX
    MOV DX,VARDX+2
    ADD    AX,TWOBSQUARED
    ADC    DX,TWOBSQUARED+2
    MOV VARDX,AX
    MOV VARDX+2,DX
    ADD    AX,BSQUARED
    ADC    DX,BSQUARED+2
    ADD VARD,AX
    ADC    VARD+2,DX
    JMP    C10

;PLOT PIXELS FROM CURRENT (X,Y) UNTIL Y<0

C20:
    PUSH    BX
    PUSH    CX
    MOV    AX,ASQUARED
    MOV    DX,ASQUARED+2
    SUB    AX,BSQUARED
    SBB    DX,BSQUARED+2
    MOV BX,AX
    MOV CX,DX

    SAR DX,1
    RCR    AX,1
    ADD AX,BX
    ADC    DX,CX

    SUB AX,VARDX
    SBB    DX,VARDX+2
    SUB    AX,VARDY
    SBB    DX,VARDY+2

    SAR    DX,1
    RCR    AX,1

    ADD    VARD,AX
    ADC    VARD+2,DX

;LOOP UNTIL Y<0
    POP CX
    POP BX
C21:
    CALL SET4PIXELS
    MOV CX,100H

    CMP    VARD+2,0
    JNS    C22

    MOV CL,1
    MOV AX,VARDX
    MOV DX,VARDX+2
    ADD AX,TWOBSQUARED
    ADC    DX,TWOBSQUARED+2
    MOV    VARDX,AX
    MOV    VARDX+2,DX

    ADD    VARD,AX
    ADC    VARD+2,DX

C22:
    MOV AX,VARDY
    MOV    DX,VARDY+2
    SUB    AX,TWOASQUARED
    SBB    DX,TWOASQUARED+2
    MOV    VARDY,AX
    MOV    VARDY+2,DX

    SUB    AX,ASQUARED
    SBB    DX,ASQUARED+2
    SUB    VARD,AX
    SBB    VARD+2,DX

    DEC    BX
    JNS    C21

;RESTORE DEFAULT GRAPHICS CONTROLLER REGISTERS
CEXIT:
    POP DI
    POP SI
    POP    ES
    POP    DS
    MOV SP,BP
    POP    BP
    RET
_CIRCLE13    ENDP

;NAME:    CIRCLE13
;    CIRCLE13(XC,YC,A,B,N)
;
ARGXC    EQU WORD PTR [BP+6]
ARGYC    EQU WORD PTR [BP+8]
ARGA    EQU WORD PTR [BP+10]
ARGB    EQU WORD PTR [BP+12]

ULADDR    EQU WORD PTR [BP-6]
URADDR    EQU WORD PTR [BP-8]
LLADDR    EQU WORD PTR [BP-10]
LRADDR    EQU WORD PTR [BP-12]
LMASK    EQU BYTE PTR [BP-14]
RMASK    EQU BYTE PTR [BP-16]


VARD        EQU WORD PTR [BP-20]
VARDX        EQU WORD PTR [BP-24]
VARDY        EQU WORD PTR [BP-28]
ASQUARED    EQU WORD PTR [BP-32]
BSQUARED    EQU WORD PTR [BP-36]
TWOASQUARED    EQU WORD PTR [BP-40]
TWOBSQUARED    EQU WORD PTR [BP-44]

RMWBITS        EQU    00H
BYTESPERLINE EQU    320

_INCIRC13    PROC    FAR
    PUSH    BP
    MOV    BP,SP
    SUB    SP,50
    PUSH    DS
    PUSH    ES
    PUSH    SI
    PUSH    DI


;INITIAL CONSTANTS
    MOV AX,ARGA
    MUL    AX
    MOV ASQUARED,AX
    MOV    ASQUARED+2,DX
    SHL    AX,1
    RCL    DX,1
    MOV    TWOASQUARED,AX
    MOV    TWOASQUARED+2,DX
    MOV    AX,ARGB
    MUL    AX
    MOV BSQUARED,AX
    MOV BSQUARED+2,DX
    SHL    AX,1
    RCL DX,1
    MOV TWOBSQUARED,AX
    MOV TWOBSQUARED+2,DX

;PLOT PIXELS FROM (0,B) UNTIL DY/DX =-1
;INITIAL BUFFER ADDRESS AND BIT MASK
    MOV    AX,BYTESPERLINE
    MUL    ARGB
    MOV    SI,AX
    MOV    DI,AX
    MOV    AX,ARGYC
    MOV    BX,ARGXC
    CALL    PIXELADDR13

    ADD    SI,BX
    MOV    ULADDR,SI
    MOV URADDR,SI
    SUB    BX,DI
    MOV    LLADDR,BX
    MOV    LRADDR,BX

;INITIAL DECISION VARIABLES
    XOR    AX,AX
    MOV    VARDX,AX
    MOV    VARDX+2,AX

    MOV    AX,TWOASQUARED
    MOV DX,TWOASQUARED+2
    MOV CX,ARGB
    CALL LONGMULTIPLY
    MOV VARDY,AX
    MOV VARDY+2,DX

    MOV AX,ASQUARED
    MOV    DX,ASQUARED+2
    SAR DX,1
    RCR    AX,1
    SAR    DX,1
    RCR AX,1

    ADD AX,BSQUARED
    ADC    DX,BSQUARED+2
    MOV    VARD,AX
    MOV VARD+2,DX

    MOV    AX,ASQUARED
    MOV    DX,ASQUARED+2
    MOV CX,ARGB
    CALL LONGMULTIPLY
    SUB    VARD,AX
    SBB    VARD+2,DX

    ;LOOP UNTIL DY/DX>=-1
    MOV    BX,ARGB
    XOR    CX,CX

IC10:
    MOV    AX,VARDX
    MOV    DX,VARDX+2
    SUB    AX,VARDY
    SBB    DX,VARDY+2
    JNS    IC20

    CALL    INVERT4PIXELS
    MOV CX,1
    CMP    VARD+2,0
    JS    IC11
    MOV    CH,1
    DEC    BX

    MOV AX,VARDY
    MOV    DX,VARDY+2
    SUB AX,TWOASQUARED
    SBB    DX,TWOASQUARED+2
    MOV VARDY,AX
    MOV    VARDY+2,DX

    SUB    VARD,AX
    SBB    VARD+2,DX

IC11:
    MOV AX,VARDX
    MOV DX,VARDX+2
    ADD    AX,TWOBSQUARED
    ADC    DX,TWOBSQUARED+2
    MOV VARDX,AX
    MOV VARDX+2,DX
    ADD    AX,BSQUARED
    ADC    DX,BSQUARED+2
    ADD VARD,AX
    ADC    VARD+2,DX
    JMP    IC10

;PLOT PIXELS FROM CURRENT (X,Y) UNTIL Y<0

IC20:
    PUSH    BX
    PUSH    CX
    MOV    AX,ASQUARED
    MOV    DX,ASQUARED+2
    SUB    AX,BSQUARED
    SBB    DX,BSQUARED+2
    MOV BX,AX
    MOV CX,DX

    SAR DX,1
    RCR    AX,1
    ADD AX,BX
    ADC    DX,CX

    SUB AX,VARDX
    SBB    DX,VARDX+2
    SUB    AX,VARDY
    SBB    DX,VARDY+2

    SAR    DX,1
    RCR    AX,1

    ADD    VARD,AX
    ADC    VARD+2,DX

;LOOP UNTIL Y<0
    POP CX
    POP BX
IC21:
    CALL INVERT4PIXELS
    MOV CX,100H

    CMP    VARD+2,0
    JNS    IC22

    MOV CL,1
    MOV AX,VARDX
    MOV DX,VARDX+2
    ADD AX,TWOBSQUARED
    ADC    DX,TWOBSQUARED+2
    MOV    VARDX,AX
    MOV    VARDX+2,DX

    ADD    VARD,AX
    ADC    VARD+2,DX

IC22:
    MOV AX,VARDY
    MOV    DX,VARDY+2
    SUB    AX,TWOASQUARED
    SBB    DX,TWOASQUARED+2
    MOV    VARDY,AX
    MOV    VARDY+2,DX

    SUB    AX,ASQUARED
    SBB    DX,ASQUARED+2
    SUB    VARD,AX
    SBB    VARD+2,DX

    DEC    BX
    JNS    IC21

;RESTORE DEFAULT GRAPHICS CONTROLLER REGISTERS
ICEXIT:
    POP DI
    POP SI
    POP    ES
    POP    DS
    MOV SP,BP
    POP    BP
    RET

_INCIRC13    ENDP

SET4PIXELS    PROC    NEAR
    PUSH    AX
    PUSH    BX
    PUSH    DX
    MOV        AL,ARGN        ; GET THE COLOR VALUE
    XOR    BX,BX
    TEST    CH,CH
    JZ    C30
    MOV    BX,BYTESPERLINE
    NEG    BX
C30:

;PIXELS AT (XC-X,YC+Y) AND XC-X,YC-Y)

    XOR    SI,SI
    TEST    CL,CL
    JZ    C31
    MOV    SI,-1
C31:

    MOV DI,SI
    ADD    SI,ULADDR
    ADD    SI,BX
    ADD    DI,LLADDR
    SUB    DI,BX
    MOV    ULADDR,SI
    MOV    LLADDR,DI
    MOV    ES:[SI],AL
    MOV    ES:[DI],AL

;PIXELS AT (XC+X,YC+Y) AND (XC+X,YC+Y)

    XOR    SI,SI
    TEST    CL,CL
    JZ    C32
    MOV    SI,1
C32:
    MOV    DI,SI

    ADD    SI,URADDR
    ADD SI,BX
    ADD    DI,LRADDR
    SUB    DI,BX

    MOV    URADDR,SI
    MOV    LRADDR,DI

    MOV    ES:[SI],AL
    MOV ES:[DI],AL

    POP    DX
    POP BX
    POP AX
    RET

SET4PIXELS    ENDP

INVERT4PIXELS    PROC    NEAR
    PUSH    AX
    PUSH    BX
    PUSH    DX
    XOR    BX,BX
    TEST    CH,CH
    JZ    IC30
    MOV    BX,BYTESPERLINE
    NEG    BX
IC30:

;PIXELS AT (XC-X,YC+Y) AND XC-X,YC-Y)

    XOR    SI,SI
    TEST    CL,CL
    JZ    IC31
    MOV    SI,-1
IC31:

    MOV DI,SI
    ADD    SI,ULADDR
    ADD    SI,BX
    ADD    DI,LLADDR
    SUB    DI,BX
    MOV    ULADDR,SI
    MOV    LLADDR,DI
    MOV    AL,ES:[SI]
    XOR AL,0FFH
    MOV    ES:[SI],AL
    MOV    AL,ES:[DI]
    XOR AL,0FFH
    MOV    ES:[DI],AL

;PIXELS AT (XC+X,YC+Y) AND (XC+X,YC+Y)

    XOR    SI,SI
    TEST    CL,CL
    JZ    IC32
    MOV    SI,1
IC32:
    MOV    DI,SI

    ADD    SI,URADDR
    ADD SI,BX
    ADD    DI,LRADDR
    SUB    DI,BX

    MOV    URADDR,SI
    MOV    LRADDR,DI

    MOV    AL,ES:[SI]
    XOR AL,0FFH
    MOV    ES:[SI],AL
    MOV    AL,ES:[DI]
    XOR AL,0FFH
    MOV    ES:[DI],AL

    POP    DX
    POP BX
    POP AX
    RET

INVERT4PIXELS    ENDP

LONGMULTIPLY    PROC    NEAR

    PUSH    AX
    MOV    AX,DX
    MUL    CX
    XCHG    AX,CX
    POP DX
    MUL DX
    ADD    DX,CX
    RET

LONGMULTIPLY    ENDP

;    ENDPS
    END