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

Assembly Source File | 1990-01-06 | 13.0 KB | 496 lines

;
;   Number Nine Revolution 512x8
;   support routines for raster oriented graphics
;
;   Tim Krauskopf      July 1986
;
;   National Center for Supercomputing Applications, University of Illinois
;   153 Water Resources Building
;   605 E. Springfield Ave.
;   Champaign, IL  61820
;   [phone]
;
;
    TITLE      NUMBER 9 GRAPHICS SUPPORT
    INCLUDE DOS.MAC
    SETX
    PSEG
    PUBLIC    PUTMAP9,NO9LINE,SHOWPAL9,NOPAL9,OUTLINE9,MAKECUR9;,NO9PT
;
SETBANK    MACRO
    LOCAL    NO706
    LOCAL    NO705
    LOCAL    OKBANK        ; A MACRO TO SET THE BANK FOR THE LINE OF THE NO9 MONITOR
                        ; BX MUST CONTAIN THE Y POSITION
    MOV    AX,BX        ; y location on screen
    MOV    CL,7        ; divide by 128
    SHR    AX,CL
    MOV    CL,AL        ; make a copy
    CMP    AL,CS:BANK    ; is it the same bank?
    JZ    OKBANK

    MOV    CS:BANK,AL    ; bank will be this one
    MOV    DH,00H        ; default, might be changed
    AND    AL,02H        ; is high bit on?
    JZ    NO706

    MOV    DH,0FFH        ;  setting for new bank
NO706:
    MOV    DL,00H        ; default setting for 705
    MOV    AL,CL        ; get back copy
    AND    AL,01H        ; is low bit on?
    JZ    NO705

    MOV    DL,0FFH        ; other portion of new bank
NO705:
    MOV    DI,0705H    ; where bank reg is
    MOV    AX,DX
    STOSW            ; sets both bytes, lo then hi
;
;   READY TO PUT THE LINE
;
OKBANK:
    ENDM            ; END OF THE COMPUTE BANK MACRO
;
;  take three arrays of color table entries and transfer them to the
;  board's registers
;
;  usage:  putmap9(rmap,gmap,bmap);
;
PUTMAP9    PROC    FAR
    PUSH    BP
    MOV    BP,SP
    PUSH    DS
    PUSH    ES
    MOV    AX,[BP+X+2]
    MOV    DS,AX            ; where to get maps (seg)
    MOV    SI,[BP+X]        ; where to get red
    MOV    AX,0C000H        ; control seg for #9
    MOV    ES,AX
    MOV    DI,0100H        ; red map
    MOV    CX,256            ; length of map
    REP    MOVSB            ; mov red
;
    MOV    SI,[BP+X+4]
    MOV    DI,0200H        ; green map
    MOV    CX,256
    REP    MOVSB
;
    MOV    SI,[BP+X+8]        ; blue map
    MOV    DI,0300H
    MOV    CX,256
    REP    MOVSB
;
    POP    ES
    POP    DS
    POP    BP
    RET

PUTMAP9    ENDP
;
;  Transfer line to #9 screen, one byte per pixel
;
;   usage : no9line(x,y,buf,xoff,nbytes)
;
NO9LINE    PROC    FAR
    PUSH    BP
    MOV    BP,SP
    PUSH    DS
    PUSH    ES
    MOV    AX,0C000H    ; control regs
    MOV    ES,AX

    MOV    AX,[BP+X+6]    ; ds of buffer
    MOV    DS,AX
    MOV    BX,[BP+X+2]    ; y location on screen
    SETBANK            ; CALL MACRO TO SET THE CORRECT MEMORY BANK FOR THE Y POSITION
    MOV    AX,0A000H    ; data buffer
    MOV    ES,AX
    MOV    SI,[BP+X+4]    ; where data will come from
    MOV    AX,[BP+X+8]    ; GET THE X OFFSET INTO THE ARRAY
    CMP    AX,0        ; CHECK FOR NEGATIVE OFFSET
    JGE    OKSIGN        ; JUMP AROUND FIXING THE WINDOW
    NEG    AX            ; TAKE THE OPPOSITE VALUE
    ADD AX,[BP+X]    ; AND ADD IT TO THE POSITION ON THE SCREEN
    MOV    [BP+X],AX    ; AND RE-STORE THE POSITION
    MOV    AX,[BP+X+8]    ; GET THE NEGATIVE OFFSET AGAIN
    ADD    AX,[BP+X+10]    ; REDUCE THE NUMBER OF BYTES TO COPY TO THE SCREEN
    MOV    [BP+X+10],AX    ; AND STORE THE NUMBER OF BYTES AGAIN
OKSIGN:
    ADD    SI,AX        ; ADD THE OFFSET TO THE OFFSET OF THE ARRAY
;
    MOV    AX,[BP+X+2]    ; get y value again
    MOV    CL,9
    SHL    AX,CL        ; get 16 bit pointer for this bank
    ADD    AX,[BP+X]    ; x value of where on screen added in
    MOV    DI,AX        ; prepare for movs
    MOV    CX,[BP+X+10]    ; how many bytes?
BLAST:
    REP    MOVSB

    POP    ES
    POP    DS
    POP    BP
    RET
BANK    DB    0FFH        ; current bank number
NO9LINE    ENDP

;
;    showpal9(&palstore,pal_xoff,pal_yoff);
;
SHOWPAL9        PROC    FAR
    PUSH    BP
    MOV        BP,SP
    PUSH    DS
    PUSH    ES

    MOV    CX,16        ; COUNT THE NUMBER OF LINES TO SAVE
    PUSH    CX        ; AND SAVE THE COUNT
SHOWTOP:
    MOV    AX,0C000H    ; control regs
    MOV    ES,AX
    MOV    BX,[BP+X+6]    ; y location on screen
    INC    WORD PTR [BP+X+6]    ; GET THE Y VALUE OF THE NEXT LINE
    SETBANK            ; CALL MACRO TO SET THE CORRECT MEMORY BANK FOR THE Y POSITION
    MOV    AX,0A000H    ; data buffer
    MOV    DS,AX
    MOV    AX,BX        ; get y value again
    MOV    CL,9
    SHL    AX,CL        ; get 16 bit pointer for this bank
    ADD    AX,[BP+X+4]    ; ADD IN THE X OFFSET
    MOV    SI,AX        ; prepare for movs
    MOV    DI,[BP+X]    ; GET OFFSET OF ARRAY
    MOV    AX,[BP+X+2]    ; GET SEGMENT OF STORAGE ARRAY
    MOV    ES,AX
    MOV    CX,0        ; how many bytes?
ZING:
    MOVSB            ; SAVE THE OLD VALUE
    DEC    SI            ; GO BACK TO PUT THE PALETTE IN MEMORY
    MOV    DS:BYTE PTR [SI],CL    ; PUT THE PALETTE VALUE THERE
    INC    SI
    INC    CX            ; INCREMENT THE LOOP COUNTER
    CMP    CH,1        ; CHECK FOR THE END OF THE LINE
    JNE    ZING        ; FINISH THE PALETTE  FOR THAT LINE

    POP    CX            ; RECOVER THE COUNT OF LINES
    DEC    CX            ;
    PUSH    CX        ; KEEP THE COUNT AROUND STILL
    MOV    [BP+X],DI    ; SAVE MODIFIED OFFSET
    CMP    CX,0        ; CHECK FOR THE COUNT BEING DONE
    JNE    SHOWTOP

    POP    CX        ; GET RID OF EXTRANEOUS PUSH

    POP    ES
    POP    DS
    POP    BP
    RET
SHOWPAL9    ENDP
;
;    nopal9(&palstore,pal_xoff,pal_yoff);
;
NOPAL9        PROC    FAR
    PUSH    BP
    MOV        BP,SP
    PUSH    DS
    PUSH    ES

    MOV    CX,16        ; THE NUMBER OF LINES TO REPLACE
    PUSH    CX        ; SAVE THE NUMBER OF LINES
NOTOP:
    MOV    AX,0C000H    ; control regs
    MOV    ES,AX
    MOV    BX,[BP+X+6]    ; y location on screen
    INC    WORD PTR [BP+X+6]    ; MAKE Y POSITION FOR NEXT LINE
    SETBANK            ; CALL MACRO TO SET THE CORRECT MEMORY BANK FOR THE Y POSITION

    MOV    AX,0A000H    ; data buffer
    MOV    ES,AX
    MOV    AX,[BP+X+2]    ; ds of buffer
    MOV    DS,AX
    MOV    SI,[BP+X]    ; where data will come from

    MOV    AX,BX        ; get y value again
    MOV    CL,9
    SHL    AX,CL        ; get 16 bit pointer for this bank
    ADD    AX,[BP+X+4]    ; x value of where on screen added in
    MOV    DI,AX        ; prepare for movs

    MOV    CX,256        ; how many bytes?
ZOOM:
    REP    MOVSB

    POP    CX            ; RECOVER THE COUNT OF LINES
    DEC    CX            ;
    PUSH    CX        ; KEEP THE COUNT AROUND STILL
    MOV    [BP+X],SI    ; SAVE MODFIED OFFSET
    CMP    CX,0        ; CHECK FOR THE COUNT BEING DONE
    JNE     NOTOP

    POP    CX            ; GET RID OF EXTRANEOUS CX PUSH

    POP    ES
    POP    DS
    POP    BP
    RET
NOPAL9    ENDP
ifdef QAK
;
;    no9pt(x,y,color);
;
NO9PT        PROC    FAR
    PUSH    BP
    MOV        BP,SP
    PUSH    DS
    PUSH    ES
    MOV    AX,0C000H    ; control regs
    MOV    ES,AX

    MOV    BX,[BP+X+2]    ; GET LINE TO COPY SCREEN BACK ONTO
    SETBANK

    MOV    AX,0A000H    ; data buffer
    MOV    ES,AX

    MOV    AX,[BP+X+2]    ; get y value again
    MOV    CL,9
    SHL    AX,CL        ; get 16 bit pointer for this bank
    ADD    AX,[BP+X]    ; ADD IN THE X OFFSET

    MOV    DI,AX        ; prepare for movs
    MOV    AL,[BP+X+4]    ; GET THE VALUE TO PUT THERE

    STOSB            ; PUT COLOR ON THE SCREEN

    POP    ES
    POP    DS
    POP    BP
    RET
NO9PT    ENDP
endif

Y_COUNT    DW    0        ; THE NUMBER OF Y LINES TO INVERT
;
;  Invert A BOX ON THE SCREEN
;
;   usage : outline9(x1,y1,x2,y2)
;
OUTLINE9    PROC    FAR
    PUSH    BP
    MOV    BP,SP
    PUSH    DS
    PUSH    ES

;    INT    3            ; PERFORM AN INTERUPT FOR DEBUGGER
    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
    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,0C000H    ; control regs
    MOV    ES,AX
    MOV    BX,[BP+X+2]    ; GET THE Y LOCATION FOR THE TOP LINE
    SETBANK            ; CALL MACRO TO SET THE CORRECT MEMORY BANK FOR THE Y POSITION
    MOV    AX,0A000H    ; SET THE DATA BUFFER
    MOV    ES,AX
    MOV    AX,[BP+X+2]    ; GET THE Y POSITION FOR THE TOP LINE AGAIN
    MOV    CL,9
    SHL    AX,CL
    ADD    AX,[BP+X]    ; ADD IN THE X OFFSET
    MOV    DI,AX        ; STORE THE OFFSET
    MOV    CX,[BP+X+4]    ; THE NUMBER OF BYTES TO INVERT
    INC    CX
BLASTA:
    MOV    AL,ES:[DI]    ; GET THE BYTE TO INVERT
    NOT    AL        ; INVERT THE BYTE
    MOV    ES:[DI],AL    ; REPLACE THE BYTE
    INC    DI        ; GO TO THE NEXT BYTE
    LOOP    BLASTA        ; FINISH THE LINE OUT

    MOV    AX,0C000H    ; control regs
    MOV    ES,AX
    ADD    BX,[BP+X+6]    ; ADD IN THE Y SIZE TO GET TO THE LAST LINE
    ADD    BX,1        ;
    SETBANK            ; CALL MACRO TO SET THE CORRECT MEMORY BANK FOR THE Y POSITION
    MOV    AX,0A000H    ; SET THE DATA BUFFER
    MOV    ES,AX
    MOV    AX,BX        ; GET THE Y POSITION FOR THE TOP LINE AGAIN
    MOV    CL,9
    SHL    AX,CL
    ADD    AX,[BP+X]    ; ADD IN THE X OFFSET
    MOV    DI,AX        ; STORE THE OFFSET
    MOV    CX,[BP+X+4]    ; THE NUMBER OF BYTES TO INVERT
    INC    CX
BLASTB:
    MOV    AL,ES:[DI]    ; GET THE BYTE TO INVERT
    NOT    AL            ; INVERT THE BYTE
    MOV    ES:[DI],AL    ; REPLACE THE BYTE
    INC    DI            ; GO TO THE NEXT BYTE
    LOOP    BLASTB    ; FINISH THE LINE OUT

    MOV    CX,[BP+X+6]    ; GET THE NUMBER OF LINES IN THE MIDDLE
    MOV    Y_COUNT,CX    ; STORE IT IN THE PROPER PLACE
OUTTOP:
    MOV    AX,0C000H    ; control regs
    MOV    ES,AX
    INC    WORD PTR [BP+X+2]    ; INCREMENT THE LINE TO INVERT
    MOV    BX,[BP+X+2]    ; GET THE LINE TO MODIFY
    SETBANK            ; CALL MACRO TO SET THE CORRECT MEMORY BANK FOR THE Y POSITION
    MOV    AX,0A000H    ; SET THE DATA BUFFER
    MOV    ES,AX
    MOV    AX,[BP+X+2]    ; GET THE Y POSITION FOR THE TOP LINE AGAIN
    MOV    CL,9
    SHL    AX,CL
    ADD    AX,[BP+X]    ; ADD IN THE X OFFSET
    MOV    DI,AX        ; STORE THE OFFSET
    MOV    AL,ES:[DI]    ; GET THE BYTE TO INVERT
    NOT    AL            ; INVERT THE BYTE
    MOV    ES:[DI],AL    ; REPLACE THE BYTE
    ADD    DI,[BP+X+4]    ; GET TO THE END OF THE LINE
    MOV    AL,ES:[DI]    ; GET THE BYTE TO INVERT
    NOT    AL            ; INVERT THE BYTE
    MOV    ES:[DI],AL    ; REPLACE THE BYTE
    DEC    Y_COUNT        ; DECREMENT THE COUNT
    CMP    Y_COUNT,0    ; CHECK FOR THE END OF THE BOX
    JG    OUTTOP        ; JUMP BACK TO THE BEGINNING

    POP    ES
    POP    DS
    POP    BP
    RET
OUTLINE9    ENDP

X_SIZE    EQU    16        ; X WIDTH OF THE CURSOR
Y_SIZE    EQU    32        ; TWICE THE Y HEIGHT OF THE CURSOR
X_HOT    EQU    7        ; HORIZONTAL HOT SPOT FOR THE CURSOR
Y_HOT    EQU    7        ; VERTICAL HOT SPOT FOR THE CURSOR
X_START    DW    ?        ; THE X POSITION TO START THE ARRAY ON
;
;    EACH BIT PLACE IN THE CURSOR ARRAY STANDS FOR A BYTE ON THE SCREEN
;    IF THE BIT IS ON, THEN THAT BYTE ON THE SCREEN WILL BE INVERTED
;    IF NOT, THEN THE BYTE WILL BE UNTOUCHED.
;    THE NUMBER OF WORDS FOR THE CURSOR ARRAY, AND THE NUMBER OF BITS
;    IN EACH IS CONTROLLED BY THE X_SIZE AND Y_SIZE VARIABLES.
CURSOR    LABEL    WORD        ; LABEL FOR THE BEGINNING OF THE CURSOR ARRAY
        DW    0000000000000000B
        DW    0000000000000000B
        DW    0000000110000000B
        DW    0000000110000000B
        DW    0000000110000000B
        DW    0000000110000000B
        DW    0000000110000000B
        DW    0011111111111100B
        DW    0011111111111100B
        DW    0000000110000000B
        DW    0000000110000000B
        DW    0000000110000000B
        DW    0000000110000000B
        DW    0000000110000000B
        DW    0000000000000000B
        DW    0000000000000000B
;
;
;    Routine to make a cursor on the screen
;    makecur9(x,y);
;
MAKECUR9    PROC    FAR
    PUSH    BP
    MOV    BP,SP
    PUSH    DS
    PUSH    ES

    MOV    AX,[BP+X+2]    ; GET THE Y VALUE TO MODIFY FOR THE HOT SPOT
    SUB    AX,Y_HOT    ; SUBTRACT THE HOT SPOT VALUE
    MOV    [BP+X+2],AX    ; REPLACE THE Y VALUE

    MOV    AX,[BP+X]    ; GET THE X VALUE TO MODIFY FOR THE HOT SPOT
    SUB    AX,X_HOT    ; SUBTRACT THE HOT SPOT VALUE
    MOV    [BP+X],AX    ; REPLACE THE X VALUE

    MOV    X_START,0    ; INITIALIZE THE X_START TO BE IN THE 0 POSITION
    MOV    SI,0        ; INITIALIZE THE Y COUNTER
CURTOP:
    MOV    AX,0C000H    ; control regs
    MOV    ES,AX
    MOV    BX,[BP+X+2]    ; GET LINE TO COPY SCREEN BACK ONTO
    CMP    BX,0        ; CHECK FOR NEGATIVE COORDINATES
    JL    CUREND        ; IF NEGATIVE COORDINATES THEN JUMP TO END OF LOOP
    SETBANK

    MOV    AX,0A000H    ; data buffer
    MOV    ES,AX

    MOV    DX,X_START    ; INITIALIZE THE X COUNTER
    MOV    BX,CURSOR[SI]    ; GET THE CURRENT CURSOR INFORMATION
    MOV    CX,X_START    ; GET THE INITIAL NUMBER OF BITS TO SHIFT THE ARRAY
    SHL    BX,CL        ; SHIFT THE ARRAY THAT MANY BYTES
TRYAGAIN:
    MOV    AX,[BP+X]    ; GET THE X POSITION
    CMP    AX,0        ; CHECK FOR NEGATIVE POSITION
    JGE    OKFINE        ; NOT A NEGATIVE VALUE
    INC    WORD PTR [BP+X]    ; INCREMENT THE X POSITION
    INC    DX            ; AND THE POSITION IN THE ARRAY
    INC    WORD PTR X_START    ; INCREMENT THE POSITION TO START IN THE ARRAY FOR NEXT LOOP THRU
    SHL    BX,1        ; GET RID OF A BIT OF THE CURSOR INFORMATION
    JMP    TRYAGAIN    ; JUMP BACK TO TRY FOR ANOTHER X POSITION
OKFINE:
    MOV    AX,[BP+X+2]    ; get y value again
    MOV    CL,9
    SHL    AX,CL        ; get 16 bit pointer for this bank
    ADD    AX,[BP+X]    ; ADD IN THE X OFFSET
    MOV    DI,AX        ; prepare for movs

LOOPTOP:
    SHL    BX,1        ; GET THE BIT FOR THIS CURSOR POSITION
    JNC    LOOPBOT        ; IF IT NOT SET THEN JUMP TO BOTTOM OF LOOP
    MOV    AL,ES:[DI]    ; GET THE BYTE TO INVERT
    NOT    AL            ; INVERT THE BYTE
    MOV    ES:[DI],AL    ; REPLACE THE INVERTED BYTE
LOOPBOT:
    INC    DI            ; INCREMENT FOR NEXT BYTE ON THE SCREEN
    INC    DX            ; INCREMENT THE POSITION IN THE ARRAY
    CMP    DX,X_SIZE    ; CHECK TO SEE IF THE END OF THE LINE HAS BEEN FOUND
    JNE    LOOPTOP        ; IF NOT END THEN JUMP TO BEGINNING OF THE LOOP

CUREND:
    INC    WORD PTR [BP+X+2]    ; INCREMENT Y VALUE FOR THE NEXT LINE
    INC    SI            ; INCREMENT THE Y POSITION IN THE ARRAY
    INC    SI
    CMP    SI,Y_SIZE    ; CHECK TO SEE IF THE BOOTOM OF THE ARRAY HAS BEEN REACHED
    JE    KLUDGE        ; JUMP AROUND JUMP BACK IF AT END
    JMP    CURTOP        ; IF NOT THEN JUMP TO BEGINNING OF A NEW LINE
KLUDGE:

    POP    ES
    POP    DS
    POP    BP
    RET
MAKECUR9    ENDP

    ENDPS
    END